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