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