kc3-lang/angle/src/libANGLE/renderer/gl/egl/SurfaceEGL.cpp

Branch - branch -main

• Show log

  Commit

• Hash : 5fd368aa
  Author :
  Date : 2025-07-30T14:45:55
  

  Replace Surface::getWidth/Height() with getSize()
  
  Most places in the code use both `getWidth/Height()` methods at the same
  time. On some back-ends it is more optimal to have single method.
  For example, `WindowSurfaceWGL` first uses `GetClientRect()` Win32 API
  inside each method to then calculate width and hight in each method,
  causing repeated `GetClientRect()` call.
  
  The only place where only one of the methods may be used is from
  `SurfaceImpl::getUserSize()` when one of the parameters is `nullptr`,
  which is only possible from `QuerySurfaceAttrib()` function. This
  method is rewritten to use new `getSize()` method and then use whatever
  dimensions is requested by the caller. This may cause
  `QuerySurfaceAttrib()` inefficiency on some back-ends that get width and
  height of the surface differently (`SurfaceEGL` for example). In such
  cases `getUserSize()` is overridden to avoid returning a dimension
  which is not required.
  
  After this change all places in the code that previously used both
  `getWidth/Height()` methods (like `Surface::getAttachmentSize()`) will
  be more efficient. The `QuerySurfaceAttrib()`, on the other hand, will
  have slightly more overhead on back-ends where base
  `SurfaceImpl::getUserSize()` method is used, which only happens on
  back-ends with trivial `getSize()` implementation.
  
  Bug: angleproject:397848903
  Change-Id: I4a22701a1e62ee4e7d07e77cac5b388050d98e4d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6802440
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Igor Nazarov <i.nazarov@samsung.com>
  

Download

• src/libANGLE/renderer/gl/egl/SurfaceEGL.cpp

• //
  // Copyright 2016 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.
  //
  
  // SurfaceEGL.cpp: EGL implementation of egl::Surface
  
  #include "libANGLE/renderer/gl/egl/SurfaceEGL.h"
  
  #include "common/debug.h"
  #include "libANGLE/Display.h"
  
  namespace rx
  {
  
  SurfaceEGL::SurfaceEGL(const egl::SurfaceState &state, const FunctionsEGL *egl, EGLConfig config)
      : SurfaceGL(state),
        mEGL(egl),
        mConfig(config),
        mSurface(EGL_NO_SURFACE),
        mHasSwapBuffersWithDamage(mEGL->hasExtension("EGL_KHR_swap_buffers_with_damage"))
  {}
  
  SurfaceEGL::~SurfaceEGL()
  {
      if (mSurface != EGL_NO_SURFACE)
      {
          EGLBoolean success = mEGL->destroySurface(mSurface);
          ASSERT(success == EGL_TRUE);
      }
  }
  
  egl::Error SurfaceEGL::makeCurrent(const gl::Context *context)
  {
      // Handling of makeCurrent is done in DisplayEGL
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::swap(const gl::Context *context, SurfaceSwapFeedback *feedback)
  {
      egl::Display::GetCurrentThreadUnlockedTailCall()->add(
          [egl = mEGL, surface = mSurface](void *resultOut) {
              ANGLE_UNUSED_VARIABLE(resultOut);
              *static_cast<EGLBoolean *>(resultOut) = egl->swapBuffers(surface);
          });
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::swapWithDamage(const gl::Context *context,
                                        const EGLint *rects,
                                        EGLint n_rects,
                                        SurfaceSwapFeedback *feedback)
  {
      if (mHasSwapBuffersWithDamage)
      {
          egl::Display::GetCurrentThreadUnlockedTailCall()->add(
              [egl = mEGL, surface = mSurface, rects, n_rects](void *resultOut) {
                  ANGLE_UNUSED_VARIABLE(resultOut);
                  *static_cast<EGLBoolean *>(resultOut) =
                      egl->swapBuffersWithDamageKHR(surface, rects, n_rects);
              });
      }
      else
      {
          egl::Display::GetCurrentThreadUnlockedTailCall()->add(
              [egl = mEGL, surface = mSurface](void *resultOut) {
                  ANGLE_UNUSED_VARIABLE(resultOut);
                  *static_cast<EGLBoolean *>(resultOut) = egl->swapBuffers(surface);
              });
      }
  
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::postSubBuffer(const gl::Context *context,
                                       EGLint x,
                                       EGLint y,
                                       EGLint width,
                                       EGLint height)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_BAD_SURFACE);
  }
  
  egl::Error SurfaceEGL::setPresentationTime(EGLnsecsANDROID time)
  {
      EGLBoolean success = mEGL->presentationTimeANDROID(mSurface, time);
      if (success == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglPresentationTimeANDROID failed");
      }
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::querySurfacePointerANGLE(EGLint attribute, void **value)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_BAD_SURFACE);
  }
  
  egl::Error SurfaceEGL::bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer)
  {
      EGLBoolean success = mEGL->bindTexImage(mSurface, buffer);
      if (success == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglBindTexImage failed");
      }
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::releaseTexImage(const gl::Context *context, EGLint buffer)
  {
      EGLBoolean success = mEGL->releaseTexImage(mSurface, buffer);
      if (success == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglReleaseTexImage failed");
      }
      return egl::NoError();
  }
  
  void SurfaceEGL::setSwapInterval(const egl::Display *display, EGLint interval)
  {
      EGLBoolean success = mEGL->swapInterval(interval);
      if (success == EGL_FALSE)
      {
          ERR() << "eglSwapInterval error " << egl::Error(mEGL->getError());
          ASSERT(false);
      }
  }
  
  gl::Extents SurfaceEGL::getSize() const
  {
      EGLint width, height;
      egl::Error error = SurfaceEGL::getUserSize(nullptr, &width, &height);
      ASSERT(!error.isError());
      return gl::Extents(width, height, 1);
  }
  
  egl::Error SurfaceEGL::getUserSize(const egl::Display *display, EGLint *width, EGLint *height) const
  {
      if (width != nullptr)
      {
          EGLBoolean success = mEGL->querySurface(mSurface, EGL_WIDTH, width);
          ASSERT(success == EGL_TRUE);
      }
      if (height != nullptr)
      {
          EGLBoolean success = mEGL->querySurface(mSurface, EGL_HEIGHT, height);
          ASSERT(success == EGL_TRUE);
      }
      return egl::NoError();
  }
  
  EGLint SurfaceEGL::isPostSubBufferSupported() const
  {
      UNIMPLEMENTED();
      return 0;
  }
  
  EGLint SurfaceEGL::getSwapBehavior() const
  {
      EGLint value;
      EGLBoolean success = mEGL->querySurface(mSurface, EGL_SWAP_BEHAVIOR, &value);
      ASSERT(success == EGL_TRUE);
      return value;
  }
  
  EGLSurface SurfaceEGL::getSurface() const
  {
      return mSurface;
  }
  
  void SurfaceEGL::setTimestampsEnabled(bool enabled)
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      EGLBoolean success =
          mEGL->surfaceAttrib(mSurface, EGL_TIMESTAMPS_ANDROID, enabled ? EGL_TRUE : EGL_FALSE);
      if (success == EGL_FALSE)
      {
          ERR() << "eglSurfaceAttribute failed: " << egl::Error(mEGL->getError());
      }
  }
  
  egl::SupportedCompositorTimings SurfaceEGL::getSupportedCompositorTimings() const
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      egl::SupportedCompositorTimings result;
      for (egl::CompositorTiming name : angle::AllEnums<egl::CompositorTiming>())
      {
          result[name] = mEGL->getCompositorTimingSupportedANDROID(mSurface, egl::ToEGLenum(name));
      }
      return result;
  }
  
  egl::Error SurfaceEGL::getCompositorTiming(EGLint numTimestamps,
                                             const EGLint *names,
                                             EGLnsecsANDROID *values) const
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      egl::Display::GetCurrentThreadUnlockedTailCall()->add(
          [egl = mEGL, surface = mSurface, numTimestamps, names, values](void *resultOut) {
              EGLBoolean success =
                  egl->getCompositorTimingANDROID(surface, numTimestamps, names, values);
              if (!success)
              {
                  ERR() << "eglGetCompositorTimingANDROID failed: " << egl::Error(egl->getError());
              }
              *static_cast<EGLBoolean *>(resultOut) = success;
          });
  
      return egl::NoError();
  }
  
  egl::Error SurfaceEGL::getNextFrameId(EGLuint64KHR *frameId) const
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      EGLBoolean success = mEGL->getNextFrameIdANDROID(mSurface, frameId);
      if (success == EGL_FALSE)
      {
          return egl::Error(mEGL->getError(), "eglGetNextFrameId failed");
      }
      return egl::NoError();
  }
  
  egl::SupportedTimestamps SurfaceEGL::getSupportedTimestamps() const
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      egl::SupportedTimestamps result;
      for (egl::Timestamp timestamp : angle::AllEnums<egl::Timestamp>())
      {
          result[timestamp] =
              mEGL->getFrameTimestampSupportedANDROID(mSurface, egl::ToEGLenum(timestamp));
      }
      return result;
  }
  
  egl::Error SurfaceEGL::getFrameTimestamps(EGLuint64KHR frameId,
                                            EGLint numTimestamps,
                                            const EGLint *timestamps,
                                            EGLnsecsANDROID *values) const
  {
      ASSERT(mEGL->hasExtension("EGL_ANDROID_get_frame_timestamps"));
  
      egl::Display::GetCurrentThreadUnlockedTailCall()->add([egl = mEGL, surface = mSurface, frameId,
                                                             numTimestamps, timestamps,
                                                             values](void *resultOut) {
          EGLBoolean success =
              egl->getFrameTimestampsANDROID(surface, frameId, numTimestamps, timestamps, values);
          if (!success)
          {
              // The driver may return EGL_BAD_ACCESS at any time if the requested frame is no longer
              // stored.
              ERR() << "eglGetFrameTimestampsANDROID failed: " << egl::Error(egl->getError());
          }
          *static_cast<EGLBoolean *>(resultOut) = success;
      });
  
      return egl::NoError();
  }
  
  bool SurfaceEGL::isExternal() const
  {
      return false;
  }
  
  }  // namespace rx
  

Download