Bug 1732115 - Part 3. Refactor decoder pipeline to partially use Unoriented/OrientedPixel. r=tnikkel

Rather than change every use of IntSize/Rect/Point in image/, this patch
attempts to draw the line at the relevant parts of the decoding pipeline
to prevent confusion about which size and orientation we are working
with.

Differential Revision: https://phabricator.services.mozilla.com/D126381

Author: aosmond

image/Decoder.cpp

@@ -266,12 +266,12 @@ void Decoder::CompleteDecode() {
   }
 }
 
-void Decoder::SetOutputSize(const gfx::IntSize& aSize) {
+void Decoder::SetOutputSize(const OrientedIntSize& aSize) {
   mOutputSize = Some(aSize);
   mHaveExplicitOutputSize = true;
 }
 
-Maybe<gfx::IntSize> Decoder::ExplicitOutputSize() const {
+Maybe<OrientedIntSize> Decoder::ExplicitOutputSize() const {
   MOZ_ASSERT_IF(mHaveExplicitOutputSize, mOutputSize);
   return mHaveExplicitOutputSize ? mOutputSize : Nothing();
 }
@@ -448,10 +448,11 @@ void Decoder::PostSize(int32_t aWidth, int32_t aHeight,
 
   // Set our output size if it's not already set.
   if (!mOutputSize) {
-    mOutputSize = Some(IntSize(aWidth, aHeight));
+    mOutputSize = Some(mImageMetadata.GetSize());
   }
 
-  MOZ_ASSERT(mOutputSize->width <= aWidth && mOutputSize->height <= aHeight,
+  MOZ_ASSERT(mOutputSize->width <= mImageMetadata.GetSize().width &&
+                 mOutputSize->height <= mImageMetadata.GetSize().height,
              "Output size will result in upscaling");
 
   // Record this notification.
@@ -486,7 +487,8 @@ void Decoder::PostFrameStop(Opacity aFrameOpacity) {
     // If we're not sending partial invalidations, then we send an invalidation
     // here when the first frame is complete.
     if (!ShouldSendPartialInvalidations()) {
-      mInvalidRect.UnionRect(mInvalidRect, IntRect(IntPoint(), Size()));
+      mInvalidRect.UnionRect(mInvalidRect,
+                             OrientedIntRect(OrientedIntPoint(), Size()));
     }
 
     // If we dispose of the first frame by clearing it, then the first frame's
@@ -498,7 +500,7 @@ void Decoder::PostFrameStop(Opacity aFrameOpacity) {
       case DisposalMethod::CLEAR:
       case DisposalMethod::CLEAR_ALL:
       case DisposalMethod::RESTORE_PREVIOUS:
-        mFirstFrameRefreshArea = IntRect(IntPoint(), Size());
+        mFirstFrameRefreshArea = IntRect(IntPoint(), Size().ToUnknownSize());
         break;
       case DisposalMethod::KEEP:
       case DisposalMethod::NOT_SPECIFIED:
@@ -512,8 +514,8 @@ void Decoder::PostFrameStop(Opacity aFrameOpacity) {
   }
 }
 
-void Decoder::PostInvalidation(const gfx::IntRect& aRect,
-                               const Maybe<gfx::IntRect>& aRectAtOutputSize
+void Decoder::PostInvalidation(const OrientedIntRect& aRect,
+                               const Maybe<OrientedIntRect>& aRectAtOutputSize
                                /* = Nothing() */) {
   // We should be mid-frame
   MOZ_ASSERT(mInFrame, "Can't invalidate when not mid-frame!");
@@ -523,7 +525,8 @@ void Decoder::PostInvalidation(const gfx::IntRect& aRect,
   // or we're past the first frame.
   if (ShouldSendPartialInvalidations() && mFrameCount == 1) {
     mInvalidRect.UnionRect(mInvalidRect, aRect);
-    mCurrentFrame->ImageUpdated(aRectAtOutputSize.valueOr(aRect));
+    mCurrentFrame->ImageUpdated(
+        aRectAtOutputSize.valueOr(aRect).ToUnknownRect());
   }
 }
 

image/Decoder.h

@@ -157,8 +157,8 @@ class Decoder {
    * TakeInvalidRect() returns only the invalidation region accumulated since
    * the last call to TakeInvalidRect().
    */
-  nsIntRect TakeInvalidRect() {
-    nsIntRect invalidRect = mInvalidRect;
+  OrientedIntRect TakeInvalidRect() {
+    OrientedIntRect invalidRect = mInvalidRect;
     mInvalidRect.SetEmpty();
     return invalidRect;
   }
@@ -211,7 +211,7 @@ class Decoder {
    *
    * This must be called before Init() is called.
    */
-  void SetOutputSize(const gfx::IntSize& aSize);
+  void SetOutputSize(const OrientedIntSize& aSize);
 
   /**
    * @return the output size of this decoder. If this is smaller than the
@@ -220,7 +220,7 @@ class Decoder {
    *
    * Illegal to call if HasSize() returns false.
    */
-  gfx::IntSize OutputSize() const {
+  OrientedIntSize OutputSize() const {
     MOZ_ASSERT(HasSize());
     return *mOutputSize;
   }
@@ -229,13 +229,13 @@ class Decoder {
    * @return either the size passed to SetOutputSize() or Nothing(), indicating
    * that SetOutputSize() was not explicitly called.
    */
-  Maybe<gfx::IntSize> ExplicitOutputSize() const;
+  Maybe<OrientedIntSize> ExplicitOutputSize() const;
 
   /**
    * Sets the expected image size of this decoder. Decoding will fail if this
    * does not match.
    */
-  void SetExpectedSize(const gfx::IntSize& aSize) {
+  void SetExpectedSize(const OrientedIntSize& aSize) {
     mExpectedSize.emplace(aSize);
   }
 
@@ -342,7 +342,7 @@ class Decoder {
    *
    * Illegal to call if HasSize() returns false.
    */
-  gfx::IntSize Size() const {
+  OrientedIntSize Size() const {
     MOZ_ASSERT(HasSize());
     return mImageMetadata.GetSize();
   }
@@ -354,8 +354,8 @@ class Decoder {
    *
    * Illegal to call if HasSize() returns false.
    */
-  gfx::IntRect FullFrame() const {
-    return gfx::IntRect(gfx::IntPoint(), Size());
+  OrientedIntRect FullFrame() const {
+    return OrientedIntRect(OrientedIntPoint(), Size());
   }
 
   /**
@@ -369,8 +369,18 @@ class Decoder {
    *
    * Illegal to call if HasSize() returns false.
    */
-  gfx::IntRect FullOutputFrame() const {
-    return gfx::IntRect(gfx::IntPoint(), OutputSize());
+  OrientedIntRect FullOutputFrame() const {
+    return OrientedIntRect(OrientedIntPoint(), OutputSize());
+  }
+
+  /**
+   * @return the orientation of the image.
+   *
+   * Illegal to call if HasSize() returns false.
+   */
+  Orientation GetOrientation() const {
+    MOZ_ASSERT(HasSize());
+    return mImageMetadata.GetOrientation();
   }
 
   /// @return final status information about this decoder. Should be called
@@ -514,8 +524,8 @@ class Decoder {
    *                          be supplied if we're downscaling during decode.
    */
   void PostInvalidation(
-      const gfx::IntRect& aRect,
-      const Maybe<gfx::IntRect>& aRectAtOutputSize = Nothing());
+      const OrientedIntRect& aRect,
+      const Maybe<OrientedIntRect>& aRectAtOutputSize = Nothing());
 
   // Called by the decoders when they have successfully decoded the image. This
   // may occur as the result of the decoder getting to the appropriate point in
@@ -586,14 +596,14 @@ class Decoder {
 
   ImageMetadata mImageMetadata;
 
-  gfx::IntRect
+  OrientedIntRect
       mInvalidRect;  // Tracks new rows as the current frame is decoded.
-  gfx::IntRect mRestoreDirtyRect;   // Tracks an invalidation region between the
-                                    // restore frame and the previous frame.
-  gfx::IntRect mRecycleRect;        // Tracks an invalidation region between the
-                                    // recycled frame and the current frame.
-  Maybe<gfx::IntSize> mOutputSize;  // The size of our output surface.
-  Maybe<gfx::IntSize> mExpectedSize;  // The expected size of the image.
+  gfx::IntRect mRestoreDirtyRect;  // Tracks an invalidation region between the
+                                   // restore frame and the previous frame.
+  gfx::IntRect mRecycleRect;       // Tracks an invalidation region between the
+                                   // recycled frame and the current frame.
+  Maybe<OrientedIntSize> mOutputSize;    // The size of our output surface.
+  Maybe<OrientedIntSize> mExpectedSize;  // The expected size of the image.
   Progress mProgress;
 
   uint32_t mFrameCount;      // Number of frames, including anything in-progress

image/DecoderFactory.cpp

@@ -170,7 +170,7 @@ nsresult DecoderFactory::CreateDecoder(
   // Initialize the decoder.
   decoder->SetMetadataDecode(false);
   decoder->SetIterator(aSourceBuffer->Iterator());
-  decoder->SetOutputSize(aOutputSize);
+  decoder->SetOutputSize(OrientedIntSize::FromUnknownSize(aOutputSize));
   decoder->SetDecoderFlags(aDecoderFlags | DecoderFlags::FIRST_FRAME_ONLY);
   decoder->SetSurfaceFlags(aSurfaceFlags);
 
@@ -320,7 +320,8 @@ already_AddRefed<IDecodingTask> DecoderFactory::CreateMetadataDecoder(
 already_AddRefed<Decoder> DecoderFactory::CreateDecoderForICOResource(
     DecoderType aType, SourceBufferIterator&& aIterator,
     NotNull<nsICODecoder*> aICODecoder, bool aIsMetadataDecode,
-    const Maybe<IntSize>& aExpectedSize, const Maybe<uint32_t>& aDataOffset
+    const Maybe<OrientedIntSize>& aExpectedSize,
+    const Maybe<uint32_t>& aDataOffset
     /* = Nothing() */) {
   // Create the decoder.
   RefPtr<Decoder> decoder;
@@ -389,7 +390,7 @@ already_AddRefed<Decoder> DecoderFactory::CreateAnonymousDecoder(
 
   // Set an output size for downscale-during-decode if requested.
   if (aOutputSize) {
-    decoder->SetOutputSize(*aOutputSize);
+    decoder->SetOutputSize(OrientedIntSize::FromUnknownSize(*aOutputSize));
   }
 
   if (NS_FAILED(decoder->Init())) {

image/DecoderFactory.h

@@ -13,6 +13,7 @@
 #include "mozilla/NotNull.h"
 #include "mozilla/gfx/2D.h"
 #include "nsCOMPtr.h"
+#include "Orientation.h"
 #include "SurfaceFlags.h"
 
 namespace mozilla::image {
@@ -154,7 +155,7 @@ class DecoderFactory {
   static already_AddRefed<Decoder> CreateDecoderForICOResource(
       DecoderType aType, SourceBufferIterator&& aIterator,
       NotNull<nsICODecoder*> aICODecoder, bool aIsMetadataDecode,
-      const Maybe<gfx::IntSize>& aExpectedSize,
+      const Maybe<OrientedIntSize>& aExpectedSize,
       const Maybe<uint32_t>& aDataOffset = Nothing());
 
   /**

image/FrameAnimator.cpp

@@ -467,7 +467,7 @@ LookupResult FrameAnimator::GetCompositedFrame(AnimationState& aState,
       // getting called which calls UpdateState. The reason we care about this
       // is that img.decode promises won't resolve until GetCompositedFrame
       // returns a frame.
-      UnorientedIntRect rect = UnorientedIntRect::FromUnknownRect(
+      OrientedIntRect rect = OrientedIntRect::FromUnknownRect(
           aState.UpdateStateInternal(result, mSize));
 
       if (!rect.IsEmpty()) {

image/IDecodingTask.cpp

@@ -65,8 +65,7 @@ void IDecodingTask::NotifyProgress(NotNull<RasterImage*> aImage,
   // calls we make off-main-thread and the notifications that RasterImage
   // actually receives, which would cause bugs.
   Progress progress = aDecoder->TakeProgress();
-  UnorientedIntRect invalidRect =
-      UnorientedIntRect::FromUnknownRect(aDecoder->TakeInvalidRect());
+  OrientedIntRect invalidRect = aDecoder->TakeInvalidRect();
   Maybe<uint32_t> frameCount = aDecoder->TakeCompleteFrameCount();
   DecoderFlags decoderFlags = aDecoder->GetDecoderFlags();
   SurfaceFlags surfaceFlags = aDecoder->GetSurfaceFlags();
@@ -106,8 +105,7 @@ void IDecodingTask::NotifyDecodeComplete(NotNull<RasterImage*> aImage,
   ImageMetadata metadata = aDecoder->GetImageMetadata();
   DecoderTelemetry telemetry = aDecoder->Telemetry();
   Progress progress = aDecoder->TakeProgress();
-  UnorientedIntRect invalidRect =
-      UnorientedIntRect::FromUnknownRect(aDecoder->TakeInvalidRect());
+  OrientedIntRect invalidRect = aDecoder->TakeInvalidRect();
   Maybe<uint32_t> frameCount = aDecoder->TakeCompleteFrameCount();
   DecoderFlags decoderFlags = aDecoder->GetDecoderFlags();
   SurfaceFlags surfaceFlags = aDecoder->GetSurfaceFlags();

image/ImageMetadata.h

@@ -56,21 +56,24 @@ class ImageMetadata {
   void SetSize(int32_t aWidth, int32_t aHeight, Orientation aOrientation,
                Resolution aResolution) {
     if (!HasSize()) {
-      mSize.emplace(nsIntSize(aWidth, aHeight));
+      mSize.emplace(
+          aOrientation.ToOriented(UnorientedIntSize(aWidth, aHeight)));
       mOrientation.emplace(aOrientation);
       mResolution = aResolution;
     }
   }
-  nsIntSize GetSize() const { return *mSize; }
+  OrientedIntSize GetSize() const { return *mSize; }
   bool HasSize() const { return mSize.isSome(); }
 
-  void AddNativeSize(const nsIntSize& aSize) {
+  void AddNativeSize(const OrientedIntSize& aSize) {
     mNativeSizes.AppendElement(aSize);
   }
 
   Resolution GetResolution() const { return mResolution; }
 
-  const nsTArray<nsIntSize>& GetNativeSizes() const { return mNativeSizes; }
+  const nsTArray<OrientedIntSize>& GetNativeSizes() const {
+    return mNativeSizes;
+  }
 
   Orientation GetOrientation() const { return *mOrientation; }
   bool HasOrientation() const { return mOrientation.isSome(); }
@@ -98,11 +101,11 @@ class ImageMetadata {
   // loops.
   Maybe<gfx::IntRect> mFirstFrameRefreshArea;
 
-  Maybe<nsIntSize> mSize;
+  Maybe<OrientedIntSize> mSize;
   Maybe<Orientation> mOrientation;
 
   // Sizes the image can natively decode to.
-  CopyableTArray<nsIntSize> mNativeSizes;
+  CopyableTArray<OrientedIntSize> mNativeSizes;
 
   bool mHasAnimation = false;
 };