/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Communicator client code.
 *
 * The Initial Developer of the Original Code is
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef GIFImageReader_h
#define GIFImageReader_h

// Define ourselves as the clientPtr.  Mozilla just hacked their C++ callback
// class into this old C decoder, so we will too.
#include "platform/image-decoders/FastSharedBufferReader.h"
#include "platform/image-decoders/gif/GIFImageDecoder.h"
#include "wtf/Allocator.h"
#include "wtf/Noncopyable.h"
#include "wtf/Vector.h"
#include <memory>

#define MAX_DICTIONARY_ENTRY_BITS 12
#define MAX_DICTIONARY_ENTRIES 4096  // 2^MAX_DICTIONARY_ENTRY_BITS
#define MAX_COLORS 256
#define BYTES_PER_COLORMAP_ENTRY 3

const int cLoopCountNotSeen = -2;

// List of possible parsing states.
enum GIFState {
  GIFType,
  GIFGlobalHeader,
  GIFGlobalColormap,
  GIFImageStart,
  GIFImageHeader,
  GIFImageColormap,
  GIFImageBody,
  GIFLZWStart,
  GIFLZW,
  GIFSubBlock,
  GIFExtension,
  GIFControlExtension,
  GIFConsumeBlock,
  GIFSkipBlock,
  GIFDone,
  GIFCommentExtension,
  GIFApplicationExtension,
  GIFNetscapeExtensionBlock,
  GIFConsumeNetscapeExtension,
  GIFConsumeComment
};

struct GIFFrameContext;

// LZW decoder state machine.
class GIFLZWContext final {
  USING_FAST_MALLOC(GIFLZWContext);
  WTF_MAKE_NONCOPYABLE(GIFLZWContext);

 public:
  GIFLZWContext(blink::GIFImageDecoder* client,
                const GIFFrameContext* frameContext)
      : codesize(0),
        codemask(0),
        clearCode(0),
        avail(0),
        oldcode(0),
        firstchar(0),
        bits(0),
        datum(0),
        ipass(0),
        irow(0),
        rowsRemaining(0),
        rowIter(0),
        m_client(client),
        m_frameContext(frameContext) {}

  bool prepareToDecode();
  bool outputRow(GIFRow::const_iterator rowBegin);
  bool doLZW(const unsigned char* block, size_t bytesInBlock);
  bool hasRemainingRows() { return rowsRemaining; }

 private:
  // LZW decoding states and output states.
  int codesize;
  int codemask;
  int clearCode;  // Codeword used to trigger dictionary reset.
  int avail;      // Index of next available slot in dictionary.
  int oldcode;
  unsigned char firstchar;
  int bits;              // Number of unread bits in "datum".
  int datum;             // 32-bit input buffer.
  int ipass;             // Interlace pass; Ranges 1-4 if interlaced.
  size_t irow;           // Current output row, starting at zero.
  size_t rowsRemaining;  // Rows remaining to be output.

  unsigned short prefix[MAX_DICTIONARY_ENTRIES];
  unsigned char suffix[MAX_DICTIONARY_ENTRIES];
  unsigned short suffixLength[MAX_DICTIONARY_ENTRIES];
  GIFRow rowBuffer;  // Single scanline temporary buffer.
  GIFRow::iterator rowIter;

  // Initialized during construction and read-only.
  blink::GIFImageDecoder* m_client;
  const GIFFrameContext* m_frameContext;
};

// Data structure for one LZW block.
struct GIFLZWBlock {
  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();

 public:
  GIFLZWBlock(size_t position, size_t size)
      : blockPosition(position), blockSize(size) {}

  size_t blockPosition;
  size_t blockSize;
};

class GIFColorMap final {
  DISALLOW_NEW();

 public:
  typedef Vector<blink::ImageFrame::PixelData> Table;

  GIFColorMap() : m_isDefined(false), m_position(0), m_colors(0) {}

  // Set position and number of colors for the RGB table in the data stream.
  void setTablePositionAndSize(size_t position, size_t colors) {
    m_position = position;
    m_colors = colors;
  }
  void setDefined() { m_isDefined = true; }
  bool isDefined() const { return m_isDefined; }

  // Build RGBA table using the data stream.
  void buildTable(blink::FastSharedBufferReader*);
  const Table& getTable() const { return m_table; }

 private:
  bool m_isDefined;
  size_t m_position;
  size_t m_colors;
  Table m_table;
};

// LocalFrame output state machine.
struct GIFFrameContext {
  USING_FAST_MALLOC(GIFFrameContext);
  WTF_MAKE_NONCOPYABLE(GIFFrameContext);

 public:
  GIFFrameContext(int id)
      : m_frameId(id),
        m_xOffset(0),
        m_yOffset(0),
        m_width(0),
        m_height(0),
        m_transparentPixel(kNotFound),
        m_disposalMethod(blink::ImageFrame::DisposeNotSpecified),
        m_dataSize(0),
        m_progressiveDisplay(false),
        m_interlaced(false),
        m_delayTime(0),
        m_currentLzwBlock(0),
        m_isComplete(false),
        m_isHeaderDefined(false),
        m_isDataSizeDefined(false) {}

  ~GIFFrameContext() {}

  void addLzwBlock(size_t position, size_t size) {
    m_lzwBlocks.append(GIFLZWBlock(position, size));
  }

  bool decode(blink::FastSharedBufferReader*,
              blink::GIFImageDecoder* client,
              bool* frameDecoded);

  int frameId() const { return m_frameId; }
  void setRect(unsigned x, unsigned y, unsigned width, unsigned height) {
    m_xOffset = x;
    m_yOffset = y;
    m_width = width;
    m_height = height;
  }
  blink::IntRect frameRect() const {
    return blink::IntRect(m_xOffset, m_yOffset, m_width, m_height);
  }
  unsigned xOffset() const { return m_xOffset; }
  unsigned yOffset() const { return m_yOffset; }
  unsigned width() const { return m_width; }
  unsigned height() const { return m_height; }
  size_t transparentPixel() const { return m_transparentPixel; }
  void setTransparentPixel(size_t pixel) { m_transparentPixel = pixel; }
  blink::ImageFrame::DisposalMethod getDisposalMethod() const {
    return m_disposalMethod;
  }
  void setDisposalMethod(blink::ImageFrame::DisposalMethod disposalMethod) {
    m_disposalMethod = disposalMethod;
  }
  unsigned delayTime() const { return m_delayTime; }
  void setDelayTime(unsigned delay) { m_delayTime = delay; }
  bool isComplete() const { return m_isComplete; }
  void setComplete() { m_isComplete = true; }
  bool isHeaderDefined() const { return m_isHeaderDefined; }
  void setHeaderDefined() { m_isHeaderDefined = true; }
  bool isDataSizeDefined() const { return m_isDataSizeDefined; }
  int dataSize() const { return m_dataSize; }
  void setDataSize(int size) {
    m_dataSize = size;
    m_isDataSizeDefined = true;
  }
  bool progressiveDisplay() const { return m_progressiveDisplay; }
  void setProgressiveDisplay(bool progressiveDisplay) {
    m_progressiveDisplay = progressiveDisplay;
  }
  bool interlaced() const { return m_interlaced; }
  void setInterlaced(bool interlaced) { m_interlaced = interlaced; }

  void clearDecodeState() { m_lzwContext.reset(); }
  const GIFColorMap& localColorMap() const { return m_localColorMap; }
  GIFColorMap& localColorMap() { return m_localColorMap; }

 private:
  int m_frameId;
  unsigned m_xOffset;
  unsigned m_yOffset;  // With respect to "screen" origin.
  unsigned m_width;
  unsigned m_height;
  size_t m_transparentPixel;  // Index of transparent pixel. Value is kNotFound
                              // if there is no transparent pixel.
  blink::ImageFrame::DisposalMethod
      m_disposalMethod;  // Restore to background, leave in place, etc.
  int m_dataSize;

  bool m_progressiveDisplay;  // If true, do Haeberli interlace hack.
  bool m_interlaced;          // True, if scanlines arrive interlaced order.

  unsigned m_delayTime;  // Display time, in milliseconds, for this image in a
                         // multi-image GIF.

  std::unique_ptr<GIFLZWContext> m_lzwContext;
  Vector<GIFLZWBlock> m_lzwBlocks;  // LZW blocks for this frame.
  GIFColorMap m_localColorMap;

  size_t m_currentLzwBlock;
  bool m_isComplete;
  bool m_isHeaderDefined;
  bool m_isDataSizeDefined;
};

class PLATFORM_EXPORT GIFImageReader final {
  USING_FAST_MALLOC(GIFImageReader);
  WTF_MAKE_NONCOPYABLE(GIFImageReader);

 public:
  GIFImageReader(blink::GIFImageDecoder* client = 0)
      : m_client(client),
        m_state(GIFType),
        m_bytesToConsume(
            6)  // Number of bytes for GIF type, either "GIF87a" or "GIF89a".
        ,
        m_bytesRead(0),
        m_version(0),
        m_screenWidth(0),
        m_screenHeight(0),
        m_sentSizeToClient(false),
        m_loopCount(cLoopCountNotSeen),
        m_parseCompleted(false) {}

  ~GIFImageReader() {}

  void setData(PassRefPtr<blink::SegmentReader> data) { m_data = data; }
  bool parse(blink::GIFImageDecoder::GIFParseQuery);
  bool decode(size_t frameIndex);

  size_t imagesCount() const {
    if (m_frames.isEmpty())
      return 0;

    // This avoids counting an empty frame when the file is truncated right
    // after GIFControlExtension but before GIFImageHeader.
    // FIXME: This extra complexity is not necessary and we should just report
    // m_frames.size().
    return m_frames.last()->isHeaderDefined() ? m_frames.size()
                                              : m_frames.size() - 1;
  }
  int loopCount() const { return m_loopCount; }

  const GIFColorMap& globalColorMap() const { return m_globalColorMap; }

  const GIFFrameContext* frameContext(size_t index) const {
    return index < m_frames.size() ? m_frames[index].get() : 0;
  }

  bool parseCompleted() const { return m_parseCompleted; }

  void clearDecodeState(size_t index) { m_frames[index]->clearDecodeState(); }

 private:
  bool parseData(size_t dataPosition,
                 size_t len,
                 blink::GIFImageDecoder::GIFParseQuery);
  void setRemainingBytes(size_t);

  void addFrameIfNecessary();
  bool currentFrameIsFirstFrame() const {
    return m_frames.isEmpty() ||
           (m_frames.size() == 1u && !m_frames[0]->isComplete());
  }

  blink::GIFImageDecoder* m_client;

  // Parsing state machine.
  GIFState m_state;         // Current decoder master state.
  size_t m_bytesToConsume;  // Number of bytes to consume for next stage of
                            // parsing.
  size_t m_bytesRead;       // Number of bytes processed.

  // Global (multi-image) state.
  int m_version;           // Either 89 for GIF89 or 87 for GIF87.
  unsigned m_screenWidth;  // Logical screen width & height.
  unsigned m_screenHeight;
  bool m_sentSizeToClient;
  GIFColorMap m_globalColorMap;
  int m_loopCount;  // Netscape specific extension block to control the number
                    // of animation loops a GIF renders.

  Vector<std::unique_ptr<GIFFrameContext>> m_frames;

  RefPtr<blink::SegmentReader> m_data;
  bool m_parseCompleted;
};

#endif