gfx/layers/Compositor.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/layers/Compositor.h"
   8 #include "mozilla/layers/CompositionRecorder.h"
   9 #include "base/message_loop.h"  // for MessageLoop
  10 #include "mozilla/gfx/Types.h"
  11 #include "mozilla/layers/CompositorBridgeParent.h"  // for CompositorBridgeParent
  12 #include "mozilla/layers/Diagnostics.h"
  13 #include "mozilla/layers/Effects.h"  // for Effect, EffectChain, etc
  14 #include "mozilla/layers/TextureClient.h"
  15 #include "mozilla/layers/TextureHost.h"
  16 #include "mozilla/layers/CompositorThread.h"
  17 #include "mozilla/mozalloc.h"  // for operator delete, etc
  18 #include "GeckoProfiler.h"
  19 #include "gfx2DGlue.h"
  20 #include "nsAppRunner.h"
  21
  22 namespace mozilla {
  23
  24 namespace layers {
  25
  26 class CompositorRecordedFrame final : public RecordedFrame {
  27  public:
  28   CompositorRecordedFrame(const TimeStamp& aTimeStamp,
  29                           RefPtr<AsyncReadbackBuffer>&& aBuffer)
  30       : RecordedFrame(aTimeStamp), mBuffer(aBuffer) {}
  31
  32   virtual already_AddRefed<gfx::DataSourceSurface> GetSourceSurface() override {
  33     if (mSurface) {
  34       return do_AddRef(mSurface);
  35     }
  36
  37     gfx::IntSize size = mBuffer->GetSize();
  38
  39     mSurface = gfx::Factory::CreateDataSourceSurface(
  40         size, gfx::SurfaceFormat::B8G8R8A8,
  41         /* aZero = */ false);
  42
  43     if (!mBuffer->MapAndCopyInto(mSurface, size)) {
  44       mSurface = nullptr;
  45       return nullptr;
  46     }
  47
  48     return do_AddRef(mSurface);
  49   }
  50
  51  private:
  52   RefPtr<AsyncReadbackBuffer> mBuffer;
  53   RefPtr<gfx::DataSourceSurface> mSurface;
  54 };
  55
  56 Compositor::Compositor(widget::CompositorWidget* aWidget)
  57     : mWidget(aWidget),
  58       mIsDestroyed(false)
  59 #if defined(MOZ_WIDGET_ANDROID)
  60       // If the default color isn't white for Fennec, there is a black
  61       // flash before the first page of a tab is loaded.
  62       ,
  63       mClearColor(ToDeviceColor(sRGBColor::OpaqueWhite()))
  64 #else
  65       ,
  66       mClearColor(gfx::DeviceColor())
  67 #endif
  68 {
  69 }
  70
  71 Compositor::~Compositor() {}
  72
  73 void Compositor::Destroy() {
  74   mWidget = nullptr;
  75
  76   TextureSourceProvider::Destroy();
  77   mIsDestroyed = true;
  78 }
  79
  80 void Compositor::EndFrame() { mLastCompositionEndTime = TimeStamp::Now(); }
  81
  82 nsTArray<TexturedVertex> TexturedTrianglesToVertexArray(
  83     const nsTArray<gfx::TexturedTriangle>& aTriangles) {
  84   const auto VertexFromPoints = [](const gfx::Point& p, const gfx::Point& t) {
  85     return TexturedVertex{{p.x, p.y}, {t.x, t.y}};
  86   };
  87
  88   nsTArray<TexturedVertex> vertices;
  89
  90   for (const gfx::TexturedTriangle& t : aTriangles) {
  91     vertices.AppendElement(VertexFromPoints(t.p1, t.textureCoords.p1));
  92     vertices.AppendElement(VertexFromPoints(t.p2, t.textureCoords.p2));
  93     vertices.AppendElement(VertexFromPoints(t.p3, t.textureCoords.p3));
  94   }
  95
  96   return vertices;
  97 }
  98
  99 static float WrapTexCoord(float v) {
 100   // This should return values in range [0, 1.0)
 101   return v - floorf(v);
 102 }
 103
 104 static void SetRects(size_t n, decomposedRectArrayT* aLayerRects,
 105                      decomposedRectArrayT* aTextureRects, float x0, float y0,
 106                      float x1, float y1, float tx0, float ty0, float tx1,
 107                      float ty1, bool flip_y) {
 108   if (flip_y) {
 109     std::swap(ty0, ty1);
 110   }
 111   (*aLayerRects)[n] = gfx::Rect(x0, y0, x1 - x0, y1 - y0);
 112   (*aTextureRects)[n] = gfx::Rect(tx0, ty0, tx1 - tx0, ty1 - ty0);
 113 }
 114
 115 #ifdef DEBUG
 116 static inline bool FuzzyEqual(float a, float b) {
 117   return fabs(a - b) < 0.0001f;
 118 }
 119 static inline bool FuzzyLTE(float a, float b) { return a <= b + 0.0001f; }
 120 #endif
 121
 122 size_t DecomposeIntoNoRepeatRects(const gfx::Rect& aRect,
 123                                   const gfx::Rect& aTexCoordRect,
 124                                   decomposedRectArrayT* aLayerRects,
 125                                   decomposedRectArrayT* aTextureRects) {
 126   gfx::Rect texCoordRect = aTexCoordRect;
 127
 128   // If the texture should be flipped, it will have negative height. Detect that
 129   // here and compensate for it. We will flip each rect as we emit it.
 130   bool flipped = false;
 131   if (texCoordRect.Height() < 0) {
 132     flipped = true;
 133     texCoordRect.MoveByY(texCoordRect.Height());
 134     texCoordRect.SetHeight(-texCoordRect.Height());
 135   }
 136
 137   // Wrap the texture coordinates so they are within [0,1] and cap width/height
 138   // at 1. We rely on this below.
 139   texCoordRect = gfx::Rect(gfx::Point(WrapTexCoord(texCoordRect.X()),
 140                                       WrapTexCoord(texCoordRect.Y())),
 141                            gfx::Size(std::min(texCoordRect.Width(), 1.0f),
 142                                      std::min(texCoordRect.Height(), 1.0f)));
 143
 144   NS_ASSERTION(
 145       texCoordRect.X() >= 0.0f && texCoordRect.X() <= 1.0f &&
 146           texCoordRect.Y() >= 0.0f && texCoordRect.Y() <= 1.0f &&
 147           texCoordRect.Width() >= 0.0f && texCoordRect.Width() <= 1.0f &&
 148           texCoordRect.Height() >= 0.0f && texCoordRect.Height() <= 1.0f &&
 149           texCoordRect.XMost() >= 0.0f && texCoordRect.XMost() <= 2.0f &&
 150           texCoordRect.YMost() >= 0.0f && texCoordRect.YMost() <= 2.0f,
 151       "We just wrapped the texture coordinates, didn't we?");
 152
 153   // Get the top left and bottom right points of the rectangle. Note that
 154   // tl.x/tl.y are within [0,1] but br.x/br.y are within [0,2].
 155   gfx::Point tl = texCoordRect.TopLeft();
 156   gfx::Point br = texCoordRect.BottomRight();
 157
 158   NS_ASSERTION(tl.x >= 0.0f && tl.x <= 1.0f && tl.y >= 0.0f && tl.y <= 1.0f &&
 159                    br.x >= tl.x && br.x <= 2.0f && br.y >= tl.y &&
 160                    br.y <= 2.0f && FuzzyLTE(br.x - tl.x, 1.0f) &&
 161                    FuzzyLTE(br.y - tl.y, 1.0f),
 162                "Somehow generated invalid texture coordinates");
 163
 164   // Then check if we wrap in either the x or y axis.
 165   bool xwrap = br.x > 1.0f;
 166   bool ywrap = br.y > 1.0f;
 167
 168   // If xwrap is false, the texture will be sampled from tl.x .. br.x.
 169   // If xwrap is true, then it will be split into tl.x .. 1.0, and
 170   // 0.0 .. WrapTexCoord(br.x). Same for the Y axis. The destination
 171   // rectangle is also split appropriately, according to the calculated
 172   // xmid/ymid values.
 173   if (!xwrap && !ywrap) {
 174     SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), aRect.XMost(),
 175              aRect.YMost(), tl.x, tl.y, br.x, br.y, flipped);
 176     return 1;
 177   }
 178
 179   // If we are dealing with wrapping br.x and br.y are greater than 1.0 so
 180   // wrap them here as well.
 181   br = gfx::Point(xwrap ? WrapTexCoord(br.x.value) : br.x.value,
 182                   ywrap ? WrapTexCoord(br.y.value) : br.y.value);
 183
 184   // If we wrap around along the x axis, we will draw first from
 185   // tl.x .. 1.0 and then from 0.0 .. br.x (which we just wrapped above).
 186   // The same applies for the Y axis. The midpoints we calculate here are
 187   // only valid if we actually wrap around.
 188   GLfloat xmid =
 189       aRect.X() + (1.0f - tl.x) / texCoordRect.Width() * aRect.Width();
 190   GLfloat ymid =
 191       aRect.Y() + (1.0f - tl.y) / texCoordRect.Height() * aRect.Height();
 192
 193   // Due to floating-point inaccuracy, we have to use XMost()-x and YMost()-y
 194   // to calculate width and height, respectively, to ensure that size will
 195   // remain consistent going from absolute to relative and back again.
 196   NS_ASSERTION(
 197       !xwrap || (xmid >= aRect.X() && xmid <= aRect.XMost() &&
 198                  FuzzyEqual((xmid - aRect.X()) + (aRect.XMost() - xmid),
 199                             aRect.XMost() - aRect.X())),
 200       "xmid should be within [x,XMost()] and the wrapped rect should have the "
 201       "same width");
 202   NS_ASSERTION(
 203       !ywrap || (ymid >= aRect.Y() && ymid <= aRect.YMost() &&
 204                  FuzzyEqual((ymid - aRect.Y()) + (aRect.YMost() - ymid),
 205                             aRect.YMost() - aRect.Y())),
 206       "ymid should be within [y,YMost()] and the wrapped rect should have the "
 207       "same height");
 208
 209   if (!xwrap && ywrap) {
 210     SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), aRect.XMost(),
 211              ymid, tl.x, tl.y, br.x, 1.0f, flipped);
 212     SetRects(1, aLayerRects, aTextureRects, aRect.X(), ymid, aRect.XMost(),
 213              aRect.YMost(), tl.x, 0.0f, br.x, br.y, flipped);
 214     return 2;
 215   }
 216
 217   if (xwrap && !ywrap) {
 218     SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), xmid,
 219              aRect.YMost(), tl.x, tl.y, 1.0f, br.y, flipped);
 220     SetRects(1, aLayerRects, aTextureRects, xmid, aRect.Y(), aRect.XMost(),
 221              aRect.YMost(), 0.0f, tl.y, br.x, br.y, flipped);
 222     return 2;
 223   }
 224
 225   SetRects(0, aLayerRects, aTextureRects, aRect.X(), aRect.Y(), xmid, ymid,
 226            tl.x, tl.y, 1.0f, 1.0f, flipped);
 227   SetRects(1, aLayerRects, aTextureRects, xmid, aRect.Y(), aRect.XMost(), ymid,
 228            0.0f, tl.y, br.x, 1.0f, flipped);
 229   SetRects(2, aLayerRects, aTextureRects, aRect.X(), ymid, xmid, aRect.YMost(),
 230            tl.x, 0.0f, 1.0f, br.y, flipped);
 231   SetRects(3, aLayerRects, aTextureRects, xmid, ymid, aRect.XMost(),
 232            aRect.YMost(), 0.0f, 0.0f, br.x, br.y, flipped);
 233   return 4;
 234 }
 235
 236 already_AddRefed<RecordedFrame> Compositor::RecordFrame(
 237     const TimeStamp& aTimeStamp) {
 238   RefPtr<CompositingRenderTarget> renderTarget = GetWindowRenderTarget();
 239   if (!renderTarget) {
 240     return nullptr;
 241   }
 242
 243   RefPtr<AsyncReadbackBuffer> buffer =
 244       CreateAsyncReadbackBuffer(renderTarget->GetSize());
 245
 246   if (!ReadbackRenderTarget(renderTarget, buffer)) {
 247     return nullptr;
 248   }
 249
 250   return MakeAndAddRef<CompositorRecordedFrame>(aTimeStamp, std::move(buffer));
 251 }
 252
 253 bool Compositor::ShouldRecordFrames() const {
 254   return profiler_feature_active(ProfilerFeature::Screenshots) || mRecordFrames;
 255 }
 256
 257 }  // namespace layers
 258 }  // namespace mozilla