image/SurfacePipeFactory.h
author cku <cku@mozilla.com>
Thu, 18 May 2017 22:03:41 +0200
changeset 359088 bbf16eb4f821b2d535826141f9f33f3eb49a54c6
parent 302654 212067476b418138224e2a694965b5f3e0c4fe86
child 420273 87a0a6e103d8151d0e40929580545e3fbcc6b490
permissions -rw-r--r--
Bug 1351440 - Part 2. Encapsulate DrawResult and imgIContainer::FLAG_* into imgDrawingParams, and pass it to PaintSVG. r=jwatt The DrawResult return was not in fact anything to do with the success or failure of that method, but was actually passing out a very specific piece of information about the success or failure of any imagelib drawing that may not have occurred under the various PaintSVG calls. The signature of PaintSVG is changed from DrawResult PaintSVG(...., uint32 flags); to void PaintSVG(...., imgDrawingParams& aPackage); imgDrawingParams wraps DrawResult and imgIContainer::FLAG_* as a pack, pass through PaintSVG to imagelib draw calls under beneath. MozReview-Commit-ID: IOq2evUAOQF

/* -*- 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