summaryrefslogtreecommitdiffstats
path: root/gfx/angle/checkout/src/libANGLE/Surface.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /gfx/angle/checkout/src/libANGLE/Surface.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/angle/checkout/src/libANGLE/Surface.h')
-rw-r--r--gfx/angle/checkout/src/libANGLE/Surface.h388
1 files changed, 388 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libANGLE/Surface.h b/gfx/angle/checkout/src/libANGLE/Surface.h
new file mode 100644
index 0000000000..862d2f57b2
--- /dev/null
+++ b/gfx/angle/checkout/src/libANGLE/Surface.h
@@ -0,0 +1,388 @@
+//
+// 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 <memory>
+
+#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;
+ bool hasProtectedContent() const;
+ EGLint getPreferredSwapInterval() const;
+
+ EGLLabelKHR label;
+ const egl::Config *config;
+ AttributeMap attributes;
+
+ bool timestampsEnabled;
+ bool autoRefreshEnabled;
+ SupportedCompositorTiming supportedCompositorTimings;
+ SupportedTimestamps supportedTimestamps;
+ bool directComposition;
+ EGLenum swapBehavior;
+};
+
+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 prepareSwap(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);
+
+ 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;
+ bool hasProtectedContent() const override;
+
+ // For lock surface buffer
+ EGLint getBitmapPitch() const;
+ EGLint getBitmapOrigin() const;
+ EGLint getRedOffset() const;
+ EGLint getGreenOffset() const;
+ EGLint getBlueOffset() const;
+ EGLint getAlphaOffset() const;
+ EGLint getLuminanceOffset() const;
+ EGLint getBitmapPixelSize() const;
+ EGLAttribKHR getBitmapPointer() const;
+ egl::Error lockSurfaceKHR(const egl::Display *display, const AttributeMap &attributes);
+ egl::Error unlockSurfaceKHR(const egl::Display *display);
+
+ bool isLocked() const;
+ bool isCurrentOnAnyContext() const { return mIsCurrentOnAnyContext; }
+
+ 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;
+ bool isCreatedWithAHB() 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;
+
+ EGLint getOrientation() const { return mOrientation; }
+
+ bool directComposition() const { return mState.directComposition; }
+
+ gl::InitState initState(GLenum binding, const gl::ImageIndex &imageIndex) const override;
+ void setInitState(GLenum binding,
+ 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;
+
+ // EGL_ANDROID_front_buffer_auto_refresh entry points
+ Error setAutoRefreshEnabled(bool enabled);
+
+ 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);
+
+ Error setRenderBuffer(EGLint renderBuffer);
+
+ bool bufferAgeQueriedSinceLastSwap() const { return mBufferAgeQueriedSinceLastSwap; }
+ void setDamageRegion(const EGLint *rects, EGLint n_rects);
+ bool isDamageRegionSet() const { return mIsDamageRegionSet; }
+
+ void addRef() { mRefCount++; }
+ void release()
+ {
+ ASSERT(mRefCount > 0);
+ mRefCount--;
+ }
+
+ protected:
+ Surface(EGLint surfaceType,
+ GLuint serialId,
+ const egl::Config *config,
+ const AttributeMap &attributes,
+ bool forceRobustResourceInit,
+ EGLenum buftype = EGL_NONE);
+ ~Surface() override;
+ rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const override;
+
+ // 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 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
+
+ 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;
+
+ bool mIsCurrentOnAnyContext; // The surface is current to a context/client API
+ uint8_t *mLockBufferPtr; // Memory owned by backend.
+ EGLint mLockBufferPitch;
+
+ bool mBufferAgeQueriedSinceLastSwap;
+ bool mIsDamageRegionSet;
+
+ private:
+ Error getBufferAgeImpl(const gl::Context *context, EGLint *age) const;
+
+ 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 mColorInitState;
+ gl::InitState mDepthStencilInitState;
+ angle::ObserverBinding mImplObserverBinding;
+
+ GLuint mSerialId;
+};
+
+class WindowSurface final : public Surface
+{
+ public:
+ WindowSurface(rx::EGLImplFactory *implFactory,
+ const Config *config,
+ EGLNativeWindowType window,
+ const AttributeMap &attribs,
+ bool robustResourceInit);
+ ~WindowSurface() override;
+};
+
+class PbufferSurface final : public Surface
+{
+ public:
+ PbufferSurface(rx::EGLImplFactory *implFactory,
+ const Config *config,
+ const AttributeMap &attribs,
+ bool robustResourceInit);
+ PbufferSurface(rx::EGLImplFactory *implFactory,
+ const Config *config,
+ EGLenum buftype,
+ EGLClientBuffer clientBuffer,
+ const AttributeMap &attribs,
+ bool robustResourceInit);
+
+ protected:
+ ~PbufferSurface() override;
+};
+
+class PixmapSurface final : public Surface
+{
+ public:
+ PixmapSurface(rx::EGLImplFactory *implFactory,
+ const Config *config,
+ NativePixmapType nativePixmap,
+ const AttributeMap &attribs,
+ bool robustResourceInit);
+
+ protected:
+ ~PixmapSurface() override;
+};
+
+class [[nodiscard]] ScopedSurfaceRef
+{
+ public:
+ ScopedSurfaceRef(Surface *surface) : mSurface(surface)
+ {
+ if (mSurface)
+ {
+ mSurface->addRef();
+ }
+ }
+ ~ScopedSurfaceRef()
+ {
+ if (mSurface)
+ {
+ mSurface->release();
+ }
+ }
+
+ private:
+ Surface *const mSurface;
+};
+
+class SurfaceDeleter final
+{
+ public:
+ SurfaceDeleter(const Display *display);
+ ~SurfaceDeleter();
+ void operator()(Surface *surface);
+
+ private:
+ const Display *mDisplay;
+};
+
+using SurfacePointer = std::unique_ptr<Surface, SurfaceDeleter>;
+
+} // namespace egl
+
+#endif // LIBANGLE_SURFACE_H_