kc3-lang/angle/src/libANGLE/Surface.h

• Show log

  Commit

• Hash : 22fc9523
  Author :
  Date : 2021-02-03T15:32:48
  

  EGL: implement EGL_EXT_buffer_age
  
  Add extension flag.
  Add Validation check to surface query.
  Enable extension for vulkan.
  Modify AcquireNextImage to ++frame count and tag images
  with frame number.
  Buffer age is the difference between current frame count
  and the tagged frame number on the buffer.
  getBuffeAge may need to trigger AcquireNextImage to be current.
  Pass through egl extension and query.
  Add EGLBufferAgeTest
  
  Test: angle_end2end_test --gtest_filter=EGLBufferAgeTest
  Test: angle_deqp_egl_tests
  --deqp-case=dEQP-EGL.functional.buffer_age.*
  
  Bug: angleproject:3529
  Change-Id: I0cb94be1c3e85d6f33e82a6a1ccdc9731b6a7f23
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2684724
  Commit-Queue: Mohan Maiya <m.maiya@samsung.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  

Download

• src/libANGLE/Surface.h

• //
  // Copyright 2002 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.
  //
  
  // Surface.h: Defines the egl::Surface class, representing a drawing surface
  // such as the client area of a window, including any back buffers.
  // Implements EGLSurface and related functionality. [EGL 1.4] section 2.2 page 3.
  
  #ifndef LIBANGLE_SURFACE_H_
  #define LIBANGLE_SURFACE_H_
  
  #include <EGL/egl.h>
  
  #include "common/PackedEnums.h"
  #include "common/angleutils.h"
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Debug.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/FramebufferAttachment.h"
  #include "libANGLE/RefCountObject.h"
  #include "libANGLE/formatutils.h"
  #include "libANGLE/renderer/SurfaceImpl.h"
  
  namespace gl
  {
  class Context;
  class Framebuffer;
  class Texture;
  }  // namespace gl
  
  namespace rx
  {
  class EGLImplFactory;
  }
  
  namespace egl
  {
  class Display;
  struct Config;
  
  using SupportedCompositorTiming = angle::PackedEnumBitSet<CompositorTiming>;
  using SupportedTimestamps       = angle::PackedEnumBitSet<Timestamp>;
  
  struct SurfaceState final : private angle::NonCopyable
  {
      SurfaceState(const egl::Config *configIn, const AttributeMap &attributesIn);
      ~SurfaceState();
  
      bool isRobustResourceInitEnabled() const;
  
      EGLLabelKHR label;
      const egl::Config *config;
      AttributeMap attributes;
  
      bool timestampsEnabled;
      SupportedCompositorTiming supportedCompositorTimings;
      SupportedTimestamps supportedTimestamps;
      bool directComposition;
  };
  
  class Surface : public LabeledObject, public gl::FramebufferAttachmentObject
  {
    public:
      rx::SurfaceImpl *getImplementation() const { return mImplementation; }
  
      void setLabel(EGLLabelKHR label) override;
      EGLLabelKHR getLabel() const override;
  
      EGLint getType() const;
  
      Error initialize(const Display *display);
      Error makeCurrent(const gl::Context *context);
      Error unMakeCurrent(const gl::Context *context);
      Error swap(const gl::Context *context);
      Error swapWithDamage(const gl::Context *context, const EGLint *rects, EGLint n_rects);
      Error swapWithFrameToken(const gl::Context *context, EGLFrameTokenANGLE frameToken);
      Error postSubBuffer(const gl::Context *context,
                          EGLint x,
                          EGLint y,
                          EGLint width,
                          EGLint height);
      Error setPresentationTime(EGLnsecsANDROID time);
      Error querySurfacePointerANGLE(EGLint attribute, void **value);
      Error bindTexImage(gl::Context *context, gl::Texture *texture, EGLint buffer);
      Error releaseTexImage(const gl::Context *context, EGLint buffer);
  
      Error getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc);
      Error getMscRate(EGLint *numerator, EGLint *denominator);
  
      EGLint isPostSubBufferSupported() const;
  
      void setSwapInterval(EGLint interval);
      Error onDestroy(const Display *display);
  
      void setMipmapLevel(EGLint level);
      void setMultisampleResolve(EGLenum resolve);
      void setSwapBehavior(EGLenum behavior);
  
      void setFixedWidth(EGLint width);
      void setFixedHeight(EGLint height);
  
      gl::Framebuffer *createDefaultFramebuffer(const gl::Context *context,
                                                egl::Surface *readSurface);
  
      const Config *getConfig() const;
  
      // width and height can change with client window resizing
      EGLint getWidth() const;
      EGLint getHeight() const;
      // Note: windows cannot be resized on Android.  The approach requires
      // calling vkGetPhysicalDeviceSurfaceCapabilitiesKHR.  However, that is
      // expensive; and there are troublesome timing issues for other parts of
      // ANGLE (which cause test failures and crashes).  Therefore, a
      // special-Android-only path is created just for the querying of EGL_WIDTH
      // and EGL_HEIGHT.
      // https://issuetracker.google.com/issues/153329980
      egl::Error getUserWidth(const egl::Display *display, EGLint *value) const;
      egl::Error getUserHeight(const egl::Display *display, EGLint *value) const;
      EGLint getPixelAspectRatio() const;
      EGLenum getRenderBuffer() const;
      EGLenum getSwapBehavior() const;
      TextureFormat getTextureFormat() const;
      EGLenum getTextureTarget() const;
      bool getLargestPbuffer() const;
      EGLenum getGLColorspace() const;
      EGLenum getVGAlphaFormat() const;
      EGLenum getVGColorspace() const;
      bool getMipmapTexture() const;
      EGLint getMipmapLevel() const;
      EGLint getHorizontalResolution() const;
      EGLint getVerticalResolution() const;
      EGLenum getMultisampleResolve() const;
  
      gl::Texture *getBoundTexture() const { return mTexture; }
  
      EGLint isFixedSize() const;
  
      // FramebufferAttachmentObject implementation
      gl::Extents getAttachmentSize(const gl::ImageIndex &imageIndex) const override;
      gl::Format getAttachmentFormat(GLenum binding, const gl::ImageIndex &imageIndex) const override;
      GLsizei getAttachmentSamples(const gl::ImageIndex &imageIndex) const override;
      bool isRenderable(const gl::Context *context,
                        GLenum binding,
                        const gl::ImageIndex &imageIndex) const override;
      bool isYUV() const override;
  
      void onAttach(const gl::Context *context, rx::Serial framebufferSerial) override {}
      void onDetach(const gl::Context *context, rx::Serial framebufferSerial) override {}
      GLuint getId() const override;
  
      bool flexibleSurfaceCompatibilityRequested() const
      {
          return mFlexibleSurfaceCompatibilityRequested;
      }
      EGLint getOrientation() const { return mOrientation; }
  
      bool directComposition() const { return mState.directComposition; }
  
      gl::InitState initState(const gl::ImageIndex &imageIndex) const override;
      void setInitState(const gl::ImageIndex &imageIndex, gl::InitState initState) override;
  
      bool isRobustResourceInitEnabled() const { return mRobustResourceInitialization; }
  
      const gl::Format &getBindTexImageFormat() const { return mColorFormat; }
  
      // EGL_ANDROID_get_frame_timestamps entry points
      void setTimestampsEnabled(bool enabled);
      bool isTimestampsEnabled() const;
  
      const SupportedCompositorTiming &getSupportedCompositorTimings() const;
      Error getCompositorTiming(EGLint numTimestamps,
                                const EGLint *names,
                                EGLnsecsANDROID *values) const;
  
      Error getNextFrameId(EGLuint64KHR *frameId) const;
      const SupportedTimestamps &getSupportedTimestamps() const;
      Error getFrameTimestamps(EGLuint64KHR frameId,
                               EGLint numTimestamps,
                               const EGLint *timestamps,
                               EGLnsecsANDROID *values) const;
  
      // Returns the offset into the texture backing the surface if specified via texture offset
      // attributes (see EGL_ANGLE_d3d_texture_client_buffer extension). Returns zero offset
      // otherwise.
      const gl::Offset &getTextureOffset() const { return mTextureOffset; }
  
      Error getBufferAge(const gl::Context *context, EGLint *age) const;
  
    protected:
      Surface(EGLint surfaceType,
              const egl::Config *config,
              const AttributeMap &attributes,
              EGLenum buftype = EGL_NONE);
      ~Surface() override;
      rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
  
      gl::Framebuffer *createDefaultFramebuffer(const Display *display);
  
      // ANGLE-only method, used internally
      friend class gl::Texture;
      Error releaseTexImageFromTexture(const gl::Context *context);
  
      SurfaceState mState;
      rx::SurfaceImpl *mImplementation;
      int mRefCount;
      bool mDestroyed;
  
      EGLint mType;
      EGLenum mBuftype;
  
      bool mPostSubBufferRequested;
      bool mFlexibleSurfaceCompatibilityRequested;
  
      bool mLargestPbuffer;
      EGLenum mGLColorspace;
      EGLenum mVGAlphaFormat;
      EGLenum mVGColorspace;
      bool mMipmapTexture;
      EGLint mMipmapLevel;
      EGLint mHorizontalResolution;
      EGLint mVerticalResolution;
      EGLenum mMultisampleResolve;
  
      bool mFixedSize;
      size_t mFixedWidth;
      size_t mFixedHeight;
  
      bool mRobustResourceInitialization;
  
      TextureFormat mTextureFormat;
      EGLenum mTextureTarget;
  
      EGLint mPixelAspectRatio;  // Display aspect ratio
      EGLenum mRenderBuffer;     // Render buffer
      EGLenum mSwapBehavior;     // Buffer swap behavior
  
      EGLint mOrientation;
  
      // We don't use a binding pointer here. We don't ever want to own an orphaned texture. If a
      // Texture is deleted the Surface is unbound in onDestroy.
      gl::Texture *mTexture;
  
      gl::Format mColorFormat;
      gl::Format mDSFormat;
  
      gl::Offset mTextureOffset;
  
    private:
      Error destroyImpl(const Display *display);
  
      void postSwap(const gl::Context *context);
      Error releaseRef(const Display *display);
  
      // ObserverInterface implementation.
      void onSubjectStateChange(angle::SubjectIndex index, angle::SubjectMessage message) override;
  
      gl::InitState mInitState;
      angle::ObserverBinding mImplObserverBinding;
  };
  
  class WindowSurface final : public Surface
  {
    public:
      WindowSurface(rx::EGLImplFactory *implFactory,
                    const Config *config,
                    EGLNativeWindowType window,
                    const AttributeMap &attribs);
      ~WindowSurface() override;
  };
  
  class PbufferSurface final : public Surface
  {
    public:
      PbufferSurface(rx::EGLImplFactory *implFactory,
                     const Config *config,
                     const AttributeMap &attribs);
      PbufferSurface(rx::EGLImplFactory *implFactory,
                     const Config *config,
                     EGLenum buftype,
                     EGLClientBuffer clientBuffer,
                     const AttributeMap &attribs);
  
    protected:
      ~PbufferSurface() override;
  };
  
  class PixmapSurface final : public Surface
  {
    public:
      PixmapSurface(rx::EGLImplFactory *implFactory,
                    const Config *config,
                    NativePixmapType nativePixmap,
                    const AttributeMap &attribs);
  
    protected:
      ~PixmapSurface() override;
  };
  
  class SurfaceDeleter final
  {
    public:
      SurfaceDeleter(const Display *display);
      ~SurfaceDeleter();
      void operator()(Surface *surface);
  
    private:
      const Display *mDisplay;
  };
  
  using SurfacePointer = angle::UniqueObjectPointerBase<Surface, SurfaceDeleter>;
  
  }  // namespace egl
  
  #endif  // LIBANGLE_SURFACE_H_
  

Download