1 /*
2  * Copyright (C) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the 'License');
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an 'AS IS' BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include "napi/native_api.h"
16 #include "multimedia/player_framework/native_cencinfo.h"
17 #include "multimedia/player_framework/native_averrors.h"
18 #include "multimedia/player_framework/native_avcodec_base.h"
19 #include "multimedia/player_framework/native_avbuffer.h"
20 
21 #include <cstring>
22 #include <cstdio>
23 #include <stdlib.h>
24 
25 #define KEY_DATA_LEN 16
26 #define BUFF_DATA_SIZE 2000
Test_CencInfo_Destroy(napi_env env, napi_callback_info info)27 static napi_value Test_CencInfo_Destroy(napi_env env, napi_callback_info info)
28 {
29     napi_value result;
30     size_t argc = 2;
31     napi_value args[2] = {nullptr};
32     size_t argc_oneLen = 0;
33     char *argc_one = nullptr;
34     size_t argc_twoLen = 0;
35     char *argc_two = nullptr;
36     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
37     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
38     argc_one = new char[argc_oneLen + 1];
39     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
40 
41     napi_get_value_string_utf8(env, args[1], nullptr, 0, &argc_twoLen);
42     argc_two = new char[argc_twoLen + 1];
43     napi_get_value_string_utf8(env, args[1], argc_two, argc_twoLen + 1, &argc_twoLen);
44 
45     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
46     OH_AVCencInfo *handle_ptr = nullptr;
47     if (0 != strcmp(argc_one, " ")) {
48         handle_ptr = handle;
49     }
50     OH_AVErrCode ret1 = OH_AVCencInfo_Destroy(handle_ptr);
51     napi_create_int32(env, ret1, &result);
52     return result;
53 }
Test_AVCencInfo_SetAlgorithm(napi_env env, napi_callback_info info)54 static napi_value Test_AVCencInfo_SetAlgorithm(napi_env env, napi_callback_info info)
55 {
56     napi_value result;
57     OH_AVErrCode ret = AV_ERR_INVALID_VAL;
58     size_t argc = 2;
59     napi_value args[2] = {nullptr};
60     size_t argc_oneLen = 0;
61     char *argc_one = nullptr;
62     int32_t argc_two ;
63     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
64     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
65     argc_one = new char[argc_oneLen + 1];
66     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
67     napi_get_value_int32(env,args[1],&argc_two);
68 
69     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
70     OH_AVCencInfo *handle_ptr = nullptr;
71     if (0 != strcmp(argc_one, " ")) {
72         handle_ptr = handle;
73     }
74     OH_AVErrCode ret1 = OH_AVCencInfo_SetAlgorithm(handle_ptr,(DrmCencAlgorithm)argc_two);
75     OH_AVErrCode ret2 = OH_AVCencInfo_Destroy(handle);
76     if (ret1 == AV_ERR_OK && ret2 == AV_ERR_OK ) {
77         ret = AV_ERR_OK;
78     } else {
79         ret = AV_ERR_INVALID_VAL;
80     }
81     napi_create_int32(env, ret, &result);
82     return result;
83 }
Test_AVCencInfo_SetKeyIdAndIv(napi_env env, napi_callback_info info)84 static napi_value Test_AVCencInfo_SetKeyIdAndIv(napi_env env, napi_callback_info info)
85 {
86     napi_value result;
87     OH_AVErrCode ret = AV_ERR_INVALID_VAL;
88     size_t argc = 5;
89     napi_value args[5] = {nullptr};
90     size_t argc_oneLen = 0;
91     char *argc_one = nullptr;
92     size_t argc_twoLen = 0;
93     char *argc_two = nullptr;
94     uint32_t keyIdLen = 0;
95     size_t argc_fourLen = 0;
96     char *argc_four = nullptr;
97     uint32_t argc_five = 0;
98     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
99     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
100     argc_one = new char[argc_oneLen + 1];
101     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
102     napi_get_value_string_utf8(env, args[1], nullptr, 0, &argc_twoLen);
103     argc_two = new char[argc_twoLen + 1];
104     napi_get_value_string_utf8(env, args[1], argc_two, argc_twoLen + 1, &argc_twoLen);
105 
106     napi_get_value_uint32(env,args[2],&keyIdLen);
107     napi_get_value_string_utf8(env, args[3], nullptr, 0, &argc_fourLen);
108     argc_four = new char[argc_fourLen + 1];
109     napi_get_value_string_utf8(env, args[3], argc_four, argc_fourLen + 1, &argc_fourLen);
110     napi_get_value_uint32(env,args[4],&argc_five);
111 
112     uint8_t keyIdData[KEY_DATA_LEN] = {0x01, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, 0x34, 0x34, 0x4E, 0x6A, 0x42};
113     uint8_t ivData[KEY_DATA_LEN] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x10};
114     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
115     OH_AVCencInfo *handle_ptr = nullptr;
116     if (0 != strcmp(argc_one, " ")) {
117         handle_ptr = handle;
118     }
119     uint8_t *keyId_ptr = nullptr;
120     if (0 != strcmp(argc_two, " ")) {
121         keyId_ptr = keyIdData;
122     }
123     uint8_t *iv_ptr = nullptr;
124     if (0 != strcmp(argc_four, " ")) {
125         iv_ptr = ivData;
126     }
127     uint32_t ivLen = argc_five;
128 
129     OH_AVErrCode ret1 = OH_AVCencInfo_SetKeyIdAndIv(handle_ptr, keyId_ptr, keyIdLen, iv_ptr, ivLen);
130     OH_AVErrCode ret2 = OH_AVCencInfo_Destroy(handle);
131     if (ret1 == AV_ERR_OK && ret2 == AV_ERR_OK ) {
132         ret = AV_ERR_OK;
133     } else {
134         ret = AV_ERR_INVALID_VAL;
135     }
136     napi_create_int32(env, ret, &result);
137     return result;
138 }
Test_AVCencInfo_SetSubsampleInfo(napi_env env, napi_callback_info info)139 static napi_value Test_AVCencInfo_SetSubsampleInfo(napi_env env, napi_callback_info info)
140 {
141     napi_value result;
142     OH_AVErrCode ret = AV_ERR_INVALID_VAL;
143     size_t argc = 6;
144     napi_value args[6] = {nullptr};
145     size_t argc_oneLen = 0;
146     char *argc_one = nullptr;
147     uint32_t argc_two = 0;
148     uint32_t argc_three = 0;
149     uint32_t argc_four = 0;
150     uint32_t argc_five = 0;
151     size_t argc_sixLen = 0;
152     char *argc_six = nullptr;
153     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
154     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
155     argc_one = new char[argc_oneLen + 1];
156     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
157     napi_get_value_uint32(env,args[1],&argc_two);
158     napi_get_value_uint32(env,args[2],&argc_three);
159     napi_get_value_uint32(env,args[3],&argc_four);
160     napi_get_value_uint32(env,args[4],&argc_five);
161     napi_get_value_string_utf8(env, args[5], nullptr, 0, &argc_sixLen);
162     argc_six = new char[argc_sixLen + 1];
163     napi_get_value_string_utf8(env, args[5], argc_six, argc_sixLen + 1, &argc_sixLen);
164     DrmSubsample subsamples[10] = {{0x10,0x16},{0x20,0x22},{0x30,0x35},{0x40,0x47},{0x50,0x50},{0x60,0x6f},{0x70,0x71},{0x80,0x82},{0x90,0x22},{0xa0,0x22}};
165     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
166     OH_AVCencInfo *handle_ptr = nullptr;
167     if (0 != strcmp(argc_one, " ")) {
168         handle_ptr = handle;
169     }
170     uint32_t encryptedBlockCount = argc_two;
171     uint32_t skippedBlockCount = argc_three;
172     uint32_t firstEncryptedOffset = argc_four;
173     uint32_t subsampleCount = argc_five;
174     DrmSubsample *subsamples_ptr = nullptr;
175     if (0 != strcmp(argc_six, " ")) {
176         subsamples_ptr = subsamples;
177     }
178     OH_AVErrCode ret1 = OH_AVCencInfo_SetSubsampleInfo(handle_ptr, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset, subsampleCount, subsamples_ptr);
179     OH_AVErrCode ret2 = OH_AVCencInfo_Destroy(handle);
180     if (ret1 == AV_ERR_OK && ret2 == AV_ERR_OK ) {
181         ret = AV_ERR_OK;
182     } else {
183         ret = AV_ERR_INVALID_VAL;
184     }
185     napi_create_int32(env, ret, &result);
186     return result;
187 }
Test_AVCencInfo_SetMode(napi_env env, napi_callback_info info)188 static napi_value Test_AVCencInfo_SetMode(napi_env env, napi_callback_info info)
189 {
190     napi_value result;
191     OH_AVErrCode ret = AV_ERR_INVALID_VAL;
192     size_t argc = 2;
193     napi_value args[2] = {nullptr};
194     size_t argc_oneLen = 0;
195     char *argc_one = nullptr;
196     uint32_t argc_two = 0;
197 
198     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
199     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
200     argc_one = new char[argc_oneLen + 1];
201     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
202     napi_get_value_uint32(env,args[1],&argc_two);
203 
204     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
205     OH_AVCencInfo *handle_ptr = nullptr;
206     if (0 != strcmp(argc_one, " ")) {
207         handle_ptr = handle;
208     }
209     DrmCencInfoMode mode = (DrmCencInfoMode)argc_two;
210 
211     OH_AVErrCode ret1 = OH_AVCencInfo_SetMode(handle_ptr, mode);
212     OH_AVErrCode ret2 = OH_AVCencInfo_Destroy(handle);
213     if (ret1 == AV_ERR_OK && ret2 == AV_ERR_OK ) {
214         ret = AV_ERR_OK;
215     } else {
216         ret = AV_ERR_INVALID_VAL;
217     }
218     napi_create_int32(env, ret, &result);
219     return result;
220 }
Test_AVCencInfo_SetAVBuffer(napi_env env, napi_callback_info info)221 static napi_value Test_AVCencInfo_SetAVBuffer(napi_env env, napi_callback_info info)
222 {
223     napi_value result;
224     OH_AVErrCode ret = AV_ERR_INVALID_VAL;
225     size_t argc = 2;
226     napi_value args[2] = {nullptr};
227     size_t argc_oneLen = 0;
228     char *argc_one = nullptr;
229     size_t argc_twoLen = 0;
230     char *argc_two = nullptr;
231     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
232     napi_get_value_string_utf8(env, args[0], nullptr, 0, &argc_oneLen);
233     argc_one = new char[argc_oneLen + 1];
234     napi_get_value_string_utf8(env, args[0], argc_one, argc_oneLen + 1, &argc_oneLen);
235     napi_get_value_string_utf8(env, args[1], nullptr, 0, &argc_twoLen);
236     argc_two = new char[argc_twoLen + 1];
237     napi_get_value_string_utf8(env, args[1], argc_two, argc_twoLen + 1, &argc_twoLen);
238     uint8_t keyIdData[KEY_DATA_LEN] = {0x01, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, 0x34, 0x34, 0x4E, 0x6A, 0x42};
239     uint8_t ivData[KEY_DATA_LEN] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x10};
240     DrmSubsample subsamples[10] = {{0x10,0x16},{0x20,0x22},{0x30,0x35},{0x40,0x47},{0x50,0x50},{0x60,0x6f},{0x70,0x71},{0x80,0x82},{0x90,0x22},{0xa0,0x22}};
241     uint32_t encryptedBlockCount = 0xff;
242     uint32_t skippedBlockCount = 0x10;
243     uint32_t firstEncryptedOffset = 0x20;
244     uint32_t subsampleCount = 2;
245     OH_AVCencInfo *handle = OH_AVCencInfo_Create();
246     OH_AVErrCode ret1 = OH_AVCencInfo_SetAlgorithm(handle, DRM_ALG_CENC_SM4_CBC);
247     OH_AVErrCode ret2 = OH_AVCencInfo_SetKeyIdAndIv(handle, keyIdData, KEY_DATA_LEN, ivData, KEY_DATA_LEN);
248     OH_AVErrCode ret3 = OH_AVCencInfo_SetSubsampleInfo(handle, encryptedBlockCount, skippedBlockCount, firstEncryptedOffset, subsampleCount, subsamples);
249     OH_AVErrCode ret4 = OH_AVCencInfo_SetMode(handle, DRM_CENC_INFO_KEY_IV_SUBSAMPLES_NOT_SET);
250     OH_AVErrCode ret5 = AV_ERR_INVALID_VAL;
251     OH_AVBuffer *inBuf = OH_AVBuffer_Create(BUFF_DATA_SIZE);
252     if(inBuf != nullptr){
253         OH_AVCencInfo *handle_ptr = nullptr;
254         if (0 != strcmp(argc_one, " ")) {
255             handle_ptr = handle;
256         }
257         if (0 != strcmp(argc_one, " ")) {
258             ret5 = OH_AVCencInfo_SetAVBuffer(handle_ptr, inBuf);
259         } else{
260             ret5 = OH_AVCencInfo_SetAVBuffer(handle_ptr, nullptr);
261         }
262     }
263     OH_AVErrCode ret6 = OH_AVCencInfo_Destroy(handle);
264     OH_AVErrCode ret7 = OH_AVBuffer_Destroy(inBuf);
265     if (ret1 == AV_ERR_OK && ret2 == AV_ERR_OK && ret3 == AV_ERR_OK
266     && ret4 == AV_ERR_OK && ret5 == AV_ERR_OK && ret6 == AV_ERR_OK && ret7 == AV_ERR_OK) {
267         ret = AV_ERR_OK;
268     } else {
269         ret = AV_ERR_INVALID_VAL;
270     }
271     napi_create_int32(env, ret, &result);
272     return result;
273 }
274 
275 EXTERN_C_START
Init(napi_env env, napi_value exports)276 static napi_value Init(napi_env env, napi_value exports)
277 {
278     napi_property_descriptor desc[] = {
279         { "Test_CencInfo_Destroy", nullptr, Test_CencInfo_Destroy, nullptr, nullptr, nullptr, napi_default, nullptr },
280         { "Test_AVCencInfo_SetAlgorithm", nullptr, Test_AVCencInfo_SetAlgorithm, nullptr, nullptr, nullptr, napi_default, nullptr },
281         { "Test_AVCencInfo_SetKeyIdAndIv", nullptr, Test_AVCencInfo_SetKeyIdAndIv, nullptr, nullptr, nullptr, napi_default, nullptr },
282         { "Test_AVCencInfo_SetSubsampleInfo", nullptr, Test_AVCencInfo_SetSubsampleInfo, nullptr, nullptr, nullptr, napi_default, nullptr },
283         { "Test_AVCencInfo_SetMode", nullptr, Test_AVCencInfo_SetMode, nullptr, nullptr, nullptr, napi_default, nullptr },
284         { "Test_AVCencInfo_SetAVBuffer", nullptr, Test_AVCencInfo_SetAVBuffer, nullptr, nullptr, nullptr, napi_default, nullptr }
285     };
286     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
287     return exports;
288 }
289 EXTERN_C_END
290 
291 static napi_module demoModule = {
292     .nm_version = 1,
293     .nm_flags = 0,
294     .nm_filename = nullptr,
295     .nm_register_func = Init,
296     .nm_modname = "entry",
297     .nm_priv = ((void*)0),
298     .reserved = { 0 },
299 };
300 
RegisterEntryModule(void)301 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
302 {
303     napi_module_register(&demoModule);
304 }
305 
306