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