1 /*
2 * Copyright (c) 2023 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
16 #include "napi/native_api.h"
17 #include <GLES2/gl2.h>
18 #include <bits/alltypes.h>
19 #include <cstddef>
20 #include <native_buffer/buffer_common.h>
21 #include <native_buffer/native_buffer.h>
22 #include <climits>
23 #include <native_image/native_image.h>
24 #include <sys/types.h>
25 #include <vector>
26 #include <hilog/log.h>
27 const unsigned int LOG_PRINT_DOMAIN = 0xFF00;
28
29 #define SUCCESS 0
30 #define FAIL (-1)
31 #define NUMBER_MINUS_1 (-1)
32 #define NUMBER_0 0
33 #define NUMBER_1 1
34 #define NUMBER_2 2
35 #define NUMBER_3 3
36 #define NUMBER_4 4
37 #define NUMBER_5 5
38 #define NUMBER_6 6
39 #define NUMBER_7 7
40 #define NUMBER_8 8
41 #define NUMBER_9 9
42 #define NUMBER_10 10
43 #define NUMBER_11 11
44 #define NUMBER_12 12
45 #define NUMBER_13 13
46 #define NUMBER_14 14
47 #define NUMBER_15 15
48 #define NUMBER_16 16
49 #define NUMBER_17 17
50 #define NUMBER_18 18
51 #define NUMBER_19 19
52 #define NUMBER_20 20
53 #define NUMBER_32 32
54 #define NUMBER_50 50
55 #define NUMBER_60 60
56 #define NUMBER_500 500
57 #define NUMBER_1000 1000
58 #define NUMBER_1001 1001
59 #define NUMBER_1002 1002
60 #define NUMBER_2001 2001
61 #define NUMBER_2002 2002
62 #define NUMBER_2999 2999
63 #define NUMBER_3000 3000
64 #define NUMBER_3001 3001
65 #define NUMBER_3002 3002
66 #define NUMBER_3003 3003
67 #define NUMBER_4001 4001
68 #define NUMBER_4002 4002
69 #define NUMBER_4003 4003
70 #define NUMBER_5001 5001
71 #define NUMBER_5002 5002
72 #define NUMBER_5003 5003
73 #define NUMBER_6001 6001
74 #define NUMBER_6002 6002
75 #define NUMBER_6003 6003
76 #define NUMBER_7001 7001
77 #define NUMBER_7002 7002
78 #define NUMBER_8001 8001
79 #define NUMBER_8002 8002
80 #define NUMBER_8003 8003
81 #define NUMBER_10000 10000
82 #define NUMBER_100000000 100000000
83 #define NUMBER_40001000 40001000
84 #define NUMBER_50002000 50002000
85 #define NUMBER_50007000 50007000
86 #define NUMBER_50102000 50102000
getBuffer()87 static OH_NativeBuffer *getBuffer()
88 {
89 OH_NativeBuffer_Config config = {
90 .width = 0x100,
91 .height = 0x100,
92 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
93 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
94 };
95 OH_NativeBuffer *buffer = OH_NativeBuffer_Alloc(&config);
96 return buffer;
97 }
OHNativeBufferAlloc(napi_env env,napi_callback_info info)98 static napi_value OHNativeBufferAlloc(napi_env env, napi_callback_info info)
99 {
100
101 napi_value result = nullptr;
102 int backInfo = FAIL;
103 OH_NativeBuffer *buffer = getBuffer();
104 if (buffer != nullptr) {
105 backInfo = SUCCESS;
106 }
107 napi_create_int32(env, backInfo, &result);
108 OH_NativeBuffer_Unreference(buffer);
109 return result;
110 }
OHNativeBufferAllocAbnormal(napi_env env,napi_callback_info info)111 static napi_value OHNativeBufferAllocAbnormal(napi_env env, napi_callback_info info)
112 {
113 napi_value result = nullptr;
114 int backInfo = FAIL;
115 OH_NativeBuffer *buffer = OH_NativeBuffer_Alloc(nullptr);
116
117 if (buffer != nullptr) {
118 backInfo = SUCCESS;
119 }
120 napi_create_int32(env, backInfo, &result);
121 OH_NativeBuffer_Unreference(buffer);
122 return result;
123 }
OHNativeBufferReference(napi_env env,napi_callback_info info)124 static napi_value OHNativeBufferReference(napi_env env, napi_callback_info info)
125 {
126 int backInfo = FAIL;
127 OH_NativeBuffer *buffer = getBuffer();
128 if (buffer != nullptr) {
129 int32_t ret = OH_NativeBuffer_Reference(buffer);
130 backInfo = ret;
131 }
132 napi_value result = nullptr;
133 napi_create_int32(env, backInfo, &result);
134 OH_NativeBuffer_Unreference(buffer);
135 return result;
136 }
OHNativeBufferReferenceAbnormal(napi_env env,napi_callback_info info)137 static napi_value OHNativeBufferReferenceAbnormal(napi_env env, napi_callback_info info)
138 {
139 int backInfo = FAIL;
140 int32_t ret = OH_NativeBuffer_Reference(nullptr);
141 if (ret == 0) {
142 backInfo = SUCCESS;
143 }
144 napi_value result = nullptr;
145 napi_create_int32(env, backInfo, &result);
146 return result;
147 }
OHNativeBufferUnreference(napi_env env,napi_callback_info info)148 static napi_value OHNativeBufferUnreference(napi_env env, napi_callback_info info)
149 {
150 int backInfo = FAIL;
151 OH_NativeBuffer *buffer = getBuffer();
152
153 if (buffer != nullptr) {
154 int32_t ret = OH_NativeBuffer_Unreference(buffer);
155 backInfo = ret;
156 }
157 napi_value result = nullptr;
158 napi_create_int32(env, backInfo, &result);
159 OH_NativeBuffer_Unreference(buffer);
160 return result;
161 }
162
OHNativeBufferUnreferenceAbnormal(napi_env env,napi_callback_info info)163 static napi_value OHNativeBufferUnreferenceAbnormal(napi_env env, napi_callback_info info)
164 {
165 int backInfo = FAIL;
166
167 int32_t ret = OH_NativeBuffer_Unreference(nullptr);
168 if (ret == 0) {
169 backInfo = SUCCESS;
170 }
171 napi_value result = nullptr;
172 napi_create_int32(env, backInfo, &result);
173 return result;
174 }
175
OHNativeBufferGetConfig(napi_env env,napi_callback_info info)176 static napi_value OHNativeBufferGetConfig(napi_env env, napi_callback_info info)
177 {
178 int backInfo = FAIL;
179 OH_NativeBuffer *buffer = getBuffer();
180 if (buffer != nullptr) {
181 OH_NativeBuffer_Config checkConfig = {};
182 checkConfig.width = 0x0;
183 checkConfig.height = 0x0;
184 checkConfig.format = 0x0;
185 checkConfig.usage = 0x0;
186 OH_NativeBuffer_GetConfig(buffer, &checkConfig);
187 if (&checkConfig != nullptr) {
188 backInfo = SUCCESS;
189 }
190 }
191 napi_value result = nullptr;
192 napi_create_int32(env, backInfo, &result);
193 OH_NativeBuffer_Unreference(buffer);
194 return result;
195 }
196
OHNativeBufferMap(napi_env env,napi_callback_info info)197 static napi_value OHNativeBufferMap(napi_env env, napi_callback_info info)
198 {
199 int backInfo = FAIL;
200 OH_NativeBuffer *buffer = getBuffer();
201
202 if (buffer != nullptr) {
203 void *virAddr = nullptr;
204 int32_t ret = OH_NativeBuffer_Map(buffer, &virAddr);
205 backInfo = ret;
206 }
207 napi_value result = nullptr;
208 napi_create_int32(env, backInfo, &result);
209 OH_NativeBuffer_Unreference(buffer);
210 return result;
211 }
OHNativeBufferMapAbnormal(napi_env env,napi_callback_info info)212 static napi_value OHNativeBufferMapAbnormal(napi_env env, napi_callback_info info)
213 {
214 int backInfo = FAIL;
215 void *virAddr = nullptr;
216 int32_t ret = OH_NativeBuffer_Map(nullptr, &virAddr);
217 if (ret == 0) {
218 backInfo = SUCCESS;
219 }
220 napi_value result = nullptr;
221 napi_create_int32(env, backInfo, &result);
222 return result;
223 }
OHNativeBufferUnmap(napi_env env,napi_callback_info info)224 static napi_value OHNativeBufferUnmap(napi_env env, napi_callback_info info)
225 {
226 int backInfo = FAIL;
227 OH_NativeBuffer *buffer = getBuffer();
228
229 if (buffer != nullptr) {
230 int32_t ret = OH_NativeBuffer_Unmap(buffer);
231 backInfo = ret;
232 }
233 napi_value result = nullptr;
234 napi_create_int32(env, backInfo, &result);
235 OH_NativeBuffer_Unreference(buffer);
236 return result;
237 }
OHNativeBufferUnmapAbnormal(napi_env env,napi_callback_info info)238 static napi_value OHNativeBufferUnmapAbnormal(napi_env env, napi_callback_info info)
239 {
240 int backInfo = FAIL;
241 int32_t ret = OH_NativeBuffer_Unmap(nullptr);
242 if (ret == 0) {
243 backInfo = SUCCESS;
244 }
245 napi_value result = nullptr;
246 napi_create_int32(env, backInfo, &result);
247 return result;
248 }
OHNativeBufferGetSeqNum(napi_env env,napi_callback_info info)249 static napi_value OHNativeBufferGetSeqNum(napi_env env, napi_callback_info info)
250 {
251 int backInfo = FAIL;
252 OH_NativeBuffer *buffer = getBuffer();
253
254 if (buffer != nullptr) {
255 uint32_t id = OH_NativeBuffer_GetSeqNum(buffer);
256 if (id > 0) {
257 backInfo = SUCCESS;
258 }
259 }
260 napi_value result = nullptr;
261 napi_create_int32(env, backInfo, &result);
262 OH_NativeBuffer_Unreference(buffer);
263 return result;
264 }
OHNativeBufferGetSeqNumAbnormal(napi_env env,napi_callback_info info)265 static napi_value OHNativeBufferGetSeqNumAbnormal(napi_env env, napi_callback_info info)
266 {
267 int backInfo = FAIL;
268 uint32_t id = OH_NativeBuffer_GetSeqNum(nullptr);
269 if (id > 0 && id != UINT_MAX) {
270 backInfo = SUCCESS;
271 }
272 napi_value result = nullptr;
273 napi_create_int32(env, backInfo, &result);
274 return result;
275 }
276
OHNativeBufferAllocNullptr(napi_env env,napi_callback_info info)277 static napi_value OHNativeBufferAllocNullptr(napi_env env, napi_callback_info info)
278 {
279 napi_value result = nullptr;
280 OH_NativeBuffer *ptr = OH_NativeBuffer_Alloc(nullptr);
281 if (ptr == nullptr) {
282 napi_create_int32(env, FAIL, &result);
283 } else {
284 napi_create_int32(env, SUCCESS, &result);
285 }
286 return result;
287 }
nativeBufferConfigArrTest(napi_env & env,napi_value & result,std::vector<OH_NativeBuffer_Config> & nativeBufferConfigArr)288 void nativeBufferConfigArrTest(napi_env &env, napi_value &result,
289 std::vector<OH_NativeBuffer_Config> &nativeBufferConfigArr)
290 {
291 for (uint32_t index = 0; index < NUMBER_7; index++) {
292 OH_NativeBuffer *ptr = OH_NativeBuffer_Alloc(&nativeBufferConfigArr[index]);
293 napi_value resultIndex = nullptr;
294 if (ptr == NULL) {
295 napi_create_int32(env, FAIL, &resultIndex);
296 } else {
297 napi_create_int32(env, SUCCESS, &result);
298 }
299 napi_set_element(env, result, index, resultIndex);
300 }
301 }
OHNativeBufferAllocNormal(napi_env env,napi_callback_info info)302 static napi_value OHNativeBufferAllocNormal(napi_env env, napi_callback_info info)
303 {
304 napi_value result = nullptr;
305 napi_create_array_with_length(env, NUMBER_7, &result);
306 std::vector<OH_NativeBuffer_Config> nativeBufferConfigArr = {
307 {
308 .width = 0x100,
309 .height = 0x100,
310 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
311 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
312 }, {
313 .width = 0x7FFFFFFF,
314 .height = 0x100,
315 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_5658,
316 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
317 }, {
318 .width = 0,
319 .height = 0x100,
320 .format = NATIVEBUFFER_PIXEL_FMT_BGRA_5551,
321 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
322 }, {
323 .width = 0x7FFFFFFE,
324 .height = 0x100,
325 .format = NATIVEBUFFER_PIXEL_FMT_YUV_422_I,
326 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
327 .stride = 0,
328 }, {
329 .width = 0x100,
330 .height = 0x7FFFFFFF,
331 .format = NATIVEBUFFER_PIXEL_FMT_CLUT4,
332 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
333 .stride = 1,
334 }, {
335 .width = 0x100,
336 .height = 0,
337 .format = NATIVEBUFFER_PIXEL_FMT_BGRA_8888,
338 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
339 .stride = 0x7FFFFFFF,
340 }, {
341 .width = 0x100,
342 .height = 0x7FFFFFFE,
343 .format = NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP,
344 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
345 }
346 };
347
348 nativeBufferConfigArrTest(env, result, nativeBufferConfigArr);
349 return result;
350 }
OHNativeBufferAllocAbormal(napi_env env,napi_callback_info info)351 static napi_value OHNativeBufferAllocAbormal(napi_env env, napi_callback_info info)
352 {
353 napi_value result = nullptr;
354 napi_create_array_with_length(env, NUMBER_7, &result);
355 std::vector<OH_NativeBuffer_Config> nativeBufferConfigArr = {
356 {
357 .width = - 0x100,
358 .height = 0x100,
359 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
360 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
361 }, {
362 .width = 0x100,
363 .height = 0x100,
364 .format = NATIVEBUFFER_PIXEL_FMT_BGRA_5551,
365 .usage = -1,
366 }, {
367 .width = 0x100,
368 .height = 0x100,
369 .format = -1,
370 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
371 }, {
372 .width = 0x100,
373 .height = -0x100,
374 .format = NATIVEBUFFER_PIXEL_FMT_CLUT4,
375 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
376 }, {
377 .width = 0x100,
378 .height = 0x100,
379 .format = NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP,
380 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
381 .stride = -100,
382 }
383 };
384
385 for (uint32_t index = 0; index < nativeBufferConfigArr.size(); index++) {
386 OH_NativeBuffer *ptr = OH_NativeBuffer_Alloc(&nativeBufferConfigArr[index]);
387 napi_value resultIndex = nullptr;
388 if (ptr == NULL) {
389 napi_create_int32(env, FAIL, &resultIndex);
390 } else {
391 napi_create_int32(env, SUCCESS, &result);
392 }
393 napi_set_element(env, result, index, resultIndex);
394 }
395 return result;
396 }
397
OHNativeBufferAllocMuch(napi_env env,napi_callback_info info)398 static napi_value OHNativeBufferAllocMuch(napi_env env, napi_callback_info info)
399 {
400 napi_value result = nullptr;
401 OH_NativeBuffer_Config nativeBufferConfig = {
402 .width = 0x100,
403 .height = 0x100,
404 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
405 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
406 };
407 OH_NativeBuffer *bufferArr[NUMBER_500];
408 for (uint32_t index = 0; index < NUMBER_500; index++) {
409 bufferArr[index] = OH_NativeBuffer_Alloc(&nativeBufferConfig);
410 if (bufferArr[index] == nullptr) {
411 napi_create_int32(env, FAIL, &result);
412 break;
413 } else {
414 napi_create_int32(env, SUCCESS, &result);
415 }
416 }
417 for (uint32_t index = 0; index < NUMBER_500; index++) {
418 OH_NativeBuffer_Unreference(bufferArr[index]);
419 }
420 return result;
421 }
422
OHNativeBufferFromNativeWindowBufferNullptr(napi_env env,napi_callback_info info)423 static napi_value OHNativeBufferFromNativeWindowBufferNullptr(napi_env env, napi_callback_info info)
424 {
425 napi_value result = nullptr;
426 napi_create_array_with_length(env, NUMBER_2, &result);
427 napi_value result1 = nullptr;
428 OH_NativeBuffer_Config nativeBufferConfig = {
429 .width = 0x100,
430 .height = 0x100,
431 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
432 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
433 };
434 OH_NativeBuffer *buffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
435 int32_t ret = OH_NativeBuffer_FromNativeWindowBuffer(nullptr, &buffer);
436 napi_create_int32(env, ret, &result1);
437 napi_set_element(env, result, NUMBER_0, result1);
438 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
439 GLuint textureId;
440 glGenTextures(1, &textureId);
441 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
442 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(_image);
443 int code = SET_BUFFER_GEOMETRY;
444 int32_t width_ = 0x100;
445 int32_t height_ = 0x100;
446 ret = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width_, height_);
447 code = SET_USAGE;
448 int32_t usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA;
449 ret = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, usage);
450 int fenceFd = NUMBER_MINUS_1;
451 int ret0 = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
452
453 ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, nullptr);
454 napi_create_int32(env, ret, &result1);
455 napi_set_element(env, result, NUMBER_1, result1);
456 OH_NativeBuffer_Unreference(buffer);
457 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
458 OH_NativeImage_Destroy(&_image);
459 return result;
460 }
461
462 // 失败
OHNativeBufferFromNativeWindowBufferNormal(napi_env env,napi_callback_info info)463 static napi_value OHNativeBufferFromNativeWindowBufferNormal(napi_env env, napi_callback_info info)
464 {
465 napi_value result = nullptr;
466 napi_create_array_with_length(env, NUMBER_3, &result);
467 napi_value result1 = nullptr;
468 OH_NativeBuffer *buffer = nullptr;
469 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
470
471 GLuint textureId;
472 glGenTextures(1, &textureId);
473 auto _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
474 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(_image);
475 int code = SET_BUFFER_GEOMETRY;
476 int32_t width_ = 0x100;
477 int32_t height_ = 0x100;
478 int32_t ret = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width_, height_);
479 code = SET_USAGE;
480 int32_t usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA;
481 ret = OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, usage);
482 int fenceFd = NUMBER_MINUS_1;
483 int ret0 = OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &nativeWindowBuffer, &fenceFd);
484 ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, &buffer);
485 napi_create_int32(env, ret, &result1);
486 napi_set_element(env, result, NUMBER_0, result1);
487
488 // nativeWindowBuffer和nativeBuffer是否一致 一致返回success,失败返回fail
489 if (buffer != nullptr) {
490 napi_create_int32(env, SUCCESS, &result1);
491 } else {
492 napi_create_int32(env, FAIL, &result1);
493 }
494 napi_set_element(env, result, NUMBER_1, result1);
495
496 ret = OH_NativeBuffer_FromNativeWindowBuffer(nativeWindowBuffer, &buffer);
497 napi_create_int32(env, ret, &result1);
498 napi_set_element(env, result, NUMBER_2, result1);
499 OH_NativeBuffer_Unreference(buffer);
500 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
501 OH_NativeImage_Destroy(&_image);
502 return result;
503 }
504
OHNativeBufferGetConfigNullptr(napi_env env,napi_callback_info info)505 static napi_value OHNativeBufferGetConfigNullptr(napi_env env, napi_callback_info info)
506 {
507 napi_value result = nullptr;
508
509 OH_NativeBuffer_Config *nativeBufferConfig = nullptr;
510 OH_NativeBuffer_GetConfig(nullptr, nativeBufferConfig);
511 // 怎么做判断？
512 if (nativeBufferConfig != nullptr) {
513 napi_create_int32(env, SUCCESS, &result);
514 } else {
515 napi_create_int32(env, FAIL, &result);
516 }
517
518 return result;
519 }
520
OHNativeBufferGetConfigNormal(napi_env env,napi_callback_info info)521 static napi_value OHNativeBufferGetConfigNormal(napi_env env, napi_callback_info info)
522 {
523 napi_value result = nullptr;
524 OH_NativeBuffer_Config nativeBufferConfig = {
525 .width = 0x100,
526 .height = 0x100,
527 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
528 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
529 };
530 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
531 OH_NativeBuffer_Config nativeBufferConfig2;
532 OH_NativeBuffer_GetConfig(nativeBuffer, &nativeBufferConfig2);
533
534 // 手动比较 nativeBufferConfig 和 nativeBufferConfig2 的成员
535 bool areEqual = true;
536 if (nativeBufferConfig.width != nativeBufferConfig2.width) {
537 areEqual = false;
538 } else if (nativeBufferConfig.height != nativeBufferConfig2.height) {
539 areEqual = false;
540 } else if (nativeBufferConfig.format != nativeBufferConfig2.format) {
541 areEqual = false;
542 } else if (nativeBufferConfig.usage != nativeBufferConfig2.usage) {
543 areEqual = false;
544 }
545
546 if (areEqual) {
547 napi_create_int32(env, SUCCESS, &result);
548 } else {
549 napi_create_int32(env, FAIL, &result);
550 }
551 OH_NativeBuffer_Unreference(nativeBuffer);
552 return result;
553 }
554
OHNativeBufferGetSeqNumNullptr(napi_env env,napi_callback_info info)555 static napi_value OHNativeBufferGetSeqNumNullptr(napi_env env, napi_callback_info info)
556 {
557 napi_value result = nullptr;
558 uint32_t ret = OH_NativeBuffer_GetSeqNum(nullptr);
559 napi_create_int32(env, ret, &result);
560 return result;
561 }
562
OHNativeBufferGetSeqNumNormal(napi_env env,napi_callback_info info)563 static napi_value OHNativeBufferGetSeqNumNormal(napi_env env, napi_callback_info info)
564 {
565 napi_value result = nullptr;
566 OH_NativeBuffer_Config nativeBufferConfig = {
567 .width = 0x100,
568 .height = 0x100,
569 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
570 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
571 };
572 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
573 uint32_t ret = 0;
574 ret = OH_NativeBuffer_GetSeqNum(nativeBuffer);
575 if (ret > 0 && ret != UINT_MAX) {
576 napi_create_int32(env, SUCCESS, &result);
577 } else {
578 napi_create_int32(env, FAIL, &result);
579 }
580 OH_NativeBuffer_Unreference(nativeBuffer);
581 return result;
582 }
OHNativeBuffeMapNullptr(napi_env env,napi_callback_info info)583 static napi_value OHNativeBuffeMapNullptr(napi_env env, napi_callback_info info)
584 {
585 napi_value result = nullptr;
586 uint32_t ret = OH_NativeBuffer_Map(nullptr, nullptr);
587 napi_create_int32(env, ret, &result);
588 return result;
589 }
OHNativeBufferMapNormal(napi_env env,napi_callback_info info)590 static napi_value OHNativeBufferMapNormal(napi_env env, napi_callback_info info)
591 {
592 napi_value result = nullptr;
593 //
594 OH_NativeBuffer_Config nativeBufferConfig = {
595 .width = 0x100,
596 .height = 0x100,
597 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
598 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
599 };
600 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
601 void *virAddr = nullptr;
602 uint32_t ret = OH_NativeBuffer_Map(nativeBuffer, &virAddr);
603 if (virAddr != nullptr) {
604 napi_create_int32(env, SUCCESS, &result);
605 } else {
606 napi_create_int32(env, FAIL, &result);
607 }
608 OH_NativeBuffer_Unreference(nativeBuffer);
609 return result;
610 }
OHNativeBuffeMapPlanesNullptr(napi_env env,napi_callback_info info)611 static napi_value OHNativeBuffeMapPlanesNullptr(napi_env env, napi_callback_info info)
612 {
613 napi_value result = nullptr;
614 napi_value result1 = nullptr;
615 napi_create_array_with_length(env, NUMBER_2, &result);
616 OH_NativeBuffer_Config nativeBufferConfig = {
617 .width = 0x100,
618 .height = 0x100,
619 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
620 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
621 };
622 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
623 void *virAddr = nullptr;
624 OH_NativeBuffer_Planes outPlanes;
625 int32_t ret = OH_NativeBuffer_MapPlanes(nullptr, &virAddr, &outPlanes);
626 napi_create_int32(env, ret, &result1);
627 napi_set_element(env, result, NUMBER_0, result1);
628 ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, nullptr);
629 napi_create_int32(env, ret, &result1);
630 napi_set_element(env, result, NUMBER_1, result1);
631 OH_NativeBuffer_Unreference(nativeBuffer);
632 return result;
633 }
OHNativeBufferMapPlanesAbNormal(napi_env env,napi_callback_info info)634 static napi_value OHNativeBufferMapPlanesAbNormal(napi_env env, napi_callback_info info)
635 {
636 napi_value result = nullptr;
637 napi_create_array_with_length(env, NUMBER_3, &result);
638 OH_NativeBuffer_Config nativeBufferConfig = {
639 .width = 0x100,
640 .height = 0x100,
641 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
642 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
643 };
644 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
645 void *virAddr = nullptr;
646 OH_NativeBuffer_Planes outPlanes;
647 int32_t ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, &outPlanes);
648 if (ret != NUMBER_50007000) {
649 napi_create_int32(env, NUMBER_1001, &result);
650 return result;
651 } else {
652 napi_create_int32(env, ret, &result);
653 }
654 OH_NativeBuffer_Unreference(nativeBuffer);
655 return result;
656 }
657
OHNativeBufferMapPlanesNormal(napi_env env,napi_callback_info info)658 static napi_value OHNativeBufferMapPlanesNormal(napi_env env, napi_callback_info info)
659 {
660 napi_value result = nullptr;
661 napi_create_array_with_length(env, NUMBER_3, &result);
662 OH_NativeBuffer_Format format[] = {
663 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_SP,
664 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_SP,
665 NATIVEBUFFER_PIXEL_FMT_YCBCR_420_P,
666 NATIVEBUFFER_PIXEL_FMT_YCRCB_420_P
667 };
668 for (int i = 0; i < sizeof(format) / sizeof(format[0]); i++) {
669 OH_NativeBuffer_Config nativeBufferConfig = {
670 .width = 0x100,
671 .height = 0x100,
672 .format = format[i],
673 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
674 };
675 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
676 void *virAddr = nullptr;
677 OH_NativeBuffer_Planes outPlanes;
678 int32_t ret = OH_NativeBuffer_MapPlanes(nativeBuffer, &virAddr, &outPlanes);
679 if (ret != SUCCESS) {
680 napi_create_int32(env, NUMBER_1000 * (i + 1) + NUMBER_1, &result);
681 return result;
682 } else {
683 napi_create_int32(env, SUCCESS, &result);
684 }
685 OH_NativeBuffer_Unreference(nativeBuffer);
686 }
687 return result;
688 }
OHNativeBuffeReferenceNullptr(napi_env env,napi_callback_info info)689 static napi_value OHNativeBuffeReferenceNullptr(napi_env env, napi_callback_info info)
690 {
691 napi_value result = nullptr;
692 int32_t ret = OH_NativeBuffer_Reference(nullptr);
693 napi_create_int32(env, ret, &result);
694 return result;
695 }
OHNativeBuffeUnreferenceNullptr(napi_env env,napi_callback_info info)696 static napi_value OHNativeBuffeUnreferenceNullptr(napi_env env, napi_callback_info info)
697 {
698 napi_value result = nullptr;
699 int32_t ret = OH_NativeBuffer_Unreference(nullptr);
700 napi_create_int32(env, ret, &result);
701 return result;
702 }
OHNativeBufferReferenceNormal(napi_env env,napi_callback_info info)703 static napi_value OHNativeBufferReferenceNormal(napi_env env, napi_callback_info info)
704 {
705 napi_value result = nullptr;
706 OH_NativeBuffer_Config nativeBufferConfig = {
707 .width = 0x100,
708 .height = 0x100,
709 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
710 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
711 };
712 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
713 int32_t ret = OH_NativeBuffer_Reference(nativeBuffer);
714 napi_create_int32(env, ret, &result);
715 OH_NativeBuffer_Unreference(nativeBuffer);
716 return result;
717 }
OHNativeBufferReferenceMax(napi_env env,napi_callback_info info)718 static napi_value OHNativeBufferReferenceMax(napi_env env, napi_callback_info info)
719 {
720 napi_value result = nullptr;
721 OH_NativeBuffer_Config nativeBufferConfig = {
722 .width = 0x100,
723 .height = 0x100,
724 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
725 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
726 };
727 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
728 for (uint32_t index = 0; index < NUMBER_1000; index++) {
729 int32_t ret = OH_NativeBuffer_Reference(nativeBuffer);
730 napi_create_int32(env, ret, &result);
731 if (ret != 0) {
732 break;
733 }
734 }
735 OH_NativeBuffer_Unreference(nativeBuffer);
736 return result;
737 }
OHNativeBufferUnreferenceNormal(napi_env env,napi_callback_info info)738 static napi_value OHNativeBufferUnreferenceNormal(napi_env env, napi_callback_info info)
739 {
740 napi_value result = nullptr;
741 OH_NativeBuffer_Config nativeBufferConfig = {
742 .width = 0x100,
743 .height = 0x100,
744 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
745 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
746 };
747 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
748 int32_t ret = OH_NativeBuffer_Unreference(nativeBuffer);
749 napi_create_int32(env, ret, &result);
750 OH_NativeBuffer_Unreference(nativeBuffer);
751 return result;
752 }
OHNativeBuffeUnmapNullptr(napi_env env,napi_callback_info info)753 static napi_value OHNativeBuffeUnmapNullptr(napi_env env, napi_callback_info info)
754 {
755 napi_value result = nullptr;
756 int32_t ret = OH_NativeBuffer_Unmap(nullptr);
757 napi_create_int32(env, ret, &result);
758 return result;
759 }
OHNativeBufferUnmapNormal(napi_env env,napi_callback_info info)760 static napi_value OHNativeBufferUnmapNormal(napi_env env, napi_callback_info info)
761 {
762 napi_value result = nullptr;
763 OH_NativeBuffer_Config nativeBufferConfig = {
764 .width = 0x100,
765 .height = 0x100,
766 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
767 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
768 };
769 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
770 int32_t ret = OH_NativeBuffer_Unmap(nativeBuffer);
771 napi_create_int32(env, ret, &result);
772 OH_NativeBuffer_Unreference(nativeBuffer);
773 return result;
774 }
OHNativeBufferGetColorSpaceFirst(napi_env env,napi_callback_info info)775 static napi_value OHNativeBufferGetColorSpaceFirst(napi_env env, napi_callback_info info)
776 {
777 napi_value result = nullptr;
778 OH_NativeBuffer_Config nativeBufferConfig = {
779 .width = 0x100,
780 .height = 0x100,
781 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
782 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
783 };
784 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
785 OH_NativeBuffer_ColorSpace colorSpace;
786 int32_t ret = OH_NativeBuffer_GetColorSpace(nativeBuffer, &colorSpace);
787 if (ret != NUMBER_50002000 && ret != NUMBER_50102000) {
788 napi_create_int32(env, NUMBER_1001, &result);
789 return result;
790 }
791 OH_NativeBuffer_Unreference(nativeBuffer);
792 napi_create_int32(env, SUCCESS, &result);
793 return result;
794 }
OHNativeBufferSetColorSpaceNormal(napi_env env,napi_callback_info info)795 static napi_value OHNativeBufferSetColorSpaceNormal(napi_env env, napi_callback_info info)
796 {
797 napi_value result = nullptr;
798 OH_NativeBuffer_Config nativeBufferConfig = {
799 .width = 0x100,
800 .height = 0x100,
801 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
802 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
803 };
804 for (uint32_t index = 0; index < sizeof(OH_NativeBuffer_ColorSpace); index++) {
805 OH_NativeBuffer_ColorSpace colorSpace1 = static_cast<OH_NativeBuffer_ColorSpace>(index);
806 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
807 int32_t ret = OH_NativeBuffer_SetColorSpace(nativeBuffer, colorSpace1);
808 if (ret != 0) {
809 napi_create_int32(env, NUMBER_1000 * index + NUMBER_1, &result);
810 return result;
811 }
812 OH_NativeBuffer_ColorSpace colorspace;
813 ret = OH_NativeBuffer_GetColorSpace(nativeBuffer, &colorspace);
814 if (ret != 0) {
815 napi_create_int32(env, NUMBER_1000 * index + NUMBER_2, &result);
816 return result;
817 }
818 if (colorspace != colorSpace1) {
819 napi_create_int32(env, NUMBER_1000 * index + NUMBER_3, &result);
820 return result;
821 }
822 OH_NativeBuffer_Unreference(nativeBuffer);
823 }
824 napi_create_int32(env, SUCCESS, &result);
825 return result;
826 }
827
OHNativeBufferSetColorSpaceNullptr(napi_env env,napi_callback_info info)828 static napi_value OHNativeBufferSetColorSpaceNullptr(napi_env env, napi_callback_info info)
829 {
830 napi_value result = nullptr;
831 OH_NativeBuffer_ColorSpace colorSpace = OH_NativeBuffer_ColorSpace::OH_COLORSPACE_ADOBERGB_LIMIT;
832 int32_t ret = OH_NativeBuffer_SetColorSpace(nullptr, colorSpace);
833 napi_create_int32(env, ret, &result);
834 return result;
835 }
OHNativeBufferSetColorSpaceAbnormal(napi_env env,napi_callback_info info)836 static napi_value OHNativeBufferSetColorSpaceAbnormal(napi_env env, napi_callback_info info)
837 {
838 napi_value result = nullptr;
839 OH_NativeBuffer_Config nativeBufferConfig = {
840 .width = 0x100,
841 .height = 0x100,
842 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
843 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
844 };
845 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
846 OH_NativeBuffer_ColorSpace colorSpace = (OH_NativeBuffer_ColorSpace)(-10);
847 int32_t ret = OH_NativeBuffer_SetColorSpace(nativeBuffer, colorSpace);
848 napi_create_int32(env, ret, &result);
849 OH_NativeBuffer_Unreference(nativeBuffer);
850 return result;
851 }
OHNativeBufferGetColorSpaceNullptr(napi_env env,napi_callback_info info)852 static napi_value OHNativeBufferGetColorSpaceNullptr(napi_env env, napi_callback_info info)
853 {
854 napi_value result = nullptr;
855 napi_value result1 = nullptr;
856 napi_create_array_with_length(env, NUMBER_4, &result);
857 OH_NativeBuffer_Config nativeBufferConfig = {
858 .width = 0x100,
859 .height = 0x100,
860 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
861 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
862 };
863 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
864 OH_NativeBuffer_ColorSpace colorSpace = OH_NativeBuffer_ColorSpace::OH_COLORSPACE_ADOBERGB_LIMIT;
865 int32_t ret = OH_NativeBuffer_SetColorSpace(nativeBuffer, colorSpace);
866 napi_create_int32(env, ret, &result1);
867 napi_set_element(env, result, NUMBER_0, result1);
868 ret = OH_NativeBuffer_GetColorSpace(nullptr, &colorSpace);
869 napi_create_int32(env, ret, &result1);
870 napi_set_element(env, result, NUMBER_1, result1);
871 ret = OH_NativeBuffer_GetColorSpace(nativeBuffer, nullptr);
872 napi_create_int32(env, ret, &result1);
873 napi_set_element(env, result, NUMBER_2, result1);
874 OH_NativeBuffer_ColorSpace colorSpaceGet;
875 ret = OH_NativeBuffer_GetColorSpace(nativeBuffer, &colorSpaceGet);
876 napi_create_int32(env, ret, &result1);
877 napi_set_element(env, result, NUMBER_3, result1);
878 OH_NativeBuffer_Unreference(nativeBuffer);
879 return result;
880 }
OHNativeBufferGetMetadataValueFirst(napi_env env,napi_callback_info info)881 static napi_value OHNativeBufferGetMetadataValueFirst(napi_env env, napi_callback_info info)
882 {
883 napi_value result = nullptr;
884 OH_NativeBuffer_Config nativeBufferConfig = {
885 .width = 0x100,
886 .height = 0x100,
887 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
888 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
889 };
890 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
891 OH_NativeBuffer_MetadataKey metadataKey = OH_NativeBuffer_MetadataKey::OH_HDR_DYNAMIC_METADATA;
892 int32_t size = 0;
893 uint8_t *metadata = nullptr;
894 int32_t ret = OH_NativeBuffer_GetMetadataValue(nativeBuffer, metadataKey, &size, &metadata);
895 if (ret != NUMBER_50002000 && ret != NUMBER_50102000) {
896 napi_create_int32(env, NUMBER_1001, &result);
897 return result;
898 }
899 napi_create_int32(env, SUCCESS, &result);
900 OH_NativeBuffer_Unreference(nativeBuffer);
901 return result;
902 }
903
OHNativeBufferSetDynamicMetadataValue1(napi_env env,OH_NativeBuffer * nativeBuffer)904 napi_value OHNativeBufferSetDynamicMetadataValue1(napi_env env, OH_NativeBuffer *nativeBuffer)
905 {
906 napi_value result = nullptr;
907 int32_t bufferSize;
908 uint8_t *buffer;
909 int32_t X = NUMBER_MINUS_1;
910 uint8_t metaData[NUMBER_60];
911 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData);
912 if (flag != NUMBER_40001000) {
913 napi_create_int32(env, NUMBER_1001, &result);
914 return result;
915 }
916 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
917 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
918 napi_create_int32(env, NUMBER_1002, &result);
919 return result;
920 }
921 X = 0;
922 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData);
923 if (flag != NUMBER_40001000) {
924 napi_create_int32(env, NUMBER_2001, &result);
925 return result;
926 }
927 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
928 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
929 napi_create_int32(env, NUMBER_2002, &result);
930 return result;
931 }
932 X = 1;
933 metaData[0] = static_cast<uint8_t>(0);
934 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData);
935 if (flag != 0) {
936 napi_create_int32(env, flag, &result);
937 return result;
938 }
939 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
940 if (flag != 0) {
941 napi_create_int32(env, NUMBER_3002, &result);
942 return result;
943 }
944 if (bufferSize != X) {
945 napi_create_int32(env, NUMBER_3003, &result);
946 return result;
947 }
948 delete[] buffer;
949 napi_create_int32(env, SUCCESS, &result);
950 return result;
951 }
952
OHNativeBufferSetDynamicMetadataValue2(napi_env env,OH_NativeBuffer * nativeBuffer)953 napi_value OHNativeBufferSetDynamicMetadataValue2(napi_env env, OH_NativeBuffer *nativeBuffer)
954 {
955 napi_value result = nullptr;
956 int32_t bufferSize;
957 uint8_t *buffer;
958 int32_t X = NUMBER_60;
959 uint8_t metaData[NUMBER_60];
960 for (int i = 0; i < X; ++i) {
961 metaData[i] = static_cast<uint8_t>(i);
962 }
963 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData);
964 if (flag != 0) {
965 napi_create_int32(env, NUMBER_4001, &result);
966 return result;
967 }
968 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
969 if (flag != 0) {
970 napi_create_int32(env, NUMBER_4002, &result);
971 return result;
972 }
973 if (bufferSize != X) {
974 napi_create_int32(env, NUMBER_4003, &result);
975 return result;
976 }
977 X = NUMBER_2999;
978 uint8_t metaData2[X];
979 for (int i = 0; i < X; ++i) {
980 metaData2[i] = static_cast<uint8_t>(i);
981 }
982 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData2);
983 if (flag != 0) {
984 napi_create_int32(env, NUMBER_5001, &result);
985 return result;
986 }
987 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
988 if (flag != 0) {
989 napi_create_int32(env, NUMBER_5002, &result);
990 return result;
991 }
992 if (bufferSize != X) {
993 napi_create_int32(env, NUMBER_5003, &result);
994 return result;
995 }
996 delete[] buffer;
997 napi_create_int32(env, SUCCESS, &result);
998 return result;
999 }
1000
OHNativeBufferSetDynamicMetadataValue3(napi_env env,OH_NativeBuffer * nativeBuffer)1001 napi_value OHNativeBufferSetDynamicMetadataValue3(napi_env env, OH_NativeBuffer *nativeBuffer)
1002 {
1003 napi_value result = nullptr;
1004 int32_t bufferSize;
1005 uint8_t *buffer;
1006 int32_t X = NUMBER_3000;
1007 uint8_t metaData[NUMBER_60];
1008 uint8_t metaData3[X];
1009 for (int i = 0; i < X; ++i) {
1010 metaData3[i] = static_cast<uint8_t>(i);
1011 }
1012 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData3);
1013 if (flag != 0) {
1014 napi_create_int32(env, NUMBER_6001, &result);
1015 return result;
1016 }
1017 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1018 if (flag != 0) {
1019 napi_create_int32(env, NUMBER_6002, &result);
1020 return result;
1021 }
1022 if (bufferSize != X) {
1023 napi_create_int32(env, NUMBER_6003, &result);
1024 return result;
1025 }
1026 X = NUMBER_3001;
1027 uint8_t metaData4[X];
1028 for (int i = 0; i < X; ++i) {
1029 metaData4[i] = static_cast<uint8_t>(i);
1030 }
1031 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData4);
1032 if (flag != 0) {
1033 napi_create_int32(env, NUMBER_7001, &result);
1034 return result;
1035 }
1036 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &bufferSize, &buffer);
1037 if (flag != 0) {
1038 napi_create_int32(env, NUMBER_7002, &result);
1039 return result;
1040 }
1041 X = NUMBER_10000;
1042 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, X, metaData);
1043 if (flag == 0) {
1044 napi_create_int32(env, NUMBER_8001, &result);
1045 return result;
1046 }
1047 delete[] buffer;
1048 napi_create_int32(env, SUCCESS, &result);
1049 return result;
1050 }
1051
OHNativeBufferSetDynamicMetadataValue(napi_env env,napi_callback_info info)1052 static napi_value OHNativeBufferSetDynamicMetadataValue(napi_env env, napi_callback_info info)
1053 {
1054 napi_value result = nullptr;
1055 OH_NativeBuffer_Config nativeBufferConfig = {
1056 .width = 0x100,
1057 .height = 0x100,
1058 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1059 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1060 };
1061 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1062 OH_NativeBuffer_MetadataKey metadataKey = OH_NativeBuffer_MetadataKey::OH_HDR_DYNAMIC_METADATA;
1063
1064 result = OHNativeBufferSetDynamicMetadataValue1(env, nativeBuffer);
1065 if (result != NULL) {
1066 return result;
1067 }
1068 result = OHNativeBufferSetDynamicMetadataValue2(env, nativeBuffer);
1069 if (result != NULL) {
1070 return result;
1071 }
1072 result = OHNativeBufferSetDynamicMetadataValue3(env, nativeBuffer);
1073 if (result != NULL) {
1074 return result;
1075 }
1076
1077 OH_NativeBuffer_Unreference(nativeBuffer);
1078 napi_create_int32(env, SUCCESS, &result);
1079 return result;
1080 }
OHNativeBufferSetMetadataValueTimes(napi_env env,napi_callback_info info)1081 static napi_value OHNativeBufferSetMetadataValueTimes(napi_env env, napi_callback_info info)
1082 {
1083 napi_value result = nullptr;
1084 OH_NativeBuffer_Config nativeBufferConfig = {
1085 .width = 0x100,
1086 .height = 0x100,
1087 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1088 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1089 };
1090 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1091 OH_NativeBuffer_MetadataKey metadataKey = OH_NativeBuffer_MetadataKey::OH_HDR_DYNAMIC_METADATA;
1092 int32_t size = NUMBER_60;
1093 uint8_t metadata = NUMBER_2;
1094 for (uint32_t index = 0; index < NUMBER_50; index++) {
1095 int32_t ret = OH_NativeBuffer_SetMetadataValue(nativeBuffer, metadataKey, size, &metadata);
1096 if (ret != 0) {
1097 napi_create_int32(env, ret, &result);
1098 break;
1099 }
1100 int32_t size2 = 0;
1101 uint8_t *metadata2 = nullptr;
1102 ret = OH_NativeBuffer_GetMetadataValue(nativeBuffer, metadataKey, &size2, &metadata2);
1103 if (ret != 0) {
1104 napi_create_int32(env, ret, &result);
1105 break;
1106 }
1107 if (size != size2) {
1108 napi_create_int32(env, FAIL, &result);
1109 break;
1110 } else {
1111 napi_create_int32(env, SUCCESS, &result);
1112 }
1113 }
1114 OH_NativeBuffer_Unreference(nativeBuffer);
1115 napi_create_int32(env, SUCCESS, &result);
1116 return result;
1117 }
1118
OHNativeBufferSetStaticMetadataValue1(napi_env env,OH_NativeBuffer * nativeBuffer)1119 napi_value OHNativeBufferSetStaticMetadataValue1(napi_env env, OH_NativeBuffer *nativeBuffer)
1120 {
1121 napi_value result = nullptr;
1122 int32_t bufferSize;
1123 uint8_t *buffer;
1124 int32_t X = NUMBER_MINUS_1;
1125 uint8_t metaData[NUMBER_60];
1126 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData);
1127 if (flag != NUMBER_40001000) {
1128 napi_create_int32(env, NUMBER_1001, &result);
1129 return result;
1130 }
1131 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1132 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
1133 napi_create_int32(env, NUMBER_1002, &result);
1134 return result;
1135 }
1136 X = 0;
1137 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData);
1138 if (flag != NUMBER_40001000) {
1139 napi_create_int32(env, NUMBER_2001, &result);
1140 return result;
1141 }
1142 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1143 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
1144 napi_create_int32(env, NUMBER_2002, &result);
1145 return result;
1146 }
1147 X = 1;
1148 metaData[0] = static_cast<uint8_t>(0);
1149 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData);
1150 if (flag != 0) {
1151 napi_create_int32(env, flag, &result);
1152 return result;
1153 }
1154 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1155 if (flag != 0) {
1156 napi_create_int32(env, NUMBER_3002, &result);
1157 return result;
1158 }
1159 if (bufferSize != X) {
1160 napi_create_int32(env, NUMBER_3003, &result);
1161 return result;
1162 }
1163 delete[] buffer;
1164 napi_create_int32(env, SUCCESS, &result);
1165 return result;
1166 }
1167
OHNativeBufferSetStaticMetadataValue2(napi_env env,OH_NativeBuffer * nativeBuffer)1168 napi_value OHNativeBufferSetStaticMetadataValue2(napi_env env, OH_NativeBuffer *nativeBuffer)
1169 {
1170 napi_value result = nullptr;
1171 int32_t bufferSize;
1172 uint8_t *buffer;
1173 int32_t X = NUMBER_60;
1174 uint8_t metaData[NUMBER_60];
1175 for (int i = 0; i < X; ++i) {
1176 metaData[i] = static_cast<uint8_t>(i);
1177 }
1178 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData);
1179 if (flag != 0) {
1180 napi_create_int32(env, NUMBER_4001, &result);
1181 return result;
1182 }
1183 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1184 if (flag != 0) {
1185 napi_create_int32(env, NUMBER_4002, &result);
1186 return result;
1187 }
1188 if (bufferSize != X) {
1189 napi_create_int32(env, NUMBER_4003, &result);
1190 return result;
1191 }
1192 X = NUMBER_2999;
1193 uint8_t metaData2[X];
1194 for (int i = 0; i < X; ++i) {
1195 metaData2[i] = static_cast<uint8_t>(i);
1196 }
1197 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData2);
1198 if (flag != 0) {
1199 napi_create_int32(env, NUMBER_5001, &result);
1200 return result;
1201 }
1202 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1203 if (flag != 0) {
1204 napi_create_int32(env, NUMBER_5002, &result);
1205 return result;
1206 }
1207 if (bufferSize != X) {
1208 napi_create_int32(env, NUMBER_5003, &result);
1209 return result;
1210 }
1211 delete[] buffer;
1212 napi_create_int32(env, SUCCESS, &result);
1213 return result;
1214 }
1215
OHNativeBufferSetStaticMetadataValue3(napi_env env,OH_NativeBuffer * nativeBuffer)1216 napi_value OHNativeBufferSetStaticMetadataValue3(napi_env env, OH_NativeBuffer *nativeBuffer)
1217 {
1218 napi_value result = nullptr;
1219 int32_t bufferSize;
1220 uint8_t *buffer;
1221 int32_t X = NUMBER_3000;
1222 uint8_t metaData[NUMBER_60];
1223 uint8_t metaData3[X];
1224 for (int i = 0; i < X; ++i) {
1225 metaData3[i] = static_cast<uint8_t>(i);
1226 }
1227 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData3);
1228 if (flag != 0) {
1229 napi_create_int32(env, NUMBER_6001, &result);
1230 return result;
1231 }
1232 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1233 if (flag != 0) {
1234 napi_create_int32(env, NUMBER_6002, &result);
1235 return result;
1236 }
1237 if (bufferSize != X) {
1238 napi_create_int32(env, NUMBER_6003, &result);
1239 return result;
1240 }
1241 X = NUMBER_3001;
1242 uint8_t metaData4[X];
1243 for (int i = 0; i < X; ++i) {
1244 metaData4[i] = static_cast<uint8_t>(i);
1245 }
1246 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData4);
1247 if (flag != 0) {
1248 napi_create_int32(env, NUMBER_7001, &result);
1249 return result;
1250 }
1251 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, &bufferSize, &buffer);
1252 if (flag != 0) {
1253 napi_create_int32(env, NUMBER_7002, &result);
1254 return result;
1255 }
1256 X = NUMBER_10000;
1257 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_STATIC_METADATA, X, metaData);
1258 if (flag == 0) {
1259 napi_create_int32(env, NUMBER_8001, &result);
1260 return result;
1261 }
1262 delete[] buffer;
1263 napi_create_int32(env, SUCCESS, &result);
1264 return result;
1265 }
1266
OHNativeBufferSetStaticMetadataValue(napi_env env,napi_callback_info info)1267 static napi_value OHNativeBufferSetStaticMetadataValue(napi_env env, napi_callback_info info)
1268 {
1269 napi_value result = nullptr;
1270 napi_create_array_with_length(env, NUMBER_20, &result);
1271 OH_NativeBuffer_Config nativeBufferConfig = {
1272 .width = 0x100,
1273 .height = 0x100,
1274 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1275 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1276 };
1277 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1278 result = OHNativeBufferSetStaticMetadataValue1(env, nativeBuffer);
1279 if (result != NULL) {
1280 return result;
1281 }
1282 result = OHNativeBufferSetStaticMetadataValue2(env, nativeBuffer);
1283 if (result != NULL) {
1284 return result;
1285 }
1286 result = OHNativeBufferSetStaticMetadataValue3(env, nativeBuffer);
1287 if (result != NULL) {
1288 return result;
1289 }
1290
1291 OH_NativeBuffer_Unreference(nativeBuffer);
1292 napi_create_int32(env, SUCCESS, &result);
1293 return result;
1294 }
1295
OHNativeBufferSetMetadataValue1(napi_env env,OH_NativeBuffer * nativeBuffer)1296 napi_value OHNativeBufferSetMetadataValue1(napi_env env, OH_NativeBuffer *nativeBuffer)
1297 {
1298 napi_value result = nullptr;
1299 int32_t bufferSize;
1300 uint8_t *buffer;
1301 int32_t X = NUMBER_MINUS_1;
1302 uint8_t metaData[NUMBER_60];
1303 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData);
1304 if (flag != NUMBER_40001000) {
1305 napi_create_int32(env, NUMBER_1001, &result);
1306 return result;
1307 }
1308 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1309 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
1310 napi_create_int32(env, NUMBER_1002, &result);
1311 return result;
1312 }
1313 // 2. X=0 set调用失败 get调用失败
1314 X = 0;
1315 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData);
1316 if (flag != NUMBER_40001000) {
1317 napi_create_int32(env, NUMBER_2001, &result);
1318 return result;
1319 }
1320 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1321 if (flag != NUMBER_50002000 && flag != NUMBER_50102000) {
1322 napi_create_int32(env, NUMBER_2002, &result);
1323 return result;
1324 }
1325 // 3. X=1 set调用成功 get调用成功 两者一致
1326 X = 1;
1327 metaData[0] = static_cast<uint8_t>(X);
1328 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData);
1329 if (flag != 0) {
1330 napi_create_int32(env, flag, &result);
1331 return result;
1332 }
1333 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1334 if (flag != 0) {
1335 napi_create_int32(env, NUMBER_3002, &result);
1336 return result;
1337 }
1338 if (bufferSize != NUMBER_4) {
1339 napi_create_int32(env, NUMBER_6003, &result);
1340 return result;
1341 }
1342 delete[] buffer;
1343 napi_create_int32(env, SUCCESS, &result);
1344 return result;
1345 }
1346
OHNativeBufferSetMetadataValue2(napi_env env,OH_NativeBuffer * nativeBuffer)1347 napi_value OHNativeBufferSetMetadataValue2(napi_env env, OH_NativeBuffer *nativeBuffer)
1348 {
1349 napi_value result = nullptr;
1350 int32_t bufferSize;
1351 uint8_t *buffer;
1352 int32_t X = NUMBER_4;
1353 uint8_t metaData[NUMBER_60];
1354 // 4. X=60 set调用成功 get调用成功 两者一致
1355 for (int i = 0; i < X; ++i) {
1356 metaData[i] = static_cast<uint8_t>(i);
1357 }
1358 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData);
1359 if (flag != 0) {
1360 napi_create_int32(env, NUMBER_4001, &result);
1361 return result;
1362 }
1363 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1364 if (flag != 0) {
1365 napi_create_int32(env, NUMBER_4002, &result);
1366 return result;
1367 }
1368 if (bufferSize != NUMBER_4) {
1369 napi_create_int32(env, NUMBER_6003, &result);
1370 return result;
1371 }
1372 X = NUMBER_2999;
1373 uint8_t metaData2[X];
1374 for (int i = 0; i < X; ++i) {
1375 metaData2[i] = static_cast<uint8_t>(i);
1376 }
1377 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData2);
1378 if (flag != 0) {
1379 napi_create_int32(env, NUMBER_5001, &result);
1380 return result;
1381 }
1382 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1383 if (flag != 0) {
1384 napi_create_int32(env, NUMBER_5002, &result);
1385 return result;
1386 }
1387 if (bufferSize != NUMBER_4) {
1388 napi_create_int32(env, NUMBER_6003, &result);
1389 return result;
1390 }
1391 delete[] buffer;
1392 napi_create_int32(env, SUCCESS, &result);
1393 return result;
1394 }
1395
OHNativeBufferSetMetadataValue3(napi_env env,OH_NativeBuffer * nativeBuffer)1396 napi_value OHNativeBufferSetMetadataValue3(napi_env env, OH_NativeBuffer *nativeBuffer)
1397 {
1398 napi_value result = nullptr;
1399 int32_t bufferSize;
1400 uint8_t *buffer;
1401 int32_t X = NUMBER_3000;
1402 uint8_t metaData3[X];
1403 for (int i = 0; i < X; ++i) {
1404 metaData3[i] = static_cast<uint8_t>(i);
1405 }
1406 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData3);
1407 if (flag != 0) {
1408 napi_create_int32(env, NUMBER_6001, &result);
1409 return result;
1410 }
1411 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1412 if (flag != 0) {
1413 napi_create_int32(env, NUMBER_6002, &result);
1414 return result;
1415 }
1416 if (bufferSize != NUMBER_4) {
1417 napi_create_int32(env, NUMBER_6003, &result);
1418 return result;
1419 }
1420
1421 X = NUMBER_3001;
1422 uint8_t metaData4[X];
1423 for (int i = 0; i < X; ++i) {
1424 metaData4[i] = static_cast<uint8_t>(i);
1425 }
1426 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData4);
1427 if (flag != 0) {
1428 napi_create_int32(env, NUMBER_7001, &result);
1429 return result;
1430 }
1431 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1432 if (flag != 0) {
1433 napi_create_int32(env, NUMBER_7002, &result);
1434 return result;
1435 }
1436 delete[] buffer;
1437 napi_create_int32(env, SUCCESS, &result);
1438 return result;
1439 }
1440
OHNativeBufferSetMetadataValue4(napi_env env,OH_NativeBuffer * nativeBuffer)1441 napi_value OHNativeBufferSetMetadataValue4(napi_env env, OH_NativeBuffer *nativeBuffer)
1442 {
1443 napi_value result = nullptr;
1444 int32_t bufferSize;
1445 uint8_t *buffer;
1446 uint8_t metaData[NUMBER_60];
1447 int32_t X = NUMBER_100000000;
1448 auto flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, X, metaData);
1449 if (flag != 0) {
1450 napi_create_int32(env, NUMBER_8001, &result);
1451 return result;
1452 }
1453 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_METADATA_TYPE, &bufferSize, &buffer);
1454 if (flag != 0) {
1455 napi_create_int32(env, NUMBER_8002, &result);
1456 return result;
1457 }
1458 if (bufferSize != NUMBER_4) {
1459 napi_create_int32(env, NUMBER_8003, &result);
1460 return result;
1461 }
1462 delete[] buffer;
1463 napi_create_int32(env, SUCCESS, &result);
1464 return result;
1465 }
1466
OHNativeBufferSetMetadataValue(napi_env env,napi_callback_info info)1467 static napi_value OHNativeBufferSetMetadataValue(napi_env env, napi_callback_info info)
1468 {
1469 napi_value result = nullptr;
1470 napi_create_array_with_length(env, NUMBER_20, &result);
1471 OH_NativeBuffer_Config nativeBufferConfig = {
1472 .width = 0x100,
1473 .height = 0x100,
1474 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1475 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1476 };
1477 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1478
1479 result = OHNativeBufferSetMetadataValue1(env, nativeBuffer);
1480 if (result != NULL) {
1481 return result;
1482 }
1483 result = OHNativeBufferSetMetadataValue2(env, nativeBuffer);
1484 if (result != NULL) {
1485 return result;
1486 }
1487 result = OHNativeBufferSetMetadataValue3(env, nativeBuffer);
1488 if (result != NULL) {
1489 return result;
1490 }
1491 result = OHNativeBufferSetMetadataValue4(env, nativeBuffer);
1492 if (result != NULL) {
1493 return result;
1494 }
1495
1496 OH_NativeBuffer_Unreference(nativeBuffer);
1497 napi_create_int32(env, SUCCESS, &result);
1498 return result;
1499 }
OHNativeBufferSetNullMetadataValue(napi_env env,napi_callback_info info)1500 static napi_value OHNativeBufferSetNullMetadataValue(napi_env env, napi_callback_info info)
1501 {
1502 napi_value result = nullptr;
1503 OH_NativeBuffer_Config nativeBufferConfig = {
1504 .width = 0x100,
1505 .height = 0x100,
1506 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1507 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1508 };
1509 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1510 OH_NativeBuffer_MetadataKey metadataKey = (OH_NativeBuffer_MetadataKey)(NUMBER_MINUS_1);
1511 int32_t size = NUMBER_60;
1512 uint8_t metadata = NUMBER_2;
1513 int32_t ret = OH_NativeBuffer_SetMetadataValue(nativeBuffer, metadataKey, size, &metadata);
1514 napi_create_int32(env, ret, &result);
1515 OH_NativeBuffer_Unreference(nativeBuffer);
1516 return result;
1517 }
OHNativeBufferSetMetadataValueNullptr(napi_env env,napi_callback_info info)1518 static napi_value OHNativeBufferSetMetadataValueNullptr(napi_env env, napi_callback_info info)
1519 {
1520 napi_value result = nullptr;
1521 napi_value result1 = nullptr;
1522 napi_create_array_with_length(env, NUMBER_2, &result);
1523 OH_NativeBuffer_Config nativeBufferConfig = {
1524 .width = 0x100,
1525 .height = 0x100,
1526 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1527 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1528 };
1529 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1530 OH_NativeBuffer_MetadataKey metadataKey = OH_NativeBuffer_MetadataKey::OH_HDR_METADATA_TYPE;
1531 int32_t size = NUMBER_60;
1532 uint8_t metadata = NUMBER_2;
1533 int32_t ret = OH_NativeBuffer_SetMetadataValue(nullptr, metadataKey, size, &metadata);
1534 napi_create_int32(env, ret, &result1);
1535 napi_set_element(env, result, NUMBER_0, result1);
1536 ret = OH_NativeBuffer_SetMetadataValue(nativeBuffer, metadataKey, size, nullptr);
1537 napi_create_int32(env, ret, &result1);
1538 napi_set_element(env, result, NUMBER_1, result1);
1539 OH_NativeBuffer_Unreference(nativeBuffer);
1540 return result;
1541 }
OHNativeBufferGetMetadataValueAbnormal(napi_env env,napi_callback_info info)1542 static napi_value OHNativeBufferGetMetadataValueAbnormal(napi_env env, napi_callback_info info)
1543 {
1544 napi_value result = nullptr;
1545 napi_value result1 = nullptr;
1546 napi_create_array_with_length(env, NUMBER_2, &result);
1547 OH_NativeBuffer_Config nativeBufferConfig = {
1548 .width = 0x100,
1549 .height = 0x100,
1550 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1551 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1552 };
1553 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1554 OH_NativeBuffer_MetadataKey metadataKey = OH_NativeBuffer_MetadataKey::OH_HDR_METADATA_TYPE;
1555 int32_t size = NUMBER_60;
1556 uint8_t *metadata = nullptr;
1557 int32_t ret = OH_NativeBuffer_GetMetadataValue(nullptr, metadataKey, &size, &metadata);
1558 napi_create_int32(env, ret, &result1);
1559 napi_set_element(env, result, NUMBER_0, result1);
1560 ret = OH_NativeBuffer_GetMetadataValue(nativeBuffer, metadataKey, &size, nullptr);
1561 napi_create_int32(env, ret, &result1);
1562 napi_set_element(env, result, NUMBER_1, result1);
1563 OH_NativeBuffer_Unreference(nativeBuffer);
1564 return result;
1565 }
OHNativeBufferGetMetadataValueNullptr(napi_env env,napi_callback_info info)1566 static napi_value OHNativeBufferGetMetadataValueNullptr(napi_env env, napi_callback_info info)
1567 {
1568 napi_value result = nullptr;
1569 napi_value result1 = nullptr;
1570 napi_create_array_with_length(env, NUMBER_6, &result);
1571 OH_NativeBuffer_Config nativeBufferConfig = {
1572 .width = 0x100,
1573 .height = 0x100,
1574 .format = NATIVEBUFFER_PIXEL_FMT_RGBA_8888,
1575 .usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA,
1576 };
1577 OH_NativeBuffer *nativeBuffer = OH_NativeBuffer_Alloc(&nativeBufferConfig);
1578 int32_t flag;
1579 uint8_t *buffer = new uint8_t[NUMBER_60];
1580 int32_t ret1;
1581 uint8_t *ret2;
1582 // 1.
1583 flag = OH_NativeBuffer_SetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, NUMBER_60, buffer);
1584 if (flag != 0) {
1585 napi_create_int32(env, flag, &result);
1586 return result;
1587 }
1588 // 2.
1589 flag = OH_NativeBuffer_GetMetadataValue(nullptr, OH_HDR_DYNAMIC_METADATA, &ret1, &ret2);
1590 if (flag != NUMBER_40001000) {
1591 napi_create_int32(env, NUMBER_2, &result);
1592 return result;
1593 }
1594 // 3.
1595 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, nullptr, &ret2);
1596 if (flag != NUMBER_40001000) {
1597 napi_create_int32(env, NUMBER_3, &result);
1598 return result;
1599 }
1600 // 4.
1601 flag = OH_NativeBuffer_GetMetadataValue(nativeBuffer, OH_HDR_DYNAMIC_METADATA, &ret1, nullptr);
1602 if (flag != NUMBER_40001000) {
1603 napi_create_int32(env, NUMBER_4, &result);
1604 return result;
1605 }
1606 delete[] buffer;
1607 OH_NativeBuffer_Unreference(nativeBuffer);
1608 napi_create_int32(env, SUCCESS, &result);
1609 return result;
1610 }
1611
NativeBufferInit(napi_env env,napi_value exports)1612 napi_value NativeBufferInit(napi_env env, napi_value exports)
1613 {
1614 napi_property_descriptor desc[] = {
1615 {"oHNativeBufferAlloc", nullptr, OHNativeBufferAlloc, nullptr, nullptr, nullptr, napi_default, nullptr},
1616 {"oHNativeBufferReference", nullptr, OHNativeBufferReference, nullptr, nullptr, nullptr, napi_default, nullptr},
1617 {"oHNativeBufferUnreference", nullptr, OHNativeBufferUnreference, nullptr, nullptr, nullptr, napi_default,
1618 nullptr},
1619 {"oHNativeBufferGetConfig", nullptr, OHNativeBufferGetConfig, nullptr, nullptr, nullptr, napi_default, nullptr},
1620 {"oHNativeBufferMap", nullptr, OHNativeBufferMap, nullptr, nullptr, nullptr, napi_default, nullptr},
1621 {"oHNativeBufferUnmap", nullptr, OHNativeBufferUnmap, nullptr, nullptr, nullptr, napi_default, nullptr},
1622 {"oHNativeBufferGetSeqNum", nullptr, OHNativeBufferGetSeqNum, nullptr, nullptr, nullptr, napi_default, nullptr},
1623 {"oHNativeBufferAllocAbnormal", nullptr, OHNativeBufferAllocAbnormal, nullptr, nullptr, nullptr, napi_default,
1624 nullptr},
1625 {"oHNativeBufferReferenceAbnormal", nullptr, OHNativeBufferReferenceAbnormal, nullptr, nullptr, nullptr,
1626 napi_default, nullptr},
1627 {"oHNativeBufferUnreferenceAbnormal", nullptr, OHNativeBufferUnreferenceAbnormal, nullptr, nullptr, nullptr,
1628 napi_default, nullptr},
1629 {"oHNativeBufferMapAbnormal", nullptr, OHNativeBufferMapAbnormal, nullptr, nullptr, nullptr, napi_default,
1630 nullptr},
1631 {"oHNativeBufferUnmapAbnormal", nullptr, OHNativeBufferUnmapAbnormal, nullptr, nullptr, nullptr, napi_default,
1632 nullptr},
1633 {"oHNativeBufferGetSeqNumAbnormal", nullptr, OHNativeBufferGetSeqNumAbnormal, nullptr, nullptr, nullptr,
1634 napi_default, nullptr},
1635 {"oHNativeBufferAllocNullptr", nullptr, OHNativeBufferAllocNullptr, nullptr, nullptr, nullptr, napi_default,
1636 nullptr},
1637 {"oHNativeBufferAllocNormal", nullptr, OHNativeBufferAllocNormal, nullptr, nullptr, nullptr, napi_default,
1638 nullptr},
1639 };
1640 napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
1641 return exports;
1642 }
1643
NativeBufferInit2(napi_env env,napi_value exports)1644 napi_value NativeBufferInit2(napi_env env, napi_value exports)
1645 {
1646 napi_property_descriptor desc[] = {
1647 {"oHNativeBufferAllocAbormal", nullptr, OHNativeBufferAllocAbormal, nullptr, nullptr, nullptr, napi_default,
1648 nullptr},
1649 {"oHNativeBufferAllocMuch", nullptr, OHNativeBufferAllocMuch, nullptr, nullptr, nullptr, napi_default, nullptr},
1650 {"oHNativeBufferFromNativeWindowBufferNullptr", nullptr, OHNativeBufferFromNativeWindowBufferNullptr, nullptr,
1651 nullptr, nullptr, napi_default, nullptr},
1652 {"oHNativeBufferFromNativeWindowBufferNormal", nullptr, OHNativeBufferFromNativeWindowBufferNormal, nullptr,
1653 nullptr, nullptr, napi_default, nullptr},
1654 {"oHNativeBufferGetConfigNullptr", nullptr, OHNativeBufferGetConfigNullptr, nullptr, nullptr, nullptr,
1655 napi_default, nullptr},
1656 {"oHNativeBufferGetConfigNormal", nullptr, OHNativeBufferGetConfigNormal, nullptr, nullptr, nullptr,
1657 napi_default, nullptr},
1658 {"oHNativeBufferGetSeqNumNullptr", nullptr, OHNativeBufferGetSeqNumNullptr, nullptr, nullptr, nullptr,
1659 napi_default, nullptr},
1660 {"oHNativeBufferGetSeqNumNormal", nullptr, OHNativeBufferGetSeqNumNormal, nullptr, nullptr, nullptr,
1661 napi_default, nullptr},
1662 {"oHNativeBuffeMapNullptr", nullptr, OHNativeBuffeMapNullptr, nullptr, nullptr, nullptr, napi_default, nullptr},
1663 {"oHNativeBufferMapNormal", nullptr, OHNativeBufferMapNormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1664 {"oHNativeBuffeMapPlanesNullptr", nullptr, OHNativeBuffeMapPlanesNullptr, nullptr, nullptr, nullptr,
1665 napi_default, nullptr},
1666 {"oHNativeBufferMapPlanesAbNormal", nullptr, OHNativeBufferMapPlanesAbNormal, nullptr, nullptr, nullptr,
1667 napi_default, nullptr},
1668 {"oHNativeBufferMapPlanesNormal", nullptr, OHNativeBufferMapPlanesNormal, nullptr, nullptr, nullptr,
1669 napi_default, nullptr},
1670 {"oHNativeBuffeReferenceNullptr", nullptr, OHNativeBuffeReferenceNullptr, nullptr, nullptr, nullptr,
1671 napi_default, nullptr},
1672 {"oHNativeBuffeUnreferenceNullptr", nullptr, OHNativeBuffeUnreferenceNullptr, nullptr, nullptr, nullptr,
1673 napi_default, nullptr},
1674 {"oHNativeBufferReferenceNormal", nullptr, OHNativeBufferReferenceNormal, nullptr, nullptr, nullptr,
1675 napi_default, nullptr},
1676 {"oHNativeBufferReferenceMax", nullptr, OHNativeBufferReferenceMax, nullptr, nullptr, nullptr, napi_default,
1677 nullptr},
1678 {"oHNativeBufferUnreferenceNormal", nullptr, OHNativeBufferUnreferenceNormal, nullptr, nullptr, nullptr,
1679 napi_default, nullptr},
1680 };
1681 napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
1682 return exports;
1683 }
1684
1685 EXTERN_C_START
Init(napi_env env,napi_value exports)1686 static napi_value Init(napi_env env, napi_value exports)
1687 {
1688 NativeBufferInit(env, exports);
1689 NativeBufferInit2(env, exports);
1690 napi_property_descriptor desc[] = {
1691 {"oHNativeBuffeUnmapNullptr", nullptr, OHNativeBuffeUnmapNullptr, nullptr, nullptr, nullptr, napi_default,
1692 nullptr},
1693 {"oHNativeBufferUnmapNormal", nullptr, OHNativeBufferUnmapNormal, nullptr, nullptr, nullptr, napi_default,
1694 nullptr},
1695 {"oHNativeBufferGetColorSpaceFirst", nullptr, OHNativeBufferGetColorSpaceFirst, nullptr, nullptr, nullptr,
1696 napi_default, nullptr},
1697 {"oHNativeBufferSetColorSpaceNormal", nullptr, OHNativeBufferSetColorSpaceNormal, nullptr, nullptr, nullptr,
1698 napi_default, nullptr},
1699 {"oHNativeBufferSetColorSpaceNullptr", nullptr, OHNativeBufferSetColorSpaceNullptr, nullptr, nullptr, nullptr,
1700 napi_default, nullptr},
1701 {"oHNativeBufferSetColorSpaceAbnormal", nullptr, OHNativeBufferSetColorSpaceAbnormal, nullptr, nullptr, nullptr,
1702 napi_default, nullptr},
1703 {"oHNativeBufferGetColorSpaceNullptr", nullptr, OHNativeBufferGetColorSpaceNullptr, nullptr, nullptr, nullptr,
1704 napi_default, nullptr},
1705 {"oHNativeBufferGetMetadataValueFirst", nullptr, OHNativeBufferGetMetadataValueFirst, nullptr, nullptr, nullptr,
1706 napi_default, nullptr},
1707 {"oHNativeBufferSetDynamicMetadataValue", nullptr, OHNativeBufferSetDynamicMetadataValue, nullptr, nullptr,
1708 nullptr, napi_default, nullptr},
1709 {"oHNativeBufferSetMetadataValueTimes", nullptr, OHNativeBufferSetMetadataValueTimes, nullptr, nullptr, nullptr,
1710 napi_default, nullptr},
1711 {"oHNativeBufferSetStaticMetadataValue", nullptr, OHNativeBufferSetStaticMetadataValue, nullptr, nullptr,
1712 nullptr, napi_default, nullptr},
1713 {"oHNativeBufferSetMetadataValue", nullptr, OHNativeBufferSetMetadataValue, nullptr, nullptr, nullptr,
1714 napi_default, nullptr},
1715 {"oHNativeBufferSetNullMetadataValue", nullptr, OHNativeBufferSetNullMetadataValue, nullptr, nullptr, nullptr,
1716 napi_default, nullptr},
1717 {"oHNativeBufferSetMetadataValueNullptr", nullptr, OHNativeBufferSetMetadataValueNullptr, nullptr, nullptr,
1718 nullptr, napi_default, nullptr},
1719 {"oHNativeBufferGetMetadataValueAbnormal", nullptr, OHNativeBufferGetMetadataValueAbnormal, nullptr, nullptr,
1720 nullptr, napi_default, nullptr},
1721 {"oHNativeBufferGetMetadataValueNullptr", nullptr, OHNativeBufferGetMetadataValueNullptr, nullptr, nullptr,
1722 nullptr, napi_default, nullptr},
1723 };
1724 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1725 return exports;
1726 }
1727 EXTERN_C_END
1728
1729 static napi_module demoModule = {
1730 .nm_version = 1,
1731 .nm_flags = 0,
1732 .nm_filename = nullptr,
1733 .nm_register_func = Init,
1734 .nm_modname = "nativebuffer",
1735 .nm_priv = ((void *)0),
1736 .reserved = {0},
1737 };
1738
RegisterModule(void)1739 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); };
1740