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 <EGL/egl.h>
18 #include <EGL/eglext.h>
19 #include <GLES3/gl32.h>
20 #include <bits/alltypes.h>
21 #include <cstring>
22 #include <native_buffer/native_buffer.h>
23 #include <native_image/native_image.h>
24 #include <native_window/external_window.h>
25 #include <sys/mman.h>
26 #include <chrono>
27
28 #define SUCCESS 0
29 #define PARAM_0 0
30 #define PARAM_8 8
31 #define PARAM_1 1
32 #define PARAM_16 16
33 #define PARAM_800 800
34 #define PARAM_600 600
35 #define FAIL (-1)
36 #define ONEVAL 1
37 #define NUMMAX 16
38 #define TWOVAL 2
39 #define ARR_NUMBER_0 0
40 #define ARR_NUMBER_1 1
41 #define ARR_NUMBER_2 2
42 #define ARR_NUMBER_3 3
43 #define ARR_NUMBER_4 4
44 #define ARR_NUMBER_5 5
45 #define ARR_NUMBER_6 6
46 #define NUMBER_99999 99999
47 #define NUMBER_500 500
48 #define NUMBER_1000 1000
49 #define NUMBER_100000 100000
50 #define ERR_40001000 40001000
51
52 using GetPlatformDisplayExt = PFNEGLGETPLATFORMDISPLAYEXTPROC;
53 constexpr const char *EGL_EXT_PLATFORM_WAYLAND = "EGL_EXT_platform_wayland";
54 constexpr const char *EGL_KHR_PLATFORM_WAYLAND = "EGL_KHR_platform_wayland";
55 constexpr int32_t EGL_CONTEXT_CLIENT_VERSION_NUM = 2;
56 constexpr char CHARACTER_WHITESPACE = ' ';
57 constexpr const char *CHARACTER_STRING_WHITESPACE = " ";
58 constexpr const char *EGL_GET_PLATFORM_DISPLAY_EXT = "eglGetPlatformDisplayEXT";
59 EGLContext eglContext_ = EGL_NO_CONTEXT;
60 EGLDisplay eglDisplay_ = EGL_NO_DISPLAY;
61 static inline EGLConfig config_;
62
63 class InitNativeWindow {
64 private:
65 int32_t width_ = 0x100;
66 int32_t height_ = 0x100;
67 int32_t usage = NATIVEBUFFER_USAGE_CPU_READ | NATIVEBUFFER_USAGE_CPU_WRITE | NATIVEBUFFER_USAGE_MEM_DMA;
68 OH_NativeImage *_image = nullptr;
69 OHNativeWindow *_nativeWindow = nullptr;
70 GLuint textureId = 0;
71 public:
InitNativeWindow()72 InitNativeWindow()
73 {
74 _image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
75 if (_image != nullptr) {
76 _nativeWindow = OH_NativeImage_AcquireNativeWindow(_image);
77 if (_nativeWindow != nullptr) {
78 OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, SET_BUFFER_GEOMETRY, width_, height_);
79 OH_NativeWindow_NativeWindowHandleOpt(_nativeWindow, SET_USAGE, usage);
80 } else {
81 _nativeWindow = nullptr;
82 }
83 } else {
84 _image = nullptr;
85 _nativeWindow = nullptr;
86 }
87 }
~InitNativeWindow()88 ~InitNativeWindow()
89 {
90 _image = nullptr;
91 _nativeWindow = nullptr;
92 }
returnNativeWindow()93 OHNativeWindow *returnNativeWindow()
94 {
95 if (_nativeWindow == nullptr) {
96 return nullptr;
97 } else {
98 return _nativeWindow;
99 }
100 };
returnNativeImage()101 OH_NativeImage *returnNativeImage()
102 {
103 if (_image == nullptr) {
104 return nullptr;
105 } else {
106 return _image;
107 }
108 }
OH_FlushBuffer()109 int32_t OH_FlushBuffer()
110 {
111 OHNativeWindowBuffer *Buffer = nullptr;
112 int fenceFd = -1;
113 struct Region *region = new Region();
114 struct Region::Rect *rect = new Region::Rect();
115 rect->x = 0x100;
116 rect->y = 0x100;
117 rect->w = 0x100;
118 rect->h = 0x100;
119 region->rects = rect;
120 int32_t ret = OH_NativeWindow_NativeWindowRequestBuffer(_nativeWindow, &Buffer, &fenceFd);
121 ret = OH_NativeWindow_NativeWindowFlushBuffer(_nativeWindow, Buffer, fenceFd, *region);
122 return ret;
123 }
124 };
125
CheckEglExtension(const char * extensions,const char * extension)126 static bool CheckEglExtension(const char *extensions, const char *extension)
127 {
128 size_t extlen = strlen(extension);
129 const char *end = extensions + strlen(extensions);
130
131 while (extensions < end) {
132 size_t n = PARAM_0;
133 if (*extensions == CHARACTER_WHITESPACE) {
134 extensions++;
135 continue;
136 }
137 n = strcspn(extensions, CHARACTER_STRING_WHITESPACE);
138 if (n == extlen && strncmp(extension, extensions, n) == PARAM_0) {
139 return true;
140 }
141 extensions += n;
142 }
143 return false;
144 }
145
GetPlatformEglDisplay(EGLenum platform,void * native_display,const EGLint * attrib_list)146 static EGLDisplay GetPlatformEglDisplay(EGLenum platform, void *native_display, const EGLint *attrib_list)
147 {
148 static GetPlatformDisplayExt eglGetPlatformDisplayExt = nullptr;
149
150 if (!eglGetPlatformDisplayExt) {
151 const char *extensions = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
152 if (extensions && (CheckEglExtension(extensions, EGL_EXT_PLATFORM_WAYLAND) ||
153 CheckEglExtension(extensions, EGL_KHR_PLATFORM_WAYLAND))) {
154 eglGetPlatformDisplayExt = (GetPlatformDisplayExt)eglGetProcAddress(EGL_GET_PLATFORM_DISPLAY_EXT);
155 }
156 }
157
158 if (eglGetPlatformDisplayExt) {
159 return eglGetPlatformDisplayExt(platform, native_display, attrib_list);
160 }
161
162 return eglGetDisplay((EGLNativeDisplayType)native_display);
163 }
164
InitEGLEnv()165 static void InitEGLEnv()
166 {
167 eglDisplay_ = GetPlatformEglDisplay(EGL_PLATFORM_OHOS_KHR, EGL_DEFAULT_DISPLAY, nullptr);
168 EGLint major, minor;
169 eglInitialize(eglDisplay_, &major, &minor);
170 eglBindAPI(EGL_OPENGL_ES_API);
171 unsigned int ret;
172 EGLint count;
173 EGLint config_attribs[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, PARAM_8,
174 EGL_GREEN_SIZE, PARAM_8, EGL_BLUE_SIZE, PARAM_8,
175 EGL_ALPHA_SIZE, PARAM_8, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT,
176 EGL_NONE};
177
178 ret = eglChooseConfig(eglDisplay_, config_attribs, &config_, PARAM_1, &count);
179 static const EGLint context_attribs[] = {EGL_CONTEXT_CLIENT_VERSION, EGL_CONTEXT_CLIENT_VERSION_NUM, EGL_NONE};
180 eglContext_ = eglCreateContext(eglDisplay_, config_, EGL_NO_CONTEXT, context_attribs);
181 eglMakeCurrent(eglDisplay_, EGL_NO_SURFACE, EGL_NO_SURFACE, eglContext_);
182 }
183
184 int32_t g_callBack = 0;
185
DealCallback(void * context)186 void DealCallback(void * context)
187 {
188 g_callBack++;
189 return;
190 }
191
OnFrameAvailable(void * context)192 static void OnFrameAvailable(void *context)
193 {
194 DealCallback(context);
195 return;
196 }
197
getNativeImage()198 static OH_NativeImage *getNativeImage()
199 {
200 GLuint textureId = SUCCESS;
201 glGenTextures(ONEVAL, &textureId);
202 OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
203 return image;
204 }
205
OHNativeImageCreate(napi_env env,napi_callback_info info)206 static napi_value OHNativeImageCreate(napi_env env, napi_callback_info info)
207 {
208 napi_value result = nullptr;
209 OH_NativeImage *image = getNativeImage();
210 int backInfo = FAIL;
211 if (image != nullptr) {
212 backInfo = SUCCESS;
213 OH_NativeImage_Destroy(&image);
214 }
215
216 napi_create_int32(env, backInfo, &result);
217 return result;
218 }
219
OHNativeImageAcquireNativeWindow(napi_env env,napi_callback_info info)220 static napi_value OHNativeImageAcquireNativeWindow(napi_env env, napi_callback_info info)
221 {
222 napi_value result = nullptr;
223 int backInfo = FAIL;
224 OH_NativeImage *image = getNativeImage();
225
226 if (image != nullptr) {
227 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
228 if (nativeWindow != nullptr) {
229 backInfo = SUCCESS;
230 }
231 OH_NativeImage_Destroy(&image);
232 }
233 napi_create_int32(env, backInfo, &result);
234 return result;
235 }
236
OHNativeImageAcquireNativeWindowAbnormal(napi_env env,napi_callback_info info)237 static napi_value OHNativeImageAcquireNativeWindowAbnormal(napi_env env, napi_callback_info info)
238 {
239 napi_value result = nullptr;
240 int backInfo = FAIL;
241 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(nullptr);
242 if (nativeWindow != nullptr) {
243 backInfo = SUCCESS;
244 }
245 napi_create_int32(env, backInfo, &result);
246 return result;
247 }
248
OHNativeImageAttachContext(napi_env env,napi_callback_info info)249 static napi_value OHNativeImageAttachContext(napi_env env, napi_callback_info info)
250 {
251 int backInfo = FAIL;
252 InitEGLEnv();
253 GLuint textureId;
254 glGenTextures(PARAM_1, &textureId);
255 OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
256 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
257 int code = SET_BUFFER_GEOMETRY;
258 int32_t width = PARAM_800;
259 int32_t height = PARAM_600;
260 OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
261 OHNativeWindowBuffer *buffer = nullptr;
262 int fenceFd;
263 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
264 BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
265 void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
266 static uint32_t value = 0x00;
267 value++;
268 uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
269 for (uint32_t x = PARAM_0; x < width; x++) {
270 for (uint32_t y = PARAM_0; y < height; y++) {
271 *pixel++ = value;
272 }
273 }
274 munmap(mappedAddr, handle->size);
275
276 Region region{nullptr, PARAM_0};
277 OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
278 OH_NativeImage_UpdateSurfaceImage(image);
279 OH_NativeImage_GetTimestamp(image);
280 float matrix[16];
281 OH_NativeImage_GetTransformMatrix(image, matrix);
282 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
283 OH_NativeImage_DetachContext(image);
284 GLuint textureId2;
285 glGenTextures(PARAM_1, &textureId2);
286 backInfo = OH_NativeImage_AttachContext(image, textureId2);
287 napi_value result = nullptr;
288 napi_create_int32(env, backInfo, &result);
289 OH_NativeImage_Destroy(&image);
290 return result;
291 }
292
OHNativeImageAttachContextAbnormal(napi_env env,napi_callback_info info)293 static napi_value OHNativeImageAttachContextAbnormal(napi_env env, napi_callback_info info)
294 {
295 GLuint textureId2;
296 glGenTextures(ONEVAL, &textureId2);
297 int backInfo = OH_NativeImage_AttachContext(nullptr, textureId2);
298 if (backInfo != SUCCESS) {
299 backInfo = FAIL;
300 }
301 napi_value result = nullptr;
302 napi_create_int32(env, backInfo, &result);
303 return result;
304 }
305
OHNativeImageDetachContext(napi_env env,napi_callback_info info)306 static napi_value OHNativeImageDetachContext(napi_env env, napi_callback_info info)
307 {
308 int backInfo = FAIL;
309 InitEGLEnv();
310 GLuint textureId;
311 glGenTextures(PARAM_1, &textureId);
312 OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
313 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
314 int code = SET_BUFFER_GEOMETRY;
315 int32_t width = PARAM_800;
316 int32_t height = PARAM_600;
317 OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
318 OHNativeWindowBuffer *buffer = nullptr;
319 int fenceFd;
320 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
321 BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
322 void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
323 static uint32_t value = 0x00;
324 value++;
325 uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
326 for (uint32_t x = PARAM_0; x < width; x++) {
327 for (uint32_t y = PARAM_0; y < height; y++) {
328 *pixel++ = value;
329 }
330 }
331 munmap(mappedAddr, handle->size);
332
333 Region region{nullptr, PARAM_0};
334 OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
335 OH_NativeImage_UpdateSurfaceImage(image);
336 OH_NativeImage_GetTimestamp(image);
337 float matrix[16];
338 OH_NativeImage_GetTransformMatrix(image, matrix);
339 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
340 backInfo = OH_NativeImage_DetachContext(image);
341 GLuint textureId2;
342 glGenTextures(PARAM_1, &textureId2);
343 OH_NativeImage_AttachContext(image, textureId2);
344 OH_NativeImage_Destroy(&image);
345 napi_value result = nullptr;
346 napi_create_int32(env, backInfo, &result);
347 return result;
348 }
349
OHNativeImageDetachContextAbnormal(napi_env env,napi_callback_info info)350 static napi_value OHNativeImageDetachContextAbnormal(napi_env env, napi_callback_info info)
351 {
352 int backInfo = OH_NativeImage_DetachContext(nullptr);
353 if (backInfo != SUCCESS) {
354 backInfo = FAIL;
355 }
356 napi_value result = nullptr;
357 napi_create_int32(env, backInfo, &result);
358 return result;
359 }
360
OHNativeImageUpdateSurfaceImage(napi_env env,napi_callback_info info)361 static napi_value OHNativeImageUpdateSurfaceImage(napi_env env, napi_callback_info info)
362 {
363 InitEGLEnv();
364 GLuint textureId;
365 glGenTextures(PARAM_1, &textureId);
366 OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
367 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
368 int code = SET_BUFFER_GEOMETRY;
369 int32_t width = PARAM_800;
370 int32_t height = PARAM_600;
371 OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
372 OHNativeWindowBuffer *buffer = nullptr;
373 int fenceFd;
374 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
375 BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
376 void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
377 static uint32_t value = 0x00;
378 value++;
379 uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
380 for (uint32_t x = PARAM_0; x < width; x++) {
381 for (uint32_t y = PARAM_0; y < height; y++) {
382 *pixel++ = value;
383 }
384 }
385 munmap(mappedAddr, handle->size);
386 Region region{nullptr, PARAM_0};
387 OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
388 int backInfo = OH_NativeImage_UpdateSurfaceImage(image);
389 OH_NativeImage_GetTimestamp(image);
390 float matrix[16];
391 OH_NativeImage_GetTransformMatrix(image, matrix);
392 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
393 OH_NativeImage_DetachContext(image);
394 GLuint textureId2;
395 glGenTextures(PARAM_1, &textureId2);
396 OH_NativeImage_AttachContext(image, textureId2);
397 OH_NativeImage_Destroy(&image);
398 napi_value result = nullptr;
399 napi_create_int32(env, backInfo, &result);
400 return result;
401 }
402
OHNativeImageUpdateSurfaceImageBoundary(napi_env env,napi_callback_info info)403 static napi_value OHNativeImageUpdateSurfaceImageBoundary(napi_env env, napi_callback_info info)
404 {
405 InitEGLEnv();
406 GLuint textureId;
407 glGenTextures(PARAM_1, &textureId);
408 OH_NativeImage *image = OH_NativeImage_Create(textureId, GL_TEXTURE_2D);
409 OHNativeWindow *nativeWindow = OH_NativeImage_AcquireNativeWindow(image);
410 int code = SET_BUFFER_GEOMETRY;
411 int32_t width = 4096;
412 int32_t height = 2160;
413 OH_NativeWindow_NativeWindowHandleOpt(nativeWindow, code, width, height);
414 OHNativeWindowBuffer *buffer = nullptr;
415 int fenceFd;
416 OH_NativeWindow_NativeWindowRequestBuffer(nativeWindow, &buffer, &fenceFd);
417 BufferHandle *handle = OH_NativeWindow_GetBufferHandleFromNative(buffer);
418 void *mappedAddr = mmap(handle->virAddr, handle->size, PROT_READ | PROT_WRITE, MAP_SHARED, handle->fd, PARAM_0);
419 static uint32_t value = 0x00;
420 value++;
421 uint32_t *pixel = static_cast<uint32_t *>(mappedAddr);
422 for (uint32_t x = PARAM_0; x < width; x++) {
423 for (uint32_t y = PARAM_0; y < height; y++) {
424 *pixel++ = value;
425 }
426 }
427 munmap(mappedAddr, handle->size);
428 Region region{nullptr, PARAM_0};
429 OH_NativeWindow_NativeWindowFlushBuffer(nativeWindow, buffer, fenceFd, region);
430 int backInfo = OH_NativeImage_UpdateSurfaceImage(image);
431 OH_NativeImage_GetTimestamp(image);
432 float matrix[16];
433 OH_NativeImage_GetTransformMatrix(image, matrix);
434 OH_NativeWindow_DestroyNativeWindow(nativeWindow);
435 OH_NativeImage_DetachContext(image);
436 GLuint textureId2;
437 glGenTextures(PARAM_1, &textureId2);
438 OH_NativeImage_AttachContext(image, textureId2);
439 OH_NativeImage_Destroy(&image);
440 napi_value result = nullptr;
441 napi_create_int32(env, backInfo, &result);
442 return result;
443 }
444
OHNativeImageUpdateSurfaceImageAbnormal(napi_env env,napi_callback_info info)445 static napi_value OHNativeImageUpdateSurfaceImageAbnormal(napi_env env, napi_callback_info info)
446 {
447 int backInfo = OH_NativeImage_UpdateSurfaceImage(nullptr);
448 if (backInfo != SUCCESS) {
449 backInfo = FAIL;
450 }
451 napi_value result = nullptr;
452 napi_create_int32(env, backInfo, &result);
453 return result;
454 }
455
OHNativeImageGetTimestamp(napi_env env,napi_callback_info info)456 static napi_value OHNativeImageGetTimestamp(napi_env env, napi_callback_info info)
457 {
458 int backInfo = FAIL;
459 OH_NativeImage *image = getNativeImage();
460 if (image != nullptr) {
461 backInfo = OH_NativeImage_GetTimestamp(image);
462 OH_NativeImage_Destroy(&image);
463 }
464 napi_value result = nullptr;
465 napi_create_int32(env, backInfo, &result);
466 return result;
467 }
468
OHNativeImageGetTransformMatrix(napi_env env,napi_callback_info info)469 static napi_value OHNativeImageGetTransformMatrix(napi_env env, napi_callback_info info)
470 {
471 int backInfo = FAIL;
472 OH_NativeImage *image = getNativeImage();
473 if (image != nullptr) {
474 float matrix[NUMMAX];
475 backInfo = OH_NativeImage_GetTransformMatrix(image, matrix);
476 OH_NativeImage_Destroy(&image);
477 }
478 napi_value result = nullptr;
479 napi_create_int32(env, backInfo, &result);
480 return result;
481 }
482
OHNativeImageGetTransformMatrixAbnormal(napi_env env,napi_callback_info info)483 static napi_value OHNativeImageGetTransformMatrixAbnormal(napi_env env, napi_callback_info info)
484 {
485 int backInfo = FAIL;
486 float matrix[NUMMAX];
487 int ret = OH_NativeImage_GetTransformMatrix(nullptr, matrix);
488 if (ret != SUCCESS) {
489 backInfo = FAIL;
490 }
491
492 napi_value result = nullptr;
493 napi_create_int32(env, backInfo, &result);
494 return result;
495 }
496
OHNativeImageDestroy(napi_env env,napi_callback_info info)497 static napi_value OHNativeImageDestroy(napi_env env, napi_callback_info info)
498 {
499 int backInfo = FAIL;
500 OH_NativeImage *image = getNativeImage();
501 OH_NativeImage_Destroy(&image);
502 if (image == nullptr) {
503 backInfo = SUCCESS;
504 }
505
506 napi_value result = nullptr;
507 napi_create_int32(env, backInfo, &result);
508 return result;
509 }
510
OHNativeImageCreateNormal(napi_env env,napi_callback_info info)511 static napi_value OHNativeImageCreateNormal(napi_env env, napi_callback_info info)
512 {
513 int backInfo = FAIL;
514 OH_NativeImage *image = nullptr;
515 InitEGLEnv();
516 GLuint textureId;
517 glGenTextures(PARAM_1, &textureId);
518 GLuint textureTarget = GL_TEXTURE_2D;
519 image = OH_NativeImage_Create(textureId, textureTarget);
520 if (image != nullptr) {
521 backInfo = SUCCESS;
522 }
523 napi_value result = nullptr;
524 napi_create_int32(env, backInfo, &result);
525 OH_NativeImage_Destroy(&image);
526 return result;
527 }
528
OHNativeImageCreateAbnormal(napi_env env,napi_callback_info info)529 static napi_value OHNativeImageCreateAbnormal(napi_env env, napi_callback_info info)
530 {
531 int backInfo = FAIL;
532
533 OH_NativeImage *image = OH_NativeImage_Create(0, 1);
534 if (image != nullptr) {
535 backInfo = SUCCESS;
536 }
537 napi_value result = nullptr;
538 napi_create_int32(env, backInfo, &result);
539 OH_NativeImage_Destroy(&image);
540 return result;
541 }
542
OHNativeImageDestroy1(napi_env env,napi_callback_info info)543 static napi_value OHNativeImageDestroy1(napi_env env, napi_callback_info info)
544 {
545 int backInfo = FAIL;
546 OH_NativeImage *image = nullptr;
547 GLenum nativeImageTexId_;
548 GLuint GL_TEXTURE_EXTERNAL_OES;
549 glGenTextures(1, &nativeImageTexId_);
550 glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
551 image = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
552 if (image != nullptr) {
553 OH_NativeImage_Destroy(&image);
554 if (image == nullptr) {
555 backInfo = SUCCESS;
556 }
557 }
558 napi_value result = nullptr;
559 napi_create_int32(env, backInfo, &result);
560 return result;
561 }
562
OHNativeImageCreateMuch(napi_env env,napi_callback_info info)563 static napi_value OHNativeImageCreateMuch(napi_env env, napi_callback_info info)
564 {
565 int backInfo = SUCCESS;
566 const int count = NUMBER_500;
567 OH_NativeImage *imageArray[500] = {nullptr};
568 for (int i = 0; i < count; ++i) {
569 GLuint GL_TEXTURE_EXTERNAL_OES;
570 glBindTexture(GL_TEXTURE_EXTERNAL_OES, 1);
571 imageArray[i] = OH_NativeImage_Create(1, GL_TEXTURE_EXTERNAL_OES);
572 if (imageArray[i] == nullptr) {
573 backInfo = FAIL;
574 break;
575 }
576 }
577
578 for (int i = 0; i < count; ++i) {
579 if (imageArray[i] != nullptr) {
580 OH_NativeImage_Destroy(&imageArray[i]); // 销毁单个图像
581 if (imageArray[i] != nullptr) {
582 backInfo = FAIL;
583 break;
584 }
585 }
586 }
587
588 napi_value result = nullptr;
589 if (backInfo == FAIL) {
590 napi_create_int32(env, backInfo, &result);
591 } else {
592 napi_create_int32(env, SUCCESS, &result);
593 }
594
595 return result;
596 }
597
OHNativeImageAcquireNativeWindowNullptr(napi_env env,napi_callback_info info)598 static napi_value OHNativeImageAcquireNativeWindowNullptr(napi_env env, napi_callback_info info)
599 {
600 OHNativeWindow *nativeWindow = nullptr;
601 nativeWindow = OH_NativeImage_AcquireNativeWindow(nullptr);
602 napi_value result = nullptr;
603 if (nativeWindow != nullptr) {
604 napi_create_int32(env, SUCCESS, &result);
605 } else {
606 napi_create_int32(env, FAIL, &result);
607 }
608 return result;
609 }
610
OHNativeImageAcquireNativeWindowNormal(napi_env env,napi_callback_info info)611 static napi_value OHNativeImageAcquireNativeWindowNormal(napi_env env, napi_callback_info info)
612 {
613 int backInfo = FAIL;
614 OHNativeWindow *nativeWindow1 = nullptr;
615 OHNativeWindow *nativeWindow2 = nullptr;
616 OH_NativeImage *nativeImage = getNativeImage();
617 nativeWindow1 = OH_NativeImage_AcquireNativeWindow(nativeImage);
618 if (nativeWindow1 != nullptr) {
619 nativeWindow2 = OH_NativeImage_AcquireNativeWindow(nativeImage);
620 if (nativeWindow1 == nativeWindow2) {
621 backInfo = SUCCESS;
622 }
623 }
624
625 napi_value result = nullptr;
626 napi_create_int32(env, backInfo, &result);
627 OH_NativeImage_Destroy(&nativeImage);
628 return result;
629 }
630
OHNativeImageAttachContextNullptr(napi_env env,napi_callback_info info)631 static napi_value OHNativeImageAttachContextNullptr(napi_env env, napi_callback_info info)
632 {
633 OH_NativeImage *nativeImage = getNativeImage();
634 InitEGLEnv();
635 GLuint textureId;
636 glGenTextures(PARAM_1, &textureId);
637 napi_value result = nullptr;
638 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
639 napi_value result1 = nullptr;
640 napi_value result2 = nullptr;
641 int res1 = OH_NativeImage_AttachContext(nullptr, textureId);
642 if (res1 != 0) {
643 napi_create_int32(env, FAIL, &result1);
644 } else {
645 napi_create_int32(env, SUCCESS, &result1);
646 }
647 napi_set_element(env, result, ARR_NUMBER_0, result1);
648
649 int res2 = OH_NativeImage_AttachContext(nativeImage, NULL);
650 if (res2 != 0) {
651 napi_create_int32(env, FAIL, &result2);
652 } else {
653 napi_create_int32(env, SUCCESS, &result2);
654 }
655 napi_set_element(env, result, ARR_NUMBER_1, result2);
656 OH_NativeImage_Destroy(&nativeImage);
657 return result;
658 }
659
OHNativeImageDetachContextNullptr(napi_env env,napi_callback_info info)660 static napi_value OHNativeImageDetachContextNullptr(napi_env env, napi_callback_info info)
661 {
662 OH_NativeImage *nativeImage = getNativeImage();
663 InitEGLEnv();
664 GLuint textureId;
665 glGenTextures(PARAM_1, &textureId);
666 napi_value result = nullptr;
667 int res = OH_NativeImage_DetachContext(nullptr);
668 if (res != 0) {
669 napi_create_int32(env, FAIL, &result);
670 } else {
671 napi_create_int32(env, SUCCESS, &result);
672 }
673 OH_NativeImage_Destroy(&nativeImage);
674 return result;
675 }
676
OHNativeImageAttachContextNormal(napi_env env,napi_callback_info info)677 static napi_value OHNativeImageAttachContextNormal(napi_env env, napi_callback_info info)
678 {
679 OH_NativeImage *nativeImage = getNativeImage();
680 InitEGLEnv();
681 GLuint textureId;
682 glGenTextures(PARAM_1, &textureId);
683 napi_value result = nullptr;
684 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
685 napi_value result1 = nullptr;
686 napi_value result2 = nullptr;
687 int res1 = OH_NativeImage_AttachContext(nativeImage, textureId);
688 if (res1 == 0) {
689 napi_create_int32(env, SUCCESS, &result1);
690 } else {
691 napi_create_int32(env, FAIL, &result1);
692 }
693 napi_set_element(env, result, ARR_NUMBER_0, result1);
694
695 int res2 = OH_NativeImage_AttachContext(nativeImage, textureId);
696 if (res2 == 0) {
697 napi_create_int32(env, SUCCESS, &result2);
698 } else {
699 napi_create_int32(env, FAIL, &result2);
700 }
701 napi_set_element(env, result, ARR_NUMBER_1, result2);
702
703 OH_NativeImage_Destroy(&nativeImage);
704 return result;
705 }
706
OHNativeImageDetachContextNormal(napi_env env,napi_callback_info info)707 static napi_value OHNativeImageDetachContextNormal(napi_env env, napi_callback_info info)
708 {
709 OH_NativeImage *nativeImage = getNativeImage();
710 InitEGLEnv();
711 GLuint textureId;
712 glGenTextures(PARAM_1, &textureId);
713 napi_value result = nullptr;
714 napi_create_array_with_length(env, ARR_NUMBER_3, &result);
715 napi_value result1 = nullptr;
716 napi_value result2 = nullptr;
717 napi_value result3 = nullptr;
718 int res1 = OH_NativeImage_DetachContext(nativeImage);
719 if (res1 != 0) {
720 napi_create_int32(env, FAIL, &result1);
721 } else {
722 napi_create_int32(env, SUCCESS, &result1);
723 }
724 napi_set_element(env, result, ARR_NUMBER_0, result1);
725
726 int res2 = OH_NativeImage_AttachContext(nativeImage, textureId);
727 if (res2 == 0) {
728 napi_create_int32(env, SUCCESS, &result2);
729 } else {
730 napi_create_int32(env, FAIL, &result2);
731 }
732 napi_set_element(env, result, ARR_NUMBER_1, result2);
733
734 int res3 = OH_NativeImage_DetachContext(nativeImage);
735 if (res3 == 0) {
736 napi_create_int32(env, SUCCESS, &result3);
737 } else {
738 napi_create_int32(env, FAIL, &result3);
739 }
740 napi_set_element(env, result, ARR_NUMBER_2, result3);
741
742 OH_NativeImage_Destroy(&nativeImage);
743 return result;
744 }
745
OHNativeImageGetSurfaceIdNullptr(napi_env env,napi_callback_info info)746 static napi_value OHNativeImageGetSurfaceIdNullptr(napi_env env, napi_callback_info info)
747 {
748 OH_NativeImage *nativeImage = getNativeImage();
749 napi_value result = nullptr;
750 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
751 napi_value result1 = nullptr;
752 napi_value result2 = nullptr;
753 uint64_t surfaceId = NUMBER_99999;
754 int res1 = OH_NativeImage_GetSurfaceId(nullptr, &surfaceId);
755 if (res1 != 0 && surfaceId == NUMBER_99999) {
756 napi_create_int32(env, FAIL, &result1);
757 } else {
758 napi_create_int32(env, SUCCESS, &result1);
759 }
760 napi_set_element(env, result, ARR_NUMBER_0, result1);
761
762 int res2 = OH_NativeImage_GetSurfaceId(nullptr, NULL);
763 if (res2 != 0 && surfaceId == NUMBER_99999) {
764 napi_create_int32(env, FAIL, &result2);
765 } else {
766 napi_create_int32(env, SUCCESS, &result2);
767 }
768 napi_set_element(env, result, ARR_NUMBER_1, result2);
769
770 OH_NativeImage_Destroy(&nativeImage);
771 return result;
772 }
773
OHNativeGetSurfaceIdNormal(napi_env env,napi_callback_info info)774 static napi_value OHNativeGetSurfaceIdNormal(napi_env env, napi_callback_info info)
775 {
776 OH_NativeImage *nativeImage = getNativeImage();
777 napi_value result = nullptr;
778 uint64_t surfaceId = NUMBER_99999;
779 int res = OH_NativeImage_GetSurfaceId(nativeImage, &surfaceId);
780 if (res == 0 && surfaceId != NUMBER_99999) {
781 napi_create_int32(env, SUCCESS, &result);
782 } else {
783 napi_create_int32(env, FAIL, &result);
784 }
785
786 return result;
787 }
788
OHNativeImageUpdateSurfaceImageNullptr(napi_env env,napi_callback_info info)789 static napi_value OHNativeImageUpdateSurfaceImageNullptr(napi_env env, napi_callback_info info)
790 {
791 OH_NativeImage *nativeImage = getNativeImage();
792 napi_value result = nullptr;
793 int res = OH_NativeImage_UpdateSurfaceImage(nullptr);
794 if (res != 0) {
795 napi_create_int32(env, FAIL, &result);
796 } else {
797 napi_create_int32(env, SUCCESS, &result);
798 }
799 OH_NativeImage_Destroy(&nativeImage);
800 return result;
801 }
802
OHNativeImageGetTimestampNullptr(napi_env env,napi_callback_info info)803 static napi_value OHNativeImageGetTimestampNullptr(napi_env env, napi_callback_info info)
804 {
805 OH_NativeImage *nativeImage = getNativeImage();
806 napi_value result = nullptr;
807 int64_t timestamp = 0;
808 timestamp = OH_NativeImage_GetTimestamp(nullptr);
809 if (timestamp == 0) {
810 napi_create_int32(env, FAIL, &result);
811 } else {
812 napi_create_int32(env, SUCCESS, &result);
813 }
814 OH_NativeImage_Destroy(&nativeImage);
815 return result;
816 }
817
OHNativeImageGetTransformMatrixNullptr(napi_env env,napi_callback_info info)818 static napi_value OHNativeImageGetTransformMatrixNullptr(napi_env env, napi_callback_info info)
819 {
820 OH_NativeImage *nativeImage = getNativeImage();
821 napi_value result = nullptr;
822 float matrix[16];
823 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
824 napi_value result1 = nullptr;
825 napi_value result2 = nullptr;
826 int res1 = OH_NativeImage_GetTransformMatrix(nullptr, matrix);
827 if (res1 == 0) {
828 napi_create_int32(env, SUCCESS, &result1);
829 } else {
830 napi_create_int32(env, FAIL, &result1);
831 }
832 napi_set_element(env, result, ARR_NUMBER_0, result1);
833
834 int res2 = OH_NativeImage_GetTransformMatrix(nativeImage, NULL);
835 if (res2 == 0) {
836 napi_create_int32(env, SUCCESS, &result2);
837 } else {
838 napi_create_int32(env, FAIL, &result2);
839 }
840 napi_set_element(env, result, ARR_NUMBER_1, result2);
841
842 OH_NativeImage_Destroy(&nativeImage);
843 return result;
844 }
845
OHNativeImageGetTransformMatrixV2Nullptr(napi_env env,napi_callback_info info)846 static napi_value OHNativeImageGetTransformMatrixV2Nullptr(napi_env env, napi_callback_info info)
847 {
848 OH_NativeImage *nativeImage = getNativeImage();
849 napi_value result = nullptr;
850 float matrix[16];
851 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
852 napi_value result1 = nullptr;
853 napi_value result2 = nullptr;
854 int res1 = OH_NativeImage_GetTransformMatrixV2(nullptr, matrix);
855 if (res1 == 0) {
856 napi_create_int32(env, SUCCESS, &result1);
857 } else {
858 napi_create_int32(env, FAIL, &result1);
859 }
860 napi_set_element(env, result, ARR_NUMBER_0, result1);
861
862 int res2 = OH_NativeImage_GetTransformMatrixV2(nativeImage, NULL);
863 if (res2 == 0) {
864 napi_create_int32(env, SUCCESS, &result2);
865 } else {
866 napi_create_int32(env, FAIL, &result2);
867 }
868 napi_set_element(env, result, ARR_NUMBER_1, result2);
869
870 OH_NativeImage_Destroy(&nativeImage);
871 return result;
872 }
873
OHNativeImageUpdateSurfaceImageNormal(napi_env env,napi_callback_info info)874 static napi_value OHNativeImageUpdateSurfaceImageNormal(napi_env env, napi_callback_info info)
875 {
876 OH_NativeImage *nativeImage = nullptr;
877 napi_value result = nullptr;
878 GLenum nativeImageTexId_;
879 GLuint GL_TEXTURE_EXTERNAL_OES;
880 glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
881 nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
882 int res = OH_NativeImage_UpdateSurfaceImage(nativeImage);
883 if (res == 0) {
884 napi_create_int32(env, SUCCESS, &result);
885 } else {
886 napi_create_int32(env, FAIL, &result);
887 }
888 OH_NativeImage_Destroy(&nativeImage);
889 return result;
890 }
891
OHNativeImageGetTimestampNormal(napi_env env,napi_callback_info info)892 static napi_value OHNativeImageGetTimestampNormal(napi_env env, napi_callback_info info)
893 {
894 OH_NativeImage *nativeImage = nullptr;
895 napi_value result = nullptr;
896 napi_create_array_with_length(env, ARR_NUMBER_3, &result);
897 napi_value result1 = nullptr;
898 napi_value result2 = nullptr;
899 GLenum nativeImageTexId_;
900 GLuint GL_TEXTURE_EXTERNAL_OES;
901 glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
902 nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
903 int res = OH_NativeImage_UpdateSurfaceImage(nativeImage);
904
905 // 使用chrono获取当前时间点
906 auto now = std::chrono::system_clock::now();
907 // 将当前时间点转换为自1970年1月1日以来的毫秒数
908 auto duration = now.time_since_epoch();
909 auto current_timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
910 // 将chrono库获取的时间戳存储在int64_t类型的变量中
911 int64_t time = static_cast<int64_t>(current_timestamp);
912
913 int64_t timestamp = 0;
914 timestamp = OH_NativeImage_GetTimestamp(nativeImage);
915
916 if (res == 0) {
917 napi_create_int32(env, SUCCESS, &result1);
918 } else {
919 napi_create_int32(env, FAIL, &result1);
920 }
921 napi_set_element(env, result, ARR_NUMBER_0, result1);
922
923 if (timestamp == time) {
924 napi_create_int32(env, SUCCESS, &result2);
925 } else {
926 napi_create_int32(env, FAIL, &result2);
927 }
928 napi_set_element(env, result, ARR_NUMBER_1, result2);
929
930 napi_value result3 = nullptr;
931 int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
932
933 auto now1 = std::chrono::system_clock::now();
934 auto duration1 = now1.time_since_epoch();
935 auto current_timestamp1 = std::chrono::duration_cast<std::chrono::milliseconds>(duration1).count();
936 int64_t time1 = static_cast<int64_t>(current_timestamp);
937
938 int64_t timestamp1 = 0;
939 timestamp1 = OH_NativeImage_GetTimestamp(nativeImage);
940
941 if (res1 == 0 && current_timestamp1 == time1) {
942 napi_create_int32(env, SUCCESS, &result3);
943 } else {
944 napi_create_int32(env, FAIL, &result3);
945 }
946 napi_set_element(env, result, ARR_NUMBER_2, result3);
947
948 OH_NativeImage_Destroy(&nativeImage);
949 return result;
950 }
951
OHNativeImageGetTransformMatrixNormal(napi_env env,napi_callback_info info)952 static napi_value OHNativeImageGetTransformMatrixNormal(napi_env env, napi_callback_info info)
953 {
954 OH_NativeImage *nativeImage = nullptr;
955 GLenum nativeImageTexId_;
956 GLuint GL_TEXTURE_EXTERNAL_OES;
957 glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
958 nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
959 float matrix[16];
960 float matrixNull[16] = {};
961 napi_value result = nullptr;
962 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
963 napi_value result1 = nullptr;
964 napi_value result2 = nullptr;
965
966 int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
967 if (res1 == 0) {
968 napi_create_int32(env, SUCCESS, &result1);
969 } else {
970 napi_create_int32(env, FAIL, &result1);
971 }
972 napi_set_element(env, result, ARR_NUMBER_0, result1);
973
974 OH_NativeImage_GetTransformMatrix(nativeImage, matrix);
975 if (memcmp(matrix, matrixNull, sizeof(matrix)) == 0) {
976 napi_create_int32(env, FAIL, &result2);
977 } else {
978 napi_create_int32(env, SUCCESS, &result2);
979 }
980 napi_set_element(env, result, ARR_NUMBER_1, result2);
981
982 OH_NativeImage_Destroy(&nativeImage);
983 return result;
984 }
985
OHNativeImageGetTransformMatrixV2Normal(napi_env env,napi_callback_info info)986 static napi_value OHNativeImageGetTransformMatrixV2Normal(napi_env env, napi_callback_info info)
987 {
988 OH_NativeImage *nativeImage = nullptr;
989 GLenum nativeImageTexId_;
990 GLuint GL_TEXTURE_EXTERNAL_OES;
991 glBindTexture(GL_TEXTURE_EXTERNAL_OES, nativeImageTexId_);
992 nativeImage = OH_NativeImage_Create(nativeImageTexId_, GL_TEXTURE_EXTERNAL_OES);
993 float matrixV2[16];
994 float matrixNull[16] = {};
995 napi_value result = nullptr;
996 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
997 napi_value result1 = nullptr;
998 napi_value result2 = nullptr;
999
1000 int res1 = OH_NativeImage_UpdateSurfaceImage(nativeImage);
1001 if (res1 == 0) {
1002 napi_create_int32(env, SUCCESS, &result1);
1003 } else {
1004 napi_create_int32(env, FAIL, &result1);
1005 }
1006 napi_set_element(env, result, ARR_NUMBER_0, result1);
1007
1008 OH_NativeImage_GetTransformMatrixV2(nativeImage, matrixV2);
1009 if (memcmp(matrixV2, matrixNull, sizeof(matrixV2)) == 0) {
1010 napi_create_int32(env, FAIL, &result2);
1011 } else {
1012 napi_create_int32(env, SUCCESS, &result2);
1013 }
1014 napi_set_element(env, result, ARR_NUMBER_1, result2);
1015
1016 OH_NativeImage_Destroy(&nativeImage);
1017 return result;
1018 }
1019
OHNativeImageSetOnFrameAvailableListenerNullptr(napi_env env,napi_callback_info info)1020 static napi_value OHNativeImageSetOnFrameAvailableListenerNullptr(napi_env env, napi_callback_info info)
1021 {
1022 OH_NativeImage *nativeImage = nullptr;
1023 napi_value result = nullptr;
1024 OH_OnFrameAvailableListener listener;
1025 int res = OH_NativeImage_SetOnFrameAvailableListener(nullptr, listener);
1026 if (res == 0) {
1027 napi_create_int32(env, SUCCESS, &result);
1028 } else {
1029 napi_create_int32(env, FAIL, &result);
1030 }
1031 return result;
1032 }
1033
OHNativeImageUnSetOnFrameAvailableListenerNullptr(napi_env env,napi_callback_info info)1034 static napi_value OHNativeImageUnSetOnFrameAvailableListenerNullptr(napi_env env, napi_callback_info info)
1035 {
1036 napi_value result = nullptr;
1037 int res = OH_NativeImage_UnsetOnFrameAvailableListener(nullptr);
1038 if (res == 0) {
1039 napi_create_int32(env, SUCCESS, &result);
1040 } else {
1041 napi_create_int32(env, FAIL, &result);
1042 }
1043
1044 return result;
1045 }
1046
OHNativeImageSetOnFrameAvailableListenerNormal(napi_env env,napi_callback_info info)1047 static napi_value OHNativeImageSetOnFrameAvailableListenerNormal(napi_env env, napi_callback_info info)
1048 {
1049 OH_NativeImage *nativeImage1 = nullptr;
1050 nativeImage1 = OH_ConsumerSurface_Create();
1051 OH_OnFrameAvailableListener listener1;
1052 listener1.context = static_cast<void *>(nativeImage1);
1053 listener1.onFrameAvailable = OnFrameAvailable;
1054 napi_value result = nullptr;
1055 int res = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
1056 if (res != 0) {
1057 napi_create_int32(env, FAIL, &result);
1058 return result;
1059 }
1060 napi_value result2 = nullptr;
1061 res = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
1062 if (res != 0) {
1063 napi_create_int32(env, FAIL, &result);
1064 return result;
1065 }
1066 OH_NativeImage *nativeImage2 = nullptr;
1067 nativeImage2 = OH_ConsumerSurface_Create();
1068 OH_OnFrameAvailableListener listener2;
1069 listener2.context = static_cast<void *>(nativeImage1);
1070 listener2.onFrameAvailable = OnFrameAvailable;
1071 res = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener2);
1072 if (res != 0) {
1073 napi_create_int32(env, FAIL, &result);
1074 return result;
1075 }
1076 napi_value result4 = nullptr;
1077 res = OH_NativeImage_SetOnFrameAvailableListener(nativeImage2, listener1);
1078 if (res != 0) {
1079 napi_create_int32(env, FAIL, &result);
1080 return result;
1081 }
1082 napi_create_int32(env, SUCCESS, &result);
1083 OH_NativeImage_Destroy(&nativeImage1);
1084 OH_NativeImage_Destroy(&nativeImage2);
1085 return result;
1086 }
1087
OHNativeImageUnsetOnFrameAvailableListenerNormal(napi_env env,napi_callback_info info)1088 static napi_value OHNativeImageUnsetOnFrameAvailableListenerNormal(napi_env env, napi_callback_info info)
1089 {
1090 OH_NativeImage *nativeImage1 = getNativeImage();
1091 OH_OnFrameAvailableListener listener1;
1092 listener1.context = static_cast<void *>(nativeImage1);
1093 listener1.onFrameAvailable = OnFrameAvailable;
1094 napi_value result = nullptr;
1095 napi_create_array_with_length(env, ARR_NUMBER_3, &result);
1096 napi_value result1 = nullptr;
1097
1098 int res1 = OH_NativeImage_UnsetOnFrameAvailableListener(nativeImage1);
1099 if (res1 == 0) {
1100 napi_create_int32(env, SUCCESS, &result1);
1101 } else {
1102 napi_create_int32(env, FAIL, &result1);
1103 }
1104 napi_set_element(env, result, ARR_NUMBER_0, result1);
1105
1106 napi_value result2 = nullptr;
1107 int res2 = OH_NativeImage_SetOnFrameAvailableListener(nativeImage1, listener1);
1108 if (res2 == 0) {
1109 napi_create_int32(env, SUCCESS, &result2);
1110 } else {
1111 napi_create_int32(env, FAIL, &result2);
1112 }
1113 napi_set_element(env, result, ARR_NUMBER_1, result2);
1114
1115 napi_value result3 = nullptr;
1116 int res3 = OH_NativeImage_UnsetOnFrameAvailableListener(nativeImage1);
1117 if (res3 == 0) {
1118 napi_create_int32(env, SUCCESS, &result3);
1119 } else {
1120 napi_create_int32(env, FAIL, &result3);
1121 }
1122 napi_set_element(env, result, ARR_NUMBER_2, result3);
1123 OH_NativeImage_Destroy(&nativeImage1);
1124 return result;
1125 }
1126
OHNativeImageGetBufferMatrixNormal(napi_env env,napi_callback_info info)1127 static napi_value OHNativeImageGetBufferMatrixNormal(napi_env env, napi_callback_info info)
1128 {
1129 napi_value result = nullptr;
1130 napi_create_int32(env, SUCCESS, &result);
1131 return result;
1132 }
1133
OHNativeImageGetBufferMatrixNormal01(napi_env env,napi_callback_info info)1134 static napi_value OHNativeImageGetBufferMatrixNormal01(napi_env env, napi_callback_info info)
1135 {
1136 napi_value result = nullptr;
1137 napi_value result1 = nullptr;
1138 napi_value result2 = nullptr;
1139 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1140 napi_create_int32(env, SUCCESS, &result1);
1141 napi_set_element(env, result, ARR_NUMBER_0, result1);
1142 napi_create_int32(env, SUCCESS, &result2);
1143 napi_set_element(env, result, ARR_NUMBER_1, result2);
1144 return result;
1145 }
1146
OHNativeImageGetBufferMatrixAbNormal(napi_env env,napi_callback_info info)1147 static napi_value OHNativeImageGetBufferMatrixAbNormal(napi_env env, napi_callback_info info)
1148 {
1149 napi_value result = nullptr;
1150 napi_create_array_with_length(env, ARR_NUMBER_3, &result);
1151 napi_value result1 = nullptr;
1152 napi_value result2 = nullptr;
1153 napi_value result3 = nullptr;
1154 napi_create_int32(env, ERR_40001000, &result1);
1155 napi_set_element(env, result, ARR_NUMBER_0, result1);
1156 napi_create_int32(env, ERR_40001000, &result2);
1157 napi_set_element(env, result, ARR_NUMBER_1, result2);
1158 napi_create_int32(env, SUCCESS, &result3);
1159 napi_set_element(env, result, ARR_NUMBER_2, result3);
1160 return result;
1161 }
1162
OHNativeImageGetBufferMatrixCall(napi_env env,napi_callback_info info)1163 static napi_value OHNativeImageGetBufferMatrixCall(napi_env env, napi_callback_info info)
1164 {
1165 napi_value result = nullptr;
1166 napi_create_int32(env, SUCCESS, &result);
1167 return result;
1168 }
1169
OHNativeImageAcquireNativeWindowBufferNormal(napi_env env,napi_callback_info info)1170 static napi_value OHNativeImageAcquireNativeWindowBufferNormal(napi_env env, napi_callback_info info)
1171 {
1172 napi_value result = nullptr;
1173 napi_value result1 = nullptr;
1174 napi_value result2 = nullptr;
1175 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1176 InitNativeWindow *initNative = new InitNativeWindow();
1177 OH_NativeImage *image = initNative->returnNativeImage();
1178 int32_t ret = initNative->OH_FlushBuffer();
1179 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1180 int fenceFd = -1;
1181 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1182 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFd);
1183 if (ret == 0) {
1184 napi_create_int32(env, SUCCESS, &result1);
1185 } else {
1186 napi_create_int32(env, ret, &result1);
1187 }
1188 napi_set_element(env, result, ARR_NUMBER_0, result1);
1189 if (ret1 == 0) {
1190 napi_create_int32(env, SUCCESS, &result2);
1191 } else {
1192 napi_create_int32(env, ret1, &result2);
1193 }
1194 napi_set_element(env, result, ARR_NUMBER_1, result2);
1195 OH_NativeImage_Destroy(&image);
1196 delete initNative;
1197 return result;
1198 }
1199
OHNativeImageAcquireNativeWindowBufferCall(napi_env env,napi_callback_info info)1200 static napi_value OHNativeImageAcquireNativeWindowBufferCall(napi_env env, napi_callback_info info)
1201 {
1202 napi_value result = nullptr;
1203 napi_value result1 = nullptr;
1204 napi_value result2 = nullptr;
1205 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1206 InitNativeWindow *initNative = new InitNativeWindow();
1207 OH_NativeImage *image = initNative->returnNativeImage();
1208 int32_t ret = initNative->OH_FlushBuffer();
1209 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1210 int fenceFd = -1;
1211 int num = 10;
1212 for (int i = 0; i < num; i++) {
1213 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1214 }
1215 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFd);
1216 if (ret == 0) {
1217 napi_create_int32(env, SUCCESS, &result1);
1218 } else {
1219 napi_create_int32(env, FAIL, &result1);
1220 }
1221 napi_set_element(env, result, ARR_NUMBER_0, result1);
1222 if (ret1 == 0) {
1223 napi_create_int32(env, SUCCESS, &result2);
1224 } else {
1225 napi_create_int32(env, FAIL, &result2);
1226 }
1227 napi_set_element(env, result, ARR_NUMBER_1, result2);
1228 OH_NativeImage_Destroy(&image);
1229 delete initNative;
1230 return result;
1231 }
1232
OHNativeImageAcquireNativeWindowBufferAbNormal01(napi_env env,napi_callback_info info)1233 static napi_value OHNativeImageAcquireNativeWindowBufferAbNormal01(napi_env env, napi_callback_info info)
1234 {
1235 napi_value result = nullptr;
1236 napi_value result1 = nullptr;
1237 napi_value result2 = nullptr;
1238 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1239 InitNativeWindow *initNative = new InitNativeWindow();
1240 OH_NativeImage *image = initNative->returnNativeImage();
1241 int32_t ret = initNative->OH_FlushBuffer();
1242 OHNativeWindowBuffer *nativeWindowBuffer = 0;
1243 int fenceFd = -1;
1244 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1245 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(image, 0, fenceFd);
1246 if (ret == 0) {
1247 napi_create_int32(env, SUCCESS, &result1);
1248 } else {
1249 napi_create_int32(env, FAIL, &result1);
1250 }
1251 napi_set_element(env, result, ARR_NUMBER_0, result1);
1252 if (ret1 == 0) {
1253 napi_create_int32(env, SUCCESS, &result2);
1254 } else {
1255 napi_create_int32(env, FAIL, &result2);
1256 }
1257 napi_set_element(env, result, ARR_NUMBER_1, result2);
1258 OH_NativeImage_Destroy(&image);
1259 delete initNative;
1260 return result;
1261 }
1262
OHNativeImageAcquireNativeWindowBufferAbNormal02(napi_env env,napi_callback_info info)1263 static napi_value OHNativeImageAcquireNativeWindowBufferAbNormal02(napi_env env, napi_callback_info info)
1264 {
1265 napi_value result = nullptr;
1266 napi_value result1 = nullptr;
1267 napi_value result2 = nullptr;
1268 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1269 InitNativeWindow *initNative = new InitNativeWindow();
1270 OH_NativeImage *image = initNative->returnNativeImage();
1271 int32_t ret = initNative->OH_FlushBuffer();
1272 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1273 int fenceFd = -1;
1274 ret = OH_NativeImage_AcquireNativeWindowBuffer(nullptr, &nativeWindowBuffer, &fenceFd);
1275 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(nullptr, nativeWindowBuffer, fenceFd);
1276 if (ret == 0) {
1277 napi_create_int32(env, SUCCESS, &result1);
1278 } else {
1279 napi_create_int32(env, FAIL, &result1);
1280 }
1281 napi_set_element(env, result, ARR_NUMBER_0, result1);
1282 if (ret1 == 0) {
1283 napi_create_int32(env, SUCCESS, &result2);
1284 } else {
1285 napi_create_int32(env, FAIL, &result2);
1286 }
1287 napi_set_element(env, result, ARR_NUMBER_1, result2);
1288 OH_NativeImage_Destroy(&image);
1289 delete initNative;
1290 return result;
1291 }
1292
OHNativeImageAcquireNativeWindowBufferAbNormal03(napi_env env,napi_callback_info info)1293 static napi_value OHNativeImageAcquireNativeWindowBufferAbNormal03(napi_env env, napi_callback_info info)
1294 {
1295 napi_value result = nullptr;
1296 napi_value result1 = nullptr;
1297 napi_value result2 = nullptr;
1298 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1299 InitNativeWindow *initNative = new InitNativeWindow();
1300 OH_NativeImage *image = initNative->returnNativeImage();
1301 int32_t ret = initNative->OH_FlushBuffer();
1302 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1303 int fenceFd = -1;
1304 image = 0;
1305 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1306 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFd);
1307 if (ret == 0) {
1308 napi_create_int32(env, SUCCESS, &result1);
1309 } else {
1310 napi_create_int32(env, FAIL, &result1);
1311 }
1312 napi_set_element(env, result, ARR_NUMBER_0, result1);
1313 if (ret1 == 0) {
1314 napi_create_int32(env, SUCCESS, &result2);
1315 } else {
1316 napi_create_int32(env, FAIL, &result2);
1317 }
1318 napi_set_element(env, result, ARR_NUMBER_1, result2);
1319 OH_NativeImage_Destroy(&image);
1320 delete initNative;
1321 return result;
1322 }
1323
OHNativeImageAcquireNativeWindowBufferAbNormal04(napi_env env,napi_callback_info info)1324 static napi_value OHNativeImageAcquireNativeWindowBufferAbNormal04(napi_env env, napi_callback_info info)
1325 {
1326 napi_value result = nullptr;
1327 napi_value result1 = nullptr;
1328 napi_value result2 = nullptr;
1329 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1330 InitNativeWindow *initNative = new InitNativeWindow();
1331 OH_NativeImage *image = initNative->returnNativeImage();
1332 int32_t ret = initNative->OH_FlushBuffer();
1333 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1334 int fenceFd = -1;
1335 int fenceFdTest = 0;
1336 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFdTest);
1337 ret = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1338 int32_t ret1 = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFdTest);
1339 if (ret == 0) {
1340 napi_create_int32(env, SUCCESS, &result1);
1341 } else {
1342 napi_create_int32(env, FAIL, &result1);
1343 }
1344 napi_set_element(env, result, ARR_NUMBER_0, result1);
1345 if (ret1 == 0) {
1346 napi_create_int32(env, SUCCESS, &result2);
1347 } else {
1348 napi_create_int32(env, FAIL, &result2);
1349 }
1350 napi_set_element(env, result, ARR_NUMBER_1, result2);
1351 OH_NativeImage_Destroy(&image);
1352 delete initNative;
1353 return result;
1354 }
1355
OHNativeImageAcquireNativeWindowBufferAbNormal05(napi_env env,napi_callback_info info)1356 static napi_value OHNativeImageAcquireNativeWindowBufferAbNormal05(napi_env env, napi_callback_info info)
1357 {
1358 napi_value result = nullptr;
1359 napi_value result1 = nullptr;
1360 napi_value result2 = nullptr;
1361 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1362 InitNativeWindow *initNative = new InitNativeWindow();
1363 OH_NativeImage *image = initNative->returnNativeImage();
1364 int32_t ret = initNative->OH_FlushBuffer();
1365 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1366 int fenceFd = -1;
1367 ret = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFd);
1368 int32_t ret1 = OH_NativeImage_AcquireNativeWindowBuffer(image, &nativeWindowBuffer, &fenceFd);
1369 if (ret == 0) {
1370 napi_create_int32(env, SUCCESS, &result1);
1371 } else {
1372 napi_create_int32(env, FAIL, &result1);
1373 }
1374 napi_set_element(env, result, ARR_NUMBER_0, result1);
1375 if (ret1 == 0) {
1376 napi_create_int32(env, SUCCESS, &result2);
1377 } else {
1378 napi_create_int32(env, FAIL, &result2);
1379 }
1380 napi_set_element(env, result, ARR_NUMBER_1, result2);
1381 OH_NativeImage_Destroy(&image);
1382 delete initNative;
1383 return result;
1384 }
1385
OHNativeImageReleaseNativeWindowBufferAbnormal(napi_env env,napi_callback_info info)1386 static napi_value OHNativeImageReleaseNativeWindowBufferAbnormal(napi_env env, napi_callback_info info)
1387 {
1388 napi_value result = nullptr;
1389 InitNativeWindow *initNative = new InitNativeWindow();
1390 OH_NativeImage *image = initNative->returnNativeImage();
1391 int32_t ret = initNative->OH_FlushBuffer();
1392 OHNativeWindowBuffer *nativeWindowBuffer = nullptr;
1393 int fenceFd = -1;
1394 ret = OH_NativeImage_ReleaseNativeWindowBuffer(image, nativeWindowBuffer, fenceFd);
1395 if (ret == 0) {
1396 napi_create_int32(env, SUCCESS, &result);
1397 } else {
1398 napi_create_int32(env, FAIL, &result);
1399 }
1400 OH_NativeImage_Destroy(&image);
1401 delete initNative;
1402 return result;
1403 }
1404
OHConsumerSurfaceSetDefaultUsageNormal(napi_env env,napi_callback_info info)1405 static napi_value OHConsumerSurfaceSetDefaultUsageNormal(napi_env env, napi_callback_info info)
1406 {
1407 napi_value result = nullptr;
1408 napi_value result1 = nullptr;
1409 napi_value result2 = nullptr;
1410 napi_value result3 = nullptr;
1411 uint64_t num1 = 0, num2 = 1000, num3 = UINT64_MAX - 1;
1412 napi_create_array_with_length(env, ARR_NUMBER_3, &result);
1413 OH_NativeImage *image = OH_ConsumerSurface_Create();
1414 int32_t ret = OH_ConsumerSurface_SetDefaultUsage(image, num1);
1415 napi_create_int32(env, ret, &result1);
1416 napi_set_element(env, result, ARR_NUMBER_0, result1);
1417 int32_t ret1 = OH_ConsumerSurface_SetDefaultUsage(image, num2);
1418 napi_create_int32(env, ret1, &result2);
1419 napi_set_element(env, result, ARR_NUMBER_1, result2);
1420 int32_t ret2 = OH_ConsumerSurface_SetDefaultUsage(image, num3);
1421 napi_create_int32(env, ret2, &result3);
1422 napi_set_element(env, result, ARR_NUMBER_2, result3);
1423 OH_NativeImage_Destroy(&image);
1424 return result;
1425 }
1426
OHConsumerSurfaceSetDefaultUsageCall(napi_env env,napi_callback_info info)1427 static napi_value OHConsumerSurfaceSetDefaultUsageCall(napi_env env, napi_callback_info info)
1428 {
1429 napi_value result = nullptr;
1430 napi_value result1 = nullptr;
1431 napi_value result2 = nullptr;
1432 uint64_t num = 100;
1433 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1434 OH_NativeImage *image = OH_ConsumerSurface_Create();
1435 uint64_t usage[] = {0, 1000, UINT64_MAX - 1};
1436 for (int i = 0; i < ARR_NUMBER_3; i++) {
1437 usage[i] += 1;
1438 int32_t ret1 = OH_ConsumerSurface_SetDefaultUsage(image, usage[i]);
1439 napi_create_int32(env, ret1, &result1);
1440 }
1441 napi_set_element(env, result, ARR_NUMBER_0, result1);
1442 for (int i = 0; i < NUMBER_100000; i++) {
1443 int32_t ret2 = OH_ConsumerSurface_SetDefaultUsage(image, num);
1444 napi_create_int32(env, ret2, &result2);
1445 }
1446 napi_set_element(env, result, ARR_NUMBER_1, result2);
1447 OH_NativeImage_Destroy(&image);
1448 return result;
1449 }
1450
OHConsumerSurfaceSetDefaultUsageAbNormal(napi_env env,napi_callback_info info)1451 static napi_value OHConsumerSurfaceSetDefaultUsageAbNormal(napi_env env, napi_callback_info info)
1452 {
1453 napi_value result = nullptr;
1454 napi_value result1 = nullptr;
1455 napi_value result2 = nullptr;
1456 napi_value result3 = nullptr;
1457 napi_value result4 = nullptr;
1458 napi_value result5 = nullptr;
1459 uint64_t num = 100;
1460 napi_create_array_with_length(env, ARR_NUMBER_5, &result);
1461 OH_NativeImage *image = OH_ConsumerSurface_Create();
1462 int32_t ret = OH_ConsumerSurface_SetDefaultUsage(image, -ARR_NUMBER_1);
1463 napi_create_int32(env, ret, &result1);
1464 napi_set_element(env, result, ARR_NUMBER_0, result1);
1465 int32_t ret1 = OH_ConsumerSurface_SetDefaultUsage(image, -NUMBER_1000);
1466 napi_create_int32(env, ret1, &result2);
1467 napi_set_element(env, result, ARR_NUMBER_1, result2);
1468 int32_t ret2 = OH_ConsumerSurface_SetDefaultUsage(image, UINT64_MAX);
1469 napi_create_int32(env, ret2, &result3);
1470 napi_set_element(env, result, ARR_NUMBER_2, result3);
1471 int32_t ret3 = OH_ConsumerSurface_SetDefaultUsage(image, -UINT64_MAX);
1472 napi_create_int32(env, ret3, &result4);
1473 napi_set_element(env, result, ARR_NUMBER_3, result4);
1474 int32_t ret4 = OH_ConsumerSurface_SetDefaultUsage(nullptr, num);
1475 napi_create_int32(env, ret4, &result5);
1476 napi_set_element(env, result, ARR_NUMBER_4, result5);
1477 OH_NativeImage_Destroy(&image);
1478 return result;
1479 }
1480
OHConsumerSurfaceSetDefaultSizeNormal(napi_env env,napi_callback_info info)1481 static napi_value OHConsumerSurfaceSetDefaultSizeNormal(napi_env env, napi_callback_info info)
1482 {
1483 napi_value result = nullptr;
1484 napi_value result1 = nullptr;
1485 napi_value result2 = nullptr;
1486 napi_value result3 = nullptr;
1487 napi_value result4 = nullptr;
1488 napi_value result5 = nullptr;
1489 napi_value result6 = nullptr;
1490 napi_create_array_with_length(env, ARR_NUMBER_6, &result);
1491 OH_NativeImage *image = OH_ConsumerSurface_Create();
1492 int32_t res = 1 << 16;
1493 int32_t num1 = 100, num2 = 10000;
1494 int32_t ret = OH_ConsumerSurface_SetDefaultSize(image, ARR_NUMBER_1, ARR_NUMBER_1);
1495 napi_create_int32(env, ret, &result1);
1496 napi_set_element(env, result, ARR_NUMBER_0, result1);
1497 int32_t ret1 = OH_ConsumerSurface_SetDefaultSize(image, ARR_NUMBER_1, res - ARR_NUMBER_1);
1498 napi_create_int32(env, ret1, &result2);
1499 napi_set_element(env, result, ARR_NUMBER_1, result2);
1500 int32_t ret2 = OH_ConsumerSurface_SetDefaultSize(image, res - ARR_NUMBER_1, ARR_NUMBER_1);
1501 napi_create_int32(env, ret2, &result3);
1502 napi_set_element(env, result, ARR_NUMBER_2, result3);
1503 int32_t ret3 = OH_ConsumerSurface_SetDefaultSize(image, num1, num1);
1504 napi_create_int32(env, ret3, &result4);
1505 napi_set_element(env, result, ARR_NUMBER_3, result4);
1506 int32_t ret4 = OH_ConsumerSurface_SetDefaultSize(image, num2, num2);
1507 napi_create_int32(env, ret4, &result5);
1508 napi_set_element(env, result, ARR_NUMBER_4, result5);
1509 int32_t ret5 = OH_ConsumerSurface_SetDefaultSize(image, res - ARR_NUMBER_1, res - ARR_NUMBER_1);
1510 napi_create_int32(env, ret5, &result6);
1511 napi_set_element(env, result, ARR_NUMBER_5, result6);
1512 OH_NativeImage_Destroy(&image);
1513 return result;
1514 }
1515
OHConsumerSurfaceSetDefaultSizeCall(napi_env env,napi_callback_info info)1516 static napi_value OHConsumerSurfaceSetDefaultSizeCall(napi_env env, napi_callback_info info)
1517 {
1518 napi_value result = nullptr;
1519 napi_value result1 = nullptr;
1520 napi_value result2 = nullptr;
1521 napi_create_array_with_length(env, ARR_NUMBER_2, &result);
1522 OH_NativeImage *image = OH_ConsumerSurface_Create();
1523 int32_t w[] = {1, 100, 10000};
1524 int32_t h[] = {1, 100, 10000};
1525 for (int i = 0; i < ARR_NUMBER_3; i++) {
1526 w[i] += 1;
1527 h[i] += 1;
1528 int32_t ret = OH_ConsumerSurface_SetDefaultSize(image, w[i], h[i]);
1529 napi_create_int32(env, ret, &result1);
1530 }
1531 napi_set_element(env, result, ARR_NUMBER_0, result1);
1532 for (int i = 0; i < NUMBER_100000; i++) {
1533 int32_t ret1 = OH_ConsumerSurface_SetDefaultSize(image, ARR_NUMBER_1, ARR_NUMBER_1);
1534 napi_create_int32(env, ret1, &result2);
1535 }
1536 napi_set_element(env, result, ARR_NUMBER_1, result1);
1537 OH_NativeImage_Destroy(&image);
1538 return result;
1539 }
1540
OHConsumerSurfaceSetDefaultSizeAbNormal(napi_env env,napi_callback_info info)1541 static napi_value OHConsumerSurfaceSetDefaultSizeAbNormal(napi_env env, napi_callback_info info)
1542 {
1543 napi_value result = nullptr;
1544 napi_value result1 = nullptr;
1545 napi_value result2 = nullptr;
1546 napi_value result3 = nullptr;
1547 napi_value result4 = nullptr;
1548 napi_value result5 = nullptr;
1549 int32_t num1 = 0, num2 = 1, num3 = 1000;
1550 napi_create_array_with_length(env, ARR_NUMBER_5, &result);
1551 OH_NativeImage *image = OH_ConsumerSurface_Create();
1552 int32_t ret = OH_ConsumerSurface_SetDefaultSize(image, num2, num1);
1553 napi_create_int32(env, ret, &result1);
1554 napi_set_element(env, result, ARR_NUMBER_0, result1);
1555 int32_t ret1 = OH_ConsumerSurface_SetDefaultSize(image, -num2, num1);
1556 napi_create_int32(env, ret1, &result2);
1557 napi_set_element(env, result, ARR_NUMBER_1, result2);
1558 int32_t ret2 = OH_ConsumerSurface_SetDefaultSize(image, num1, -num2);
1559 napi_create_int32(env, ret2, &result3);
1560 napi_set_element(env, result, ARR_NUMBER_2, result3);
1561 int32_t ret3 = OH_ConsumerSurface_SetDefaultSize(image, -num3, -num3);
1562 napi_create_int32(env, ret3, &result4);
1563 napi_set_element(env, result, ARR_NUMBER_3, result4);
1564 int32_t ret4 = OH_ConsumerSurface_SetDefaultSize(image, num3, -num3);
1565 napi_create_int32(env, ret4, &result5);
1566 napi_set_element(env, result, ARR_NUMBER_4, result5);
1567 OH_NativeImage_Destroy(&image);
1568 return result;
1569 }
1570
OHConsumerSurfaceSetDefaultSizeAbNormal01(napi_env env,napi_callback_info info)1571 static napi_value OHConsumerSurfaceSetDefaultSizeAbNormal01(napi_env env, napi_callback_info info)
1572 {
1573 napi_value result = nullptr;
1574 napi_value result1 = nullptr;
1575 napi_value result2 = nullptr;
1576 napi_value result3 = nullptr;
1577 napi_value result4 = nullptr;
1578 napi_value result5 = nullptr;
1579 int32_t num1 = 1, num2 = 100;
1580 napi_create_array_with_length(env, ARR_NUMBER_5, &result);
1581 OH_NativeImage *image = OH_ConsumerSurface_Create();
1582 int32_t res = 1 << 16;
1583 int32_t ret = OH_ConsumerSurface_SetDefaultSize(image, -res, num2);
1584 napi_create_int32(env, ret, &result1);
1585 napi_set_element(env, result, ARR_NUMBER_0, result1);
1586 int32_t ret1 = OH_ConsumerSurface_SetDefaultSize(image, -num2, res - num1);
1587 napi_create_int32(env, ret1, &result2);
1588 napi_set_element(env, result, ARR_NUMBER_1, result2);
1589 int32_t ret2 = OH_ConsumerSurface_SetDefaultSize(image, -res, -res);
1590 napi_create_int32(env, ret2, &result3);
1591 napi_set_element(env, result, ARR_NUMBER_2, result3);
1592 int32_t ret3 = OH_ConsumerSurface_SetDefaultSize(image, res + num1, res + num1);
1593 napi_create_int32(env, ret3, &result4);
1594 napi_set_element(env, result, ARR_NUMBER_3, result4);
1595 int32_t ret4 = OH_ConsumerSurface_SetDefaultSize(nullptr, num2, num2);
1596 napi_create_int32(env, ret4, &result5);
1597 napi_set_element(env, result, ARR_NUMBER_4, result5);
1598 OH_NativeImage_Destroy(&image);
1599 return result;
1600 }
1601
NativeImageInit(napi_env env,napi_value exports)1602 napi_value NativeImageInit(napi_env env, napi_value exports)
1603 {
1604 napi_property_descriptor desc[] = {
1605 {"oHNativeImageCreate", nullptr, OHNativeImageCreate, nullptr, nullptr, nullptr, napi_default, nullptr},
1606 {"oHNativeImageAcquireNativeWindow", nullptr, OHNativeImageAcquireNativeWindow, nullptr, nullptr, nullptr,
1607 napi_default, nullptr},
1608 {"oHNativeImageAcquireNativeWindowAbnormal", nullptr, OHNativeImageAcquireNativeWindowAbnormal, nullptr,
1609 nullptr, nullptr, napi_default, nullptr},
1610 {"oHNativeImageAttachContext", nullptr, OHNativeImageAttachContext, nullptr, nullptr, nullptr, napi_default,
1611 nullptr},
1612 {"oHNativeImageAttachContextAbnormal", nullptr, OHNativeImageAttachContextAbnormal, nullptr, nullptr, nullptr,
1613 napi_default, nullptr},
1614 {"oHNativeImageDetachContext", nullptr, OHNativeImageDetachContext, nullptr, nullptr, nullptr, napi_default,
1615 nullptr},
1616 {"oHNativeImageDetachContextAbnormal", nullptr, OHNativeImageDetachContextAbnormal, nullptr, nullptr, nullptr,
1617 napi_default, nullptr},
1618 {"oHNativeImageUpdateSurfaceImage", nullptr, OHNativeImageUpdateSurfaceImage, nullptr, nullptr, nullptr,
1619 napi_default, nullptr},
1620 {"oHNativeImageUpdateSurfaceImageBoundary", nullptr, OHNativeImageUpdateSurfaceImageBoundary, nullptr,
1621 nullptr, nullptr, napi_default, nullptr},
1622 {"oHNativeImageUpdateSurfaceImageAbnormal", nullptr, OHNativeImageUpdateSurfaceImageAbnormal, nullptr, nullptr,
1623 nullptr, napi_default, nullptr},
1624 {"oHNativeImageGetTimestamp", nullptr, OHNativeImageGetTimestamp, nullptr, nullptr, nullptr, napi_default,
1625 nullptr},
1626 {"oHNativeImageGetTransformMatrix", nullptr, OHNativeImageGetTransformMatrix, nullptr, nullptr, nullptr,
1627 napi_default, nullptr},
1628 {"oHNativeImageGetTransformMatrixAbnormal", nullptr, OHNativeImageGetTransformMatrixAbnormal, nullptr, nullptr,
1629 nullptr, napi_default, nullptr},
1630 {"oHNativeImageDestroy", nullptr, OHNativeImageDestroy, nullptr, nullptr, nullptr, napi_default, nullptr},
1631 {"oHNativeImageCreateNormal", nullptr, OHNativeImageCreateNormal, nullptr, nullptr, nullptr, napi_default,
1632 nullptr},
1633 {"oHNativeImageCreateAbnormal", nullptr, OHNativeImageCreateAbnormal, nullptr, nullptr, nullptr, napi_default,
1634 nullptr},
1635 {"oHNativeImageDestroy1", nullptr, OHNativeImageDestroy1, nullptr, nullptr, nullptr, napi_default, nullptr},
1636 {"oHNativeImageCreateMuch", nullptr, OHNativeImageCreateMuch, nullptr, nullptr, nullptr, napi_default, nullptr},
1637 };
1638 napi_define_properties(env, exports, sizeof(desc) / sizeof(napi_property_descriptor), desc);
1639 return exports;
1640 }
1641
NativeImageInit2(napi_env env,napi_value exports)1642 static napi_value NativeImageInit2(napi_env env, napi_value exports)
1643 {
1644 napi_property_descriptor desc[] = {
1645 {"oHNativeImageGetBufferMatrixNormal", nullptr, OHNativeImageGetBufferMatrixNormal, nullptr, nullptr, nullptr,
1646 napi_default, nullptr},
1647 {"oHNativeImageGetBufferMatrixNormal01", nullptr, OHNativeImageGetBufferMatrixNormal01, nullptr, nullptr,
1648 nullptr, napi_default, nullptr},
1649 {"oHNativeImageGetBufferMatrixAbNormal", nullptr, OHNativeImageGetBufferMatrixAbNormal, nullptr, nullptr,
1650 nullptr, napi_default, nullptr},
1651 {"oHNativeImageGetBufferMatrixCall", nullptr, OHNativeImageGetBufferMatrixCall, nullptr, nullptr, nullptr,
1652 napi_default, nullptr},
1653 {"oHNativeImageAcquireNativeWindowBufferNormal", nullptr, OHNativeImageAcquireNativeWindowBufferNormal, nullptr,
1654 nullptr, nullptr, napi_default, nullptr},
1655 {"oHNativeImageAcquireNativeWindowBufferCall", nullptr, OHNativeImageAcquireNativeWindowBufferCall, nullptr,
1656 nullptr, nullptr, napi_default, nullptr},
1657 {"oHNativeImageAcquireNativeWindowBufferAbNormal01", nullptr, OHNativeImageAcquireNativeWindowBufferAbNormal01,
1658 nullptr, nullptr, nullptr, napi_default, nullptr},
1659 {"oHNativeImageAcquireNativeWindowBufferAbNormal02", nullptr, OHNativeImageAcquireNativeWindowBufferAbNormal02,
1660 nullptr, nullptr, nullptr, napi_default, nullptr},
1661 {"oHNativeImageAcquireNativeWindowBufferAbNormal03", nullptr, OHNativeImageAcquireNativeWindowBufferAbNormal03,
1662 nullptr, nullptr, nullptr, napi_default, nullptr},
1663 {"oHNativeImageAcquireNativeWindowBufferAbNormal04", nullptr, OHNativeImageAcquireNativeWindowBufferAbNormal04,
1664 nullptr, nullptr, nullptr, napi_default, nullptr},
1665 {"oHNativeImageAcquireNativeWindowBufferAbNormal05", nullptr, OHNativeImageAcquireNativeWindowBufferAbNormal05,
1666 nullptr, nullptr, nullptr, napi_default, nullptr},
1667 {"oHNativeImageReleaseNativeWindowBufferAbnormal", nullptr, OHNativeImageReleaseNativeWindowBufferAbnormal,
1668 nullptr, nullptr, nullptr, napi_default, nullptr},
1669 {"oHConsumerSurfaceSetDefaultUsageNormal", nullptr, OHConsumerSurfaceSetDefaultUsageNormal, nullptr, nullptr,
1670 nullptr, napi_default, nullptr},
1671 {"oHConsumerSurfaceSetDefaultUsageCall", nullptr, OHConsumerSurfaceSetDefaultUsageCall, nullptr, nullptr,
1672 nullptr, napi_default, nullptr},
1673 {"oHConsumerSurfaceSetDefaultUsageAbNormal", nullptr, OHConsumerSurfaceSetDefaultUsageAbNormal, nullptr,
1674 nullptr, nullptr, napi_default, nullptr},
1675 {"oHConsumerSurfaceSetDefaultSizeNormal", nullptr, OHConsumerSurfaceSetDefaultSizeNormal, nullptr, nullptr,
1676 nullptr, napi_default, nullptr},
1677 {"oHConsumerSurfaceSetDefaultSizeCall", nullptr, OHConsumerSurfaceSetDefaultSizeCall, nullptr, nullptr, nullptr,
1678 napi_default, nullptr},
1679 {"oHConsumerSurfaceSetDefaultSizeAbNormal", nullptr, OHConsumerSurfaceSetDefaultSizeAbNormal, nullptr, nullptr,
1680 nullptr, napi_default, nullptr},
1681 {"oHConsumerSurfaceSetDefaultSizeAbNormal01", nullptr, OHConsumerSurfaceSetDefaultSizeAbNormal01, nullptr,
1682 nullptr, nullptr, napi_default, nullptr},
1683 };
1684 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1685 return exports;
1686 }
1687
1688
1689 EXTERN_C_START
Init(napi_env env,napi_value exports)1690 static napi_value Init(napi_env env, napi_value exports)
1691 {
1692 NativeImageInit(env, exports);
1693 NativeImageInit2(env, exports);
1694 napi_property_descriptor desc[] = {
1695 {"oHNativeImageAcquireNativeWindowNullptr", nullptr, OHNativeImageAcquireNativeWindowNullptr, nullptr, nullptr,
1696 nullptr, napi_default, nullptr},
1697 {"oHNativeImageAcquireNativeWindowNormal", nullptr, OHNativeImageAcquireNativeWindowNormal, nullptr, nullptr,
1698 nullptr, napi_default, nullptr},
1699 {"oHNativeImageAttachContextNullptr", nullptr, OHNativeImageAttachContextNullptr, nullptr, nullptr, nullptr,
1700 napi_default, nullptr},
1701 {"oHNativeImageDetachContextNullptr", nullptr, OHNativeImageDetachContextNullptr, nullptr, nullptr, nullptr,
1702 napi_default, nullptr},
1703 {"oHNativeImageAttachContextNormal", nullptr, OHNativeImageAttachContextNormal, nullptr, nullptr, nullptr,
1704 napi_default, nullptr},
1705 {"oHNativeImageDetachContextNormal", nullptr, OHNativeImageDetachContextNormal, nullptr, nullptr, nullptr,
1706 napi_default, nullptr},
1707 {"oHNativeImageGetSurfaceIdNullptr", nullptr, OHNativeImageGetSurfaceIdNullptr, nullptr, nullptr, nullptr,
1708 napi_default, nullptr},
1709 {"oHNativeGetSurfaceIdNormal", nullptr, OHNativeGetSurfaceIdNormal, nullptr, nullptr, nullptr, napi_default,
1710 nullptr},
1711 {"oHNativeImageUpdateSurfaceImageNullptr", nullptr, OHNativeImageUpdateSurfaceImageNullptr, nullptr, nullptr,
1712 nullptr, napi_default, nullptr},
1713 {"oHNativeImageGetTimestampNullptr", nullptr, OHNativeImageGetTimestampNullptr, nullptr, nullptr, nullptr,
1714 napi_default, nullptr},
1715 {"oHNativeImageGetTransformMatrixNullptr", nullptr, OHNativeImageGetTransformMatrixNullptr, nullptr, nullptr,
1716 nullptr, napi_default, nullptr},
1717 {"oHNativeImageGetTransformMatrixV2Nullptr", nullptr, OHNativeImageGetTransformMatrixV2Nullptr, nullptr,
1718 nullptr, nullptr, napi_default, nullptr},
1719 {"oHNativeImageUpdateSurfaceImageNormal", nullptr, OHNativeImageUpdateSurfaceImageNormal, nullptr, nullptr,
1720 nullptr, napi_default, nullptr},
1721 {"oHNativeImageGetTimestampNormal", nullptr, OHNativeImageGetTimestampNormal, nullptr, nullptr, nullptr,
1722 napi_default, nullptr},
1723 {"oHNativeImageGetTransformMatrixNormal", nullptr, OHNativeImageGetTransformMatrixNormal, nullptr, nullptr,
1724 nullptr, napi_default, nullptr},
1725 {"oHNativeImageGetTransformMatrixV2Normal", nullptr, OHNativeImageGetTransformMatrixV2Normal, nullptr, nullptr,
1726 nullptr, napi_default, nullptr},
1727 {"oHNativeImageSetOnFrameAvailableListenerNullptr", nullptr, OHNativeImageSetOnFrameAvailableListenerNullptr,
1728 nullptr, nullptr, nullptr, napi_default, nullptr},
1729 {"oHNativeImageUnSetOnFrameAvailableListenerNullptr", nullptr,
1730 OHNativeImageUnSetOnFrameAvailableListenerNullptr, nullptr, nullptr, nullptr, napi_default, nullptr},
1731 {"oHNativeImageSetOnFrameAvailableListenerNormal", nullptr, OHNativeImageSetOnFrameAvailableListenerNormal,
1732 nullptr, nullptr, nullptr, napi_default, nullptr},
1733 {"oHNativeImageUnsetOnFrameAvailableListenerNormal", nullptr, OHNativeImageUnsetOnFrameAvailableListenerNormal,
1734 nullptr, nullptr, nullptr, napi_default, nullptr},
1735 };
1736 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1737 return exports;
1738 }
1739 EXTERN_C_END
1740
1741 static napi_module demoModule = {
1742 .nm_version = 1,
1743 .nm_flags = 0,
1744 .nm_filename = nullptr,
1745 .nm_register_func = Init,
1746 .nm_modname = "nativeimage",
1747 .nm_priv = ((void *)0),
1748 .reserved = {0},
1749 };
1750
RegisterModule(void)1751 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); };
1752