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

• Show log

  Commit

• Hash : 20c97cac
  Author :
  Date : 2016-11-04T18:27:56
  

  Squashed commit of the following:
  
  commit 0146dfeefa47b520e71f0e74230abd7dac163a79
  Author: Stanislav Chiknavaryan <stanisc@chromium.org>
  Date:   Fri Nov 4 17:43:03 2016 -0700
  
      Revert "Implementation of eglGetSyncValuesCHROMIUM extension."
  
      This reverts commit 5d9f5df01ac5a384d9b7cbb49d9f98a76b62c7ad.
  
  commit 0d920fe27bd8e73d831a9002548bde00fea78709
  Author: Stanislav Chiknavaryan <stanisc@chromium.org>
  Date:   Fri Nov 4 17:23:11 2016 -0700
  
      Revert "Fix EGLSyncControlTest.SyncValuesTest timeout on Windowse Server 2012 R2"
  
      This reverts commit d258ca045f31eb43ec01b5501c84e9afd8e82cd6.
  
  commit bde8defe53741855bb71fbf27bcb0a91cfafbd01
  Author: Stanislav Chiknavaryan <stanisc@chromium.org>
  Date:   Fri Nov 4 17:22:58 2016 -0700
  
      Revert "Disabling EGLSyncControlTest.SyncValuesTest"
  
      This reverts commit a74183613955bd891f56f6a979a5391c16c64138.
  
  commit f78e4b7e97b9d1259878f6902bb6ddeb0aeded87
  Author: Stanislav Chiknavaryan <stanisc@chromium.org>
  Date:   Fri Nov 4 17:22:36 2016 -0700
  
      Revert "Fix and re-enable EGLSyncControlTest.SyncValuesTest"
  
      This reverts commit 138ec92f52da7c0fc8e6df08ac4e4e572bbf6b39.
  
  commit f3933e6a04bd23473077d2fd74616023db3c9601
  Author: Stanislav Chiknavaryan <stanisc@chromium.org>
  Date:   Fri Nov 4 17:20:26 2016 -0700
  
      Revert "Handle nullptr mSwapChain in SwapChain11::getSyncValues"
  
      This reverts commit af7f301f6ba9e5f31d1511142a936a9ba84169d0.
  
  BUG=angleproject:1402
  
  Change-Id: I99969e906e316574e9f739141de0e360d1edebd9
  Reviewed-on: https://chromium-review.googlesource.com/408752
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Stanislav Chiknavaryan <stanisc@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 eglCreateStreamProducerD3DTextureNV12ANGLE(EGLDisplay dpy,
                                                                    EGLStreamKHR stream,
                                                                    const EGLAttrib *attrib_list)
  {
      return egl::CreateStreamProducerD3DTextureNV12ANGLE(dpy, stream, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglStreamPostD3DTextureNV12ANGLE(EGLDisplay dpy,
                                                          EGLStreamKHR stream,
                                                          void *texture,
                                                          const EGLAttrib *attrib_list)
  {
      return egl::StreamPostD3DTextureNV12ANGLE(dpy, stream, texture, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapBuffersWithDamageEXT(EGLDisplay dpy,
                                                     EGLSurface surface,
                                                     EGLint *rects,
                                                     EGLint n_rects)
  {
      return egl::SwapBuffersWithDamageEXT(dpy, surface, rects, n_rects);
  }
  }
  

Download