summaryrefslogtreecommitdiffstats
path: root/image/imgFrame.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--image/imgFrame.cpp729
1 files changed, 729 insertions, 0 deletions
diff --git a/image/imgFrame.cpp b/image/imgFrame.cpp
new file mode 100644
index 0000000000..0df40fcfa9
--- /dev/null
+++ b/image/imgFrame.cpp
@@ -0,0 +1,729 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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/. */
+
+#include "imgFrame.h"
+#include "ImageRegion.h"
+#include "SurfaceCache.h"
+
+#include "prenv.h"
+
+#include "gfx2DGlue.h"
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+
+#include "gfxUtils.h"
+
+#include "MainThreadUtils.h"
+#include "mozilla/CheckedInt.h"
+#include "mozilla/gfx/Tools.h"
+#include "mozilla/Likely.h"
+#include "mozilla/MemoryReporting.h"
+#include "mozilla/ProfilerLabels.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "nsMargin.h"
+#include "nsRefreshDriver.h"
+#include "nsThreadUtils.h"
+
+#include <algorithm> // for min, max
+
+namespace mozilla {
+
+using namespace gfx;
+
+namespace image {
+
+/**
+ * This class is identical to SourceSurfaceSharedData but returns a different
+ * type so that SharedSurfacesChild is aware imagelib wants to recycle this
+ * surface for future animation frames.
+ */
+class RecyclingSourceSurfaceSharedData final : public SourceSurfaceSharedData {
+ public:
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(RecyclingSourceSurfaceSharedData,
+ override)
+
+ SurfaceType GetType() const override {
+ return SurfaceType::DATA_RECYCLING_SHARED;
+ }
+};
+
+static already_AddRefed<SourceSurfaceSharedData> AllocateBufferForImage(
+ const IntSize& size, SurfaceFormat format, bool aShouldRecycle = false) {
+ // Stride must be a multiple of four or cairo will complain.
+ int32_t stride = (size.width * BytesPerPixel(format) + 0x3) & ~0x3;
+
+ RefPtr<SourceSurfaceSharedData> newSurf;
+ if (aShouldRecycle) {
+ newSurf = new RecyclingSourceSurfaceSharedData();
+ } else {
+ newSurf = new SourceSurfaceSharedData();
+ }
+ if (!newSurf->Init(size, stride, format)) {
+ return nullptr;
+ }
+ return newSurf.forget();
+}
+
+static bool GreenSurface(SourceSurfaceSharedData* aSurface,
+ const IntSize& aSize, SurfaceFormat aFormat) {
+ int32_t stride = aSurface->Stride();
+ uint32_t* surfaceData = reinterpret_cast<uint32_t*>(aSurface->GetData());
+ uint32_t surfaceDataLength = (stride * aSize.height) / sizeof(uint32_t);
+
+ // Start by assuming that GG is in the second byte and
+ // AA is in the final byte -- the most common case.
+ uint32_t color = mozilla::NativeEndian::swapFromBigEndian(0x00FF00FF);
+
+ // We are only going to handle this type of test under
+ // certain circumstances.
+ MOZ_ASSERT(surfaceData);
+ MOZ_ASSERT(aFormat == SurfaceFormat::B8G8R8A8 ||
+ aFormat == SurfaceFormat::B8G8R8X8 ||
+ aFormat == SurfaceFormat::R8G8B8A8 ||
+ aFormat == SurfaceFormat::R8G8B8X8 ||
+ aFormat == SurfaceFormat::A8R8G8B8 ||
+ aFormat == SurfaceFormat::X8R8G8B8);
+ MOZ_ASSERT((stride * aSize.height) % sizeof(uint32_t));
+
+ if (aFormat == SurfaceFormat::A8R8G8B8 ||
+ aFormat == SurfaceFormat::X8R8G8B8) {
+ color = mozilla::NativeEndian::swapFromBigEndian(0xFF00FF00);
+ }
+
+ for (uint32_t i = 0; i < surfaceDataLength; i++) {
+ surfaceData[i] = color;
+ }
+
+ return true;
+}
+
+static bool ClearSurface(SourceSurfaceSharedData* aSurface,
+ const IntSize& aSize, SurfaceFormat aFormat) {
+ int32_t stride = aSurface->Stride();
+ uint8_t* data = aSurface->GetData();
+ MOZ_ASSERT(data);
+
+ if (aFormat == SurfaceFormat::OS_RGBX) {
+ // Skia doesn't support RGBX surfaces, so ensure the alpha value is set
+ // to opaque white. While it would be nice to only do this for Skia,
+ // imgFrame can run off main thread and past shutdown where
+ // we might not have gfxPlatform, so just memset every time instead.
+ memset(data, 0xFF, stride * aSize.height);
+ } else if (aSurface->OnHeap()) {
+ // We only need to memset it if the buffer was allocated on the heap.
+ // Otherwise, it's allocated via mmap and refers to a zeroed page and will
+ // be COW once it's written to.
+ memset(data, 0, stride * aSize.height);
+ }
+
+ return true;
+}
+
+imgFrame::imgFrame()
+ : mMonitor("imgFrame"),
+ mDecoded(0, 0, 0, 0),
+ mAborted(false),
+ mFinished(false),
+ mShouldRecycle(false),
+ mTimeout(FrameTimeout::FromRawMilliseconds(100)),
+ mDisposalMethod(DisposalMethod::NOT_SPECIFIED),
+ mBlendMethod(BlendMethod::OVER),
+ mFormat(SurfaceFormat::UNKNOWN),
+ mNonPremult(false) {}
+
+imgFrame::~imgFrame() {
+#ifdef DEBUG
+ MonitorAutoLock lock(mMonitor);
+ MOZ_ASSERT(mAborted || AreAllPixelsWritten());
+ MOZ_ASSERT(mAborted || mFinished);
+#endif
+}
+
+nsresult imgFrame::InitForDecoder(const nsIntSize& aImageSize,
+ SurfaceFormat aFormat, bool aNonPremult,
+ const Maybe<AnimationParams>& aAnimParams,
+ bool aShouldRecycle) {
+ // Assert for properties that should be verified by decoders,
+ // warn for properties related to bad content.
+ if (!SurfaceCache::IsLegalSize(aImageSize)) {
+ NS_WARNING("Should have legal image size");
+ MonitorAutoLock lock(mMonitor);
+ mAborted = true;
+ return NS_ERROR_FAILURE;
+ }
+
+ mImageSize = aImageSize;
+
+ // May be updated shortly after InitForDecoder by BlendAnimationFilter
+ // because it needs to take into consideration the previous frames to
+ // properly calculate. We start with the whole frame as dirty.
+ mDirtyRect = GetRect();
+
+ if (aAnimParams) {
+ mBlendRect = aAnimParams->mBlendRect;
+ mTimeout = aAnimParams->mTimeout;
+ mBlendMethod = aAnimParams->mBlendMethod;
+ mDisposalMethod = aAnimParams->mDisposalMethod;
+ } else {
+ mBlendRect = GetRect();
+ }
+
+ if (aShouldRecycle) {
+ // If we are recycling then we should always use BGRA for the underlying
+ // surface because if we use BGRX, the next frame composited into the
+ // surface could be BGRA and cause rendering problems.
+ MOZ_ASSERT(aAnimParams);
+ mFormat = SurfaceFormat::OS_RGBA;
+ } else {
+ mFormat = aFormat;
+ }
+
+ mNonPremult = aNonPremult;
+
+ MonitorAutoLock lock(mMonitor);
+ mShouldRecycle = aShouldRecycle;
+
+ MOZ_ASSERT(!mRawSurface, "Called imgFrame::InitForDecoder() twice?");
+
+ mRawSurface = AllocateBufferForImage(mImageSize, mFormat, mShouldRecycle);
+ if (!mRawSurface) {
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (StaticPrefs::browser_measurement_render_anims_and_video_solid() &&
+ aAnimParams) {
+ mBlankRawSurface = AllocateBufferForImage(mImageSize, mFormat);
+ if (!mBlankRawSurface) {
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ if (!ClearSurface(mRawSurface, mImageSize, mFormat)) {
+ NS_WARNING("Could not clear allocated buffer");
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (mBlankRawSurface) {
+ if (!GreenSurface(mBlankRawSurface, mImageSize, mFormat)) {
+ NS_WARNING("Could not clear allocated blank buffer");
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+ }
+
+ return NS_OK;
+}
+
+nsresult imgFrame::InitForDecoderRecycle(const AnimationParams& aAnimParams) {
+ // We want to recycle this frame, but there is no guarantee that consumers are
+ // done with it in a timely manner. Let's ensure they are done with it first.
+ MonitorAutoLock lock(mMonitor);
+
+ MOZ_ASSERT(mRawSurface);
+
+ if (!mShouldRecycle) {
+ // This frame either was never marked as recyclable, or the flag was cleared
+ // for a caller which does not support recycling.
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ // Ensure we account for all internal references to the surface.
+ MozRefCountType internalRefs = 1;
+ if (mOptSurface == mRawSurface) {
+ ++internalRefs;
+ }
+
+ if (mRawSurface->refCount() > internalRefs) {
+ if (NS_IsMainThread()) {
+ // We should never be both decoding and recycling on the main thread. Sync
+ // decoding can only be used to produce the first set of frames. Those
+ // either never use recycling because advancing was blocked (main thread
+ // is busy) or we were auto-advancing (to seek to a frame) and the frames
+ // were never accessed (and thus cannot have recycle locks).
+ MOZ_ASSERT_UNREACHABLE("Recycling/decoding on the main thread?");
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+
+ // We don't want to wait forever to reclaim the frame because we have no
+ // idea why it is still held. It is possibly due to OMTP. Since we are off
+ // the main thread, and we generally have frames already buffered for the
+ // animation, we can afford to wait a short period of time to hopefully
+ // complete the transaction and reclaim the buffer.
+ //
+ // We choose to wait for, at most, the refresh driver interval, so that we
+ // won't skip more than one frame. If the frame is still in use due to
+ // outstanding transactions, we are already skipping frames. If the frame
+ // is still in use for some other purpose, it won't be returned to the pool
+ // and its owner can hold onto it forever without additional impact here.
+ int32_t refreshInterval =
+ std::max(std::min(nsRefreshDriver::DefaultInterval(), 20), 4);
+ TimeDuration waitInterval =
+ TimeDuration::FromMilliseconds(refreshInterval >> 2);
+ TimeStamp timeout =
+ TimeStamp::Now() + TimeDuration::FromMilliseconds(refreshInterval);
+ while (true) {
+ mMonitor.Wait(waitInterval);
+ if (mRawSurface->refCount() <= internalRefs) {
+ break;
+ }
+
+ if (timeout <= TimeStamp::Now()) {
+ // We couldn't secure the frame for recycling. It will allocate a new
+ // frame instead.
+ return NS_ERROR_NOT_AVAILABLE;
+ }
+ }
+ }
+
+ mBlendRect = aAnimParams.mBlendRect;
+ mTimeout = aAnimParams.mTimeout;
+ mBlendMethod = aAnimParams.mBlendMethod;
+ mDisposalMethod = aAnimParams.mDisposalMethod;
+ mDirtyRect = GetRect();
+
+ return NS_OK;
+}
+
+nsresult imgFrame::InitWithDrawable(gfxDrawable* aDrawable,
+ const nsIntSize& aSize,
+ const SurfaceFormat aFormat,
+ SamplingFilter aSamplingFilter,
+ uint32_t aImageFlags,
+ gfx::BackendType aBackend) {
+ // Assert for properties that should be verified by decoders,
+ // warn for properties related to bad content.
+ if (!SurfaceCache::IsLegalSize(aSize)) {
+ NS_WARNING("Should have legal image size");
+ MonitorAutoLock lock(mMonitor);
+ mAborted = true;
+ return NS_ERROR_FAILURE;
+ }
+
+ mImageSize = aSize;
+ mFormat = aFormat;
+
+ RefPtr<DrawTarget> target;
+
+ bool canUseDataSurface = Factory::DoesBackendSupportDataDrawtarget(aBackend);
+ if (canUseDataSurface) {
+ MonitorAutoLock lock(mMonitor);
+ // It's safe to use data surfaces for content on this platform, so we can
+ // get away with using volatile buffers.
+ MOZ_ASSERT(!mRawSurface, "Called imgFrame::InitWithDrawable() twice?");
+
+ mRawSurface = AllocateBufferForImage(mImageSize, mFormat);
+ if (!mRawSurface) {
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (!ClearSurface(mRawSurface, mImageSize, mFormat)) {
+ NS_WARNING("Could not clear allocated buffer");
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ target = gfxPlatform::CreateDrawTargetForData(
+ mRawSurface->GetData(), mImageSize, mRawSurface->Stride(), mFormat);
+ } else {
+ // We can't use data surfaces for content, so we'll create an offscreen
+ // surface instead. This means if someone later calls RawAccessRef(), we
+ // may have to do an expensive readback, but we warned callers about that in
+ // the documentation for this method.
+#ifdef DEBUG
+ {
+ MonitorAutoLock lock(mMonitor);
+ MOZ_ASSERT(!mOptSurface, "Called imgFrame::InitWithDrawable() twice?");
+ }
+#endif
+
+ if (gfxPlatform::GetPlatform()->SupportsAzureContentForType(aBackend)) {
+ target = gfxPlatform::GetPlatform()->CreateDrawTargetForBackend(
+ aBackend, mImageSize, mFormat);
+ } else {
+ target = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
+ mImageSize, mFormat);
+ }
+ }
+
+ if (!target || !target->IsValid()) {
+ MonitorAutoLock lock(mMonitor);
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ // Draw using the drawable the caller provided.
+ gfxContext ctx(target);
+
+ gfxUtils::DrawPixelSnapped(&ctx, aDrawable, SizeDouble(mImageSize),
+ ImageRegion::Create(ThebesRect(GetRect())),
+ mFormat, aSamplingFilter, aImageFlags);
+
+ MonitorAutoLock lock(mMonitor);
+ if (canUseDataSurface && !mRawSurface) {
+ NS_WARNING("Failed to create SourceSurfaceSharedData");
+ mAborted = true;
+ return NS_ERROR_OUT_OF_MEMORY;
+ }
+
+ if (!canUseDataSurface) {
+ // We used an offscreen surface, which is an "optimized" surface from
+ // imgFrame's perspective.
+ mOptSurface = target->Snapshot();
+ } else {
+ FinalizeSurfaceInternal();
+ }
+
+ // If we reach this point, we should regard ourselves as complete.
+ mDecoded = GetRect();
+ mFinished = true;
+
+ MOZ_ASSERT(AreAllPixelsWritten());
+
+ return NS_OK;
+}
+
+DrawableFrameRef imgFrame::DrawableRef() { return DrawableFrameRef(this); }
+
+RawAccessFrameRef imgFrame::RawAccessRef() { return RawAccessFrameRef(this); }
+
+imgFrame::SurfaceWithFormat imgFrame::SurfaceForDrawing(
+ bool aDoPartialDecode, bool aDoTile, ImageRegion& aRegion,
+ SourceSurface* aSurface) {
+ MOZ_ASSERT(NS_IsMainThread());
+ mMonitor.AssertCurrentThreadOwns();
+
+ if (!aDoPartialDecode) {
+ return SurfaceWithFormat(new gfxSurfaceDrawable(aSurface, mImageSize),
+ mFormat);
+ }
+
+ gfxRect available =
+ gfxRect(mDecoded.X(), mDecoded.Y(), mDecoded.Width(), mDecoded.Height());
+
+ if (aDoTile) {
+ // Create a temporary surface.
+ // Give this surface an alpha channel because there are
+ // transparent pixels in the padding or undecoded area
+ RefPtr<DrawTarget> target =
+ gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget(
+ mImageSize, SurfaceFormat::OS_RGBA);
+ if (!target) {
+ return SurfaceWithFormat();
+ }
+
+ SurfacePattern pattern(aSurface, aRegion.GetExtendMode(),
+ Matrix::Translation(mDecoded.X(), mDecoded.Y()));
+ target->FillRect(ToRect(aRegion.Intersect(available).Rect()), pattern);
+
+ RefPtr<SourceSurface> newsurf = target->Snapshot();
+ return SurfaceWithFormat(new gfxSurfaceDrawable(newsurf, mImageSize),
+ target->GetFormat());
+ }
+
+ // Not tiling, and we have a surface, so we can account for
+ // a partial decode just by twiddling parameters.
+ aRegion = aRegion.Intersect(available);
+ IntSize availableSize(mDecoded.Width(), mDecoded.Height());
+
+ return SurfaceWithFormat(new gfxSurfaceDrawable(aSurface, availableSize),
+ mFormat);
+}
+
+bool imgFrame::Draw(gfxContext* aContext, const ImageRegion& aRegion,
+ SamplingFilter aSamplingFilter, uint32_t aImageFlags,
+ float aOpacity) {
+ AUTO_PROFILER_LABEL("imgFrame::Draw", GRAPHICS);
+
+ MOZ_ASSERT(NS_IsMainThread());
+ NS_ASSERTION(!aRegion.Rect().IsEmpty(), "Drawing empty region!");
+ NS_ASSERTION(!aRegion.IsRestricted() ||
+ !aRegion.Rect().Intersect(aRegion.Restriction()).IsEmpty(),
+ "We must be allowed to sample *some* source pixels!");
+
+ // Perform the draw and freeing of the surface outside the lock. We want to
+ // avoid contention with the decoder if we can. The surface may also attempt
+ // to relock the monitor if it is freed (e.g. RecyclingSourceSurface).
+ RefPtr<SourceSurface> surf;
+ SurfaceWithFormat surfaceResult;
+ ImageRegion region(aRegion);
+ gfxRect imageRect(0, 0, mImageSize.width, mImageSize.height);
+
+ {
+ MonitorAutoLock lock(mMonitor);
+
+ bool doPartialDecode = !AreAllPixelsWritten();
+
+ // Most draw targets will just use the surface only during DrawPixelSnapped
+ // but captures/recordings will retain a reference outside this stack
+ // context. While in theory a decoder thread could be trying to recycle this
+ // frame at this very moment, in practice the only way we can get here is if
+ // this frame is the current frame of the animation. Since we can only
+ // advance on the main thread, we know nothing else will try to use it.
+ DrawTarget* drawTarget = aContext->GetDrawTarget();
+ bool recording = drawTarget->GetBackendType() == BackendType::RECORDING;
+ RefPtr<SourceSurface> surf = GetSourceSurfaceInternal();
+ if (!surf) {
+ return false;
+ }
+
+ bool doTile = !imageRect.Contains(aRegion.Rect()) &&
+ !(aImageFlags & imgIContainer::FLAG_CLAMP);
+
+ surfaceResult = SurfaceForDrawing(doPartialDecode, doTile, region, surf);
+
+ // If we are recording, then we cannot recycle the surface. The blob
+ // rasterizer is not properly synchronized for recycling in the compositor
+ // process. The easiest thing to do is just mark the frames it consumes as
+ // non-recyclable.
+ if (recording && surfaceResult.IsValid()) {
+ mShouldRecycle = false;
+ }
+ }
+
+ if (surfaceResult.IsValid()) {
+ gfxUtils::DrawPixelSnapped(aContext, surfaceResult.mDrawable,
+ imageRect.Size(), region, surfaceResult.mFormat,
+ aSamplingFilter, aImageFlags, aOpacity);
+ }
+
+ return true;
+}
+
+nsresult imgFrame::ImageUpdated(const nsIntRect& aUpdateRect) {
+ MonitorAutoLock lock(mMonitor);
+ return ImageUpdatedInternal(aUpdateRect);
+}
+
+nsresult imgFrame::ImageUpdatedInternal(const nsIntRect& aUpdateRect) {
+ mMonitor.AssertCurrentThreadOwns();
+
+ // Clamp to the frame rect to ensure that decoder bugs don't result in a
+ // decoded rect that extends outside the bounds of the frame rect.
+ IntRect updateRect = aUpdateRect.Intersect(GetRect());
+ if (updateRect.IsEmpty()) {
+ return NS_OK;
+ }
+
+ mDecoded.UnionRect(mDecoded, updateRect);
+
+ // Update our invalidation counters for any consumers watching for changes
+ // in the surface.
+ if (mRawSurface) {
+ mRawSurface->Invalidate(updateRect);
+ }
+ return NS_OK;
+}
+
+void imgFrame::Finish(Opacity aFrameOpacity /* = Opacity::SOME_TRANSPARENCY */,
+ bool aFinalize /* = true */,
+ bool aOrientationSwapsWidthAndHeight /* = false */) {
+ MonitorAutoLock lock(mMonitor);
+
+ IntRect frameRect(GetRect());
+ if (!mDecoded.IsEqualEdges(frameRect)) {
+ // The decoder should have produced rows starting from either the bottom or
+ // the top of the image. We need to calculate the region for which we have
+ // not yet invalidated. And if the orientation swaps width and height then
+ // its from the left or right.
+ IntRect delta(0, 0, frameRect.width, 0);
+ if (!aOrientationSwapsWidthAndHeight) {
+ delta.width = frameRect.width;
+ if (mDecoded.y == 0) {
+ delta.y = mDecoded.height;
+ delta.height = frameRect.height - mDecoded.height;
+ } else if (mDecoded.y + mDecoded.height == frameRect.height) {
+ delta.height = frameRect.height - mDecoded.y;
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Decoder only updated middle of image!");
+ delta = frameRect;
+ }
+ } else {
+ delta.height = frameRect.height;
+ if (mDecoded.x == 0) {
+ delta.x = mDecoded.width;
+ delta.width = frameRect.width - mDecoded.width;
+ } else if (mDecoded.x + mDecoded.width == frameRect.width) {
+ delta.width = frameRect.width - mDecoded.x;
+ } else {
+ MOZ_ASSERT_UNREACHABLE("Decoder only updated middle of image!");
+ delta = frameRect;
+ }
+ }
+
+ ImageUpdatedInternal(delta);
+ }
+
+ MOZ_ASSERT(mDecoded.IsEqualEdges(frameRect));
+
+ if (aFinalize) {
+ FinalizeSurfaceInternal();
+ }
+
+ mFinished = true;
+
+ // The image is now complete, wake up anyone who's waiting.
+ mMonitor.NotifyAll();
+}
+
+uint32_t imgFrame::GetImageBytesPerRow() const {
+ mMonitor.AssertCurrentThreadOwns();
+
+ if (mRawSurface) {
+ return mImageSize.width * BytesPerPixel(mFormat);
+ }
+
+ return 0;
+}
+
+uint32_t imgFrame::GetImageDataLength() const {
+ return GetImageBytesPerRow() * mImageSize.height;
+}
+
+void imgFrame::GetImageData(uint8_t** aData, uint32_t* aLength) const {
+ MonitorAutoLock lock(mMonitor);
+ GetImageDataInternal(aData, aLength);
+}
+
+void imgFrame::GetImageDataInternal(uint8_t** aData, uint32_t* aLength) const {
+ mMonitor.AssertCurrentThreadOwns();
+ MOZ_ASSERT(mRawSurface);
+
+ if (mRawSurface) {
+ // TODO: This is okay for now because we only realloc shared surfaces on
+ // the main thread after decoding has finished, but if animations want to
+ // read frame data off the main thread, we will need to reconsider this.
+ *aData = mRawSurface->GetData();
+ MOZ_ASSERT(*aData,
+ "mRawSurface is non-null, but GetData is null in GetImageData");
+ } else {
+ *aData = nullptr;
+ }
+
+ *aLength = GetImageDataLength();
+}
+
+uint8_t* imgFrame::GetImageData() const {
+ uint8_t* data;
+ uint32_t length;
+ GetImageData(&data, &length);
+ return data;
+}
+
+void imgFrame::FinalizeSurface() {
+ MonitorAutoLock lock(mMonitor);
+ FinalizeSurfaceInternal();
+}
+
+void imgFrame::FinalizeSurfaceInternal() {
+ mMonitor.AssertCurrentThreadOwns();
+
+ // Not all images will have mRawSurface to finalize (i.e. paletted images).
+ if (mShouldRecycle || !mRawSurface ||
+ mRawSurface->GetType() != SurfaceType::DATA_SHARED) {
+ return;
+ }
+
+ auto* sharedSurf = static_cast<SourceSurfaceSharedData*>(mRawSurface.get());
+ sharedSurf->Finalize();
+}
+
+already_AddRefed<SourceSurface> imgFrame::GetSourceSurface() {
+ MonitorAutoLock lock(mMonitor);
+ return GetSourceSurfaceInternal();
+}
+
+already_AddRefed<SourceSurface> imgFrame::GetSourceSurfaceInternal() {
+ mMonitor.AssertCurrentThreadOwns();
+
+ if (mOptSurface) {
+ if (mOptSurface->IsValid()) {
+ RefPtr<SourceSurface> surf(mOptSurface);
+ return surf.forget();
+ }
+ mOptSurface = nullptr;
+ }
+
+ if (mBlankRawSurface) {
+ // We are going to return the blank surface because of the flags.
+ // We are including comments here that are copied from below
+ // just so that we are on the same page!
+ RefPtr<SourceSurface> surf(mBlankRawSurface);
+ return surf.forget();
+ }
+
+ RefPtr<SourceSurface> surf(mRawSurface);
+ return surf.forget();
+}
+
+void imgFrame::Abort() {
+ MonitorAutoLock lock(mMonitor);
+
+ mAborted = true;
+
+ // Wake up anyone who's waiting.
+ mMonitor.NotifyAll();
+}
+
+bool imgFrame::IsAborted() const {
+ MonitorAutoLock lock(mMonitor);
+ return mAborted;
+}
+
+bool imgFrame::IsFinished() const {
+ MonitorAutoLock lock(mMonitor);
+ return mFinished;
+}
+
+void imgFrame::WaitUntilFinished() const {
+ MonitorAutoLock lock(mMonitor);
+
+ while (true) {
+ // Return if we're aborted or complete.
+ if (mAborted || mFinished) {
+ return;
+ }
+
+ // Not complete yet, so we'll have to wait.
+ mMonitor.Wait();
+ }
+}
+
+bool imgFrame::AreAllPixelsWritten() const {
+ mMonitor.AssertCurrentThreadOwns();
+ return mDecoded.IsEqualInterior(GetRect());
+}
+
+void imgFrame::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
+ const AddSizeOfCb& aCallback) const {
+ MonitorAutoLock lock(mMonitor);
+
+ AddSizeOfCbData metadata;
+ metadata.mFinished = mFinished;
+
+ if (mOptSurface) {
+ metadata.mHeapBytes += aMallocSizeOf(mOptSurface);
+
+ SourceSurface::SizeOfInfo info;
+ mOptSurface->SizeOfExcludingThis(aMallocSizeOf, info);
+ metadata.Accumulate(info);
+ }
+ if (mRawSurface) {
+ metadata.mHeapBytes += aMallocSizeOf(mRawSurface);
+
+ SourceSurface::SizeOfInfo info;
+ mRawSurface->SizeOfExcludingThis(aMallocSizeOf, info);
+ metadata.Accumulate(info);
+ }
+
+ aCallback(metadata);
+}
+
+} // namespace image
+} // namespace mozilla