summaryrefslogtreecommitdiffstats
path: root/image/Downscaler.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /image/Downscaler.h
parentInitial commit. (diff)
downloadfirefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz
firefox-26a029d407be480d791972afb5975cf62c9360a6.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'image/Downscaler.h')
-rw-r--r--image/Downscaler.h146
1 files changed, 146 insertions, 0 deletions
diff --git a/image/Downscaler.h b/image/Downscaler.h
new file mode 100644
index 0000000000..e5fcf0387e
--- /dev/null
+++ b/image/Downscaler.h
@@ -0,0 +1,146 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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/. */
+
+/**
+ * Downscaler is a high-quality, streaming image downscaler based upon Skia's
+ * scaling implementation.
+ */
+
+#ifndef mozilla_image_Downscaler_h
+#define mozilla_image_Downscaler_h
+
+#include "mozilla/Maybe.h"
+#include "mozilla/UniquePtr.h"
+#include "gfxPoint.h"
+#include "nsRect.h"
+#include "mozilla/gfx/ConvolutionFilter.h"
+#include "mozilla/gfx/Matrix.h"
+
+namespace mozilla {
+namespace image {
+
+/**
+ * DownscalerInvalidRect wraps two invalidation rects: one in terms of the
+ * original image size, and one in terms of the target size.
+ */
+struct DownscalerInvalidRect {
+ nsIntRect mOriginalSizeRect;
+ nsIntRect mTargetSizeRect;
+};
+
+/**
+ * Downscaler is a high-quality, streaming image downscaler based upon Skia's
+ * scaling implementation.
+ *
+ * Decoders can construct a Downscaler once they know their target size, then
+ * call BeginFrame() for each frame they decode. They should write a decoded row
+ * into the buffer returned by RowBuffer(), and then call CommitRow() to signal
+ * that they have finished.
+ *
+
+ * Because invalidations need to be computed in terms of the scaled version of
+ * the image, Downscaler also tracks them. Decoders can call HasInvalidation()
+ * and TakeInvalidRect() instead of tracking invalidations themselves.
+ */
+class Downscaler {
+ public:
+ /// Constructs a new Downscaler which to scale to size @aTargetSize.
+ explicit Downscaler(const nsIntSize& aTargetSize);
+ ~Downscaler();
+
+ const nsIntSize& OriginalSize() const { return mOriginalSize; }
+ const nsIntSize& TargetSize() const { return mTargetSize; }
+ const nsIntSize FrameSize() const {
+ return nsIntSize(mFrameRect.Width(), mFrameRect.Height());
+ }
+ const gfx::MatrixScalesDouble& Scale() const { return mScale; }
+
+ /**
+ * Begins a new frame and reinitializes the Downscaler.
+ *
+ * @param aOriginalSize The original size of this frame, before scaling.
+ * @param aFrameRect The region of the original image which has data.
+ * Every pixel outside @aFrameRect is considered blank and
+ * has zero alpha.
+ * @param aOutputBuffer The buffer to which the Downscaler should write its
+ * output; this is the same buffer where the Decoder
+ * would write its output when not downscaling during
+ * decode.
+ * @param aHasAlpha Whether or not this frame has an alpha channel.
+ * Performance is a little better if it doesn't have one.
+ * @param aFlipVertically If true, output rows will be written to the output
+ * buffer in reverse order vertically, which matches
+ * the way they are stored in some image formats.
+ */
+ nsresult BeginFrame(const nsIntSize& aOriginalSize,
+ const Maybe<nsIntRect>& aFrameRect,
+ uint8_t* aOutputBuffer, bool aHasAlpha,
+ bool aFlipVertically = false);
+
+ bool IsFrameComplete() const {
+ return mCurrentInLine >= mOriginalSize.height;
+ }
+
+ /// Retrieves the buffer into which the Decoder should write each row.
+ uint8_t* RowBuffer() {
+ return mRowBuffer.get() + mFrameRect.X() * sizeof(uint32_t);
+ }
+
+ /// Clears the current row buffer.
+ void ClearRow() { ClearRestOfRow(0); }
+
+ /// Clears the current row buffer starting at @aStartingAtCol.
+ void ClearRestOfRow(uint32_t aStartingAtCol);
+
+ /// Signals that the decoder has finished writing a row into the row buffer.
+ void CommitRow();
+
+ /// Returns true if there is a non-empty invalid rect available.
+ bool HasInvalidation() const;
+
+ /// Takes the Downscaler's current invalid rect and resets it.
+ DownscalerInvalidRect TakeInvalidRect();
+
+ /**
+ * Resets the Downscaler's position in the image, for a new progressive pass
+ * over the same frame. Because the same data structures can be reused, this
+ * is more efficient than calling BeginFrame.
+ */
+ void ResetForNextProgressivePass();
+
+ private:
+ void DownscaleInputLine();
+ void ReleaseWindow();
+ void SkipToRow(int32_t aRow);
+
+ nsIntSize mOriginalSize;
+ nsIntSize mTargetSize;
+ nsIntRect mFrameRect;
+ gfx::MatrixScalesDouble mScale;
+
+ uint8_t* mOutputBuffer;
+
+ UniquePtr<uint8_t[]> mRowBuffer;
+ UniquePtr<uint8_t*[]> mWindow;
+
+ gfx::ConvolutionFilter mXFilter;
+ gfx::ConvolutionFilter mYFilter;
+
+ int32_t mWindowCapacity;
+
+ int32_t mLinesInBuffer;
+ int32_t mPrevInvalidatedLine;
+ int32_t mCurrentOutLine;
+ int32_t mCurrentInLine;
+
+ bool mHasAlpha : 1;
+ bool mFlipVertically : 1;
+};
+
+} // namespace image
+} // namespace mozilla
+
+#endif // mozilla_image_Downscaler_h