kc3-lang/angle/src/libEGL/libEGL.cpp

• Show log

  Commit

• Hash : 3dddccff
  Author :
  Date : 2017-11-14T16:44:36
  

  Support RGB gl-tex-external stream consumers for StreamProducerNV12.
  
  This makes it relatively simple to sample from a D3D11Texture of
  arbitrary format.
  
  From: https://bugzilla.mozilla.org/show_bug.cgi?id=1322746
  
  BUG=angleproject:2233
  TEST=angle_end2end_tests
  
  Change-Id: I10cd3043b5cb0c5d36dd613467ba6c0ceadf41af
  Reviewed-on: https://chromium-review.googlesource.com/758042
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libEGL/libEGL.cpp

• //
  // Copyright (c) 2002-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.
  //
  
  // libEGL.cpp: Implements the exported EGL functions.
  
  #include "libGLESv2/entry_points_egl.h"
  #include "libGLESv2/entry_points_egl_ext.h"
  
  extern "C"
  {
  
  EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
  {
      return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
  }
  
  EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
  {
      return egl::CopyBuffers(dpy, surface, target);
  }
  
  EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
  {
      return egl::CreateContext(dpy, config, share_context, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
  {
      return egl::CreatePbufferSurface(dpy, config, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
  {
      return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list)
  {
      return egl::CreateWindowSurface(dpy, config, win, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
  {
      return egl::DestroyContext(dpy, ctx);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
  {
      return egl::DestroySurface(dpy, surface);
  }
  
  EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
  {
      return egl::GetConfigAttrib(dpy, config, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
  {
      return egl::GetConfigs(dpy, configs, config_size, num_config);
  }
  
  EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
  {
      return egl::GetCurrentDisplay();
  }
  
  EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
  {
      return egl::GetCurrentSurface(readdraw);
  }
  
  EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
  {
      return egl::GetDisplay(display_id);
  }
  
  EGLint EGLAPIENTRY eglGetError(void)
  {
      return egl::GetError();
  }
  
  EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
  {
      return egl::Initialize(dpy, major, minor);
  }
  
  EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
  {
      return egl::MakeCurrent(dpy, draw, read, ctx);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
  {
      return egl::QueryContext(dpy, ctx, attribute, value);
  }
  
  const char* EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
  {
      return egl::QueryString(dpy, name);
  }
  
  EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
  {
      return egl::QuerySurface(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
  {
      return egl::SwapBuffers(dpy, surface);
  }
  
  EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
  {
      return egl::Terminate(dpy);
  }
  
  EGLBoolean EGLAPIENTRY eglWaitGL(void)
  {
      return egl::WaitGL();
  }
  
  EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
  {
      return egl::WaitNative(engine);
  }
  
  EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
  {
      return egl::BindTexImage(dpy, surface, buffer);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
  {
      return egl::ReleaseTexImage(dpy, surface, buffer);
  }
  
  EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
  {
      return egl::SurfaceAttrib(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
  {
      return egl::SwapInterval(dpy, interval);
  }
  
  EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
  {
      return egl::BindAPI(api);
  }
  
  EGLenum EGLAPIENTRY eglQueryAPI(void)
  {
      return egl::QueryAPI();
  }
  
  EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
  {
      return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseThread(void)
  {
      return egl::ReleaseThread();
  }
  
  EGLBoolean EGLAPIENTRY eglWaitClient(void)
  {
      return egl::WaitClient();
  }
  
  EGLContext EGLAPIENTRY eglGetCurrentContext(void)
  {
      return egl::GetCurrentContext();
  }
  
  EGLSync EGLAPIENTRY eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
  {
      return egl::CreateSync(dpy, type, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroySync(EGLDisplay dpy, EGLSync sync)
  {
      return egl::DestroySync(dpy, sync);
  }
  
  EGLint EGLAPIENTRY eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)
  {
      return egl::ClientWaitSync(dpy, sync, flags, timeout);
  }
  
  EGLBoolean EGLAPIENTRY eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value)
  {
      return egl::GetSyncAttrib(dpy, sync, attribute, value);
  }
  
  EGLImage EGLAPIENTRY eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
  {
      return egl::CreateImage(dpy, ctx, target, buffer, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyImage(EGLDisplay dpy, EGLImage image)
  {
      return egl::DestroyImage(dpy, image);
  }
  
  EGLDisplay EGLAPIENTRY eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list)
  {
      return egl::GetPlatformDisplay(platform, native_display, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
  {
      return egl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
  {
      return egl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
  {
      return egl::WaitSync(dpy, sync, flags);
  }
  
  EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value)
  {
      return egl::QuerySurfacePointerANGLE(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)
  {
      return egl::PostSubBufferNV(dpy, surface, x, y, width, height);
  }
  
  EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
  {
      return egl::GetPlatformDisplayEXT(platform, native_display, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
  {
      return egl::QueryDisplayAttribEXT(dpy, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value)
  {
      return egl::QueryDeviceAttribEXT(device, attribute, value);
  }
  
  const char * EGLAPIENTRY eglQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
  {
      return egl::QueryDeviceStringEXT(device, name);
  }
  
  EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy,
                                            EGLContext ctx,
                                            EGLenum target,
                                            EGLClientBuffer buffer,
                                            const EGLint *attrib_list)
  {
      return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
  {
      return egl::DestroyImageKHR(dpy, image);
  }
  
  EGLDeviceEXT EGLAPIENTRY eglCreateDeviceANGLE(EGLint device_type,
                                                void *native_device,
                                                const EGLAttrib *attrib_list)
  {
      return egl::CreateDeviceANGLE(device_type, native_device, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseDeviceANGLE(EGLDeviceEXT device)
  {
      return egl::ReleaseDeviceANGLE(device);
  }
  
  __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
  {
      return egl::GetProcAddress(procname);
  }
  
  EGLStreamKHR EGLAPIENTRY eglCreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list)
  {
      return egl::CreateStreamKHR(dpy, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      return egl::DestroyStreamKHR(dpy, stream);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamAttribKHR(EGLDisplay dpy,
                                            EGLStreamKHR stream,
                                            EGLenum attribute,
                                            EGLint value)
  {
      return egl::StreamAttribKHR(dpy, stream, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryStreamKHR(EGLDisplay dpy,
                                           EGLStreamKHR stream,
                                           EGLenum attribute,
                                           EGLint *value)
  {
      return egl::QueryStreamKHR(dpy, stream, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryStreamu64KHR(EGLDisplay dpy,
                                              EGLStreamKHR stream,
                                              EGLenum attribute,
                                              EGLuint64KHR *value)
  {
      return egl::QueryStreamu64KHR(dpy, stream, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      return egl::StreamConsumerGLTextureExternalKHR(dpy, stream);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      return egl::StreamConsumerAcquireKHR(dpy, stream);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream)
  {
      return egl::StreamConsumerReleaseKHR(dpy, stream);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy,
                                                                     EGLStreamKHR stream,
                                                                     EGLAttrib *attrib_list)
  {
      return egl::StreamConsumerGLTextureExternalAttribsNV(dpy, stream, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglCreateStreamProducerD3DTextureANGLE(EGLDisplay dpy,
                                                                EGLStreamKHR stream,
                                                                const EGLAttrib *attrib_list)
  {
      return egl::CreateStreamProducerD3DTextureANGLE(dpy, stream, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamPostD3DTextureANGLE(EGLDisplay dpy,
                                                      EGLStreamKHR stream,
                                                      void *texture,
                                                      const EGLAttrib *attrib_list)
  {
      return egl::StreamPostD3DTextureANGLE(dpy, stream, texture, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglGetSyncValuesCHROMIUM(EGLDisplay dpy,
                                                  EGLSurface surface,
                                                  EGLuint64KHR *ust,
                                                  EGLuint64KHR *msc,
                                                  EGLuint64KHR *sbc)
  {
      return egl::GetSyncValuesCHROMIUM(dpy, surface, ust, msc, sbc);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT(EGLDisplay dpy,
                                                     EGLSurface surface,
                                                     EGLint *rects,
                                                     EGLint n_rects)
  {
      return egl::SwapBuffersWithDamageEXT(dpy, surface, rects, n_rects);
  }
  
  EGLint EGLAPIENTRY eglProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib)
  {
      return egl::ProgramCacheGetAttribANGLE(dpy, attrib);
  }
  
  void EGLAPIENTRY eglProgramCacheQueryANGLE(EGLDisplay dpy,
                                             EGLint index,
                                             void *key,
                                             EGLint *keysize,
                                             void *binary,
                                             EGLint *binarysize)
  {
      egl::ProgramCacheQueryANGLE(dpy, index, key, keysize, binary, binarysize);
  }
  
  void EGLAPIENTRY eglProgramCachePopulateANGLE(EGLDisplay dpy,
                                                const void *key,
                                                EGLint keysize,
                                                const void *binary,
                                                EGLint binarysize)
  {
      egl::ProgramCachePopulateANGLE(dpy, key, keysize, binary, binarysize);
  }
  
  EGLint EGLAPIENTRY eglProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLenum mode)
  {
      return egl::ProgramCacheResizeANGLE(dpy, limit, mode);
  }
  
  }  // extern "C"
  

Download