mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 21:55:31 +00:00
c7b01ecbda
CLOSED TREE Backed out changeset 652c909b75ad (bug 1290293) Backed out changeset 90a284ea19e3 (bug 1290292) Backed out changeset 8401d12fe936 (bug 1290293) Backed out changeset d87488b69c18 (bug 1290293) Backed out changeset 7368aa665fae (bug 1290293)
794 lines
29 KiB
C++
794 lines
29 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=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/. */
|
|
|
|
/**
|
|
* A SurfacePipe is a pipeline that consists of a series of SurfaceFilters
|
|
* terminating in a SurfaceSink. Each SurfaceFilter transforms the image data in
|
|
* some way before the SurfaceSink ultimately writes it to the surface. This
|
|
* design allows for each transformation to be tested independently, for the
|
|
* transformations to be combined as needed to meet the needs of different
|
|
* situations, and for all image decoders to share the same code for these
|
|
* transformations.
|
|
*
|
|
* Writing to the SurfacePipe is done using lambdas that act as generator
|
|
* functions. Because the SurfacePipe machinery controls where the writes take
|
|
* place, a bug in an image decoder cannot cause a buffer overflow of the
|
|
* underlying surface.
|
|
*/
|
|
|
|
#ifndef mozilla_image_SurfacePipe_h
|
|
#define mozilla_image_SurfacePipe_h
|
|
|
|
#include <stdint.h>
|
|
|
|
#include "nsDebug.h"
|
|
|
|
#include "mozilla/Likely.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/Move.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/Unused.h"
|
|
#include "mozilla/Variant.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
|
|
namespace mozilla {
|
|
namespace image {
|
|
|
|
class Decoder;
|
|
|
|
/**
|
|
* An invalid rect for a surface. Results are given both in the space of the
|
|
* input image (i.e., before any SurfaceFilters are applied) and in the space
|
|
* of the output surface (after all SurfaceFilters).
|
|
*/
|
|
struct SurfaceInvalidRect
|
|
{
|
|
gfx::IntRect mInputSpaceRect; /// The invalid rect in pre-SurfacePipe space.
|
|
gfx::IntRect mOutputSpaceRect; /// The invalid rect in post-SurfacePipe space.
|
|
};
|
|
|
|
/**
|
|
* An enum used to allow the lambdas passed to WritePixels() to communicate
|
|
* their state to the caller.
|
|
*/
|
|
enum class WriteState : uint8_t
|
|
{
|
|
NEED_MORE_DATA, /// The lambda ran out of data.
|
|
|
|
FINISHED, /// The lambda is done writing to the surface; future writes
|
|
/// will fail.
|
|
|
|
FAILURE /// The lambda encountered an error. The caller may recover
|
|
/// if possible and continue to write. (This never indicates
|
|
/// an error in the SurfacePipe machinery itself; it's only
|
|
/// generated by the lambdas.)
|
|
};
|
|
|
|
/**
|
|
* A template alias used to make the return value of WritePixels() lambdas
|
|
* (which may return either a pixel value or a WriteState) easier to specify.
|
|
*/
|
|
template <typename PixelType>
|
|
using NextPixel = Variant<PixelType, WriteState>;
|
|
|
|
/**
|
|
* SurfaceFilter is the abstract superclass of SurfacePipe pipeline stages. It
|
|
* implements the the code that actually writes to the surface - WritePixels()
|
|
* and the other Write*() methods - which are non-virtual for efficiency.
|
|
*
|
|
* SurfaceFilter's API is nonpublic; only SurfacePipe and other SurfaceFilters
|
|
* should use it. Non-SurfacePipe code should use the methods on SurfacePipe.
|
|
*
|
|
* To implement a SurfaceFilter, it's necessary to subclass SurfaceFilter and
|
|
* implement, at a minimum, the pure virtual methods. It's also necessary to
|
|
* define a Config struct with a Filter typedef member that identifies the
|
|
* matching SurfaceFilter class, and a Configure() template method. See an
|
|
* existing SurfaceFilter subclass, such as RemoveFrameRectFilter, for an
|
|
* example of how the Configure() method must be implemented. It takes a list of
|
|
* Config structs, passes the tail of the list to the next filter in the chain's
|
|
* Configure() method, and then uses the head of the list to configure itself. A
|
|
* SurfaceFilter's Configure() method must also call
|
|
* SurfaceFilter::ConfigureFilter() to provide the Write*() methods with the
|
|
* information they need to do their jobs.
|
|
*/
|
|
class SurfaceFilter
|
|
{
|
|
public:
|
|
SurfaceFilter()
|
|
: mRowPointer(nullptr)
|
|
, mCol(0)
|
|
, mPixelSize(0)
|
|
{ }
|
|
|
|
virtual ~SurfaceFilter() { }
|
|
|
|
/**
|
|
* Reset this surface to the first row. It's legal for this filter to throw
|
|
* away any previously written data at this point, as all rows must be written
|
|
* to on every pass.
|
|
*
|
|
* @return a pointer to the buffer for the first row.
|
|
*/
|
|
uint8_t* ResetToFirstRow()
|
|
{
|
|
mCol = 0;
|
|
mRowPointer = DoResetToFirstRow();
|
|
return mRowPointer;
|
|
}
|
|
|
|
/**
|
|
* Called by WritePixels() to advance this filter to the next row.
|
|
*
|
|
* @return a pointer to the buffer for the next row, or nullptr to indicate
|
|
* that we've finished the entire surface.
|
|
*/
|
|
uint8_t* AdvanceRow()
|
|
{
|
|
mCol = 0;
|
|
mRowPointer = DoAdvanceRow();
|
|
return mRowPointer;
|
|
}
|
|
|
|
/// @return a pointer to the buffer for the current row.
|
|
uint8_t* CurrentRowPointer() const { return mRowPointer; }
|
|
|
|
/// @return true if we've finished writing to the surface.
|
|
bool IsSurfaceFinished() const { return mRowPointer == nullptr; }
|
|
|
|
/// @return the input size this filter expects.
|
|
gfx::IntSize InputSize() const { return mInputSize; }
|
|
|
|
/**
|
|
* Write pixels to the surface one at a time by repeatedly calling a lambda
|
|
* that yields pixels. WritePixels() is completely memory safe.
|
|
*
|
|
* Writing continues until every pixel in the surface has been written to
|
|
* (i.e., IsSurfaceFinished() returns true) or the lambda returns a WriteState
|
|
* which WritePixels() will return to the caller.
|
|
*
|
|
* The template parameter PixelType must be uint8_t (for paletted surfaces) or
|
|
* uint32_t (for BGRA/BGRX surfaces) and must be in agreement with the pixel
|
|
* size passed to ConfigureFilter().
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove the PixelType template parameter from this
|
|
* method.
|
|
*
|
|
* @param aFunc A lambda that functions as a generator, yielding the next
|
|
* pixel in the surface each time it's called. The lambda must
|
|
* return a NextPixel<PixelType> value.
|
|
*
|
|
* @return A WriteState value indicating the lambda generator's state.
|
|
* WritePixels() itself will return WriteState::FINISHED if writing
|
|
* has finished, regardless of the lambda's internal state.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
WriteState WritePixels(Func aFunc)
|
|
{
|
|
Maybe<WriteState> result;
|
|
while (!(result = DoWritePixelsToRow<PixelType>(Forward<Func>(aFunc)))) { }
|
|
|
|
return *result;
|
|
}
|
|
|
|
/**
|
|
* A variant of WritePixels() that writes a single row of pixels to the
|
|
* surface one at a time by repeatedly calling a lambda that yields pixels.
|
|
* WritePixelsToRow() is completely memory safe.
|
|
*
|
|
* Writing continues until every pixel in the row has been written to. If the
|
|
* surface is complete at that pointer, WriteState::FINISHED is returned;
|
|
* otherwise, WritePixelsToRow() returns WriteState::NEED_MORE_DATA. The
|
|
* lambda can terminate writing early by returning a WriteState itself, which
|
|
* WritePixelsToRow() will return to the caller.
|
|
*
|
|
* The template parameter PixelType must be uint8_t (for paletted surfaces) or
|
|
* uint32_t (for BGRA/BGRX surfaces) and must be in agreement with the pixel
|
|
* size passed to ConfigureFilter().
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove the PixelType template parameter from this
|
|
* method.
|
|
*
|
|
* @param aFunc A lambda that functions as a generator, yielding the next
|
|
* pixel in the surface each time it's called. The lambda must
|
|
* return a NextPixel<PixelType> value.
|
|
*
|
|
* @return A WriteState value indicating the lambda generator's state.
|
|
* WritePixels() itself will return WriteState::FINISHED if writing
|
|
* the entire surface has finished, or WriteState::NEED_MORE_DATA if
|
|
* writing the row has finished, regardless of the lambda's internal
|
|
* state.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
WriteState WritePixelsToRow(Func aFunc)
|
|
{
|
|
return DoWritePixelsToRow<PixelType>(Forward<Func>(aFunc))
|
|
.valueOr(WriteState::NEED_MORE_DATA);
|
|
}
|
|
|
|
/**
|
|
* Write a row to the surface by copying from a buffer. This is bounds checked
|
|
* and memory safe with respect to the surface, but care must still be taken
|
|
* by the caller not to overread the source buffer. This variant of
|
|
* WriteBuffer() requires a source buffer which contains |mInputSize.width|
|
|
* pixels.
|
|
*
|
|
* The template parameter PixelType must be uint8_t (for paletted surfaces) or
|
|
* uint32_t (for BGRA/BGRX surfaces) and must be in agreement with the pixel
|
|
* size passed to ConfigureFilter().
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove the PixelType template parameter from this
|
|
* method.
|
|
*
|
|
* @param aSource A buffer to copy from. This buffer must be
|
|
* |mInputSize.width| pixels wide, which means
|
|
* |mInputSize.width * sizeof(PixelType)| bytes. May not be
|
|
* null.
|
|
*
|
|
* @return WriteState::FINISHED if the entire surface has been written to.
|
|
* Otherwise, returns WriteState::NEED_MORE_DATA. If a null |aSource|
|
|
* value is passed, returns WriteState::FAILURE.
|
|
*/
|
|
template <typename PixelType>
|
|
WriteState WriteBuffer(const PixelType* aSource)
|
|
{
|
|
return WriteBuffer(aSource, 0, mInputSize.width);
|
|
}
|
|
|
|
/**
|
|
* Write a row to the surface by copying from a buffer. This is bounds checked
|
|
* and memory safe with respect to the surface, but care must still be taken
|
|
* by the caller not to overread the source buffer. This variant of
|
|
* WriteBuffer() reads at most @aLength pixels from the buffer and writes them
|
|
* to the row starting at @aStartColumn. Any pixels in columns before
|
|
* @aStartColumn or after the pixels copied from the buffer are cleared.
|
|
*
|
|
* Bounds checking failures produce warnings in debug builds because although
|
|
* the bounds checking maintains safety, this kind of failure could indicate a
|
|
* bug in the calling code.
|
|
*
|
|
* The template parameter PixelType must be uint8_t (for paletted surfaces) or
|
|
* uint32_t (for BGRA/BGRX surfaces) and must be in agreement with the pixel
|
|
* size passed to ConfigureFilter().
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove the PixelType template parameter from this
|
|
* method.
|
|
*
|
|
* @param aSource A buffer to copy from. This buffer must be @aLength pixels
|
|
* wide, which means |aLength * sizeof(PixelType)| bytes. May
|
|
* not be null.
|
|
* @param aStartColumn The column to start writing to in the row. Columns
|
|
* before this are cleared.
|
|
* @param aLength The number of bytes, at most, which may be copied from
|
|
* @aSource. Fewer bytes may be copied in practice due to
|
|
* bounds checking.
|
|
*
|
|
* @return WriteState::FINISHED if the entire surface has been written to.
|
|
* Otherwise, returns WriteState::NEED_MORE_DATA. If a null |aSource|
|
|
* value is passed, returns WriteState::FAILURE.
|
|
*/
|
|
template <typename PixelType>
|
|
WriteState WriteBuffer(const PixelType* aSource,
|
|
const size_t aStartColumn,
|
|
const size_t aLength)
|
|
{
|
|
MOZ_ASSERT(mPixelSize == 1 || mPixelSize == 4);
|
|
MOZ_ASSERT_IF(mPixelSize == 1, sizeof(PixelType) == sizeof(uint8_t));
|
|
MOZ_ASSERT_IF(mPixelSize == 4, sizeof(PixelType) == sizeof(uint32_t));
|
|
|
|
if (IsSurfaceFinished()) {
|
|
return WriteState::FINISHED; // Already done.
|
|
}
|
|
|
|
if (MOZ_UNLIKELY(!aSource)) {
|
|
NS_WARNING("Passed a null pointer to WriteBuffer");
|
|
return WriteState::FAILURE;
|
|
}
|
|
|
|
PixelType* dest = reinterpret_cast<PixelType*>(mRowPointer);
|
|
|
|
// Clear the area before |aStartColumn|.
|
|
const size_t prefixLength = std::min<size_t>(mInputSize.width, aStartColumn);
|
|
if (MOZ_UNLIKELY(prefixLength != aStartColumn)) {
|
|
NS_WARNING("Provided starting column is out-of-bounds in WriteBuffer");
|
|
}
|
|
|
|
memset(dest, 0, mInputSize.width * sizeof(PixelType));
|
|
dest += prefixLength;
|
|
|
|
// Write |aLength| pixels from |aSource| into the row, with bounds checking.
|
|
const size_t bufferLength =
|
|
std::min<size_t>(mInputSize.width - prefixLength, aLength);
|
|
if (MOZ_UNLIKELY(bufferLength != aLength)) {
|
|
NS_WARNING("Provided buffer length is out-of-bounds in WriteBuffer");
|
|
}
|
|
|
|
memcpy(dest, aSource, bufferLength * sizeof(PixelType));
|
|
dest += bufferLength;
|
|
|
|
// Clear the rest of the row.
|
|
const size_t suffixLength = mInputSize.width - (prefixLength + bufferLength);
|
|
memset(dest, 0, suffixLength * sizeof(PixelType));
|
|
|
|
AdvanceRow();
|
|
|
|
return IsSurfaceFinished() ? WriteState::FINISHED
|
|
: WriteState::NEED_MORE_DATA;
|
|
}
|
|
|
|
/**
|
|
* Write an empty row to the surface. If some pixels have already been written
|
|
* to this row, they'll be discarded.
|
|
*
|
|
* @return WriteState::FINISHED if the entire surface has been written to.
|
|
* Otherwise, returns WriteState::NEED_MORE_DATA.
|
|
*/
|
|
WriteState WriteEmptyRow()
|
|
{
|
|
if (IsSurfaceFinished()) {
|
|
return WriteState::FINISHED; // Already done.
|
|
}
|
|
|
|
memset(mRowPointer, 0, mInputSize.width * mPixelSize);
|
|
AdvanceRow();
|
|
|
|
return IsSurfaceFinished() ? WriteState::FINISHED
|
|
: WriteState::NEED_MORE_DATA;
|
|
}
|
|
|
|
/**
|
|
* Write a row to the surface by calling a lambda that uses a pointer to
|
|
* directly write to the row. This is unsafe because SurfaceFilter can't
|
|
* provide any bounds checking; that's up to the lambda itself. For this
|
|
* reason, the other Write*() methods should be preferred whenever it's
|
|
* possible to use them; WriteUnsafeComputedRow() should be used only when
|
|
* it's absolutely necessary to avoid extra copies or other performance
|
|
* penalties.
|
|
*
|
|
* This method should never be exposed to SurfacePipe consumers; it's strictly
|
|
* for use in SurfaceFilters. If external code needs this method, it should
|
|
* probably be turned into a SurfaceFilter.
|
|
*
|
|
* The template parameter PixelType must be uint8_t (for paletted surfaces) or
|
|
* uint32_t (for BGRA/BGRX surfaces) and must be in agreement with the pixel
|
|
* size passed to ConfigureFilter().
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove the PixelType template parameter from this
|
|
* method.
|
|
*
|
|
* @param aFunc A lambda that writes directly to the row.
|
|
*
|
|
* @return WriteState::FINISHED if the entire surface has been written to.
|
|
* Otherwise, returns WriteState::NEED_MORE_DATA.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
WriteState WriteUnsafeComputedRow(Func aFunc)
|
|
{
|
|
MOZ_ASSERT(mPixelSize == 1 || mPixelSize == 4);
|
|
MOZ_ASSERT_IF(mPixelSize == 1, sizeof(PixelType) == sizeof(uint8_t));
|
|
MOZ_ASSERT_IF(mPixelSize == 4, sizeof(PixelType) == sizeof(uint32_t));
|
|
|
|
if (IsSurfaceFinished()) {
|
|
return WriteState::FINISHED; // Already done.
|
|
}
|
|
|
|
// Call the provided lambda with a pointer to the buffer for the current
|
|
// row. This is unsafe because we can't do any bounds checking; the lambda
|
|
// itself has to be responsible for that.
|
|
PixelType* rowPtr = reinterpret_cast<PixelType*>(mRowPointer);
|
|
aFunc(rowPtr, mInputSize.width);
|
|
AdvanceRow();
|
|
|
|
return IsSurfaceFinished() ? WriteState::FINISHED
|
|
: WriteState::NEED_MORE_DATA;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Methods Subclasses Should Override
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
/// @return true if this SurfaceFilter can be used with paletted surfaces.
|
|
virtual bool IsValidPalettedPipe() const { return false; }
|
|
|
|
/**
|
|
* @return a SurfaceInvalidRect representing the region of the surface that
|
|
* has been written to since the last time TakeInvalidRect() was
|
|
* called, or Nothing() if the region is empty (i.e. nothing has been
|
|
* written).
|
|
*/
|
|
virtual Maybe<SurfaceInvalidRect> TakeInvalidRect() = 0;
|
|
|
|
protected:
|
|
|
|
/**
|
|
* Called by ResetToFirstRow() to actually perform the reset. It's legal to
|
|
* throw away any previously written data at this point, as all rows must be
|
|
* written to on every pass.
|
|
*/
|
|
virtual uint8_t* DoResetToFirstRow() = 0;
|
|
|
|
/**
|
|
* Called by AdvanceRow() to actually advance this filter to the next row.
|
|
*
|
|
* @return a pointer to the buffer for the next row, or nullptr to indicate
|
|
* that we've finished the entire surface.
|
|
*/
|
|
virtual uint8_t* DoAdvanceRow() = 0;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// Methods For Internal Use By Subclasses
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Called by subclasses' Configure() methods to initialize the configuration
|
|
* of this filter. After the filter is configured, calls ResetToFirstRow().
|
|
*
|
|
* @param aInputSize The input size of this filter, in pixels. The previous
|
|
* filter in the chain will expect to write into rows
|
|
* |aInputSize.width| pixels wide.
|
|
* @param aPixelSize How large, in bytes, each pixel in the surface is. This
|
|
* should be either 1 for paletted images or 4 for BGRA/BGRX
|
|
* images.
|
|
*/
|
|
void ConfigureFilter(gfx::IntSize aInputSize, uint8_t aPixelSize)
|
|
{
|
|
mInputSize = aInputSize;
|
|
mPixelSize = aPixelSize;
|
|
|
|
ResetToFirstRow();
|
|
}
|
|
|
|
private:
|
|
|
|
/**
|
|
* An internal method used to implement both WritePixels() and
|
|
* WritePixelsToRow(). Those methods differ only in their behavior after a row
|
|
* is successfully written - WritePixels() continues to write another row,
|
|
* while WritePixelsToRow() returns to the caller. This method writes a single
|
|
* row and returns Some() if we either finished the entire surface or the
|
|
* lambda returned a WriteState indicating that we should return to the
|
|
* caller. If the row was successfully written without either of those things
|
|
* happening, it returns Nothing(), allowing WritePixels() and
|
|
* WritePixelsToRow() to implement their respective behaviors.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
Maybe<WriteState> DoWritePixelsToRow(Func aFunc)
|
|
{
|
|
MOZ_ASSERT(mPixelSize == 1 || mPixelSize == 4);
|
|
MOZ_ASSERT_IF(mPixelSize == 1, sizeof(PixelType) == sizeof(uint8_t));
|
|
MOZ_ASSERT_IF(mPixelSize == 4, sizeof(PixelType) == sizeof(uint32_t));
|
|
|
|
if (IsSurfaceFinished()) {
|
|
return Some(WriteState::FINISHED); // We're already done.
|
|
}
|
|
|
|
PixelType* rowPtr = reinterpret_cast<PixelType*>(mRowPointer);
|
|
|
|
for (; mCol < mInputSize.width; ++mCol) {
|
|
NextPixel<PixelType> result = aFunc();
|
|
if (result.template is<PixelType>()) {
|
|
rowPtr[mCol] = result.template as<PixelType>();
|
|
continue;
|
|
}
|
|
|
|
switch (result.template as<WriteState>()) {
|
|
case WriteState::NEED_MORE_DATA:
|
|
return Some(WriteState::NEED_MORE_DATA);
|
|
|
|
case WriteState::FINISHED:
|
|
ZeroOutRestOfSurface<PixelType>();
|
|
return Some(WriteState::FINISHED);
|
|
|
|
case WriteState::FAILURE:
|
|
// Note that we don't need to record this anywhere, because this
|
|
// indicates an error in aFunc, and there's nothing wrong with our
|
|
// machinery. The caller can recover as needed and continue writing to
|
|
// the row.
|
|
return Some(WriteState::FAILURE);
|
|
}
|
|
}
|
|
|
|
AdvanceRow(); // We've finished the row.
|
|
|
|
return IsSurfaceFinished() ? Some(WriteState::FINISHED)
|
|
: Nothing();
|
|
}
|
|
|
|
template <typename PixelType>
|
|
void ZeroOutRestOfSurface()
|
|
{
|
|
WritePixels<PixelType>([]{ return AsVariant(PixelType(0)); });
|
|
}
|
|
|
|
gfx::IntSize mInputSize; /// The size of the input this filter expects.
|
|
uint8_t* mRowPointer; /// Pointer to the current row or null if finished.
|
|
int32_t mCol; /// The current column we're writing to. (0-indexed)
|
|
uint8_t mPixelSize; /// How large each pixel in the surface is, in bytes.
|
|
};
|
|
|
|
class NullSurfaceSink;
|
|
|
|
/// A trivial configuration struct for NullSurfaceSink.
|
|
struct NullSurfaceConfig
|
|
{
|
|
using Filter = NullSurfaceSink;
|
|
};
|
|
|
|
/**
|
|
* NullSurfaceSink is a trivial SurfaceFilter implementation that behaves as if
|
|
* it were a zero-size SurfaceSink. It's used as the default filter chain for an
|
|
* uninitialized SurfacePipe.
|
|
*
|
|
* To avoid unnecessary allocations when creating SurfacePipe objects,
|
|
* NullSurfaceSink is a singleton. (This implies that the implementation must be
|
|
* stateless.)
|
|
*/
|
|
class NullSurfaceSink final : public SurfaceFilter
|
|
{
|
|
public:
|
|
/// Returns the singleton instance of NullSurfaceSink.
|
|
static NullSurfaceSink* Singleton();
|
|
|
|
virtual ~NullSurfaceSink() { }
|
|
|
|
nsresult Configure(const NullSurfaceConfig& aConfig);
|
|
|
|
Maybe<SurfaceInvalidRect> TakeInvalidRect() override { return Nothing(); }
|
|
|
|
protected:
|
|
uint8_t* DoResetToFirstRow() override { return nullptr; }
|
|
uint8_t* DoAdvanceRow() override { return nullptr; }
|
|
|
|
private:
|
|
static UniquePtr<NullSurfaceSink> sSingleton; /// The singleton instance.
|
|
};
|
|
|
|
|
|
/**
|
|
* SurfacePipe is the public API that decoders should use to interact with a
|
|
* SurfaceFilter pipeline.
|
|
*/
|
|
class SurfacePipe
|
|
{
|
|
public:
|
|
/// Initialize global state used by all SurfacePipes.
|
|
static void Initialize() { NullSurfaceSink::Singleton(); }
|
|
|
|
SurfacePipe()
|
|
: mHead(NullSurfaceSink::Singleton())
|
|
{ }
|
|
|
|
SurfacePipe(SurfacePipe&& aOther)
|
|
: mHead(Move(aOther.mHead))
|
|
{ }
|
|
|
|
~SurfacePipe()
|
|
{
|
|
// Ensure that we don't free the NullSurfaceSink singleton.
|
|
if (mHead.get() == NullSurfaceSink::Singleton()) {
|
|
Unused << mHead.release();
|
|
}
|
|
}
|
|
|
|
SurfacePipe& operator=(SurfacePipe&& aOther)
|
|
{
|
|
MOZ_ASSERT(this != &aOther);
|
|
|
|
// Ensure that we don't free the NullSurfaceSink singleton.
|
|
if (mHead.get() == NullSurfaceSink::Singleton()) {
|
|
Unused << mHead.release();
|
|
}
|
|
|
|
mHead = Move(aOther.mHead);
|
|
return *this;
|
|
}
|
|
|
|
/// Begins a new pass, seeking to the first row of the surface.
|
|
void ResetToFirstRow() { mHead->ResetToFirstRow(); }
|
|
|
|
/**
|
|
* Write pixels to the surface one at a time by repeatedly calling a lambda
|
|
* that yields pixels. WritePixels() is completely memory safe.
|
|
*
|
|
* @see SurfaceFilter::WritePixels() for the canonical documentation.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
WriteState WritePixels(Func aFunc)
|
|
{
|
|
return mHead->WritePixels<PixelType>(Forward<Func>(aFunc));
|
|
}
|
|
|
|
/**
|
|
* A variant of WritePixels() that writes a single row of pixels to the
|
|
* surface one at a time by repeatedly calling a lambda that yields pixels.
|
|
* WritePixelsToRow() is completely memory safe.
|
|
*
|
|
* @see SurfaceFilter::WritePixelsToRow() for the canonical documentation.
|
|
*/
|
|
template <typename PixelType, typename Func>
|
|
WriteState WritePixelsToRow(Func aFunc)
|
|
{
|
|
return mHead->WritePixelsToRow<PixelType>(Forward<Func>(aFunc));
|
|
}
|
|
|
|
/**
|
|
* Write a row to the surface by copying from a buffer. This is bounds checked
|
|
* and memory safe with respect to the surface, but care must still be taken
|
|
* by the caller not to overread the source buffer. This variant of
|
|
* WriteBuffer() requires a source buffer which contains |mInputSize.width|
|
|
* pixels.
|
|
*
|
|
* @see SurfaceFilter::WriteBuffer() for the canonical documentation.
|
|
*/
|
|
template <typename PixelType>
|
|
WriteState WriteBuffer(const PixelType* aSource)
|
|
{
|
|
return mHead->WriteBuffer<PixelType>(aSource);
|
|
}
|
|
|
|
/**
|
|
* Write a row to the surface by copying from a buffer. This is bounds checked
|
|
* and memory safe with respect to the surface, but care must still be taken
|
|
* by the caller not to overread the source buffer. This variant of
|
|
* WriteBuffer() reads at most @aLength pixels from the buffer and writes them
|
|
* to the row starting at @aStartColumn. Any pixels in columns before
|
|
* @aStartColumn or after the pixels copied from the buffer are cleared.
|
|
*
|
|
* @see SurfaceFilter::WriteBuffer() for the canonical documentation.
|
|
*/
|
|
template <typename PixelType>
|
|
WriteState WriteBuffer(const PixelType* aSource,
|
|
const size_t aStartColumn,
|
|
const size_t aLength)
|
|
{
|
|
return mHead->WriteBuffer<PixelType>(aSource, aStartColumn, aLength);
|
|
}
|
|
|
|
/**
|
|
* Write an empty row to the surface. If some pixels have already been written
|
|
* to this row, they'll be discarded.
|
|
*
|
|
* @see SurfaceFilter::WriteEmptyRow() for the canonical documentation.
|
|
*/
|
|
WriteState WriteEmptyRow()
|
|
{
|
|
return mHead->WriteEmptyRow();
|
|
}
|
|
|
|
/// @return true if we've finished writing to the surface.
|
|
bool IsSurfaceFinished() const { return mHead->IsSurfaceFinished(); }
|
|
|
|
/// @see SurfaceFilter::TakeInvalidRect() for the canonical documentation.
|
|
Maybe<SurfaceInvalidRect> TakeInvalidRect() const
|
|
{
|
|
return mHead->TakeInvalidRect();
|
|
}
|
|
|
|
private:
|
|
friend class SurfacePipeFactory;
|
|
friend class TestSurfacePipeFactory;
|
|
|
|
explicit SurfacePipe(UniquePtr<SurfaceFilter>&& aHead)
|
|
: mHead(Move(aHead))
|
|
{ }
|
|
|
|
SurfacePipe(const SurfacePipe&) = delete;
|
|
SurfacePipe& operator=(const SurfacePipe&) = delete;
|
|
|
|
UniquePtr<SurfaceFilter> mHead; /// The first filter in the chain.
|
|
};
|
|
|
|
/**
|
|
* AbstractSurfaceSink contains shared implementation for both SurfaceSink and
|
|
* PalettedSurfaceSink.
|
|
*/
|
|
class AbstractSurfaceSink : public SurfaceFilter
|
|
{
|
|
public:
|
|
AbstractSurfaceSink()
|
|
: mImageData(nullptr)
|
|
, mImageDataLength(0)
|
|
, mRow(0)
|
|
, mFlipVertically(false)
|
|
{ }
|
|
|
|
Maybe<SurfaceInvalidRect> TakeInvalidRect() override final;
|
|
|
|
protected:
|
|
uint8_t* DoResetToFirstRow() override final;
|
|
uint8_t* DoAdvanceRow() override final;
|
|
virtual uint8_t* GetRowPointer() const = 0;
|
|
|
|
gfx::IntRect mInvalidRect; /// The region of the surface that has been written
|
|
/// to since the last call to TakeInvalidRect().
|
|
uint8_t* mImageData; /// A pointer to the beginning of the surface data.
|
|
uint32_t mImageDataLength; /// The length of the surface data.
|
|
uint32_t mRow; /// The row to which we're writing. (0-indexed)
|
|
bool mFlipVertically; /// If true, write the rows from top to bottom.
|
|
};
|
|
|
|
class SurfaceSink;
|
|
|
|
/// A configuration struct for SurfaceSink.
|
|
struct SurfaceConfig
|
|
{
|
|
using Filter = SurfaceSink;
|
|
Decoder* mDecoder; /// Which Decoder to use to allocate the surface.
|
|
uint32_t mFrameNum; /// Which frame of animation this surface is for.
|
|
gfx::IntSize mOutputSize; /// The size of the surface.
|
|
gfx::SurfaceFormat mFormat; /// The surface format (BGRA or BGRX).
|
|
bool mFlipVertically; /// If true, write the rows from bottom to top.
|
|
};
|
|
|
|
/**
|
|
* A sink for normal (i.e., non-paletted) surfaces. It handles the allocation of
|
|
* the surface and protects against buffer overflow. This sink should be used
|
|
* for all non-animated images and for the first frame of animated images.
|
|
*
|
|
* Sinks must always be at the end of the SurfaceFilter chain.
|
|
*/
|
|
class SurfaceSink final : public AbstractSurfaceSink
|
|
{
|
|
public:
|
|
nsresult Configure(const SurfaceConfig& aConfig);
|
|
|
|
protected:
|
|
uint8_t* GetRowPointer() const override;
|
|
};
|
|
|
|
class PalettedSurfaceSink;
|
|
|
|
struct PalettedSurfaceConfig
|
|
{
|
|
using Filter = PalettedSurfaceSink;
|
|
Decoder* mDecoder; /// Which Decoder to use to allocate the surface.
|
|
uint32_t mFrameNum; /// Which frame of animation this surface is for.
|
|
gfx::IntSize mOutputSize; /// The logical size of the surface.
|
|
gfx::IntRect mFrameRect; /// The surface subrect which contains data.
|
|
gfx::SurfaceFormat mFormat; /// The surface format (BGRA or BGRX).
|
|
uint8_t mPaletteDepth; /// The palette depth of this surface.
|
|
bool mFlipVertically; /// If true, write the rows from bottom to top.
|
|
};
|
|
|
|
/**
|
|
* A sink for paletted surfaces. It handles the allocation of the surface and
|
|
* protects against buffer overflow. This sink can be used for frames of
|
|
* animated images except the first.
|
|
*
|
|
* Sinks must always be at the end of the SurfaceFilter chain.
|
|
*
|
|
* XXX(seth): We'll remove all support for paletted surfaces in bug 1247520,
|
|
* which means we can remove PalettedSurfaceSink entirely.
|
|
*/
|
|
class PalettedSurfaceSink final : public AbstractSurfaceSink
|
|
{
|
|
public:
|
|
bool IsValidPalettedPipe() const override { return true; }
|
|
|
|
nsresult Configure(const PalettedSurfaceConfig& aConfig);
|
|
|
|
protected:
|
|
uint8_t* GetRowPointer() const override;
|
|
|
|
private:
|
|
/**
|
|
* The surface subrect which contains data. Note that the surface size we
|
|
* actually allocate is the size of the frame rect, not the logical size of
|
|
* the surface.
|
|
*/
|
|
gfx::IntRect mFrameRect;
|
|
};
|
|
|
|
} // namespace image
|
|
} // namespace mozilla
|
|
|
|
#endif // mozilla_image_SurfacePipe_h
|