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 "native_common.h"
18 #include <ace/xcomponent/native_interface_xcomponent.h>
19 #include <EGL/egl.h>
20 #include <EGL/eglext.h>
21 #include <EGL/eglplatform.h>
22 #include <GLES3/gl3.h>
23 #define NO_ERR 0
24 #define SUCCESS 1
25 #define FAIL (-1)
26 #define TRUE 1
27 #define FALSE 0
28 #define RGB_SIZE 0x08
29 #define INIT_WIDTH 0x08
30 #define INIT_HEIGHT 0x08
31 #define GL_CLIENT_VERSION 0x02
32 #define GL_MAJOR_VERSION_2 0x02
33 #define GL_MAJOR_VERSION_3 0x03
34 #define GL_MINOR_VERSION_0 0x00
35 #define EGL_ONE 0x01
36 #define GL_VERSION_15 0x0F
37 #define GL_MAJOR_VERSION_MARK 0x0A
38 #define EGL_SIZE 0xFFFF
39
40 typedef struct _MyEGLWindow {
41 EGLDisplay eglDisplay;
42 EGLSurface eglLSurface;
43 EGLContext eglContext;
44 EGLConfig eglConfig;
45 EGLint eglVersion;
46 } MyEGLWindow;
47
createMyEglWindow(napi_env env,MyEGLWindow * myEGLWindow)48 static napi_value createMyEglWindow(napi_env env, MyEGLWindow *myEGLWindow)
49 {
50 if (myEGLWindow == nullptr) {
51 return nullptr;
52 }
53 myEGLWindow->eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
54 NAPI_ASSERT(env, myEGLWindow->eglDisplay != EGL_NO_DISPLAY, "eglInitialize error");
55 EGLint majorVersion = GL_MAJOR_VERSION_2;
56 EGLint minorVersion = GL_MINOR_VERSION_0;
57 EGLBoolean Ret = eglInitialize(myEGLWindow->eglDisplay, &majorVersion, &minorVersion);
58 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglInitialize error");
59 myEGLWindow->eglVersion = majorVersion * GL_MAJOR_VERSION_MARK + minorVersion;
60 EGLint clientVersion = majorVersion == GL_MAJOR_VERSION_3 ? EGL_OPENGL_ES3_BIT : EGL_OPENGL_ES2_BIT;
61 const EGLint configAttribs[] = {
62 EGL_RED_SIZE, RGB_SIZE, EGL_GREEN_SIZE, RGB_SIZE, EGL_BLUE_SIZE, RGB_SIZE,
63 EGL_ALPHA_SIZE, RGB_SIZE, EGL_RENDERABLE_TYPE, clientVersion, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
64 EGL_NONE, EGL_NONE};
65 EGLint numConfigs = 0x00;
66 Ret = eglChooseConfig(myEGLWindow->eglDisplay, configAttribs, &myEGLWindow->eglConfig, EGL_ONE, &numConfigs);
67 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglChooseConfig error");
68 const EGLint surfaceAttribs[] = {EGL_WIDTH, INIT_WIDTH, EGL_HEIGHT, INIT_HEIGHT,
69 EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
70 EGL_NONE, EGL_NONE};
71 myEGLWindow->eglLSurface = eglCreatePbufferSurface(myEGLWindow->eglDisplay, myEGLWindow->eglConfig, surfaceAttribs);
72 NAPI_ASSERT(env, myEGLWindow->eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
73 const EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, GL_CLIENT_VERSION, EGL_NONE, EGL_NONE};
74 myEGLWindow->eglContext =
75 eglCreateContext(myEGLWindow->eglDisplay, myEGLWindow->eglConfig, EGL_NO_CONTEXT, contextAttribs);
76 NAPI_ASSERT(env, myEGLWindow->eglContext != EGL_NO_CONTEXT, "eglCreateContext error");
77 Ret = eglMakeCurrent(myEGLWindow->eglDisplay, myEGLWindow->eglLSurface, myEGLWindow->eglLSurface,
78 myEGLWindow->eglContext);
79 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglMakeCurrent error");
80 return nullptr;
81 }
82
destroyMyEglWindow(napi_env env,MyEGLWindow * myEGLWindow)83 static napi_value destroyMyEglWindow(napi_env env, MyEGLWindow *myEGLWindow)
84 {
85 if (myEGLWindow == nullptr) {
86 return nullptr;
87 }
88 if (myEGLWindow->eglDisplay != EGL_NO_DISPLAY) {
89 EGLBoolean Ret = eglTerminate(myEGLWindow->eglDisplay);
90 NAPI_ASSERT_BASE(env, Ret == EGL_TRUE, "eglTerminate error", EGL_FALSE);
91 }
92 myEGLWindow->eglDisplay = EGL_NO_DISPLAY;
93 myEGLWindow->eglLSurface = EGL_NO_SURFACE;
94 myEGLWindow->eglContext = EGL_NO_CONTEXT;
95 myEGLWindow->eglConfig = nullptr;
96 return nullptr;
97 }
98
eglGetErrorInit()99 static napi_value eglGetErrorInit()
100 {
101 EGLint eglError = NO_ERR;
102 do {
103 eglError = eglGetError();
104 } while (eglError != EGL_SUCCESS);
105 return nullptr;
106 }
107 static const EGLint surfaceAttr[] = {EGL_WIDTH, 1, EGL_HEIGHT, 1, EGL_NONE};
108
109 static const EGLint confAttr[] = {EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
110 EGL_BLUE_SIZE, 8,
111 EGL_GREEN_SIZE, 8,
112 EGL_RED_SIZE, 8,
113 EGL_ALPHA_SIZE, 8,
114 EGL_DEPTH_SIZE, 16,
115 EGL_NONE};
116
EglChooseConfig(napi_env env,napi_callback_info info)117 static napi_value EglChooseConfig(napi_env env, napi_callback_info info)
118 {
119 EGLint numConfigs;
120 EGLConfig config = nullptr;
121 EGLint config_size = 1;
122 EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
123 NAPI_ASSERT(env, display != EGL_NO_DISPLAY, "eglGetDisplay error");
124 eglInitialize(display, nullptr, nullptr);
125 EGLBoolean Ret = eglChooseConfig(display, confAttr, &config, config_size, &numConfigs);
126 NAPI_ASSERT(env, Ret == TRUE, "eglChooseConfig error");
127 eglReleaseThread();
128 eglTerminate(display);
129 napi_value result = nullptr;
130 napi_create_int32(env, SUCCESS, &result);
131 return result;
132 }
133
EglChooseConfigAbnormal(napi_env env,napi_callback_info info)134 static napi_value EglChooseConfigAbnormal(napi_env env, napi_callback_info info)
135 {
136 EGLint numConfigs;
137 EGLConfig config = nullptr;
138 EGLDisplay display = nullptr;
139 EGLint config_size = 1;
140 EGLBoolean Ret = eglChooseConfig(display, confAttr, &config, config_size, &numConfigs);
141 NAPI_ASSERT(env, Ret == FALSE, "eglChooseConfig error");
142 napi_value result = nullptr;
143 napi_create_int32(env, SUCCESS, &result);
144 return result;
145 }
146
EglCopyBuffersAbnormal(napi_env env,napi_callback_info info)147 static napi_value EglCopyBuffersAbnormal(napi_env env, napi_callback_info info)
148 {
149 EGLDisplay m_eglDisplay = nullptr;
150 EGLConfig m_eglConf = nullptr;
151 EGLint numConfigs;
152 EGLint config_size = 1;
153 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
154 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
155 eglInitialize(m_eglDisplay, nullptr, nullptr);
156
157 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
158 EGLSurface m_eglSurface = nullptr;
159 EGLNativePixmapType mNativeDisplay = 0;
160 EGLBoolean Ret = eglCopyBuffers(m_eglDisplay, m_eglSurface, mNativeDisplay);
161 NAPI_ASSERT(env, Ret == FALSE, "eglCopyBuffers error");
162 eglDestroySurface(m_eglDisplay, m_eglSurface);
163 eglReleaseThread();
164 eglTerminate(m_eglDisplay);
165 napi_value result = nullptr;
166 napi_create_int32(env, SUCCESS, &result);
167 return result;
168 }
169
EglCreateContext(napi_env env,napi_callback_info info)170 static napi_value EglCreateContext(napi_env env, napi_callback_info info)
171 {
172 EGLDisplay m_eglDisplay = nullptr;
173 EGLConfig m_eglConf = nullptr;
174 EGLint numConfigs;
175 EGLint config_size = 1;
176 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
177 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
178 eglInitialize(m_eglDisplay, nullptr, nullptr);
179
180 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
181
182 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
183 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
184 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
185 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
186 NAPI_ASSERT(env, m_eglCtx != EGL_NO_CONTEXT, "eglCreateContext error");
187 eglDestroyContext(m_eglDisplay, m_eglCtx);
188 eglDestroySurface(m_eglDisplay, m_eglSurface);
189 eglReleaseThread();
190 eglTerminate(m_eglDisplay);
191 napi_value result = nullptr;
192 napi_create_int32(env, SUCCESS, &result);
193 return result;
194 }
195
EglCreateContextAbnormal(napi_env env,napi_callback_info info)196 static napi_value EglCreateContextAbnormal(napi_env env, napi_callback_info info)
197 {
198 EGLDisplay m_eglDisplay = nullptr;
199 EGLConfig m_eglConf = nullptr;
200 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
201 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
202 NAPI_ASSERT(env, m_eglCtx == EGL_NO_CONTEXT, "eglCreateContext error");
203 eglDestroyContext(m_eglDisplay, m_eglCtx);
204 eglReleaseThread();
205 eglTerminate(m_eglDisplay);
206 napi_value result = nullptr;
207 napi_create_int32(env, SUCCESS, &result);
208 return result;
209 }
210
EglCreatePbufferSurface(napi_env env,napi_callback_info info)211 static napi_value EglCreatePbufferSurface(napi_env env, napi_callback_info info)
212 {
213 EGLDisplay m_eglDisplay = nullptr;
214 EGLConfig m_eglConf = nullptr;
215 EGLint numConfigs;
216 EGLint config_size = 1;
217 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
218 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
219 eglInitialize(m_eglDisplay, nullptr, nullptr);
220 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
221 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
222 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
223 eglDestroySurface(m_eglDisplay, m_eglSurface);
224 eglReleaseThread();
225 eglTerminate(m_eglDisplay);
226 napi_value result = nullptr;
227 napi_create_int32(env, SUCCESS, &result);
228 return result;
229 }
230
EglCreatePbufferSurfaceAbnormal(napi_env env,napi_callback_info info)231 static napi_value EglCreatePbufferSurfaceAbnormal(napi_env env, napi_callback_info info)
232 {
233 EGLDisplay m_eglDisplay = nullptr;
234 EGLConfig m_eglConf = nullptr;
235 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
236 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
237 eglInitialize(m_eglDisplay, nullptr, nullptr);
238 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
239 NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreatePbufferSurface error");
240 eglDestroySurface(m_eglDisplay, m_eglSurface);
241 eglReleaseThread();
242 eglTerminate(m_eglDisplay);
243 napi_value result = nullptr;
244 napi_create_int32(env, SUCCESS, &result);
245 return result;
246 }
247
EglCreatePixmapSurfaceAbnormal(napi_env env,napi_callback_info info)248 static napi_value EglCreatePixmapSurfaceAbnormal(napi_env env, napi_callback_info info)
249 {
250 EGLDisplay m_eglDisplay = nullptr;
251 EGLConfig m_eglConf = nullptr;
252 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
253 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
254 eglInitialize(m_eglDisplay, nullptr, nullptr);
255 EGLNativePixmapType pixmap = 0;
256 EGLSurface m_eglSurface = eglCreatePixmapSurface(m_eglDisplay, m_eglConf, pixmap, surfaceAttr);
257 NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreatePixmapSurface error");
258 eglDestroySurface(m_eglDisplay, m_eglSurface);
259 eglReleaseThread();
260 eglTerminate(m_eglDisplay);
261 napi_value result = nullptr;
262 napi_create_int32(env, SUCCESS, &result);
263 return result;
264 }
265
EglCreateWindowSurfaceAbnormal(napi_env env,napi_callback_info info)266 static napi_value EglCreateWindowSurfaceAbnormal(napi_env env, napi_callback_info info)
267 {
268 EGLDisplay m_eglDisplay = nullptr;
269 EGLConfig m_eglConf = nullptr;
270 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
271 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
272 eglInitialize(m_eglDisplay, nullptr, nullptr);
273 NativeWindowType window = 0;
274 EGLSurface m_eglSurface = eglCreateWindowSurface(m_eglDisplay, m_eglConf, window, surfaceAttr);
275 NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglCreateWindowSurface error");
276 eglDestroySurface(m_eglDisplay, m_eglSurface);
277 eglReleaseThread();
278 eglTerminate(m_eglDisplay);
279 napi_value result = nullptr;
280 napi_create_int32(env, SUCCESS, &result);
281 return result;
282 }
283
EglDestroyContext(napi_env env,napi_callback_info info)284 static napi_value EglDestroyContext(napi_env env, napi_callback_info info)
285 {
286 EGLDisplay m_eglDisplay = nullptr;
287 EGLConfig m_eglConf = nullptr;
288 EGLint numConfigs;
289 EGLint config_size = 1;
290 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
291 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
292 eglInitialize(m_eglDisplay, nullptr, nullptr);
293
294 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
295
296 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
297 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
298 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
299 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
300 EGLBoolean Ret = eglDestroyContext(m_eglDisplay, m_eglCtx);
301 NAPI_ASSERT(env, Ret == TRUE, "eglDestroyContext error");
302 eglDestroySurface(m_eglDisplay, m_eglSurface);
303 eglReleaseThread();
304 eglTerminate(m_eglDisplay);
305 napi_value result = nullptr;
306 napi_create_int32(env, SUCCESS, &result);
307 return result;
308 }
309
EglDestroyContextAbnormal(napi_env env,napi_callback_info info)310 static napi_value EglDestroyContextAbnormal(napi_env env, napi_callback_info info)
311 {
312 EGLDisplay m_eglDisplay = nullptr;
313 EGLConfig m_eglConf = nullptr;
314 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, nullptr);
315 EGLBoolean Ret = eglDestroyContext(m_eglDisplay, m_eglCtx);
316 NAPI_ASSERT(env, Ret == FALSE, "eglDestroyContext error");
317 eglReleaseThread();
318 eglTerminate(m_eglDisplay);
319 napi_value result = nullptr;
320 napi_create_int32(env, SUCCESS, &result);
321 return result;
322 }
323
EglDestroySurface(napi_env env,napi_callback_info info)324 static napi_value EglDestroySurface(napi_env env, napi_callback_info info)
325 {
326 EGLDisplay m_eglDisplay = nullptr;
327 EGLConfig m_eglConf = nullptr;
328 EGLint numConfigs;
329 EGLint config_size = 1;
330 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
331 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
332 eglInitialize(m_eglDisplay, nullptr, nullptr);
333 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
334
335 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
336 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
337 EGLBoolean Ret = eglDestroySurface(m_eglDisplay, m_eglSurface);
338 NAPI_ASSERT(env, Ret == TRUE, "eglDestroySurface error");
339 eglReleaseThread();
340 eglTerminate(m_eglDisplay);
341 napi_value result = nullptr;
342 napi_create_int32(env, SUCCESS, &result);
343 return result;
344 }
345
EglDestroySurfaceAbnormal(napi_env env,napi_callback_info info)346 static napi_value EglDestroySurfaceAbnormal(napi_env env, napi_callback_info info)
347 {
348 EGLDisplay m_eglDisplay = nullptr;
349 EGLConfig m_eglConf = nullptr;
350 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
351 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
352 eglInitialize(m_eglDisplay, nullptr, nullptr);
353
354 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
355
356 EGLBoolean Ret = eglDestroySurface(m_eglDisplay, m_eglSurface);
357 NAPI_ASSERT(env, Ret == FALSE, "eglDestroySurface error");
358 eglReleaseThread();
359 eglTerminate(m_eglDisplay);
360 napi_value result = nullptr;
361 napi_create_int32(env, SUCCESS, &result);
362 return result;
363 }
364
EglGetConfigAttrib(napi_env env,napi_callback_info info)365 static napi_value EglGetConfigAttrib(napi_env env, napi_callback_info info)
366 {
367 EGLDisplay m_eglDisplay = nullptr;
368 EGLConfig m_eglConf[10];
369 EGLint numConfigs;
370 EGLint config_size = 10;
371 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
372 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
373 eglInitialize(m_eglDisplay, nullptr, nullptr);
374
375 eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
376 EGLBoolean Ret;
377 for (int i = 0; i < numConfigs; ++i) {
378 Ret = eglGetConfigAttrib(m_eglDisplay, m_eglConf[i], EGL_ALPHA_SIZE, &numConfigs);
379 }
380 NAPI_ASSERT(env, Ret == TRUE, "eglGetConfigAttrib error");
381 eglReleaseThread();
382 eglTerminate(m_eglDisplay);
383 napi_value result = nullptr;
384 napi_create_int32(env, SUCCESS, &result);
385 return result;
386 }
387
EglGetConfigAttribAbnormal(napi_env env,napi_callback_info info)388 static napi_value EglGetConfigAttribAbnormal(napi_env env, napi_callback_info info)
389 {
390 EGLConfig m_eglConf[10];
391 EGLint numConfigs;
392 EGLint config_size = 10;
393 EGLDisplay m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
394 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
395
396 eglInitialize(m_eglDisplay, nullptr, nullptr);
397 eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
398
399 EGLint value;
400 EGLBoolean Ret = eglGetConfigAttrib(m_eglDisplay, m_eglConf[0], EGL_SIZE, &value);
401 NAPI_ASSERT(env, Ret == FALSE, "eglGetConfigAttrib invalid attribute case error");
402
403 eglReleaseThread();
404 eglTerminate(m_eglDisplay);
405 napi_value result = nullptr;
406 napi_create_int32(env, SUCCESS, &result);
407 return result;
408 }
409
EglGetConfigs(napi_env env,napi_callback_info info)410 static napi_value EglGetConfigs(napi_env env, napi_callback_info info)
411 {
412 EGLDisplay m_eglDisplay = nullptr;
413 EGLConfig m_eglConf[10];
414 EGLint numConfigs;
415 EGLint config_size = 10;
416 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
417 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
418 eglInitialize(m_eglDisplay, nullptr, nullptr);
419
420 EGLBoolean Ret = eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
421 NAPI_ASSERT(env, Ret == TRUE, "eglGetConfigs error");
422 eglReleaseThread();
423 eglTerminate(m_eglDisplay);
424 napi_value result = nullptr;
425 napi_create_int32(env, SUCCESS, &result);
426 return result;
427 }
428
EglGetConfigsAbnormal(napi_env env,napi_callback_info info)429 static napi_value EglGetConfigsAbnormal(napi_env env, napi_callback_info info)
430 {
431 EGLDisplay m_eglDisplay = nullptr;
432 EGLConfig m_eglConf[10];
433 EGLint numConfigs;
434 EGLint config_size = 10;
435
436 EGLBoolean Ret = eglGetConfigs(m_eglDisplay, m_eglConf, config_size, &numConfigs);
437 NAPI_ASSERT(env, Ret == FALSE, "eglGetConfigs error");
438 eglReleaseThread();
439 eglTerminate(m_eglDisplay);
440 napi_value result = nullptr;
441 napi_create_int32(env, SUCCESS, &result);
442 return result;
443 }
444
EglGetCurrentDisplay(napi_env env,napi_callback_info info)445 static napi_value EglGetCurrentDisplay(napi_env env, napi_callback_info info)
446 {
447 EGLDisplay m_eglDisplay = nullptr;
448 EGLConfig m_eglConf = nullptr;
449 EGLint numConfigs;
450 EGLint config_size = 1;
451 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
452 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
453 eglInitialize(m_eglDisplay, nullptr, nullptr);
454
455 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
456
457 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
458 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
459 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
460 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
461 eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
462 m_eglDisplay = eglGetCurrentDisplay();
463 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
464 eglDestroyContext(m_eglDisplay, m_eglCtx);
465 eglDestroySurface(m_eglDisplay, m_eglSurface);
466 eglReleaseThread();
467 eglTerminate(m_eglDisplay);
468 napi_value result = nullptr;
469 napi_create_int32(env, SUCCESS, &result);
470 return result;
471 }
472
EglGetCurrentDisplayAbnormal(napi_env env,napi_callback_info info)473 static napi_value EglGetCurrentDisplayAbnormal(napi_env env, napi_callback_info info)
474 {
475 EGLDisplay m_eglDisplay = nullptr;
476 m_eglDisplay = eglGetCurrentDisplay();
477 NAPI_ASSERT(env, m_eglDisplay == EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
478 eglReleaseThread();
479 eglTerminate(m_eglDisplay);
480 napi_value result = nullptr;
481 napi_create_int32(env, SUCCESS, &result);
482 return result;
483 }
484
EglGetCurrentSurface(napi_env env,napi_callback_info info)485 static napi_value EglGetCurrentSurface(napi_env env, napi_callback_info info)
486 {
487 EGLDisplay m_eglDisplay = nullptr;
488 EGLConfig m_eglConf = nullptr;
489 EGLint numConfigs;
490 EGLint config_size = 1;
491 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
492 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
493 eglInitialize(m_eglDisplay, nullptr, nullptr);
494
495 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
496
497 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
498 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
499 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
500 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
501 eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
502 m_eglDisplay = eglGetCurrentDisplay();
503 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetCurrentDisplay error");
504 m_eglSurface = eglGetCurrentSurface(EGL_DRAW);
505 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglGetCurrentSurface error");
506 eglDestroyContext(m_eglDisplay, m_eglCtx);
507 eglDestroySurface(m_eglDisplay, m_eglSurface);
508 eglReleaseThread();
509 eglTerminate(m_eglDisplay);
510 napi_value result = nullptr;
511 napi_create_int32(env, SUCCESS, &result);
512 return result;
513 }
514
EglGetCurrentSurfaceAbnormal(napi_env env,napi_callback_info info)515 static napi_value EglGetCurrentSurfaceAbnormal(napi_env env, napi_callback_info info)
516 {
517 eglGetCurrentDisplay();
518 EGLSurface m_eglSurface = eglGetCurrentSurface(EGL_DRAW);
519 NAPI_ASSERT(env, m_eglSurface == EGL_NO_SURFACE, "eglGetCurrentSurface error");
520 napi_value result = nullptr;
521 napi_create_int32(env, SUCCESS, &result);
522 return result;
523 }
524
EglGetDisplay(napi_env env,napi_callback_info info)525 static napi_value EglGetDisplay(napi_env env, napi_callback_info info)
526 {
527 EGLDisplay m_eglDisplay = nullptr;
528 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
529 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
530 eglReleaseThread();
531 eglTerminate(m_eglDisplay);
532 napi_value result = nullptr;
533 napi_create_int32(env, SUCCESS, &result);
534 return result;
535 }
536
EglGetError(napi_env env,napi_callback_info info)537 static napi_value EglGetError(napi_env env, napi_callback_info info)
538 {
539 EGLDisplay m_eglDisplay = nullptr;
540 EGLConfig m_eglConf = nullptr;
541 eglGetErrorInit();
542 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
543 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
544 NAPI_ASSERT(env, m_eglCtx == EGL_NO_CONTEXT, "eglGetCurrentSurface error");
545 EGLint Ret = eglGetError();
546 NAPI_ASSERT(env, Ret == EGL_BAD_DISPLAY, "eglGetError error");
547 eglReleaseThread();
548 eglTerminate(m_eglDisplay);
549 napi_value result = nullptr;
550 napi_create_int32(env, SUCCESS, &result);
551 return result;
552 }
553
554 typedef EGLBoolean (*PFNCREATEIMAGEKHR)(EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const int *);
EglGetProcAddress(napi_env env,napi_callback_info info)555 static napi_value EglGetProcAddress(napi_env env, napi_callback_info info)
556 {
557 EGLDisplay m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
558 PFNCREATEIMAGEKHR createImageKHR = (PFNCREATEIMAGEKHR)eglGetProcAddress("eglCreateImageKHR");
559 NAPI_ASSERT(env, createImageKHR != nullptr, "eglGetProcAddress error");
560 eglReleaseThread();
561 eglTerminate(m_eglDisplay);
562 napi_value result = nullptr;
563 napi_create_int32(env, SUCCESS, &result);
564 return result;
565 }
566
EglGetProcAddressAbnormal(napi_env env,napi_callback_info info)567 static napi_value EglGetProcAddressAbnormal(napi_env env, napi_callback_info info)
568 {
569 PFNCREATEIMAGEKHR createImageKHR = (PFNCREATEIMAGEKHR)eglGetProcAddress("eglCreateImageKHR1");
570 NAPI_ASSERT(env, createImageKHR == nullptr, "eglGetProcAddress error");
571 napi_value result = nullptr;
572 napi_create_int32(env, SUCCESS, &result);
573 return result;
574 }
575
EglInitialize(napi_env env,napi_callback_info info)576 static napi_value EglInitialize(napi_env env, napi_callback_info info)
577 {
578 EGLDisplay m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
579 EGLBoolean Ret = eglInitialize(m_eglDisplay, nullptr, nullptr);
580 NAPI_ASSERT(env, Ret == TRUE, "eglGetProcAddress error");
581 eglReleaseThread();
582 eglTerminate(m_eglDisplay);
583 napi_value result = nullptr;
584 napi_create_int32(env, SUCCESS, &result);
585 return result;
586 }
587
EglInitializeAbnormal(napi_env env,napi_callback_info info)588 static napi_value EglInitializeAbnormal(napi_env env, napi_callback_info info)
589 {
590 EGLDisplay m_eglDisplay = nullptr;
591 EGLBoolean Ret = eglInitialize(m_eglDisplay, nullptr, nullptr);
592 NAPI_ASSERT(env, Ret == FALSE, "eglGetProcAddress error");
593 eglReleaseThread();
594 eglTerminate(m_eglDisplay);
595 napi_value result = nullptr;
596 napi_create_int32(env, SUCCESS, &result);
597 return result;
598 }
599
EglMakeCurrent(napi_env env,napi_callback_info info)600 static napi_value EglMakeCurrent(napi_env env, napi_callback_info info)
601 {
602 EGLDisplay m_eglDisplay = nullptr;
603 EGLConfig m_eglConf = nullptr;
604 EGLint numConfigs;
605 EGLint config_size = 1;
606 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
607 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
608 eglInitialize(m_eglDisplay, nullptr, nullptr);
609
610 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
611
612 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
613 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
614 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
615 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
616 EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
617 NAPI_ASSERT(env, Ret == TRUE, "eglMakeCurrent error");
618 eglDestroyContext(m_eglDisplay, m_eglCtx);
619 eglDestroySurface(m_eglDisplay, m_eglSurface);
620 eglReleaseThread();
621 eglTerminate(m_eglDisplay);
622 napi_value result = nullptr;
623 napi_create_int32(env, SUCCESS, &result);
624 return result;
625 }
626
EglMakeCurrentAbnormal(napi_env env,napi_callback_info info)627 static napi_value EglMakeCurrentAbnormal(napi_env env, napi_callback_info info)
628 {
629 EGLDisplay m_eglDisplay = nullptr;
630 EGLSurface m_eglSurface = nullptr;
631 EGLContext m_eglCtx = nullptr;
632 EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
633 NAPI_ASSERT(env, Ret == FALSE, "eglMakeCurrent error");
634 eglDestroyContext(m_eglDisplay, m_eglCtx);
635 eglDestroySurface(m_eglDisplay, m_eglSurface);
636 eglReleaseThread();
637 eglTerminate(m_eglDisplay);
638 napi_value result = nullptr;
639 napi_create_int32(env, SUCCESS, &result);
640 return result;
641 }
642
EglSwapBuffersWithDamageKHRRect1(napi_env env,napi_callback_info info)643 static napi_value EglSwapBuffersWithDamageKHRRect1(napi_env env, napi_callback_info info)
644 {
645 EGLDisplay m_eglDisplay = nullptr;
646 EGLConfig m_eglConf = nullptr;
647 EGLint numConfigs;
648 EGLint config_size = 1;
649 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
650 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
651 eglInitialize(m_eglDisplay, nullptr, nullptr);
652
653 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
654
655 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
656 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
657 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
658 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
659 EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
660 NAPI_ASSERT(env, Ret == TRUE, "eglMakeCurrent error");
661
662 EGLint rects[] = {10, 10, 100, 100}; // x,y,width,height
663 PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC eglSwapBuffersWithDamageKHR_ =
664 (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)eglGetProcAddress("eglSwapBuffersWithDamageKHR");
665 EGLint n_RectsDamageArea = 1;
666 if (eglSwapBuffersWithDamageKHR_) {
667 EGLBoolean ret = eglSwapBuffersWithDamageKHR_(m_eglDisplay, m_eglSurface, rects, n_RectsDamageArea);
668 NAPI_ASSERT(env, ret == EGL_TRUE, "eglSwapBuffersWithDamageKHR update area error");
669 }
670
671 eglDestroyContext(m_eglDisplay, m_eglCtx);
672 eglDestroySurface(m_eglDisplay, m_eglSurface);
673 eglReleaseThread();
674 eglTerminate(m_eglDisplay);
675 napi_value result = nullptr;
676 napi_create_int32(env, SUCCESS, &result);
677 return result;
678 }
679
EglSwapBuffersWithDamageKHRRect2(napi_env env,napi_callback_info info)680 static napi_value EglSwapBuffersWithDamageKHRRect2(napi_env env, napi_callback_info info)
681 {
682 EGLDisplay m_eglDisplay = nullptr;
683 EGLConfig m_eglConf = nullptr;
684 EGLint numConfigs;
685 EGLint config_size = 1;
686 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
687 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
688 eglInitialize(m_eglDisplay, nullptr, nullptr);
689
690 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
691
692 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
693 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
694 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
695 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
696 EGLBoolean Ret = eglMakeCurrent(m_eglDisplay, m_eglSurface, m_eglSurface, m_eglCtx);
697 NAPI_ASSERT(env, Ret == TRUE, "eglMakeCurrent error");
698
699 EGLint rects[8] = {
700 10, 10, 100, 100, // fisrt damaged area, x,y,width,height
701 110, 110, 100, 100 // second damaged area, x,y,width,height
702 };
703 PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC eglSwapBuffersWithDamageKHR_ =
704 (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)eglGetProcAddress("eglSwapBuffersWithDamageKHR");
705 EGLint n_RectsDamageArea = 2;
706 if (eglSwapBuffersWithDamageKHR_) {
707 EGLBoolean ret = eglSwapBuffersWithDamageKHR_(m_eglDisplay, m_eglSurface, rects, n_RectsDamageArea);
708 NAPI_ASSERT(env, ret == EGL_TRUE, "eglSwapBuffersWithDamageKHR update area error");
709 }
710
711 eglDestroyContext(m_eglDisplay, m_eglCtx);
712 eglDestroySurface(m_eglDisplay, m_eglSurface);
713 eglReleaseThread();
714 eglTerminate(m_eglDisplay);
715 napi_value result = nullptr;
716 napi_create_int32(env, SUCCESS, &result);
717 return result;
718 }
719
EglSwapBuffersWithDamageKHRSurfaceRectsNull(napi_env env,napi_callback_info info)720 static napi_value EglSwapBuffersWithDamageKHRSurfaceRectsNull(napi_env env, napi_callback_info info)
721 {
722 EGLDisplay m_eglDisplay = nullptr;
723 EGLConfig m_eglConf = nullptr;
724 EGLint numConfigs;
725 EGLint config_size = 1;
726 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
727 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
728 eglInitialize(m_eglDisplay, nullptr, nullptr);
729 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
730
731 EGLSurface m_eglSurface = nullptr;
732 EGLint *rects = nullptr;
733 PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC eglSwapBuffersWithDamageKHR_ =
734 (PFNEGLSWAPBUFFERSWITHDAMAGEKHRPROC)eglGetProcAddress("eglSwapBuffersWithDamageKHR");
735 EGLint n_RectsDamageArea = 0;
736 m_eglSurface = nullptr;
737 if (eglSwapBuffersWithDamageKHR_) {
738 EGLBoolean ret = eglSwapBuffersWithDamageKHR_(m_eglDisplay, m_eglSurface, rects, n_RectsDamageArea);
739 NAPI_ASSERT(env, ret == EGL_FALSE, "eglSwapBuffersWithDamageKHR update null area error");
740 }
741
742 eglDestroySurface(m_eglDisplay, m_eglSurface);
743 eglReleaseThread();
744 eglTerminate(m_eglDisplay);
745 napi_value result = nullptr;
746 napi_create_int32(env, SUCCESS, &result);
747 return result;
748 }
749
EglQueryContext(napi_env env,napi_callback_info info)750 static napi_value EglQueryContext(napi_env env, napi_callback_info info)
751 {
752 EGLDisplay m_eglDisplay = nullptr;
753 EGLConfig m_eglConf = nullptr;
754 EGLint numConfigs;
755 EGLint config_size = 1;
756 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
757 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
758 eglInitialize(m_eglDisplay, nullptr, nullptr);
759
760 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
761
762 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
763 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
764 const EGLint ctxAttr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
765 EGLContext m_eglCtx = eglCreateContext(m_eglDisplay, m_eglConf, EGL_NO_CONTEXT, ctxAttr);
766 EGLBoolean Ret = eglQueryContext(m_eglDisplay, m_eglCtx, EGL_CONTEXT_CLIENT_VERSION, &numConfigs);
767 NAPI_ASSERT(env, Ret == TRUE, "eglQueryContext error");
768 eglDestroyContext(m_eglDisplay, m_eglCtx);
769 eglDestroySurface(m_eglDisplay, m_eglSurface);
770 eglReleaseThread();
771 eglTerminate(m_eglDisplay);
772 napi_value result = nullptr;
773 napi_create_int32(env, SUCCESS, &result);
774 return result;
775 }
776
EglQueryContextAbnormal(napi_env env,napi_callback_info info)777 static napi_value EglQueryContextAbnormal(napi_env env, napi_callback_info info)
778 {
779 EGLDisplay m_eglDisplay = nullptr;
780 EGLConfig m_eglConf = nullptr;
781 EGLint numConfigs;
782 EGLint config_size = 1;
783 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
784 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
785 eglInitialize(m_eglDisplay, nullptr, nullptr);
786
787 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
788
789 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
790 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
791 EGLContext m_eglCtx = nullptr;
792 EGLBoolean Ret = eglQueryContext(m_eglDisplay, m_eglCtx, EGL_CONTEXT_CLIENT_VERSION, &numConfigs);
793 NAPI_ASSERT(env, Ret == FALSE, "eglQueryContext error");
794 eglDestroyContext(m_eglDisplay, m_eglCtx);
795 eglDestroySurface(m_eglDisplay, m_eglSurface);
796 eglReleaseThread();
797 eglTerminate(m_eglDisplay);
798 napi_value result = nullptr;
799 napi_create_int32(env, SUCCESS, &result);
800 return result;
801 }
802
EglQueryString(napi_env env,napi_callback_info info)803 static napi_value EglQueryString(napi_env env, napi_callback_info info)
804 {
805 EGLDisplay m_eglDisplay = nullptr;
806 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
807 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
808 eglInitialize(m_eglDisplay, nullptr, nullptr);
809 const char *vendor = eglQueryString(m_eglDisplay, EGL_VENDOR);
810 NAPI_ASSERT(env, vendor != nullptr, "eglQueryString error");
811
812 eglTerminate(m_eglDisplay);
813 napi_value result = nullptr;
814 napi_create_int32(env, SUCCESS, &result);
815 return result;
816 }
817
EglQueryStringAbnormal(napi_env env,napi_callback_info info)818 static napi_value EglQueryStringAbnormal(napi_env env, napi_callback_info info)
819 {
820 EGLDisplay m_eglDisplay = nullptr;
821 const char *vendor = eglQueryString(m_eglDisplay, EGL_VENDOR);
822 NAPI_ASSERT(env, vendor == nullptr, "eglQueryString error");
823
824 eglTerminate(m_eglDisplay);
825 napi_value result = nullptr;
826 napi_create_int32(env, SUCCESS, &result);
827 return result;
828 }
829
EglQuerySurface(napi_env env,napi_callback_info info)830 static napi_value EglQuerySurface(napi_env env, napi_callback_info info)
831 {
832 EGLDisplay m_eglDisplay = nullptr;
833 EGLConfig m_eglConf = nullptr;
834 EGLint numConfigs;
835 EGLint config_size = 1;
836 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
837 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
838 eglInitialize(m_eglDisplay, nullptr, nullptr);
839 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
840
841 EGLSurface m_eglSurface = eglCreatePbufferSurface(m_eglDisplay, m_eglConf, surfaceAttr);
842 NAPI_ASSERT(env, m_eglSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
843 EGLint width;
844 EGLBoolean Ret = eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
845 NAPI_ASSERT(env, Ret == TRUE, "eglQuerySurface error");
846 eglDestroySurface(m_eglDisplay, m_eglSurface);
847 eglReleaseThread();
848 eglTerminate(m_eglDisplay);
849 napi_value result = nullptr;
850 napi_create_int32(env, SUCCESS, &result);
851 return result;
852 }
853
EglQuerySurfaceAbnormal(napi_env env,napi_callback_info info)854 static napi_value EglQuerySurfaceAbnormal(napi_env env, napi_callback_info info)
855 {
856 EGLDisplay m_eglDisplay = nullptr;
857 EGLConfig m_eglConf = nullptr;
858 EGLint numConfigs;
859 EGLint config_size = 1;
860 m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
861 NAPI_ASSERT(env, m_eglDisplay != EGL_NO_DISPLAY, "eglGetDisplay error");
862 eglInitialize(m_eglDisplay, nullptr, nullptr);
863 eglChooseConfig(m_eglDisplay, confAttr, &m_eglConf, config_size, &numConfigs);
864
865 EGLSurface m_eglSurface = nullptr;
866 EGLint width;
867 EGLBoolean Ret = eglQuerySurface(m_eglDisplay, m_eglSurface, EGL_WIDTH, &width);
868 NAPI_ASSERT(env, Ret == FALSE, "eglQuerySurface error");
869 napi_value result = nullptr;
870 napi_create_int32(env, SUCCESS, &result);
871 return result;
872 }
873
EglSwapBuffers(napi_env env,napi_callback_info info)874 static napi_value EglSwapBuffers(napi_env env, napi_callback_info info)
875 {
876 (void)info;
877 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
878 createMyEglWindow(env, &myEGLWindow);
879 EGLBoolean Ret = eglSwapBuffers(myEGLWindow.eglDisplay, myEGLWindow.eglLSurface);
880 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSwapBuffers error");
881 destroyMyEglWindow(env, &myEGLWindow);
882 napi_value result = nullptr;
883 napi_create_int32(env, SUCCESS, &result);
884 return result;
885 }
886
EglSwapBuffersAbnormal(napi_env env,napi_callback_info info)887 static napi_value EglSwapBuffersAbnormal(napi_env env, napi_callback_info info)
888 {
889 (void)info;
890 eglGetErrorInit();
891 EGLBoolean Ret = eglSwapBuffers(EGL_NO_DISPLAY, EGL_NO_SURFACE);
892 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetError error");
893 EGLint eglError = eglGetError();
894 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
895 napi_value result = nullptr;
896 napi_create_int32(env, SUCCESS, &result);
897 return result;
898 }
899
EglTerminate(napi_env env,napi_callback_info info)900 static napi_value EglTerminate(napi_env env, napi_callback_info info)
901 {
902 (void)info;
903 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
904 createMyEglWindow(env, &myEGLWindow);
905 EGLBoolean Ret = eglTerminate(myEGLWindow.eglDisplay);
906 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglTerminate error");
907 napi_value result = nullptr;
908 napi_create_int32(env, SUCCESS, &result);
909 return result;
910 }
911
EglTerminateAbnormal(napi_env env,napi_callback_info info)912 static napi_value EglTerminateAbnormal(napi_env env, napi_callback_info info)
913 {
914 (void)info;
915 eglGetErrorInit();
916 EGLBoolean Ret = eglTerminate(EGL_NO_DISPLAY);
917 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetError error");
918 EGLint eglError = eglGetError();
919 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
920 napi_value result = nullptr;
921 napi_create_int32(env, SUCCESS, &result);
922 return result;
923 }
924
EglWaitGL(napi_env env,napi_callback_info info)925 static napi_value EglWaitGL(napi_env env, napi_callback_info info)
926 {
927 (void)info;
928 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
929 createMyEglWindow(env, &myEGLWindow);
930 EGLBoolean Ret = eglWaitGL();
931 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitGL error");
932 destroyMyEglWindow(env, &myEGLWindow);
933 napi_value result = nullptr;
934 napi_create_int32(env, SUCCESS, &result);
935 return result;
936 }
937
EglWaitNative(napi_env env,napi_callback_info info)938 static napi_value EglWaitNative(napi_env env, napi_callback_info info)
939 {
940 (void)info;
941 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
942 createMyEglWindow(env, &myEGLWindow);
943 EGLBoolean Ret = eglWaitNative(EGL_CORE_NATIVE_ENGINE);
944 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitNative error");
945 destroyMyEglWindow(env, &myEGLWindow);
946 napi_value result = nullptr;
947 napi_create_int32(env, SUCCESS, &result);
948 return result;
949 }
950
EglBindTexImage(napi_env env,napi_callback_info info)951 static napi_value EglBindTexImage(napi_env env, napi_callback_info info)
952 {
953 (void)info;
954 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
955 createMyEglWindow(env, &myEGLWindow);
956 const EGLint surfaceAttribs[] = {EGL_WIDTH, INIT_WIDTH, EGL_HEIGHT, INIT_HEIGHT,
957 EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
958 EGL_NONE, EGL_NONE};
959 EGLSurface eglLSurface = eglCreatePbufferSurface(myEGLWindow.eglDisplay, myEGLWindow.eglConfig, surfaceAttribs);
960 NAPI_ASSERT(env, eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
961 GLuint texture = GL_ZERO;
962 glGenTextures(GL_ONE, &texture);
963 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
964 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
965 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
966 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
967 EGLBoolean Ret = eglBindTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
968 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindTexImage error");
969 Ret = eglReleaseTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
970 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseTexImage error");
971 Ret = eglDestroySurface(myEGLWindow.eglDisplay, eglLSurface);
972 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySurface error");
973 destroyMyEglWindow(env, &myEGLWindow);
974 napi_value result = nullptr;
975 napi_create_int32(env, SUCCESS, &result);
976 return result;
977 }
978
EglBindTexImageAbnormal(napi_env env,napi_callback_info info)979 static napi_value EglBindTexImageAbnormal(napi_env env, napi_callback_info info)
980 {
981 (void)info;
982 EGLBoolean Ret = eglBindTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, 0x00);
983 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindTexImage error");
984 napi_value result = nullptr;
985 napi_create_int32(env, SUCCESS, &result);
986 return result;
987 }
988
EglReleaseTexImage(napi_env env,napi_callback_info info)989 static napi_value EglReleaseTexImage(napi_env env, napi_callback_info info)
990 {
991 (void)info;
992 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
993 createMyEglWindow(env, &myEGLWindow);
994 const EGLint surfaceAttribs[] = {EGL_WIDTH, INIT_WIDTH, EGL_HEIGHT, INIT_HEIGHT,
995 EGL_TEXTURE_FORMAT, EGL_TEXTURE_RGBA, EGL_TEXTURE_TARGET, EGL_TEXTURE_2D,
996 EGL_NONE, EGL_NONE};
997 EGLSurface eglLSurface = eglCreatePbufferSurface(myEGLWindow.eglDisplay, myEGLWindow.eglConfig, surfaceAttribs);
998 NAPI_ASSERT(env, eglLSurface != EGL_NO_SURFACE, "eglCreatePbufferSurface error");
999 GLuint texture = GL_ZERO;
1000 glGenTextures(GL_ONE, &texture);
1001 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
1002 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
1003 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1004 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1005 EGLBoolean Ret = eglBindTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
1006 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindTexImage error");
1007 Ret = eglReleaseTexImage(myEGLWindow.eglDisplay, eglLSurface, EGL_BACK_BUFFER);
1008 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseTexImage error");
1009 Ret = eglDestroySurface(myEGLWindow.eglDisplay, eglLSurface);
1010 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySurface error");
1011 destroyMyEglWindow(env, &myEGLWindow);
1012 napi_value result = nullptr;
1013 napi_create_int32(env, SUCCESS, &result);
1014 return result;
1015 }
1016
EglReleaseTexImageAbnormal(napi_env env,napi_callback_info info)1017 static napi_value EglReleaseTexImageAbnormal(napi_env env, napi_callback_info info)
1018 {
1019 (void)info;
1020 EGLBoolean Ret = eglReleaseTexImage(EGL_NO_DISPLAY, EGL_NO_SURFACE, 0x00);
1021 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglReleaseTexImage error");
1022 napi_value result = nullptr;
1023 napi_create_int32(env, SUCCESS, &result);
1024 return result;
1025 }
1026
EglSurfaceAttrib(napi_env env,napi_callback_info info)1027 static napi_value EglSurfaceAttrib(napi_env env, napi_callback_info info)
1028 {
1029 (void)info;
1030 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1031 createMyEglWindow(env, &myEGLWindow);
1032 EGLBoolean Ret = eglSurfaceAttrib(myEGLWindow.eglDisplay, myEGLWindow.eglLSurface, EGL_MIPMAP_LEVEL, EGL_ONE);
1033 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSurfaceAttrib error");
1034 destroyMyEglWindow(env, &myEGLWindow);
1035 napi_value result = nullptr;
1036 napi_create_int32(env, SUCCESS, &result);
1037 return result;
1038 }
1039
EglSurfaceAttribAbnormal(napi_env env,napi_callback_info info)1040 static napi_value EglSurfaceAttribAbnormal(napi_env env, napi_callback_info info)
1041 {
1042 (void)info;
1043 eglGetErrorInit();
1044 EGLBoolean Ret = eglSurfaceAttrib(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_MIPMAP_LEVEL, EGL_ONE);
1045 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglSurfaceAttrib error");
1046 EGLint eglError = eglGetError();
1047 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1048 napi_value result = nullptr;
1049 napi_create_int32(env, SUCCESS, &result);
1050 return result;
1051 }
1052
EglSwapInterval(napi_env env,napi_callback_info info)1053 static napi_value EglSwapInterval(napi_env env, napi_callback_info info)
1054 {
1055 (void)info;
1056 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1057 createMyEglWindow(env, &myEGLWindow);
1058 EGLBoolean Ret = eglSwapInterval(myEGLWindow.eglDisplay, EGL_ONE);
1059 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglSwapInterval error");
1060 destroyMyEglWindow(env, &myEGLWindow);
1061 napi_value result = nullptr;
1062 napi_create_int32(env, SUCCESS, &result);
1063 return result;
1064 }
1065
EglSwapIntervalAbnormal(napi_env env,napi_callback_info info)1066 static napi_value EglSwapIntervalAbnormal(napi_env env, napi_callback_info info)
1067 {
1068 (void)info;
1069 eglGetErrorInit();
1070 EGLBoolean Ret = eglSwapInterval(EGL_NO_DISPLAY, EGL_ONE);
1071 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglSwapInterval error");
1072 EGLint eglError = eglGetError();
1073 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1074 napi_value result = nullptr;
1075 napi_create_int32(env, SUCCESS, &result);
1076 return result;
1077 }
1078
EglBindAPI(napi_env env,napi_callback_info info)1079 static napi_value EglBindAPI(napi_env env, napi_callback_info info)
1080 {
1081 (void)info;
1082 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1083 createMyEglWindow(env, &myEGLWindow);
1084 EGLBoolean Ret = eglBindAPI(EGL_OPENGL_ES_API);
1085 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglBindAPI error");
1086 destroyMyEglWindow(env, &myEGLWindow);
1087 napi_value result = nullptr;
1088 napi_create_int32(env, SUCCESS, &result);
1089 return result;
1090 }
1091
EglBindAPIAbnormal(napi_env env,napi_callback_info info)1092 static napi_value EglBindAPIAbnormal(napi_env env, napi_callback_info info)
1093 {
1094 (void)info;
1095 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1096 createMyEglWindow(env, &myEGLWindow);
1097 EGLBoolean Ret = eglBindAPI(EGL_OPENGL_API);
1098 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindAPI error");
1099 Ret = eglBindAPI(EGL_OPENVG_API);
1100 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglBindAPI error");
1101 destroyMyEglWindow(env, &myEGLWindow);
1102 napi_value result = nullptr;
1103 napi_create_int32(env, SUCCESS, &result);
1104 return result;
1105 }
1106
EglQueryAPI(napi_env env,napi_callback_info info)1107 static napi_value EglQueryAPI(napi_env env, napi_callback_info info)
1108 {
1109 (void)info;
1110 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1111 createMyEglWindow(env, &myEGLWindow);
1112 NAPI_ASSERT(env, eglQueryAPI() == EGL_OPENGL_ES_API, "eglQueryAPI error");
1113 destroyMyEglWindow(env, &myEGLWindow);
1114 napi_value result = nullptr;
1115 napi_create_int32(env, SUCCESS, &result);
1116 return result;
1117 }
1118
EglCreatePbufferFromClientBufferAbnormal(napi_env env,napi_callback_info info)1119 static napi_value EglCreatePbufferFromClientBufferAbnormal(napi_env env, napi_callback_info info)
1120 {
1121 (void)info;
1122 eglGetErrorInit();
1123 EGLSurface eglSurface =
1124 eglCreatePbufferFromClientBuffer(EGL_NO_DISPLAY, EGL_OPENVG_IMAGE, nullptr, nullptr, nullptr);
1125 NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePbufferFromClientBuffer error");
1126 EGLint eglError = eglGetError();
1127 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1128 napi_value result = nullptr;
1129 napi_create_int32(env, SUCCESS, &result);
1130 return result;
1131 }
1132
EglReleaseThread(napi_env env,napi_callback_info info)1133 static napi_value EglReleaseThread(napi_env env, napi_callback_info info)
1134 {
1135 (void)info;
1136 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1137 createMyEglWindow(env, &myEGLWindow);
1138 EGLBoolean Ret = eglReleaseThread();
1139 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglReleaseThread error");
1140 destroyMyEglWindow(env, &myEGLWindow);
1141 napi_value result = nullptr;
1142 napi_create_int32(env, SUCCESS, &result);
1143 return result;
1144 }
1145
EglWaitClient(napi_env env,napi_callback_info info)1146 static napi_value EglWaitClient(napi_env env, napi_callback_info info)
1147 {
1148 (void)info;
1149 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1150 createMyEglWindow(env, &myEGLWindow);
1151 EGLBoolean Ret = eglWaitClient();
1152 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitClient error");
1153 destroyMyEglWindow(env, &myEGLWindow);
1154 napi_value result = nullptr;
1155 napi_create_int32(env, SUCCESS, &result);
1156 return result;
1157 }
1158
EglGetCurrentContext(napi_env env,napi_callback_info info)1159 static napi_value EglGetCurrentContext(napi_env env, napi_callback_info info)
1160 {
1161 (void)info;
1162 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1163 createMyEglWindow(env, &myEGLWindow);
1164 EGLContext eglContext = eglGetCurrentContext();
1165 NAPI_ASSERT(env, eglContext != EGL_NO_CONTEXT, "eglGetCurrentContext error");
1166 destroyMyEglWindow(env, &myEGLWindow);
1167 napi_value result = nullptr;
1168 napi_create_int32(env, SUCCESS, &result);
1169 return result;
1170 }
1171
EglCreateSync(napi_env env,napi_callback_info info)1172 static napi_value EglCreateSync(napi_env env, napi_callback_info info)
1173 {
1174 (void)info;
1175 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1176 createMyEglWindow(env, &myEGLWindow);
1177 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1178 const EGLAttrib attr[] = {EGL_NONE};
1179 EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1180 NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1181 EGLBoolean Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1182 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1183 }
1184 destroyMyEglWindow(env, &myEGLWindow);
1185 napi_value result = nullptr;
1186 napi_create_int32(env, SUCCESS, &result);
1187 return result;
1188 }
1189
EglCreateSyncAbnormal(napi_env env,napi_callback_info info)1190 static napi_value EglCreateSyncAbnormal(napi_env env, napi_callback_info info)
1191 {
1192 (void)info;
1193 eglGetErrorInit();
1194 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1195 createMyEglWindow(env, &myEGLWindow);
1196 EGLSync eglSync = eglCreateSync(EGL_NO_DISPLAY, EGL_SYNC_FENCE, nullptr);
1197 NAPI_ASSERT(env, eglSync == EGL_NO_SYNC, "eglCreateSync error");
1198 EGLint eglError = eglGetError();
1199 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1200 destroyMyEglWindow(env, &myEGLWindow);
1201 napi_value result = nullptr;
1202 napi_create_int32(env, SUCCESS, &result);
1203 return result;
1204 }
1205
EglDestroySync(napi_env env,napi_callback_info info)1206 static napi_value EglDestroySync(napi_env env, napi_callback_info info)
1207 {
1208 (void)info;
1209 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1210 createMyEglWindow(env, &myEGLWindow);
1211 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1212 const EGLAttrib attr[] = {EGL_NONE};
1213 EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1214 NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1215 EGLBoolean Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1216 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1217 }
1218 destroyMyEglWindow(env, &myEGLWindow);
1219 napi_value result = nullptr;
1220 napi_create_int32(env, SUCCESS, &result);
1221 return result;
1222 }
1223
EglDestroySyncAbnormal(napi_env env,napi_callback_info info)1224 static napi_value EglDestroySyncAbnormal(napi_env env, napi_callback_info info)
1225 {
1226 (void)info;
1227 eglGetErrorInit();
1228 EGLBoolean Ret = eglDestroySync(EGL_NO_DISPLAY, EGL_NO_SYNC);
1229 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglDestroySync error");
1230 EGLint eglError = eglGetError();
1231 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1232 napi_value result = nullptr;
1233 napi_create_int32(env, SUCCESS, &result);
1234 return result;
1235 }
1236
EglClientWaitSync(napi_env env,napi_callback_info info)1237 static napi_value EglClientWaitSync(napi_env env, napi_callback_info info)
1238 {
1239 (void)info;
1240 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1241 createMyEglWindow(env, &myEGLWindow);
1242 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1243 const EGLAttrib attr[] = {EGL_NONE};
1244 EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1245 NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1246 EGLBoolean Ret = eglClientWaitSync(myEGLWindow.eglDisplay, eglSync, 0x00, EGL_FOREVER);
1247 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglClientWaitSync error");
1248 Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1249 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1250 }
1251 destroyMyEglWindow(env, &myEGLWindow);
1252 napi_value result = nullptr;
1253 napi_create_int32(env, SUCCESS, &result);
1254 return result;
1255 }
1256
EglClientWaitSyncAbnormal(napi_env env,napi_callback_info info)1257 static napi_value EglClientWaitSyncAbnormal(napi_env env, napi_callback_info info)
1258 {
1259 (void)info;
1260 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1261 createMyEglWindow(env, &myEGLWindow);
1262 EGLBoolean Ret = eglClientWaitSync(myEGLWindow.eglDisplay, EGL_NO_SYNC, 0x00, EGL_FOREVER);
1263 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglClientWaitSync error");
1264 napi_value result = nullptr;
1265 napi_create_int32(env, SUCCESS, &result);
1266 return result;
1267 }
1268
EglGetSyncAttrib(napi_env env,napi_callback_info info)1269 static napi_value EglGetSyncAttrib(napi_env env, napi_callback_info info)
1270 {
1271 (void)info;
1272 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1273 createMyEglWindow(env, &myEGLWindow);
1274 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1275 const EGLAttrib attr[] = {EGL_NONE};
1276 EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1277 NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1278 EGLAttrib value[1] = {0x00};
1279 EGLBoolean Ret = eglGetSyncAttrib(myEGLWindow.eglDisplay, eglSync, EGL_SYNC_TYPE, value);
1280 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglGetSyncAttrib error");
1281 Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1282 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1283 }
1284 destroyMyEglWindow(env, &myEGLWindow);
1285 napi_value result = nullptr;
1286 napi_create_int32(env, SUCCESS, &result);
1287 return result;
1288 }
1289
EglGetSyncAttribAbnormal(napi_env env,napi_callback_info info)1290 static napi_value EglGetSyncAttribAbnormal(napi_env env, napi_callback_info info)
1291 {
1292 (void)info;
1293 eglGetErrorInit();
1294 EGLAttrib value[1] = {0x00};
1295 EGLBoolean Ret = eglGetSyncAttrib(EGL_NO_DISPLAY, EGL_NO_SYNC, EGL_SYNC_TYPE, value);
1296 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglGetSyncAttrib error");
1297 EGLint eglError = eglGetError();
1298 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1299 napi_value result = nullptr;
1300 napi_create_int32(env, SUCCESS, &result);
1301 return result;
1302 }
1303
EglCreateImage(napi_env env,napi_callback_info info)1304 static napi_value EglCreateImage(napi_env env, napi_callback_info info)
1305 {
1306 (void)info;
1307 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1308 createMyEglWindow(env, &myEGLWindow);
1309 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1310 int texture = EGL_ONE;
1311 glBindTexture(GL_TEXTURE_2D, texture);
1312 glTexImage2D(GL_TEXTURE_2D, 0x00, GL_RGBA, INIT_WIDTH, INIT_HEIGHT, 0x00, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
1313 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1314 const EGLAttrib eglAttrib[] = {EGL_GL_TEXTURE_LEVEL, 0x00, EGL_NONE};
1315 EGLImage image = eglCreateImage(myEGLWindow.eglDisplay, myEGLWindow.eglContext, EGL_GL_TEXTURE_2D,
1316 (void *)(static_cast<intptr_t>(texture)), eglAttrib);
1317 NAPI_ASSERT(env, image != EGL_NO_IMAGE, "eglCreateImage error");
1318 EGLBoolean Ret = eglDestroyImage(myEGLWindow.eglDisplay, image);
1319 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroyImage error");
1320 }
1321 destroyMyEglWindow(env, &myEGLWindow);
1322 napi_value result = nullptr;
1323 napi_create_int32(env, SUCCESS, &result);
1324 return result;
1325 }
1326
EglCreateImageAbnormal(napi_env env,napi_callback_info info)1327 static napi_value EglCreateImageAbnormal(napi_env env, napi_callback_info info)
1328 {
1329 (void)info;
1330 eglGetErrorInit();
1331 EGLImage image = eglCreateImage(EGL_NO_DISPLAY, EGL_NO_CONTEXT, EGL_GL_TEXTURE_2D, nullptr, nullptr);
1332 NAPI_ASSERT(env, image == EGL_NO_IMAGE, "eglCreateImage error");
1333 EGLint eglError = eglGetError();
1334 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1335 napi_value result = nullptr;
1336 napi_create_int32(env, SUCCESS, &result);
1337 return result;
1338 }
1339
EglDestroyImage(napi_env env,napi_callback_info info)1340 static napi_value EglDestroyImage(napi_env env, napi_callback_info info)
1341 {
1342 (void)info;
1343 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1344 createMyEglWindow(env, &myEGLWindow);
1345 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1346 int texture = EGL_ONE;
1347 glBindTexture(GL_TEXTURE_2D, texture);
1348 glTexImage2D(GL_TEXTURE_2D, 0x00, GL_RGBA, INIT_WIDTH, INIT_HEIGHT, 0x00, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
1349 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1350 const EGLAttrib eglAttrib[] = {EGL_GL_TEXTURE_LEVEL, 0x00, EGL_NONE};
1351 EGLImage image = eglCreateImage(myEGLWindow.eglDisplay, myEGLWindow.eglContext, EGL_GL_TEXTURE_2D,
1352 (void *)(static_cast<intptr_t>(texture)), eglAttrib);
1353 NAPI_ASSERT(env, image != EGL_NO_IMAGE, "eglCreateImage error");
1354 EGLBoolean Ret = eglDestroyImage(myEGLWindow.eglDisplay, image);
1355 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroyImage error");
1356 }
1357 destroyMyEglWindow(env, &myEGLWindow);
1358 napi_value result = nullptr;
1359 napi_create_int32(env, SUCCESS, &result);
1360 return result;
1361 }
1362
EglDestroyImageAbnormal(napi_env env,napi_callback_info info)1363 static napi_value EglDestroyImageAbnormal(napi_env env, napi_callback_info info)
1364 {
1365 (void)info;
1366 eglGetErrorInit();
1367 EGLBoolean Ret = eglDestroyImage(EGL_NO_DISPLAY, EGL_NO_IMAGE);
1368 NAPI_ASSERT(env, Ret != EGL_TRUE, "eglDestroyImage error");
1369 EGLint eglError = eglGetError();
1370 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1371 napi_value result = nullptr;
1372 napi_create_int32(env, SUCCESS, &result);
1373 return result;
1374 }
1375
EglGetPlatformDisplay(napi_env env,napi_callback_info info)1376 static napi_value EglGetPlatformDisplay(napi_env env, napi_callback_info info)
1377 {
1378 (void)info;
1379 EGLDisplay eglDisplay = eglGetPlatformDisplay(EGL_PLATFORM_OHOS_KHR, EGL_DEFAULT_DISPLAY, nullptr);
1380 NAPI_ASSERT(env, eglDisplay != EGL_NO_DISPLAY, "eglGetPlatformDisplay error");
1381 EGLBoolean Ret = eglTerminate(eglDisplay);
1382 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglTerminate error");
1383 napi_value result = nullptr;
1384 napi_create_int32(env, SUCCESS, &result);
1385 return result;
1386 }
1387
EglGetPlatformDisplayAbnormal(napi_env env,napi_callback_info info)1388 static napi_value EglGetPlatformDisplayAbnormal(napi_env env, napi_callback_info info)
1389 {
1390 (void)info;
1391 eglGetErrorInit();
1392 EGLDisplay eglDisplay = eglGetPlatformDisplay(0x00, nullptr, nullptr);
1393 NAPI_ASSERT(env, eglDisplay == EGL_NO_DISPLAY, "eglGetPlatformDisplay error");
1394 EGLint eglError = eglGetError();
1395 NAPI_ASSERT(env, eglError == EGL_BAD_PARAMETER, "eglGetError error");
1396 napi_value result = nullptr;
1397 napi_create_int32(env, SUCCESS, &result);
1398 return result;
1399 }
1400
EglCreatePlatformWindowSurfaceAbnormal(napi_env env,napi_callback_info info)1401 static napi_value EglCreatePlatformWindowSurfaceAbnormal(napi_env env, napi_callback_info info)
1402 {
1403 (void)info;
1404 eglGetErrorInit();
1405 EGLSurface eglSurface = eglCreatePlatformWindowSurface(EGL_NO_DISPLAY, nullptr, nullptr, nullptr);
1406 NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePlatformWindowSurface error");
1407 EGLint eglError = eglGetError();
1408 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1409 napi_value result = nullptr;
1410 napi_create_int32(env, SUCCESS, &result);
1411 return result;
1412 }
1413
EglCreatePlatformPixmapSurfaceAbnormal(napi_env env,napi_callback_info info)1414 static napi_value EglCreatePlatformPixmapSurfaceAbnormal(napi_env env, napi_callback_info info)
1415 {
1416 (void)info;
1417 eglGetErrorInit();
1418 EGLSurface eglSurface = eglCreatePlatformPixmapSurface(EGL_NO_DISPLAY, nullptr, nullptr, nullptr);
1419 NAPI_ASSERT(env, eglSurface == EGL_NO_SURFACE, "eglCreatePlatformPixmapSurface error");
1420 EGLint eglError = eglGetError();
1421 NAPI_ASSERT(env, eglError == EGL_BAD_DISPLAY, "eglGetError error");
1422 napi_value result = nullptr;
1423 napi_create_int32(env, SUCCESS, &result);
1424 return result;
1425 }
1426
EglWaitSync(napi_env env,napi_callback_info info)1427 static napi_value EglWaitSync(napi_env env, napi_callback_info info)
1428 {
1429 (void)info;
1430 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1431 createMyEglWindow(env, &myEGLWindow);
1432 if (myEGLWindow.eglVersion >= GL_VERSION_15) {
1433 const EGLAttrib attr[] = {EGL_NONE};
1434 EGLSync eglSync = eglCreateSync(myEGLWindow.eglDisplay, EGL_SYNC_FENCE, attr);
1435 NAPI_ASSERT(env, eglSync != EGL_NO_SYNC, "eglCreateSync error");
1436 EGLBoolean Ret = eglWaitSync(myEGLWindow.eglDisplay, eglSync, 0x00);
1437 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglWaitSync error");
1438 Ret = eglDestroySync(myEGLWindow.eglDisplay, eglSync);
1439 NAPI_ASSERT(env, Ret == EGL_TRUE, "eglDestroySync error");
1440 }
1441 destroyMyEglWindow(env, &myEGLWindow);
1442 napi_value result = nullptr;
1443 napi_create_int32(env, SUCCESS, &result);
1444 return result;
1445 }
1446
EglWaitSyncAbnormal(napi_env env,napi_callback_info info)1447 static napi_value EglWaitSyncAbnormal(napi_env env, napi_callback_info info)
1448 {
1449 (void)info;
1450 MyEGLWindow myEGLWindow = {EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_CONTEXT};
1451 createMyEglWindow(env, &myEGLWindow);
1452 EGLBoolean Ret = eglWaitSync(myEGLWindow.eglDisplay, EGL_NO_SYNC, EGL_ONE);
1453 NAPI_ASSERT(env, Ret == EGL_FALSE, "eglWaitSync error");
1454 destroyMyEglWindow(env, &myEGLWindow);
1455 napi_value result = nullptr;
1456 napi_create_int32(env, SUCCESS, &result);
1457 return result;
1458 }
1459
1460 EXTERN_C_START
Init(napi_env env,napi_value exports)1461 static napi_value Init(napi_env env, napi_value exports)
1462 {
1463 napi_property_descriptor desc[] = {
1464 {"eglChooseConfig", nullptr, EglChooseConfig, nullptr, nullptr, nullptr, napi_default, nullptr},
1465 {"eglChooseConfigAbnormal", nullptr, EglChooseConfigAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1466 {"eglCopyBuffersAbnormal", nullptr, EglCopyBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1467 {"eglCreateContext", nullptr, EglCreateContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1468 {"eglCreateContextAbnormal", nullptr, EglCreateContextAbnormal, nullptr, nullptr, nullptr, napi_default,
1469 nullptr},
1470 {"eglCreatePbufferSurface", nullptr, EglCreatePbufferSurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1471 {"eglCreatePbufferSurfaceAbnormal", nullptr, EglCreatePbufferSurfaceAbnormal, nullptr, nullptr, nullptr,
1472 napi_default, nullptr},
1473 {"eglCreatePixmapSurfaceAbnormal", nullptr, EglCreatePixmapSurfaceAbnormal, nullptr, nullptr, nullptr,
1474 napi_default, nullptr},
1475 {"eglCreateWindowSurfaceAbnormal", nullptr, EglCreateWindowSurfaceAbnormal, nullptr, nullptr, nullptr,
1476 napi_default, nullptr},
1477 {"eglDestroyContext", nullptr, EglDestroyContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1478 {"eglDestroyContextAbnormal", nullptr, EglDestroyContextAbnormal, nullptr, nullptr, nullptr, napi_default,
1479 nullptr},
1480 {"eglDestroySurface", nullptr, EglDestroySurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1481 {"eglDestroySurfaceAbnormal", nullptr, EglDestroySurfaceAbnormal, nullptr, nullptr, nullptr, napi_default,
1482 nullptr},
1483 {"eglGetConfigAttrib", nullptr, EglGetConfigAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1484 {"eglGetConfigAttribAbnormal", nullptr, EglGetConfigAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1485 nullptr},
1486 {"eglGetConfigs", nullptr, EglGetConfigs, nullptr, nullptr, nullptr, napi_default, nullptr},
1487 {"eglGetConfigsAbnormal", nullptr, EglGetConfigsAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1488 {"eglGetCurrentDisplay", nullptr, EglGetCurrentDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1489 {"eglGetCurrentDisplayAbnormal", nullptr, EglGetCurrentDisplayAbnormal, nullptr, nullptr, nullptr, napi_default,
1490 nullptr},
1491 {"eglGetCurrentSurface", nullptr, EglGetCurrentSurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1492 {"eglGetCurrentSurfaceAbnormal", nullptr, EglGetCurrentSurfaceAbnormal, nullptr, nullptr, nullptr, napi_default,
1493 nullptr},
1494 {"eglGetDisplay", nullptr, EglGetDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1495 {"eglGetError", nullptr, EglGetError, nullptr, nullptr, nullptr, napi_default, nullptr},
1496 {"eglGetProcAddress", nullptr, EglGetProcAddress, nullptr, nullptr, nullptr, napi_default, nullptr},
1497 {"eglGetProcAddressAbnormal", nullptr, EglGetProcAddressAbnormal, nullptr, nullptr, nullptr, napi_default,
1498 nullptr},
1499 {"eglInitialize", nullptr, EglInitialize, nullptr, nullptr, nullptr, napi_default, nullptr},
1500 {"eglInitializeAbnormal", nullptr, EglInitializeAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1501 {"eglMakeCurrent", nullptr, EglMakeCurrent, nullptr, nullptr, nullptr, napi_default, nullptr},
1502 {"eglMakeCurrentAbnormal", nullptr, EglMakeCurrentAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1503 {"eglSwapBuffersWithDamageKHRRect1", nullptr, EglSwapBuffersWithDamageKHRRect1, nullptr, nullptr, nullptr,
1504 napi_default, nullptr},
1505 {"eglSwapBuffersWithDamageKHRRect2", nullptr, EglSwapBuffersWithDamageKHRRect2, nullptr, nullptr, nullptr,
1506 napi_default, nullptr},
1507 {"EglSwapBuffersWithDamageKHRSurfaceRectsNull", nullptr, EglSwapBuffersWithDamageKHRSurfaceRectsNull, nullptr,
1508 nullptr, nullptr, napi_default, nullptr},
1509 {"eglQueryContext", nullptr, EglQueryContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1510 {"eglQueryContextAbnormal", nullptr, EglQueryContextAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1511 {"eglQueryString", nullptr, EglQueryString, nullptr, nullptr, nullptr, napi_default, nullptr},
1512 {"eglQueryStringAbnormal", nullptr, EglQueryStringAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1513 {"eglQuerySurface", nullptr, EglQuerySurface, nullptr, nullptr, nullptr, napi_default, nullptr},
1514 {"eglQuerySurfaceAbnormal", nullptr, EglQuerySurfaceAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1515 {"eglSwapBuffers", nullptr, EglSwapBuffers, nullptr, nullptr, nullptr, napi_default, nullptr},
1516 {"eglSwapBuffersAbnormal", nullptr, EglSwapBuffersAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1517 {"eglTerminate", nullptr, EglTerminate, nullptr, nullptr, nullptr, napi_default, nullptr},
1518 {"eglTerminateAbnormal", nullptr, EglTerminateAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1519 {"eglWaitGL", nullptr, EglWaitGL, nullptr, nullptr, nullptr, napi_default, nullptr},
1520 {"eglWaitNative", nullptr, EglWaitNative, nullptr, nullptr, nullptr, napi_default, nullptr},
1521 {"eglBindTexImage", nullptr, EglBindTexImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1522 {"eglBindTexImageAbnormal", nullptr, EglBindTexImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1523 {"eglReleaseTexImage", nullptr, EglReleaseTexImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1524 {"eglReleaseTexImageAbnormal", nullptr, EglReleaseTexImageAbnormal, nullptr, nullptr, nullptr, napi_default,
1525 nullptr},
1526 {"eglSurfaceAttrib", nullptr, EglSurfaceAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1527 {"eglSurfaceAttribAbnormal", nullptr, EglSurfaceAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1528 nullptr},
1529 {"eglSwapInterval", nullptr, EglSwapInterval, nullptr, nullptr, nullptr, napi_default, nullptr},
1530 {"eglSwapIntervalAbnormal", nullptr, EglSwapIntervalAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1531 {"eglBindAPI", nullptr, EglBindAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
1532 {"eglBindAPIAbnormal", nullptr, EglBindAPIAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1533 {"eglQueryAPI", nullptr, EglQueryAPI, nullptr, nullptr, nullptr, napi_default, nullptr},
1534 {"eglCreatePbufferFromClientBufferAbnormal", nullptr, EglCreatePbufferFromClientBufferAbnormal, nullptr,
1535 nullptr, nullptr, napi_default, nullptr},
1536 {"eglReleaseThread", nullptr, EglReleaseThread, nullptr, nullptr, nullptr, napi_default, nullptr},
1537 {"eglWaitClient", nullptr, EglWaitClient, nullptr, nullptr, nullptr, napi_default, nullptr},
1538 {"eglGetCurrentContext", nullptr, EglGetCurrentContext, nullptr, nullptr, nullptr, napi_default, nullptr},
1539 {"eglCreateSync", nullptr, EglCreateSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1540 {"eglCreateSyncAbnormal", nullptr, EglCreateSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1541 {"eglDestroySync", nullptr, EglDestroySync, nullptr, nullptr, nullptr, napi_default, nullptr},
1542 {"eglDestroySyncAbnormal", nullptr, EglDestroySyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1543 {"eglClientWaitSync", nullptr, EglClientWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1544 {"eglClientWaitSyncAbnormal", nullptr, EglClientWaitSyncAbnormal, nullptr, nullptr, nullptr, napi_default,
1545 nullptr},
1546 {"eglGetSyncAttrib", nullptr, EglGetSyncAttrib, nullptr, nullptr, nullptr, napi_default, nullptr},
1547 {"eglGetSyncAttribAbnormal", nullptr, EglGetSyncAttribAbnormal, nullptr, nullptr, nullptr, napi_default,
1548 nullptr},
1549 {"eglCreateImage", nullptr, EglCreateImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1550 {"eglCreateImageAbnormal", nullptr, EglCreateImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1551 {"eglDestroyImage", nullptr, EglDestroyImage, nullptr, nullptr, nullptr, napi_default, nullptr},
1552 {"eglDestroyImageAbnormal", nullptr, EglDestroyImageAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1553 {"eglGetPlatformDisplay", nullptr, EglGetPlatformDisplay, nullptr, nullptr, nullptr, napi_default, nullptr},
1554 {"eglGetPlatformDisplayAbnormal", nullptr, EglGetPlatformDisplayAbnormal, nullptr, nullptr, nullptr,
1555 napi_default, nullptr},
1556 {"eglCreatePlatformWindowSurfaceAbnormal", nullptr, EglCreatePlatformWindowSurfaceAbnormal, nullptr, nullptr,
1557 nullptr, napi_default, nullptr},
1558 {"eglCreatePlatformPixmapSurfaceAbnormal", nullptr, EglCreatePlatformPixmapSurfaceAbnormal, nullptr, nullptr,
1559 nullptr, napi_default, nullptr},
1560 {"eglWaitSync", nullptr, EglWaitSync, nullptr, nullptr, nullptr, napi_default, nullptr},
1561 {"eglWaitSyncAbnormal", nullptr, EglWaitSyncAbnormal, nullptr, nullptr, nullptr, napi_default, nullptr},
1562 };
1563 napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1564 return exports;
1565 }
1566 EXTERN_C_END
1567
1568 static napi_module demoModule = {
1569 .nm_version = 1,
1570 .nm_flags = 0,
1571 .nm_filename = nullptr,
1572 .nm_register_func = Init,
1573 .nm_modname = "eglndk",
1574 .nm_priv = ((void *)0),
1575 .reserved = {0},
1576 };
1577
RegisterModule(void)1578 extern "C" __attribute__((constructor)) void RegisterModule(void) { napi_module_register(&demoModule); }
1579