mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-07 21:43:24 +00:00
d0d070b48c
MozReview-Commit-ID: JNYZsts6pCO --HG-- extra : rebase_source : d37ce77ec84af302018f95285cff61b2ba28c957
192 lines
5.8 KiB
C++
192 lines
5.8 KiB
C++
/* -*- 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"
|
|
#ifdef MOZ_ENABLE_SKIA
|
|
#include "mozilla/gfx/ConvolutionFilter.h"
|
|
#endif
|
|
|
|
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;
|
|
};
|
|
|
|
#ifdef MOZ_ENABLE_SKIA
|
|
|
|
/**
|
|
* 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 gfxSize& 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;
|
|
gfxSize 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;
|
|
};
|
|
|
|
#else
|
|
|
|
/**
|
|
* Downscaler requires Skia to work, so we provide a dummy implementation if
|
|
* Skia is disabled that asserts if constructed.
|
|
*/
|
|
|
|
class Downscaler
|
|
{
|
|
public:
|
|
explicit Downscaler(const nsIntSize&) : mScale(1.0, 1.0)
|
|
{
|
|
MOZ_RELEASE_ASSERT(false, "Skia is not enabled");
|
|
}
|
|
|
|
const nsIntSize& OriginalSize() const { return mSize; }
|
|
const nsIntSize& TargetSize() const { return mSize; }
|
|
const gfxSize& Scale() const { return mScale; }
|
|
|
|
nsresult BeginFrame(const nsIntSize&, const Maybe<nsIntRect>&, uint8_t*, bool, bool = false)
|
|
{
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
bool IsFrameComplete() const { return false; }
|
|
uint8_t* RowBuffer() { return nullptr; }
|
|
void ClearRow() { }
|
|
void ClearRestOfRow(uint32_t) { }
|
|
void CommitRow() { }
|
|
bool HasInvalidation() const { return false; }
|
|
DownscalerInvalidRect TakeInvalidRect() { return DownscalerInvalidRect(); }
|
|
void ResetForNextProgressivePass() { }
|
|
const nsIntSize FrameSize() const { return nsIntSize(0, 0); }
|
|
private:
|
|
nsIntSize mSize;
|
|
gfxSize mScale;
|
|
};
|
|
|
|
#endif // MOZ_ENABLE_SKIA
|
|
|
|
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_image_Downscaler_h
|