egl_ext_stubs.cpp | Explore in Territory

//
// Copyright 2020 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// egl_ext_stubs.cpp: Stubs for EXT extension entry points.
//

#include "libGLESv2/egl_ext_stubs_autogen.h"

#include "libANGLE/Device.h"
#include "libANGLE/Display.h"
#include "libANGLE/EGLSync.h"
#include "libANGLE/Surface.h"
#include "libANGLE/Thread.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/queryutils.h"
#include "libANGLE/renderer/DisplayImpl.h"
#include "libANGLE/validationEGL.h"
#include "libANGLE/validationEGL_autogen.h"
#include "libGLESv2/global_state.h"

namespace egl
{
EGLint ClientWaitSyncKHR(Thread *thread,
                         Display *display,
                         SyncID syncID,
                         EGLint flags,
                         EGLTimeKHR timeout)
{ … }

EGLImageKHR CreateImageKHR(Thread *thread,
                           Display *display,
                           gl::ContextID contextID,
                           EGLenum target,
                           EGLClientBuffer buffer,
                           const AttributeMap &attributes)
{ … }

EGLClientBuffer CreateNativeClientBufferANDROID(Thread *thread, const AttributeMap &attribMap)
{ … }

EGLSurface CreatePlatformPixmapSurfaceEXT(Thread *thread,
                                          Display *display,
                                          Config *configPacked,
                                          void *native_pixmap,
                                          const AttributeMap &attributes)
{ … }

EGLSurface CreatePlatformWindowSurfaceEXT(Thread *thread,
                                          Display *display,
                                          Config *configPacked,
                                          void *native_window,
                                          const AttributeMap &attributes)
{ … }

EGLStreamKHR CreateStreamKHR(Thread *thread, Display *display, const AttributeMap &attributes)
{ … }

EGLSyncKHR CreateSyncKHR(Thread *thread,
                         Display *display,
                         EGLenum type,
                         const AttributeMap &attributes)
{ … }

EGLint DebugMessageControlKHR(Thread *thread,
                              EGLDEBUGPROCKHR callback,
                              const AttributeMap &attributes)
{ … }

EGLBoolean DestroyImageKHR(Thread *thread, Display *display, egl::ImageID imageID)
{ … }

EGLBoolean DestroyStreamKHR(Thread *thread, Display *display, Stream *streamObject)
{ … }

EGLBoolean DestroySyncKHR(Thread *thread, Display *display, SyncID syncID)
{ … }

EGLint DupNativeFenceFDANDROID(Thread *thread, Display *display, SyncID syncID)
{ … }

EGLClientBuffer GetNativeClientBufferANDROID(Thread *thread, const struct AHardwareBuffer *buffer)
{ … }

EGLDisplay GetPlatformDisplayEXT(Thread *thread,
                                 EGLenum platform,
                                 void *native_display,
                                 const AttributeMap &attribMap)
{ … }

EGLBoolean GetSyncAttribKHR(Thread *thread,
                            Display *display,
                            SyncID syncObject,
                            EGLint attribute,
                            EGLint *value)
{ … }

EGLint LabelObjectKHR(Thread *thread,
                      Display *display,
                      ObjectType objectTypePacked,
                      EGLObjectKHR object,
                      EGLLabelKHR label)
{ … }

EGLBoolean PostSubBufferNV(Thread *thread,
                           Display *display,
                           SurfaceID surfaceID,
                           EGLint x,
                           EGLint y,
                           EGLint width,
                           EGLint height)
{ … }

EGLBoolean PresentationTimeANDROID(Thread *thread,
                                   Display *display,
                                   SurfaceID surfaceID,
                                   EGLnsecsANDROID time)
{ … }

EGLBoolean GetCompositorTimingSupportedANDROID(Thread *thread,
                                               Display *display,
                                               SurfaceID surfaceID,
                                               CompositorTiming nameInternal)
{ … }

EGLBoolean GetCompositorTimingANDROID(Thread *thread,
                                      Display *display,
                                      SurfaceID surfaceID,
                                      EGLint numTimestamps,
                                      const EGLint *names,
                                      EGLnsecsANDROID *values)
{ … }

EGLBoolean GetNextFrameIdANDROID(Thread *thread,
                                 Display *display,
                                 SurfaceID surfaceID,
                                 EGLuint64KHR *frameId)
{ … }

EGLBoolean GetFrameTimestampSupportedANDROID(Thread *thread,
                                             Display *display,
                                             SurfaceID surfaceID,
                                             Timestamp timestampInternal)
{ … }

EGLBoolean GetFrameTimestampsANDROID(Thread *thread,
                                     Display *display,
                                     SurfaceID surfaceID,
                                     EGLuint64KHR frameId,
                                     EGLint numTimestamps,
                                     const EGLint *timestamps,
                                     EGLnsecsANDROID *values)
{ … }

EGLBoolean QueryDebugKHR(Thread *thread, EGLint attribute, EGLAttrib *value)
{ … }

EGLBoolean QueryDeviceAttribEXT(Thread *thread, Device *dev, EGLint attribute, EGLAttrib *value)
{ … }

const char *QueryDeviceStringEXT(Thread *thread, Device *dev, EGLint name)
{ … }

EGLBoolean QueryDisplayAttribEXT(Thread *thread,
                                 Display *display,
                                 EGLint attribute,
                                 EGLAttrib *value)
{ … }

EGLBoolean QueryStreamKHR(Thread *thread,
                          Display *display,
                          Stream *streamObject,
                          EGLenum attribute,
                          EGLint *value)
{ … }

EGLBoolean QueryStreamu64KHR(Thread *thread,
                             Display *display,
                             Stream *streamObject,
                             EGLenum attribute,
                             EGLuint64KHR *value)
{ … }

EGLBoolean QuerySurfacePointerANGLE(Thread *thread,
                                    Display *display,
                                    SurfaceID surfaceID,
                                    EGLint attribute,
                                    void **value)
{ … }

void SetBlobCacheFuncsANDROID(Thread *thread,
                              Display *display,
                              EGLSetBlobFuncANDROID set,
                              EGLGetBlobFuncANDROID get)
{ … }

EGLBoolean SignalSyncKHR(Thread *thread, Display *display, SyncID syncID, EGLenum mode)
{ … }

EGLBoolean StreamAttribKHR(Thread *thread,
                           Display *display,
                           Stream *streamObject,
                           EGLenum attribute,
                           EGLint value)
{ … }

EGLBoolean StreamConsumerAcquireKHR(Thread *thread, Display *display, Stream *streamObject)
{ … }

EGLBoolean StreamConsumerGLTextureExternalKHR(Thread *thread,
                                              Display *display,
                                              Stream *streamObject)
{ … }

EGLBoolean StreamConsumerGLTextureExternalAttribsNV(Thread *thread,
                                                    Display *display,
                                                    Stream *streamObject,
                                                    const AttributeMap &attributes)
{ … }

EGLBoolean StreamConsumerReleaseKHR(Thread *thread, Display *display, Stream *streamObject)
{ … }

EGLBoolean SwapBuffersWithDamageKHR(Thread *thread,
                                    Display *display,
                                    SurfaceID surfaceID,
                                    const EGLint *rects,
                                    EGLint n_rects)
{ … }

EGLBoolean PrepareSwapBuffersANGLE(Thread *thread, Display *display, SurfaceID surfaceID)
{ … }

EGLint WaitSyncKHR(Thread *thread, Display *display, SyncID syncID, EGLint flags)
{ … }

EGLDeviceEXT CreateDeviceANGLE(Thread *thread,
                               EGLint device_type,
                               void *native_device,
                               const EGLAttrib *attrib_list)
{ … }

EGLBoolean ReleaseDeviceANGLE(Thread *thread, Device *dev)
{ … }

EGLBoolean CreateStreamProducerD3DTextureANGLE(Thread *thread,
                                               Display *display,
                                               Stream *streamObject,
                                               const AttributeMap &attributes)
{ … }

EGLBoolean StreamPostD3DTextureANGLE(Thread *thread,
                                     Display *display,
                                     Stream *streamObject,
                                     void *texture,
                                     const AttributeMap &attributes)
{ … }

EGLBoolean GetMscRateANGLE(Thread *thread,
                           Display *display,
                           SurfaceID surfaceID,
                           EGLint *numerator,
                           EGLint *denominator)
{ … }

EGLBoolean GetSyncValuesCHROMIUM(Thread *thread,
                                 Display *display,
                                 SurfaceID surfaceID,
                                 EGLuint64KHR *ust,
                                 EGLuint64KHR *msc,
                                 EGLuint64KHR *sbc)
{ … }

EGLint ProgramCacheGetAttribANGLE(Thread *thread, Display *display, EGLenum attrib)
{ … }

void ProgramCacheQueryANGLE(Thread *thread,
                            Display *display,
                            EGLint index,
                            void *key,
                            EGLint *keysize,
                            void *binary,
                            EGLint *binarysize)
{ … }

void ProgramCachePopulateANGLE(Thread *thread,
                               Display *display,
                               const void *key,
                               EGLint keysize,
                               const void *binary,
                               EGLint binarysize)
{ … }

EGLint ProgramCacheResizeANGLE(Thread *thread, Display *display, EGLint limit, EGLint mode)
{ … }

const char *QueryStringiANGLE(Thread *thread, Display *display, EGLint name, EGLint index)
{ … }

EGLBoolean SwapBuffersWithFrameTokenANGLE(Thread *thread,
                                          Display *display,
                                          SurfaceID surfaceID,
                                          EGLFrameTokenANGLE frametoken)
{ … }

void ReleaseHighPowerGPUANGLE(Thread *thread, Display *display, gl::ContextID contextID)
{ … }

void ReacquireHighPowerGPUANGLE(Thread *thread, Display *display, gl::ContextID contextID)
{ … }

void HandleGPUSwitchANGLE(Thread *thread, Display *display)
{ … }

void ForceGPUSwitchANGLE(Thread *thread, Display *display, EGLint gpuIDHigh, EGLint gpuIDLow)
{ … }

void WaitUntilWorkScheduledANGLE(Thread *thread, Display *display)
{ … }

EGLBoolean QueryDisplayAttribANGLE(Thread *thread,
                                   Display *display,
                                   EGLint attribute,
                                   EGLAttrib *value)
{ … }

EGLBoolean LockSurfaceKHR(Thread *thread,
                          egl::Display *display,
                          SurfaceID surfaceID,
                          const AttributeMap &attributes)
{ … }

EGLBoolean UnlockSurfaceKHR(Thread *thread, egl::Display *display, SurfaceID surfaceID)
{ … }

EGLBoolean QuerySurface64KHR(Thread *thread,
                             egl::Display *display,
                             SurfaceID surfaceID,
                             EGLint attribute,
                             EGLAttribKHR *value)
{ … }

EGLBoolean ExportVkImageANGLE(Thread *thread,
                              egl::Display *display,
                              egl::ImageID imageID,
                              void *vk_image,
                              void *vk_image_create_info)
{ … }

EGLBoolean SetDamageRegionKHR(Thread *thread,
                              egl::Display *display,
                              SurfaceID surfaceID,
                              EGLint *rects,
                              EGLint n_rects)
{ … }

EGLBoolean QueryDmaBufFormatsEXT(Thread *thread,
                                 egl::Display *display,
                                 EGLint max_formats,
                                 EGLint *formats,
                                 EGLint *num_formats)
{ … }

EGLBoolean QueryDmaBufModifiersEXT(Thread *thread,
                                   egl::Display *display,
                                   EGLint format,
                                   EGLint max_modifiers,
                                   EGLuint64KHR *modifiers,
                                   EGLBoolean *external_only,
                                   EGLint *num_modifiers)
{ … }

void *CopyMetalSharedEventANGLE(Thread *thread, Display *display, SyncID syncID)
{ … }

void AcquireExternalContextANGLE(Thread *thread, egl::Display *display, SurfaceID drawAndReadPacked)
{ … }

void ReleaseExternalContextANGLE(Thread *thread, egl::Display *display)
{ … }

void SetValidationEnabledANGLE(Thread *thread, EGLBoolean validationState)
{ … }

}  // namespace egl
chromium/third_party/angle/src/libGLESv2/egl_ext_stubs.cpp
