diff options
Diffstat (limited to 'image/SurfacePipeFactory.h')
| -rw-r--r-- | image/SurfacePipeFactory.h | 249 |
1 files changed, 249 insertions, 0 deletions
diff --git a/image/SurfacePipeFactory.h b/image/SurfacePipeFactory.h new file mode 100644 index 0000000000..ff53fec5c2 --- /dev/null +++ b/image/SurfacePipeFactory.h @@ -0,0 +1,249 @@ +/* -*- 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/. */ + +#ifndef mozilla_image_SurfacePipeFactory_h +#define mozilla_image_SurfacePipeFactory_h + +#include "SurfacePipe.h" +#include "SurfaceFilters.h" + +namespace mozilla { +namespace image { + +namespace detail { + +/** + * FilterPipeline is a helper template for SurfacePipeFactory that determines + * the full type of the sequence of SurfaceFilters that a sequence of + * configuration structs corresponds to. To make this work, all configuration + * structs must include a typedef 'Filter' that identifies the SurfaceFilter + * they configure. + */ +template <typename... Configs> +struct FilterPipeline; + +template <typename Config, typename... Configs> +struct FilterPipeline<Config, Configs...> +{ + typedef typename Config::template Filter<typename FilterPipeline<Configs...>::Type> Type; +}; + +template <typename Config> +struct FilterPipeline<Config> +{ + typedef typename Config::Filter Type; +}; + +} // namespace detail + +/** + * Flags for SurfacePipeFactory, used in conjuction with the factory functions + * in SurfacePipeFactory to enable or disable various SurfacePipe + * functionality. + */ +enum class SurfacePipeFlags +{ + DEINTERLACE = 1 << 0, // If set, deinterlace the image. + + ADAM7_INTERPOLATE = 1 << 1, // If set, the caller is deinterlacing the + // image using ADAM7, and we may want to + // interpolate it for better intermediate results. + + FLIP_VERTICALLY = 1 << 2, // If set, flip the image vertically. + + PROGRESSIVE_DISPLAY = 1 << 3 // If set, we expect the image to be displayed + // progressively. This enables features that + // result in a better user experience for + // progressive display but which may be more + // computationally expensive. +}; +MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(SurfacePipeFlags) + +class SurfacePipeFactory +{ +public: + /** + * Creates and initializes a normal (i.e., non-paletted) SurfacePipe. + * + * @param aDecoder The decoder whose current frame the SurfacePipe will write + * to. + * @param aFrameNum Which frame the SurfacePipe will write to. This will be 0 + * for non-animated images. + * @param aInputSize The original size of the image. + * @param aOutputSize The size the SurfacePipe should output. Must be the same + * as @aInputSize or smaller. If smaller, the image will be + * downscaled during decoding. + * @param aFrameRect The portion of the image that actually contains data. + * @param aFormat The surface format of the image; generally B8G8R8A8 or + * B8G8R8X8. + * @param aFlags Flags enabling or disabling various functionality for the + * SurfacePipe; see the SurfacePipeFlags documentation for more + * information. + * + * @return A SurfacePipe if the parameters allowed one to be created + * successfully, or Nothing() if the SurfacePipe could not be + * initialized. + */ + static Maybe<SurfacePipe> + CreateSurfacePipe(Decoder* aDecoder, + uint32_t aFrameNum, + const nsIntSize& aInputSize, + const nsIntSize& aOutputSize, + const nsIntRect& aFrameRect, + gfx::SurfaceFormat aFormat, + SurfacePipeFlags aFlags) + { + const bool deinterlace = bool(aFlags & SurfacePipeFlags::DEINTERLACE); + const bool flipVertically = bool(aFlags & SurfacePipeFlags::FLIP_VERTICALLY); + const bool progressiveDisplay = bool(aFlags & SurfacePipeFlags::PROGRESSIVE_DISPLAY); + const bool downscale = aInputSize != aOutputSize; + const bool removeFrameRect = + !aFrameRect.IsEqualEdges(nsIntRect(0, 0, aInputSize.width, aInputSize.height)); + + // Don't interpolate if we're sure we won't show this surface to the user + // until it's completely decoded. The final pass of an ADAM7 image doesn't + // need interpolation, so we only need to interpolate if we'll be displaying + // the image while it's still being decoded. + const bool adam7Interpolate = bool(aFlags & SurfacePipeFlags::ADAM7_INTERPOLATE) && + progressiveDisplay; + + if (deinterlace && adam7Interpolate) { + MOZ_ASSERT_UNREACHABLE("ADAM7 deinterlacing is handled by libpng"); + return Nothing(); + } + + // Construct configurations for the SurfaceFilters. Note that the order of + // these filters is significant. We want to deinterlace or interpolate raw + // input rows, before any other transformations, and we want to remove the + // frame rect (which may involve adding blank rows or columns to the image) + // before any downscaling, so that the new rows and columns are taken into + // account. + DeinterlacingConfig<uint32_t> deinterlacingConfig { progressiveDisplay }; + ADAM7InterpolatingConfig interpolatingConfig; + RemoveFrameRectConfig removeFrameRectConfig { aFrameRect }; + DownscalingConfig downscalingConfig { aInputSize, aFormat }; + SurfaceConfig surfaceConfig { aDecoder, aFrameNum, aOutputSize, + aFormat, flipVertically }; + + Maybe<SurfacePipe> pipe; + + if (downscale) { + if (removeFrameRect) { + if (deinterlace) { + pipe = MakePipe(deinterlacingConfig, removeFrameRectConfig, + downscalingConfig, surfaceConfig); + } else if (adam7Interpolate) { + pipe = MakePipe(interpolatingConfig, removeFrameRectConfig, + downscalingConfig, surfaceConfig); + } else { // (deinterlace and adam7Interpolate are false) + pipe = MakePipe(removeFrameRectConfig, downscalingConfig, surfaceConfig); + } + } else { // (removeFrameRect is false) + if (deinterlace) { + pipe = MakePipe(deinterlacingConfig, downscalingConfig, surfaceConfig); + } else if (adam7Interpolate) { + pipe = MakePipe(interpolatingConfig, downscalingConfig, surfaceConfig); + } else { // (deinterlace and adam7Interpolate are false) + pipe = MakePipe(downscalingConfig, surfaceConfig); + } + } + } else { // (downscale is false) + if (removeFrameRect) { + if (deinterlace) { + pipe = MakePipe(deinterlacingConfig, removeFrameRectConfig, surfaceConfig); + } else if (adam7Interpolate) { + pipe = MakePipe(interpolatingConfig, removeFrameRectConfig, surfaceConfig); + } else { // (deinterlace and adam7Interpolate are false) + pipe = MakePipe(removeFrameRectConfig, surfaceConfig); + } + } else { // (removeFrameRect is false) + if (deinterlace) { + pipe = MakePipe(deinterlacingConfig, surfaceConfig); + } else if (adam7Interpolate) { + pipe = MakePipe(interpolatingConfig, surfaceConfig); + } else { // (deinterlace and adam7Interpolate are false) + pipe = MakePipe(surfaceConfig); + } + } + } + + return pipe; + } + + /** + * Creates and initializes a paletted SurfacePipe. + * + * XXX(seth): We'll remove all support for paletted surfaces in bug 1247520, + * which means we can remove CreatePalettedSurfacePipe() entirely. + * + * @param aDecoder The decoder whose current frame the SurfacePipe will write + * to. + * @param aFrameNum Which frame the SurfacePipe will write to. This will be 0 + * for non-animated images. + * @param aInputSize The original size of the image. + * @param aFrameRect The portion of the image that actually contains data. + * @param aFormat The surface format of the image; generally B8G8R8A8 or + * B8G8R8X8. + * @param aPaletteDepth The palette depth of the image. + * @param aFlags Flags enabling or disabling various functionality for the + * SurfacePipe; see the SurfacePipeFlags documentation for more + * information. + * + * @return A SurfacePipe if the parameters allowed one to be created + * successfully, or Nothing() if the SurfacePipe could not be + * initialized. + */ + static Maybe<SurfacePipe> + CreatePalettedSurfacePipe(Decoder* aDecoder, + uint32_t aFrameNum, + const nsIntSize& aInputSize, + const nsIntRect& aFrameRect, + gfx::SurfaceFormat aFormat, + uint8_t aPaletteDepth, + SurfacePipeFlags aFlags) + { + const bool deinterlace = bool(aFlags & SurfacePipeFlags::DEINTERLACE); + const bool flipVertically = bool(aFlags & SurfacePipeFlags::FLIP_VERTICALLY); + const bool progressiveDisplay = bool(aFlags & SurfacePipeFlags::PROGRESSIVE_DISPLAY); + + // Construct configurations for the SurfaceFilters. + DeinterlacingConfig<uint8_t> deinterlacingConfig { progressiveDisplay }; + PalettedSurfaceConfig palettedSurfaceConfig { aDecoder, aFrameNum, aInputSize, + aFrameRect, aFormat, aPaletteDepth, + flipVertically }; + + Maybe<SurfacePipe> pipe; + + if (deinterlace) { + pipe = MakePipe(deinterlacingConfig, palettedSurfaceConfig); + } else { + pipe = MakePipe(palettedSurfaceConfig); + } + + return pipe; + } + +private: + template <typename... Configs> + static Maybe<SurfacePipe> + MakePipe(Configs... aConfigs) + { + auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>(); + nsresult rv = pipe->Configure(aConfigs...); + if (NS_FAILED(rv)) { + return Nothing(); + } + + return Some(SurfacePipe { Move(pipe) } ); + } + + virtual ~SurfacePipeFactory() = 0; +}; + +} // namespace image +} // namespace mozilla + +#endif // mozilla_image_SurfacePipeFactory_h |