kc3-lang/angle/src/libGLESv2/entry_points_egl_ext.cpp

• Show log

  Commit

• Hash : e1aa9219
  Author :
  Date : 2018-01-08T17:53:05
  

  Create a new DeviceImpl each time one is requested from a DisplayImpl.
  
  This makes sure that the Device to DeviceImpl ratio is always 1:1 and
  avoids any potential double-deletion or unexpected deletion of
  DeviceImpl objects.
  
  BUG=742034
  
  Change-Id: I778068ccd09b7478d3683123456062b94be242a1
  Reviewed-on: https://chromium-review.googlesource.com/854627
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
  

Download

• src/libGLESv2/entry_points_egl_ext.cpp

• //
  // Copyright(c) 2014 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.
  //
  
  // entry_points_ext.cpp : Implements the EGL extension entry points.
  
  #include "libGLESv2/entry_points_egl_ext.h"
  #include "libGLESv2/global_state.h"
  
  #include "libANGLE/Context.h"
  #include "libANGLE/Display.h"
  #include "libANGLE/Device.h"
  #include "libANGLE/Surface.h"
  #include "libANGLE/Stream.h"
  #include "libANGLE/Thread.h"
  #include "libANGLE/validationEGL.h"
  
  #include "common/debug.h"
  
  namespace egl
  {
  
  // EGL_ANGLE_query_surface_pointer
  EGLBoolean EGLAPIENTRY QuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint attribute = %d, void **value = 0x%0.8p)",
            dpy, surface, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Display *display = static_cast<Display*>(dpy);
      Surface *eglSurface = static_cast<Surface*>(surface);
  
      Error error = ValidateSurface(display, eglSurface);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      if (!display->getExtensions().querySurfacePointer)
      {
          thread->setError(NoError());
          return EGL_FALSE;
      }
  
      if (surface == EGL_NO_SURFACE)
      {
          thread->setError(EglBadSurface());
          return EGL_FALSE;
      }
  
      // validate the attribute parameter
      switch (attribute)
      {
        case EGL_D3D_TEXTURE_2D_SHARE_HANDLE_ANGLE:
          if (!display->getExtensions().surfaceD3DTexture2DShareHandle)
          {
              thread->setError(EglBadAttribute());
              return EGL_FALSE;
          }
          break;
        case EGL_DXGI_KEYED_MUTEX_ANGLE:
          if (!display->getExtensions().keyedMutex)
          {
              thread->setError(EglBadAttribute());
              return EGL_FALSE;
          }
          break;
        default:
            thread->setError(EglBadAttribute());
            return EGL_FALSE;
      }
  
      error = eglSurface->querySurfacePointerANGLE(attribute, value);
      thread->setError(error);
      return (error.isError() ? EGL_FALSE : EGL_TRUE);
  }
  
  
  // EGL_NV_post_sub_buffer
  EGLBoolean EGLAPIENTRY PostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint x = %d, EGLint y = %d, EGLint width = %d, EGLint height = %d)", dpy, surface, x, y, width, height);
      Thread *thread = GetCurrentThread();
  
      if (x < 0 || y < 0 || width < 0 || height < 0)
      {
          thread->setError(EglBadParameter());
          return EGL_FALSE;
      }
  
      Display *display = static_cast<Display*>(dpy);
      Surface *eglSurface = static_cast<Surface*>(surface);
  
      Error error = ValidateSurface(display, eglSurface);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      if (display->testDeviceLost())
      {
          thread->setError(EglContextLost());
          return EGL_FALSE;
      }
  
      if (surface == EGL_NO_SURFACE)
      {
          thread->setError(EglBadSurface());
          return EGL_FALSE;
      }
  
      if (!display->getExtensions().postSubBuffer)
      {
          // Spec is not clear about how this should be handled.
          thread->setError(NoError());
          return EGL_TRUE;
      }
  
      // TODO(jmadill): Validate Surface is bound to the thread.
      error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(NoError());
      return EGL_TRUE;
  }
  
  // EGL_EXT_platform_base
  EGLDisplay EGLAPIENTRY GetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
  {
      EVENT("(EGLenum platform = %d, void* native_display = 0x%0.8p, const EGLint* attrib_list = 0x%0.8p)",
            platform, native_display, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Error err = ValidateGetPlatformDisplayEXT(platform, native_display, attrib_list);
      thread->setError(err);
      if (err.isError())
      {
          return EGL_NO_DISPLAY;
      }
  
      const auto &attribMap = AttributeMap::CreateFromIntArray(attrib_list);
      if (platform == EGL_PLATFORM_ANGLE_ANGLE)
      {
          return Display::GetDisplayFromNativeDisplay(
              gl::bitCast<EGLNativeDisplayType>(native_display), attribMap);
      }
      else if (platform == EGL_PLATFORM_DEVICE_EXT)
      {
          Device *eglDevice = reinterpret_cast<Device *>(native_display);
          return Display::GetDisplayFromDevice(eglDevice, attribMap);
      }
      else
      {
          UNREACHABLE();
          return EGL_NO_DISPLAY;
      }
  }
  
  // EGL_EXT_device_query
  EGLBoolean EGLAPIENTRY QueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value)
  {
      EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)",
            device, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Device *dev = static_cast<Device*>(device);
      if (dev == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(dev))
      {
          thread->setError(EglBadAccess());
          return EGL_FALSE;
      }
  
      // If the device was created by (and is owned by) a display, and that display doesn't support
      // device querying, then this call should fail
      Display *owningDisplay = dev->getOwningDisplay();
      if (owningDisplay != nullptr && !owningDisplay->getExtensions().deviceQuery)
      {
          thread->setError(EglBadAccess() << "Device wasn't created using eglCreateDeviceANGLE, "
                                             "and the Display that created it doesn't support "
                                             "device querying");
          return EGL_FALSE;
      }
  
      Error error(NoError());
  
      // validate the attribute parameter
      switch (attribute)
      {
        case EGL_D3D11_DEVICE_ANGLE:
        case EGL_D3D9_DEVICE_ANGLE:
          if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
          {
              thread->setError(EglBadAttribute());
              return EGL_FALSE;
          }
          error = dev->getDevice(value);
          break;
        default:
            thread->setError(EglBadAttribute());
            return EGL_FALSE;
      }
  
      thread->setError(error);
      return (error.isError() ? EGL_FALSE : EGL_TRUE);
  }
  
  // EGL_EXT_device_query
  const char * EGLAPIENTRY QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
  {
      EVENT("(EGLDeviceEXT device = 0x%0.8p, EGLint name = %d)",
            device, name);
      Thread *thread = GetCurrentThread();
  
      Device *dev = static_cast<Device*>(device);
      if (dev == EGL_NO_DEVICE_EXT || !Device::IsValidDevice(dev))
      {
          thread->setError(EglBadDevice());
          return nullptr;
      }
  
      const char *result;
      switch (name)
      {
        case EGL_EXTENSIONS:
          result = dev->getExtensionString().c_str();
          break;
        default:
            thread->setError(EglBadDevice());
            return nullptr;
      }
  
      thread->setError(NoError());
      return result;
  }
  
  // EGL_EXT_device_query
  EGLBoolean EGLAPIENTRY QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint attribute = %d, EGLAttrib *value = 0x%0.8p)",
            dpy, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Display *display = static_cast<Display*>(dpy);
  
      Error error = ValidateDisplay(display);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      if (!display->getExtensions().deviceQuery)
      {
          thread->setError(EglBadAccess());
          return EGL_FALSE;
      }
  
      // validate the attribute parameter
      switch (attribute)
      {
        case EGL_DEVICE_EXT:
          *value = reinterpret_cast<EGLAttrib>(display->getDevice());
          break;
  
        default:
            thread->setError(EglBadAttribute());
            return EGL_FALSE;
      }
  
      thread->setError(error);
      return (error.isError() ? EGL_FALSE : EGL_TRUE);
  }
  
  ANGLE_EXPORT EGLImageKHR EGLAPIENTRY CreateImageKHR(EGLDisplay dpy,
                                                      EGLContext ctx,
                                                      EGLenum target,
                                                      EGLClientBuffer buffer,
                                                      const EGLint *attrib_list)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLContext ctx = 0x%0.8p, EGLenum target = 0x%X, "
          "EGLClientBuffer buffer = 0x%0.8p, const EGLAttrib *attrib_list = 0x%0.8p)",
          dpy, ctx, target, buffer, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      gl::Context *context = static_cast<gl::Context *>(ctx);
      AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
  
      Error error = ValidateCreateImageKHR(display, context, target, buffer, attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_NO_IMAGE;
      }
  
      Image *image = nullptr;
      error        = display->createImage(context, target, buffer, attributes, &image);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_NO_IMAGE;
      }
  
      return static_cast<EGLImage>(image);
  }
  
  ANGLE_EXPORT EGLBoolean EGLAPIENTRY DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLImage image = 0x%0.8p)", dpy, image);
      Thread *thread = GetCurrentThread();
  
      Display *display = static_cast<Display *>(dpy);
      Image *img       = static_cast<Image *>(image);
  
      Error error = ValidateDestroyImageKHR(display, img);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      display->destroyImage(img);
  
      return EGL_TRUE;
  }
  
  ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY CreateDeviceANGLE(EGLint device_type,
                                                          void *native_device,
                                                          const EGLAttrib *attrib_list)
  {
      EVENT(
          "(EGLint device_type = %d, void* native_device = 0x%0.8p, const EGLAttrib* attrib_list = "
          "0x%0.8p)",
          device_type, native_device, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Error error = ValidateCreateDeviceANGLE(device_type, native_device, attrib_list);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_NO_DEVICE_EXT;
      }
  
      Device *device = nullptr;
      error          = Device::CreateDevice(device_type, native_device, &device);
      if (error.isError())
      {
          ASSERT(device == nullptr);
          thread->setError(error);
          return EGL_NO_DEVICE_EXT;
      }
  
      return device;
  }
  
  ANGLE_EXPORT EGLBoolean EGLAPIENTRY ReleaseDeviceANGLE(EGLDeviceEXT device)
  {
      EVENT("(EGLDeviceEXT device = 0x%0.8p)", device);
      Thread *thread = GetCurrentThread();
  
      Device *dev = static_cast<Device *>(device);
  
      Error error = ValidateReleaseDeviceANGLE(dev);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      SafeDelete(dev);
  
      return EGL_TRUE;
  }
  
  // EGL_KHR_stream
  EGLStreamKHR EGLAPIENTRY CreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, const EGLAttrib* attrib_list = 0x%0.8p)", dpy, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Display *display = static_cast<Display *>(dpy);
      AttributeMap attributes = AttributeMap::CreateFromIntArray(attrib_list);
  
      Error error = ValidateCreateStreamKHR(display, attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_NO_STREAM_KHR;
      }
  
      Stream *stream;
      error = display->createStream(attributes, &stream);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_NO_STREAM_KHR;
      }
  
      thread->setError(error);
      return static_cast<EGLStreamKHR>(stream);
  }
  
  EGLBoolean EGLAPIENTRY DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR = 0x%0.8p)", dpy, stream);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
  
      Error error = ValidateDestroyStreamKHR(display, streamObject);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      display->destroyStream(streamObject);
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamAttribKHR(EGLDisplay dpy,
                                         EGLStreamKHR stream,
                                         EGLenum attribute,
                                         EGLint value)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLenum attribute = 0x%X, "
          "EGLint value = 0x%X)",
          dpy, stream, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
  
      Error error = ValidateStreamAttribKHR(display, streamObject, attribute, value);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      switch (attribute)
      {
          case EGL_CONSUMER_LATENCY_USEC_KHR:
              streamObject->setConsumerLatency(value);
              break;
          case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
              streamObject->setConsumerAcquireTimeout(value);
              break;
          default:
              UNREACHABLE();
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY QueryStreamKHR(EGLDisplay dpy,
                                        EGLStreamKHR stream,
                                        EGLenum attribute,
                                        EGLint *value)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLenum attribute = 0x%X, "
          "EGLint value = 0x%0.8p)",
          dpy, stream, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
  
      Error error = ValidateQueryStreamKHR(display, streamObject, attribute, value);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      switch (attribute)
      {
          case EGL_STREAM_STATE_KHR:
              *value = streamObject->getState();
              break;
          case EGL_CONSUMER_LATENCY_USEC_KHR:
              *value = streamObject->getConsumerLatency();
              break;
          case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR:
              *value = streamObject->getConsumerAcquireTimeout();
              break;
          default:
              UNREACHABLE();
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY QueryStreamu64KHR(EGLDisplay dpy,
                                           EGLStreamKHR stream,
                                           EGLenum attribute,
                                           EGLuint64KHR *value)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLenum attribute = 0x%X, "
          "EGLuint64KHR value = 0x%0.8p)",
          dpy, stream, attribute, value);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
  
      Error error = ValidateQueryStreamu64KHR(display, streamObject, attribute, value);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      switch (attribute)
      {
          case EGL_PRODUCER_FRAME_KHR:
              *value = streamObject->getProducerFrame();
              break;
          case EGL_CONSUMER_FRAME_KHR:
              *value = streamObject->getConsumerFrame();
              break;
          default:
              UNREACHABLE();
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR = 0x%0.8p)", dpy, stream);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
      gl::Context *context = gl::GetValidGlobalContext();
  
      Error error = ValidateStreamConsumerGLTextureExternalKHR(display, context, streamObject);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->createConsumerGLTextureExternal(AttributeMap(), context);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR = 0x%0.8p)", dpy, stream);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
      gl::Context *context = gl::GetValidGlobalContext();
  
      Error error = ValidateStreamConsumerAcquireKHR(display, context, streamObject);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->consumerAcquire(context);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR = 0x%0.8p)", dpy, stream);
      Thread *thread = GetCurrentThread();
  
      Display *display     = static_cast<Display *>(dpy);
      Stream *streamObject = static_cast<Stream *>(stream);
      gl::Context *context = gl::GetValidGlobalContext();
  
      Error error = ValidateStreamConsumerReleaseKHR(display, context, streamObject);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->consumerRelease(context);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
                                                                  EGLStreamKHR stream,
                                                                  const EGLAttrib *attrib_list)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLAttrib attrib_list = 0x%0.8p",
          dpy, stream, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Display *display        = static_cast<Display *>(dpy);
      Stream *streamObject    = static_cast<Stream *>(stream);
      gl::Context *context    = gl::GetValidGlobalContext();
      AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
  
      Error error = ValidateStreamConsumerGLTextureExternalAttribsNV(display, context, streamObject,
                                                                     attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->createConsumerGLTextureExternal(attributes, context);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
                                                             EGLStreamKHR stream,
                                                             const EGLAttrib *attrib_list)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, EGLAttrib attrib_list = 0x%0.8p",
          dpy, stream, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Display *display        = static_cast<Display *>(dpy);
      Stream *streamObject    = static_cast<Stream *>(stream);
      AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
  
      Error error = ValidateCreateStreamProducerD3DTextureANGLE(display, streamObject, attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->createProducerD3D11Texture(attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY StreamPostD3DTextureANGLE(EGLDisplay dpy,
                                                   EGLStreamKHR stream,
                                                   void *texture,
                                                   const EGLAttrib *attrib_list)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLStreamKHR stream = 0x%0.8p, void* texture = 0x%0.8p, "
          "EGLAttrib attrib_list = 0x%0.8p",
          dpy, stream, texture, attrib_list);
      Thread *thread = GetCurrentThread();
  
      Display *display        = static_cast<Display *>(dpy);
      Stream *streamObject    = static_cast<Stream *>(stream);
      AttributeMap attributes = AttributeMap::CreateFromAttribArray(attrib_list);
  
      Error error = ValidateStreamPostD3DTextureANGLE(display, streamObject, texture, attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = streamObject->postD3D11Texture(texture, attributes);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  EGLBoolean EGLAPIENTRY GetSyncValuesCHROMIUM(EGLDisplay dpy,
                                               EGLSurface surface,
                                               EGLuint64KHR *ust,
                                               EGLuint64KHR *msc,
                                               EGLuint64KHR *sbc)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLuint64KHR* ust = 0x%0.8p, "
          "EGLuint64KHR* msc = 0x%0.8p, EGLuint64KHR* sbc = 0x%0.8p",
          dpy, surface, ust, msc, sbc);
      Thread *thread = GetCurrentThread();
  
      Display *display    = static_cast<Display *>(dpy);
      Surface *eglSurface = static_cast<Surface *>(surface);
  
      Error error = ValidateGetSyncValuesCHROMIUM(display, eglSurface, ust, msc, sbc);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = eglSurface->getSyncValues(ust, msc, sbc);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      thread->setError(error);
      return EGL_TRUE;
  }
  
  ANGLE_EXPORT EGLBoolean SwapBuffersWithDamageEXT(EGLDisplay dpy,
                                                   EGLSurface surface,
                                                   EGLint *rects,
                                                   EGLint n_rects)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLSurface surface = 0x%0.8p, EGLint *rects = 0x%0.8p, EGLint "
          "n_rects = %d)",
          dpy, surface, rects, n_rects);
      Thread *thread = GetCurrentThread();
  
      Display *display    = static_cast<Display *>(dpy);
      Surface *eglSurface = static_cast<Surface *>(surface);
  
      Error error = ValidateSwapBuffersWithDamageEXT(display, eglSurface, rects, n_rects);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      error = eglSurface->swapWithDamage(thread->getContext(), rects, n_rects);
      if (error.isError())
      {
          thread->setError(error);
          return EGL_FALSE;
      }
  
      return EGL_TRUE;
  }
  
  EGLint EGLAPIENTRY ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLenum attrib = 0x%X)", dpy, attrib);
  
      Display *display = static_cast<Display *>(dpy);
      Thread *thread   = GetCurrentThread();
  
      ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheGetAttribANGLE(display, attrib), 0);
  
      return display->programCacheGetAttrib(attrib);
  }
  
  void EGLAPIENTRY ProgramCacheQueryANGLE(EGLDisplay dpy,
                                          EGLint index,
                                          void *key,
                                          EGLint *keysize,
                                          void *binary,
                                          EGLint *binarysize)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, EGLint index = %d, void *key = 0x%0.8p, EGLint *keysize = "
          "0x%0.8p, void *binary = 0x%0.8p, EGLint *size = 0x%0.8p)",
          dpy, index, key, keysize, binary, binarysize);
  
      Display *display = static_cast<Display *>(dpy);
      Thread *thread   = GetCurrentThread();
  
      ANGLE_EGL_TRY(thread,
                    ValidateProgramCacheQueryANGLE(display, index, key, keysize, binary, binarysize));
  
      ANGLE_EGL_TRY(thread, display->programCacheQuery(index, key, keysize, binary, binarysize));
  }
  
  void EGLAPIENTRY ProgramCachePopulateANGLE(EGLDisplay dpy,
                                             const void *key,
                                             EGLint keysize,
                                             const void *binary,
                                             EGLint binarysize)
  {
      EVENT(
          "(EGLDisplay dpy = 0x%0.8p, void *key = 0x%0.8p, EGLint keysize = %d, void *binary = "
          "0x%0.8p, EGLint *size = 0x%0.8p)",
          dpy, key, keysize, binary, binarysize);
  
      Display *display = static_cast<Display *>(dpy);
      Thread *thread   = GetCurrentThread();
  
      ANGLE_EGL_TRY(thread,
                    ValidateProgramCachePopulateANGLE(display, key, keysize, binary, binarysize));
  
      ANGLE_EGL_TRY(thread, display->programCachePopulate(key, keysize, binary, binarysize));
  }
  
  EGLint EGLAPIENTRY ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLenum mode)
  {
      EVENT("(EGLDisplay dpy = 0x%0.8p, EGLint limit = %d, EGLenum mode = 0x%X)", dpy, limit, mode);
  
      Display *display = static_cast<Display *>(dpy);
      Thread *thread   = GetCurrentThread();
  
      ANGLE_EGL_TRY_RETURN(thread, ValidateProgramCacheResizeANGLE(display, limit, mode), 0);
  
      return display->programCacheResize(limit, mode);
  }
  
  }  // namespace egl
  

Download