diff -r 000000000000 -r 6474c204b198 image/src/Decoder.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/image/src/Decoder.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,281 @@
+/* -*- 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/. */
+
+#ifndef MOZILLA_IMAGELIB_DECODER_H_
+#define MOZILLA_IMAGELIB_DECODER_H_
+
+#include "RasterImage.h"
+#include "imgDecoderObserver.h"
+#include "mozilla/RefPtr.h"
+#include "DecodeStrategy.h"
+#include "ImageMetadata.h"
+#include "Orientation.h"
+#include "mozilla/Telemetry.h"
+
+namespace mozilla {
+namespace image {
+
+class Decoder
+{
+public:
+
+  Decoder(RasterImage& aImage);
+  virtual ~Decoder();
+
+  /**
+   * Initialize an image decoder. Decoders may not be re-initialized.
+   *
+   * Notifications Sent: TODO
+   */
+  void Init();
+
+  /**
+   * Initializes a decoder whose image and observer is already being used by a
+   * parent decoder. Decoders may not be re-initialized.
+   *
+   * Notifications Sent: TODO
+   */
+  void InitSharedDecoder(uint8_t* imageData, uint32_t imageDataLength,
+                         uint32_t* colormap, uint32_t colormapSize,
+                         imgFrame* currentFrame);
+
+  /**
+   * Writes data to the decoder.
+   *
+   * @param aBuffer buffer containing the data to be written
+   * @param aCount the number of bytes to write
+   *
+   * Any errors are reported by setting the appropriate state on the decoder.
+   *
+   * Notifications Sent: TODO
+   */
+  void Write(const char* aBuffer, uint32_t aCount, DecodeStrategy aStrategy);
+
+  /**
+   * Informs the decoder that all the data has been written.
+   *
+   * Notifications Sent: TODO
+   */
+  void Finish(RasterImage::eShutdownIntent aShutdownIntent);
+
+  /**
+   * Informs the shared decoder that all the data has been written.
+   * Should only be used if InitSharedDecoder was useed
+   *
+   * Notifications Sent: TODO
+   */
+  void FinishSharedDecoder();
+
+  /**
+   * Tells the decoder to flush any pending invalidations. This informs the image
+   * frame of its decoded region, and sends the appropriate OnDataAvailable call
+   * to consumers.
+   *
+   * This can be called any time when we're midway through decoding a frame,
+   * and must be called after finishing a frame (before starting a new one).
+   */
+  void FlushInvalidations();
+
+  // We're not COM-y, so we don't get refcounts by default
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Decoder)
+
+  /*
+   * State.
+   */
+
+  // If we're doing a "size decode", we more or less pass through the image
+  // data, stopping only to scoop out the image dimensions. A size decode
+  // must be enabled by SetSizeDecode() _before_calling Init().
+  bool IsSizeDecode() { return mSizeDecode; }
+  void SetSizeDecode(bool aSizeDecode)
+  {
+    NS_ABORT_IF_FALSE(!mInitialized, "Can't set size decode after Init()!");
+    mSizeDecode = aSizeDecode;
+  }
+
+  void SetObserver(imgDecoderObserver* aObserver)
+  {
+    MOZ_ASSERT(aObserver);
+    mObserver = aObserver;
+  }
+
+  // The number of frames we have, including anything in-progress. Thus, this
+  // is only 0 if we haven't begun any frames.
+  uint32_t GetFrameCount() { return mFrameCount; }
+
+  // The number of complete frames we have (ie, not including anything in-progress).
+  uint32_t GetCompleteFrameCount() { return mInFrame ? mFrameCount - 1 : mFrameCount; }
+
+  // Error tracking
+  bool HasError() { return HasDataError() || HasDecoderError(); }
+  bool HasDataError() { return mDataError; }
+  bool HasDecoderError() { return NS_FAILED(mFailCode); }
+  nsresult GetDecoderError() { return mFailCode; }
+  void PostResizeError() { PostDataError(); }
+  bool GetDecodeDone() const {
+    return mDecodeDone;
+  }
+
+  // flags.  Keep these in sync with imgIContainer.idl.
+  // SetDecodeFlags must be called before Init(), otherwise
+  // default flags are assumed.
+  enum {
+    DECODER_NO_PREMULTIPLY_ALPHA = 0x2,     // imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA
+    DECODER_NO_COLORSPACE_CONVERSION = 0x4  // imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION
+  };
+
+  enum DecodeStyle {
+      PROGRESSIVE, // produce intermediate frames representing the partial state of the image
+      SEQUENTIAL // decode to final image immediately
+  };
+
+  void SetDecodeFlags(uint32_t aFlags) { mDecodeFlags = aFlags; }
+  uint32_t GetDecodeFlags() { return mDecodeFlags; }
+
+  bool HasSize() const { return mImageMetadata.HasSize(); }
+  void SetSizeOnImage();
+
+  // Use HistogramCount as an invalid Histogram ID
+  virtual Telemetry::ID SpeedHistogram() { return Telemetry::HistogramCount; }
+
+  ImageMetadata& GetImageMetadata() { return mImageMetadata; }
+
+  // Tell the decoder infrastructure to allocate a frame. By default, frame 0
+  // is created as an ARGB frame with no offset and with size width * height.
+  // If decoders need something different, they must ask for it.
+  // This is called by decoders when they need a new frame. These decoders
+  // must then save the data they have been sent but not yet processed and
+  // return from WriteInternal. When the new frame is created, WriteInternal
+  // will be called again with nullptr and 0 as arguments.
+  void NeedNewFrame(uint32_t frameNum, uint32_t x_offset, uint32_t y_offset,
+                    uint32_t width, uint32_t height,
+                    gfxImageFormat format,
+                    uint8_t palette_depth = 0);
+
+  virtual bool NeedsNewFrame() const { return mNeedsNewFrame; }
+
+  // Try to allocate a frame as described in mNewFrameData and return the
+  // status code from that attempt. Clears mNewFrameData.
+  virtual nsresult AllocateFrame();
+
+  // Called when a chunk of decoding has been done and the frame needs to be
+  // marked as dirty. Must be called only on the main thread.
+  void MarkFrameDirty();
+
+  imgFrame* GetCurrentFrame() const { return mCurrentFrame; }
+
+protected:
+
+  /*
+   * Internal hooks. Decoder implementations may override these and
+   * only these methods.
+   */
+  virtual void InitInternal();
+  virtual void WriteInternal(const char* aBuffer, uint32_t aCount, DecodeStrategy aStrategy);
+  virtual void FinishInternal();
+
+  /*
+   * Progress notifications.
+   */
+
+  // Called by decoders when they determine the size of the image. Informs
+  // the image of its size and sends notifications.
+  void PostSize(int32_t aWidth,
+                int32_t aHeight,
+                Orientation aOrientation = Orientation());
+
+  // Called by decoders when they begin a frame. Informs the image, sends
+  // notifications, and does internal book-keeping.
+  void PostFrameStart();
+
+  // Called by decoders when they end a frame. Informs the image, sends
+  // notifications, and does internal book-keeping.
+  // Specify whether this frame is opaque as an optimization.
+  // For animated images, specify the disposal, blend method and timeout for
+  // this frame.
+  void PostFrameStop(FrameBlender::FrameAlpha aFrameAlpha = FrameBlender::kFrameHasAlpha,
+                     FrameBlender::FrameDisposalMethod aDisposalMethod = FrameBlender::kDisposeKeep,
+                     int32_t aTimeout = 0,
+                     FrameBlender::FrameBlendMethod aBlendMethod = FrameBlender::kBlendOver);
+
+  // Called by the decoders when they have a region to invalidate. We may not
+  // actually pass these invalidations on right away.
+  void PostInvalidation(nsIntRect& aRect);
+
+  // Called by the decoders when they have successfully decoded the image. This
+  // may occur as the result of the decoder getting to the appropriate point in
+  // the stream, or by us calling FinishInternal().
+  //
+  // May not be called mid-frame.
+  //
+  // For animated images, specify the loop count. -1 means loop forever, 0
+  // means a single iteration, stopping on the last frame.
+  void PostDecodeDone(int32_t aLoopCount = 0);
+
+  // Data errors are the fault of the source data, decoder errors are our fault
+  void PostDataError();
+  void PostDecoderError(nsresult aFailCode);
+
+  /*
+   * Member variables.
+   *
+   */
+  RasterImage &mImage;
+  imgFrame* mCurrentFrame;
+  RefPtr<imgDecoderObserver> mObserver;
+  ImageMetadata mImageMetadata;
+
+  uint8_t* mImageData;       // Pointer to image data in either Cairo or 8bit format
+  uint32_t mImageDataLength;
+  uint32_t* mColormap;       // Current colormap to be used in Cairo format
+  uint32_t mColormapSize;
+
+  uint32_t mDecodeFlags;
+  bool mDecodeDone;
+  bool mDataError;
+
+private:
+  uint32_t mFrameCount; // Number of frames, including anything in-progress
+
+  nsIntRect mInvalidRect; // Tracks an invalidation region in the current frame.
+
+  nsresult mFailCode;
+
+  struct NewFrameData
+  {
+    NewFrameData()
+    {}
+
+    NewFrameData(uint32_t num, uint32_t offsetx, uint32_t offsety,
+                 uint32_t width, uint32_t height,
+                 gfxImageFormat format, uint8_t paletteDepth)
+      : mFrameNum(num)
+      , mOffsetX(offsetx)
+      , mOffsetY(offsety)
+      , mWidth(width)
+      , mHeight(height)
+      , mFormat(format)
+      , mPaletteDepth(paletteDepth)
+    {}
+    uint32_t mFrameNum;
+    uint32_t mOffsetX;
+    uint32_t mOffsetY;
+    uint32_t mWidth;
+    uint32_t mHeight;
+    gfxImageFormat mFormat;
+    uint8_t mPaletteDepth;
+  };
+  NewFrameData mNewFrameData;
+  bool mNeedsNewFrame;
+  bool mInitialized;
+  bool mSizeDecode;
+  bool mInFrame;
+  bool mIsAnimated;
+};
+
+} // namespace image
+} // namespace mozilla
+
+#endif // MOZILLA_IMAGELIB_DECODER_H_