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