Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 195 insertions, 0 deletions

diff --git a/gfx/webrender_bindings/RenderCompositorLayersSWGL.h b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h
new file mode 100644
index 0000000000..3cf6bb44f5
--- /dev/null
+++ b/gfx/webrender_bindings/RenderCompositorLayersSWGL.h
@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef MOZILLA_GFX_RENDERCOMPOSITOR_Layers_H
+#define MOZILLA_GFX_RENDERCOMPOSITOR_Layers_H
+
+#include <unordered_map>
+
+#include "mozilla/HashFunctions.h"
+#include "mozilla/layers/Compositor.h"
+#include "mozilla/layers/ScreenshotGrabber.h"
+#include "mozilla/webrender/RenderCompositor.h"
+#include "mozilla/webrender/RenderTextureHost.h"
+
+namespace mozilla {
+
+namespace wr {
+
+class SurfaceD3D11SWGL;
+
+class RenderCompositorLayersSWGL : public RenderCompositor {
+ public:
+  static UniquePtr<RenderCompositor> Create(
+      const RefPtr<widget::CompositorWidget>& aWidget, nsACString& aError);
+
+  RenderCompositorLayersSWGL(layers::Compositor* aCompositor,
+                             const RefPtr<widget::CompositorWidget>& aWidget,
+                             void* aContext);
+  virtual ~RenderCompositorLayersSWGL();
+
+  void* swgl() const override { return mContext; }
+
+  bool MakeCurrent() override;
+
+  bool BeginFrame() override;
+  void CancelFrame() override;
+  RenderedFrameId EndFrame(const nsTArray<DeviceIntRect>& aDirtyRects) override;
+
+  bool SurfaceOriginIsTopLeft() override { return true; }
+
+  LayoutDeviceIntSize GetBufferSize() override;
+
+  // Should we support this?
+  bool SupportsExternalBufferTextures() const override { return false; }
+
+  layers::WebRenderBackend BackendType() const override {
+    return layers::WebRenderBackend::SOFTWARE;
+  }
+
+  bool ShouldUseNativeCompositor() override { return true; }
+
+  void StartCompositing(wr::ColorF aClearColor,
+                        const wr::DeviceIntRect* aDirtyRects,
+                        size_t aNumDirtyRects,
+                        const wr::DeviceIntRect* aOpaqueRects,
+                        size_t aNumOpaqueRects) override;
+
+  void CompositorBeginFrame() override {}
+  void CompositorEndFrame() override;
+  void Bind(wr::NativeTileId aId, wr::DeviceIntPoint* aOffset, uint32_t* aFboId,
+            wr::DeviceIntRect aDirtyRect,
+            wr::DeviceIntRect aValidRect) override;
+  void Unbind() override;
+  bool MapTile(wr::NativeTileId aId, wr::DeviceIntRect aDirtyRect,
+               wr::DeviceIntRect aValidRect, void** aData,
+               int32_t* aStride) override;
+  void UnmapTile() override;
+  void CreateSurface(wr::NativeSurfaceId aId, wr::DeviceIntPoint aVirtualOffset,
+                     wr::DeviceIntSize aTileSize, bool aIsOpaque) override;
+  void CreateExternalSurface(wr::NativeSurfaceId aId, bool aIsOpaque) override;
+  void DestroySurface(NativeSurfaceId aId) override;
+  void CreateTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override;
+  void DestroyTile(wr::NativeSurfaceId, int32_t aX, int32_t aY) override;
+  void AttachExternalImage(wr::NativeSurfaceId aId,
+                           wr::ExternalImageId aExternalImage) override;
+  void AddSurface(wr::NativeSurfaceId aId,
+                  const wr::CompositorSurfaceTransform& aTransform,
+                  wr::DeviceIntRect aClipRect,
+                  wr::ImageRendering aImageRendering) override;
+  void EnableNativeCompositor(bool aEnable) override {}
+  void DeInit() override {}
+
+  void MaybeRequestAllowFrameRecording(bool aWillRecord) override;
+  bool MaybeRecordFrame(layers::CompositionRecorder& aRecorder) override;
+  bool MaybeGrabScreenshot(const gfx::IntSize& aWindowSize) override;
+  bool MaybeProcessScreenshotQueue() override;
+
+  // TODO: Screenshots etc
+
+  struct TileKey {
+    TileKey(int32_t aX, int32_t aY) : mX(aX), mY(aY) {}
+
+    int32_t mX;
+    int32_t mY;
+  };
+
+  // Each tile retains a texture, and a DataSourceSurface of the
+  // same size. We draw into the source surface, and then copy the
+  // changed area into the texture.
+  class Tile {
+   public:
+    Tile() = default;
+    virtual ~Tile() = default;
+
+    virtual bool Map(wr::DeviceIntRect aDirtyRect, wr::DeviceIntRect aValidRect,
+                     void** aData, int32_t* aStride) = 0;
+    virtual void Unmap(const gfx::IntRect& aDirtyRect) = 0;
+    virtual layers::DataTextureSource* GetTextureSource() = 0;
+    virtual bool IsValid() = 0;
+
+    gfx::Rect mValidRect;
+
+    struct KeyHashFn {
+      std::size_t operator()(const TileKey& aId) const {
+        return HashGeneric(aId.mX, aId.mY);
+      }
+    };
+  };
+
+  class Surface {
+   public:
+    explicit Surface(wr::DeviceIntSize aTileSize, bool aIsOpaque)
+        : mTileSize(aTileSize), mIsOpaque(aIsOpaque) {}
+    virtual ~Surface() {}
+
+    gfx::IntSize TileSize() {
+      return gfx::IntSize(mTileSize.width, mTileSize.height);
+    }
+    virtual SurfaceD3D11SWGL* AsSurfaceD3D11SWGL() { return nullptr; }
+
+    // External images can change size depending on which image
+    // is attached, so mTileSize will be 0,0 when mIsExternal
+    // is true.
+    wr::DeviceIntSize mTileSize;
+    bool mIsOpaque;
+    bool mIsExternal = false;
+    std::unordered_map<TileKey, UniquePtr<Tile>, Tile::KeyHashFn> mTiles;
+    RefPtr<RenderTextureHost> mExternalImage;
+
+    struct IdHashFn {
+      std::size_t operator()(const wr::NativeSurfaceId& aId) const {
+        return HashGeneric(wr::AsUint64(aId));
+      }
+    };
+  };
+
+  static gfx::SamplingFilter ToSamplingFilter(
+      wr::ImageRendering aImageRendering);
+
+ protected:
+  // The set of surfaces added to be composited for the current frame
+  struct FrameSurface {
+    wr::NativeSurfaceId mId;
+    gfx::Matrix4x4 mTransform;
+    gfx::IntRect mClipRect;
+    gfx::SamplingFilter mFilter;
+  };
+
+  virtual void HandleExternalImage(RenderTextureHost* aExternalImage,
+                                   FrameSurface& aFrameSurface) = 0;
+  virtual UniquePtr<RenderCompositorLayersSWGL::Surface> DoCreateSurface(
+      wr::DeviceIntSize aTileSize, bool aIsOpaque);
+  virtual UniquePtr<RenderCompositorLayersSWGL::Tile> DoCreateTile(
+      Surface* aSurface) = 0;
+
+  RefPtr<layers::Compositor> mCompositor;
+  void* mContext = nullptr;
+
+  std::unordered_map<wr::NativeSurfaceId, UniquePtr<Surface>, Surface::IdHashFn>
+      mSurfaces;
+
+  // Temporary state held between MapTile and UnmapTile
+  Tile* mCurrentTile = nullptr;
+  gfx::IntRect mCurrentTileDirty;
+  wr::NativeTileId mCurrentTileId;
+
+  nsTArray<FrameSurface> mFrameSurfaces;
+  bool mInFrame = false;
+  bool mCompositingStarted = false;
+
+  layers::ScreenshotGrabber mProfilerScreenshotGrabber;
+};
+
+static inline bool operator==(const RenderCompositorLayersSWGL::TileKey& a0,
+                              const RenderCompositorLayersSWGL::TileKey& a1) {
+  return a0.mX == a1.mX && a0.mY == a1.mY;
+}
+
+}  // namespace wr
+}  // namespace mozilla
+
+#endif