1 //
2 // Copyright 2015 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6 
7 // validationEGL.h: Validation functions for generic EGL entry point parameters
8 
9 #ifndef LIBANGLE_VALIDATIONEGL_H_
10 #define LIBANGLE_VALIDATIONEGL_H_
11 
12 #include "common/PackedEnums.h"
13 #include "libANGLE/Error.h"
14 #include "libANGLE/Texture.h"
15 
16 #include <EGL/egl.h>
17 #include <EGL/eglext.h>
18 
19 namespace gl
20 {
21 class Context;
22 }
23 
24 namespace egl
25 {
26 
27 class AttributeMap;
28 struct ClientExtensions;
29 struct Config;
30 class Device;
31 class Display;
32 class Image;
33 class Stream;
34 class Surface;
35 class Sync;
36 class Thread;
37 class LabeledObject;
38 
39 // Object validation
40 Error ValidateDisplay(const Display *display);
41 Error ValidateSurface(const Display *display, const Surface *surface);
42 Error ValidateConfig(const Display *display, const Config *config);
43 Error ValidateContext(const Display *display, const gl::Context *context);
44 Error ValidateImage(const Display *display, const Image *image);
45 Error ValidateDevice(const Device *device);
46 Error ValidateSync(const Display *display, const Sync *sync);
47 
48 // Return the requested object only if it is valid (otherwise nullptr)
49 const Thread *GetThreadIfValid(const Thread *thread);
50 const Display *GetDisplayIfValid(const Display *display);
51 const Surface *GetSurfaceIfValid(const Display *display, const Surface *surface);
52 const Image *GetImageIfValid(const Display *display, const Image *image);
53 const Stream *GetStreamIfValid(const Display *display, const Stream *stream);
54 const gl::Context *GetContextIfValid(const Display *display, const gl::Context *context);
55 const Device *GetDeviceIfValid(const Device *device);
56 const Sync *GetSyncIfValid(const Display *display, const Sync *sync);
57 LabeledObject *GetLabeledObjectIfValid(Thread *thread,
58                                        const Display *display,
59                                        ObjectType objectType,
60                                        EGLObjectKHR object);
61 
62 // Entry point validation
63 Error ValidateInitialize(const Display *display);
64 
65 Error ValidateTerminate(const Display *display);
66 
67 Error ValidateCreateContext(Display *display,
68                             Config *configuration,
69                             gl::Context *shareContext,
70                             const AttributeMap &attributes);
71 
72 Error ValidateCreateWindowSurface(Display *display,
73                                   Config *config,
74                                   EGLNativeWindowType window,
75                                   const AttributeMap &attributes);
76 
77 Error ValidateCreatePbufferSurface(Display *display,
78                                    Config *config,
79                                    const AttributeMap &attributes);
80 Error ValidateCreatePbufferFromClientBuffer(Display *display,
81                                             EGLenum buftype,
82                                             EGLClientBuffer buffer,
83                                             Config *config,
84                                             const AttributeMap &attributes);
85 
86 Error ValidateCreatePixmapSurface(Display *display,
87                                   Config *config,
88                                   EGLNativePixmapType pixmap,
89                                   const AttributeMap &attributes);
90 
91 Error ValidateMakeCurrent(Display *display, Surface *draw, Surface *read, gl::Context *context);
92 
93 Error ValidateCreateImage(const Display *display,
94                           gl::Context *context,
95                           EGLenum target,
96                           EGLClientBuffer buffer,
97                           const AttributeMap &attributes);
98 Error ValidateDestroyImage(const Display *display, const Image *image);
99 Error ValidateCreateImageKHR(const Display *display,
100                              gl::Context *context,
101                              EGLenum target,
102                              EGLClientBuffer buffer,
103                              const AttributeMap &attributes);
104 Error ValidateDestroyImageKHR(const Display *display, const Image *image);
105 
106 Error ValidateCreateDeviceANGLE(EGLint device_type,
107                                 void *native_device,
108                                 const EGLAttrib *attrib_list);
109 Error ValidateReleaseDeviceANGLE(Device *device);
110 
111 Error ValidateCreateSyncBase(const Display *display,
112                              EGLenum type,
113                              const AttributeMap &attribs,
114                              const Display *currentDisplay,
115                              const gl::Context *currentContext,
116                              bool isExt);
117 Error ValidateGetSyncAttribBase(const Display *display, const Sync *sync, EGLint attribute);
118 
119 Error ValidateCreateSyncKHR(const Display *display,
120                             EGLenum type,
121                             const AttributeMap &attribs,
122                             const Display *currentDisplay,
123                             const gl::Context *currentContext);
124 Error ValidateCreateSync(const Display *display,
125                          EGLenum type,
126                          const AttributeMap &attribs,
127                          const Display *currentDisplay,
128                          const gl::Context *currentContext);
129 Error ValidateDestroySync(const Display *display, const Sync *sync);
130 Error ValidateClientWaitSync(const Display *display,
131                              const Sync *sync,
132                              EGLint flags,
133                              EGLTime timeout);
134 Error ValidateWaitSync(const Display *display,
135                        const gl::Context *context,
136                        const Sync *sync,
137                        EGLint flags);
138 Error ValidateGetSyncAttribKHR(const Display *display,
139                                const Sync *sync,
140                                EGLint attribute,
141                                EGLint *value);
142 Error ValidateGetSyncAttrib(const Display *display,
143                             const Sync *sync,
144                             EGLint attribute,
145                             EGLAttrib *value);
146 
147 Error ValidateCreateStreamKHR(const Display *display, const AttributeMap &attributes);
148 Error ValidateDestroyStreamKHR(const Display *display, const Stream *stream);
149 Error ValidateStreamAttribKHR(const Display *display,
150                               const Stream *stream,
151                               EGLint attribute,
152                               EGLint value);
153 Error ValidateQueryStreamKHR(const Display *display,
154                              const Stream *stream,
155                              EGLenum attribute,
156                              EGLint *value);
157 Error ValidateQueryStreamu64KHR(const Display *display,
158                                 const Stream *stream,
159                                 EGLenum attribute,
160                                 EGLuint64KHR *value);
161 Error ValidateStreamConsumerGLTextureExternalKHR(const Display *display,
162                                                  gl::Context *context,
163                                                  const Stream *stream);
164 Error ValidateStreamConsumerAcquireKHR(const Display *display,
165                                        gl::Context *context,
166                                        const Stream *stream);
167 Error ValidateStreamConsumerReleaseKHR(const Display *display,
168                                        gl::Context *context,
169                                        const Stream *stream);
170 Error ValidateStreamConsumerGLTextureExternalAttribsNV(const Display *display,
171                                                        gl::Context *context,
172                                                        const Stream *stream,
173                                                        const AttributeMap &attribs);
174 Error ValidateCreateStreamProducerD3DTextureANGLE(const Display *display,
175                                                   const Stream *stream,
176                                                   const AttributeMap &attribs);
177 Error ValidateStreamPostD3DTextureANGLE(const Display *display,
178                                         const Stream *stream,
179                                         void *texture,
180                                         const AttributeMap &attribs);
181 
182 Error ValidateGetMscRateANGLE(const Display *display,
183                               const Surface *surface,
184                               const EGLint *numerator,
185                               const EGLint *denominator);
186 Error ValidateGetSyncValuesCHROMIUM(const Display *display,
187                                     const Surface *surface,
188                                     const EGLuint64KHR *ust,
189                                     const EGLuint64KHR *msc,
190                                     const EGLuint64KHR *sbc);
191 
192 Error ValidateDestroySurface(const Display *display,
193                              const Surface *surface,
194                              const EGLSurface eglSurface);
195 
196 Error ValidateDestroyContext(const Display *display,
197                              const gl::Context *glCtx,
198                              const EGLContext eglCtx);
199 
200 Error ValidateSwapBuffers(Thread *thread, const Display *display, const Surface *surface);
201 
202 Error ValidateWaitNative(const Display *display, const EGLint engine);
203 
204 Error ValidateCopyBuffers(Display *display, const Surface *surface);
205 
206 Error ValidateSwapBuffersWithDamageKHR(const Display *display,
207                                        const Surface *surface,
208                                        EGLint *rects,
209                                        EGLint n_rects);
210 
211 Error ValidateBindTexImage(const Display *display,
212                            const Surface *surface,
213                            const EGLSurface eglSurface,
214                            const EGLint buffer,
215                            const gl::Context *context,
216                            gl::Texture **textureObject);
217 
218 Error ValidateReleaseTexImage(const Display *display,
219                               const Surface *surface,
220                               const EGLSurface eglSurface,
221                               const EGLint buffer);
222 
223 Error ValidateSwapInterval(const Display *display,
224                            const Surface *draw_surface,
225                            const gl::Context *context);
226 
227 Error ValidateBindAPI(const EGLenum api);
228 
229 Error ValidatePresentationTimeANDROID(const Display *display,
230                                       const Surface *surface,
231                                       EGLnsecsANDROID time);
232 
233 Error ValidateSetBlobCacheANDROID(const Display *display,
234                                   EGLSetBlobFuncANDROID set,
235                                   EGLGetBlobFuncANDROID get);
236 
237 Error ValidateGetConfigAttrib(const Display *display, const Config *config, EGLint attribute);
238 Error ValidateChooseConfig(const Display *display,
239                            const AttributeMap &attribs,
240                            EGLint configSize,
241                            EGLint *numConfig);
242 Error ValidateGetConfigs(const Display *display, EGLint configSize, EGLint *numConfig);
243 
244 // Other validation
245 Error ValidateCompatibleSurface(const Display *display,
246                                 gl::Context *context,
247                                 const Surface *surface);
248 
249 Error ValidateGetPlatformDisplay(EGLenum platform,
250                                  void *native_display,
251                                  const EGLAttrib *attrib_list);
252 Error ValidateGetPlatformDisplayEXT(EGLenum platform,
253                                     void *native_display,
254                                     const EGLint *attrib_list);
255 Error ValidateCreatePlatformWindowSurfaceEXT(const Display *display,
256                                              const Config *configuration,
257                                              void *nativeWindow,
258                                              const AttributeMap &attributes);
259 Error ValidateCreatePlatformPixmapSurfaceEXT(const Display *display,
260                                              const Config *configuration,
261                                              void *nativePixmap,
262                                              const AttributeMap &attributes);
263 
264 Error ValidateProgramCacheGetAttribANGLE(const Display *display, EGLenum attrib);
265 
266 Error ValidateProgramCacheQueryANGLE(const Display *display,
267                                      EGLint index,
268                                      void *key,
269                                      EGLint *keysize,
270                                      void *binary,
271                                      EGLint *binarysize);
272 
273 Error ValidateProgramCachePopulateANGLE(const Display *display,
274                                         const void *key,
275                                         EGLint keysize,
276                                         const void *binary,
277                                         EGLint binarysize);
278 
279 Error ValidateProgramCacheResizeANGLE(const Display *display, EGLint limit, EGLenum mode);
280 
281 Error ValidateSurfaceAttrib(const Display *display,
282                             const Surface *surface,
283                             EGLint attribute,
284                             EGLint value);
285 Error ValidateQuerySurface(const Display *display,
286                            const Surface *surface,
287                            EGLint attribute,
288                            EGLint *value);
289 Error ValidateQueryContext(const Display *display,
290                            const gl::Context *context,
291                            EGLint attribute,
292                            EGLint *value);
293 
294 // EGL_KHR_debug
295 Error ValidateDebugMessageControlKHR(EGLDEBUGPROCKHR callback, const AttributeMap &attribs);
296 
297 Error ValidateQueryDebugKHR(EGLint attribute, EGLAttrib *value);
298 
299 Error ValidateLabelObjectKHR(Thread *thread,
300                              const Display *display,
301                              ObjectType objectType,
302                              EGLObjectKHR object,
303                              EGLLabelKHR label);
304 
305 // ANDROID_get_frame_timestamps
306 Error ValidateGetCompositorTimingSupportedANDROID(const Display *display,
307                                                   const Surface *surface,
308                                                   CompositorTiming name);
309 
310 Error ValidateGetCompositorTimingANDROID(const Display *display,
311                                          const Surface *surface,
312                                          EGLint numTimestamps,
313                                          const EGLint *names,
314                                          EGLnsecsANDROID *values);
315 
316 Error ValidateGetNextFrameIdANDROID(const Display *display,
317                                     const Surface *surface,
318                                     EGLuint64KHR *frameId);
319 
320 Error ValidateGetFrameTimestampSupportedANDROID(const Display *display,
321                                                 const Surface *surface,
322                                                 Timestamp timestamp);
323 
324 Error ValidateGetFrameTimestampsANDROID(const Display *display,
325                                         const Surface *surface,
326                                         EGLuint64KHR frameId,
327                                         EGLint numTimestamps,
328                                         const EGLint *timestamps,
329                                         EGLnsecsANDROID *values);
330 
331 Error ValidateQueryStringiANGLE(const Display *display, EGLint name, EGLint index);
332 
333 Error ValidateQueryDisplayAttribEXT(const Display *display, const EGLint attribute);
334 Error ValidateQueryDisplayAttribANGLE(const Display *display, const EGLint attribute);
335 
336 // EGL_ANDROID_get_native_client_buffer
337 Error ValidateGetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer);
338 
339 // EGL_ANDROID_create_native_client_buffer
340 Error ValidateCreateNativeClientBufferANDROID(const egl::AttributeMap &attribMap);
341 
342 // EGL_ANDROID_native_fence_sync
343 Error ValidateDupNativeFenceFDANDROID(const Display *display, const Sync *sync);
344 
345 // EGL_ANGLE_swap_with_frame_token
346 Error ValidateSwapBuffersWithFrameTokenANGLE(const Display *display,
347                                              const Surface *surface,
348                                              EGLFrameTokenANGLE frametoken);
349 
350 // EGL_KHR_reusable_sync
351 Error ValidateSignalSyncKHR(const Display *display, const Sync *sync, EGLint mode);
352 
353 }  // namespace egl
354 
355 #define ANGLE_EGL_TRY(THREAD, EXPR, FUNCNAME, LABELOBJECT)                               \
356     do                                                                                   \
357     {                                                                                    \
358         auto ANGLE_LOCAL_VAR = (EXPR);                                                   \
359         if (ANGLE_LOCAL_VAR.isError())                                                   \
360             return THREAD->setError(ANGLE_LOCAL_VAR, GetDebug(), FUNCNAME, LABELOBJECT); \
361     } while (0)
362 
363 #define ANGLE_EGL_TRY_RETURN(THREAD, EXPR, FUNCNAME, LABELOBJECT, RETVAL)         \
364     do                                                                            \
365     {                                                                             \
366         auto ANGLE_LOCAL_VAR = (EXPR);                                            \
367         if (ANGLE_LOCAL_VAR.isError())                                            \
368         {                                                                         \
369             THREAD->setError(ANGLE_LOCAL_VAR, GetDebug(), FUNCNAME, LABELOBJECT); \
370             return RETVAL;                                                        \
371         }                                                                         \
372     } while (0)
373 
374 #endif  // LIBANGLE_VALIDATIONEGL_H_
375