Home | History | Annotate | Download | only in gif 
      1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* ***** BEGIN LICENSE BLOCK *****
      3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
      4  *
      5  * The contents of this file are subject to the Mozilla Public License Version
      6  * 1.1 (the "License"); you may not use this file except in compliance with
      7  * the License. You may obtain a copy of the License at
      8  * http://www.mozilla.org/MPL/
      9  *
     10  * Software distributed under the License is distributed on an "AS IS" basis,
     11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
     12  * for the specific language governing rights and limitations under the
     13  * License.
     14  *
     15  * The Original Code is Mozilla Communicator client code.
     16  *
     17  * The Initial Developer of the Original Code is
     18  * Netscape Communications Corporation.
     19  * Portions created by the Initial Developer are Copyright (C) 1998
     20  * the Initial Developer. All Rights Reserved.
     21  *
     22  * Contributor(s):
     23  *
     24  * Alternatively, the contents of this file may be used under the terms of
     25  * either the GNU General Public License Version 2 or later (the "GPL"), or
     26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
     27  * in which case the provisions of the GPL or the LGPL are applicable instead
     28  * of those above. If you wish to allow use of your version of this file only
     29  * under the terms of either the GPL or the LGPL, and not to allow others to
     30  * use your version of this file under the terms of the MPL, indicate your
     31  * decision by deleting the provisions above and replace them with the notice
     32  * and other provisions required by the GPL or the LGPL. If you do not delete
     33  * the provisions above, a recipient may use your version of this file under
     34  * the terms of any one of the MPL, the GPL or the LGPL.
     35  *
     36  * ***** END LICENSE BLOCK ***** */
     37 
     38 #ifndef SkGifImageReader_h
     39 #define SkGifImageReader_h
     40 
     41 // Define ourselves as the clientPtr.  Mozilla just hacked their C++ callback class into this old C decoder,
     42 // so we will too.
     43 class SkGifCodec;
     44 
     45 #include "SkCodec.h"
     46 #include "SkCodecPriv.h"
     47 #include "SkCodecAnimation.h"
     48 #include "SkColorTable.h"
     49 #include "SkData.h"
     50 #include "SkFrameHolder.h"
     51 #include "SkImageInfo.h"
     52 #include "SkStreamBuffer.h"
     53 #include "../private/SkTArray.h"
     54 #include <memory>
     55 #include <vector>
     56 
     57 typedef SkTArray<unsigned char, true> SkGIFRow;
     58 
     59 
     60 #define SK_MAX_DICTIONARY_ENTRY_BITS 12
     61 #define SK_MAX_DICTIONARY_ENTRIES    4096 // 2^SK_MAX_DICTIONARY_ENTRY_BITS
     62 #define SK_MAX_COLORS                256
     63 #define SK_BYTES_PER_COLORMAP_ENTRY  3
     64 
     65 // List of possible parsing states.
     66 enum SkGIFState {
     67     SkGIFType,
     68     SkGIFGlobalHeader,
     69     SkGIFGlobalColormap,
     70     SkGIFImageStart,
     71     SkGIFImageHeader,
     72     SkGIFImageColormap,
     73     SkGIFImageBody,
     74     SkGIFLZWStart,
     75     SkGIFLZW,
     76     SkGIFSubBlock,
     77     SkGIFExtension,
     78     SkGIFControlExtension,
     79     SkGIFConsumeBlock,
     80     SkGIFSkipBlock,
     81     SkGIFDone,
     82     SkGIFCommentExtension,
     83     SkGIFApplicationExtension,
     84     SkGIFNetscapeExtensionBlock,
     85     SkGIFConsumeNetscapeExtension,
     86     SkGIFConsumeComment
     87 };
     88 
     89 class SkGIFFrameContext;
     90 class SkGIFColorMap;
     91 
     92 // LZW decoder state machine.
     93 class SkGIFLZWContext final : public SkNoncopyable {
     94 public:
     95     SkGIFLZWContext(SkGifCodec* client, const SkGIFFrameContext* frameContext)
     96         : codesize(0)
     97         , codemask(0)
     98         , clearCode(0)
     99         , avail(0)
    100         , oldcode(0)
    101         , firstchar(0)
    102         , bits(0)
    103         , datum(0)
    104         , ipass(0)
    105         , irow(0)
    106         , rowsRemaining(0)
    107         , rowIter(0)
    108         , m_client(client)
    109         , m_frameContext(frameContext)
    110     { }
    111 
    112     bool prepareToDecode();
    113     bool outputRow(const unsigned char* rowBegin);
    114     bool doLZW(const unsigned char* block, size_t bytesInBlock);
    115     bool hasRemainingRows() { return SkToBool(rowsRemaining); }
    116 
    117 private:
    118     // LZW decoding states and output states.
    119     int codesize;
    120     int codemask;
    121     int clearCode; // Codeword used to trigger dictionary reset.
    122     int avail; // Index of next available slot in dictionary.
    123     int oldcode;
    124     unsigned char firstchar;
    125     int bits; // Number of unread bits in "datum".
    126     int datum; // 32-bit input buffer.
    127     int ipass; // Interlace pass; Ranges 1-4 if interlaced.
    128     size_t irow; // Current output row, starting at zero.
    129     size_t rowsRemaining; // Rows remaining to be output.
    130 
    131     unsigned short prefix[SK_MAX_DICTIONARY_ENTRIES];
    132     unsigned char suffix[SK_MAX_DICTIONARY_ENTRIES];
    133     unsigned short suffixLength[SK_MAX_DICTIONARY_ENTRIES];
    134     SkGIFRow rowBuffer; // Single scanline temporary buffer.
    135     unsigned char* rowIter;
    136 
    137     SkGifCodec* const m_client;
    138     const SkGIFFrameContext* m_frameContext;
    139 };
    140 
    141 struct SkGIFLZWBlock {
    142  public:
    143   SkGIFLZWBlock(size_t position, size_t size)
    144       : blockPosition(position), blockSize(size) {}
    145 
    146   size_t blockPosition;
    147   size_t blockSize;
    148 };
    149 
    150 class SkGIFColorMap final {
    151 public:
    152     static constexpr int kNotFound = -1;
    153 
    154     SkGIFColorMap()
    155         : m_isDefined(false)
    156         , m_position(0)
    157         , m_colors(0)
    158         , m_transPixel(kNotFound)
    159         , m_packColorProc(nullptr)
    160     {
    161     }
    162 
    163     void setNumColors(int colors) {
    164         SkASSERT(!m_colors);
    165         SkASSERT(!m_position);
    166 
    167         m_colors = colors;
    168     }
    169 
    170     void setTablePosition(size_t position) {
    171         SkASSERT(!m_isDefined);
    172 
    173         m_position = position;
    174         m_isDefined = true;
    175     }
    176 
    177     int numColors() const { return m_colors; }
    178 
    179     bool isDefined() const { return m_isDefined; }
    180 
    181     // Build RGBA table using the data stream.
    182     sk_sp<SkColorTable> buildTable(SkStreamBuffer*, SkColorType dstColorType,
    183                                    int transparentPixel) const;
    184 
    185 private:
    186     bool m_isDefined;
    187     size_t m_position;
    188     int m_colors;
    189     // Cached values. If these match on a new request, we can reuse m_table.
    190     mutable int m_transPixel;
    191     mutable PackColorProc m_packColorProc;
    192     mutable sk_sp<SkColorTable> m_table;
    193 };
    194 
    195 class SkGifImageReader;
    196 
    197 // LocalFrame output state machine.
    198 class SkGIFFrameContext : public SkFrame {
    199 public:
    200     SkGIFFrameContext(SkGifImageReader* reader, int id)
    201         : INHERITED(id)
    202         , m_owner(reader)
    203         , m_transparentPixel(SkGIFColorMap::kNotFound)
    204         , m_dataSize(0)
    205         , m_progressiveDisplay(false)
    206         , m_interlaced(false)
    207         , m_delayTime(0)
    208         , m_currentLzwBlock(0)
    209         , m_isComplete(false)
    210         , m_isHeaderDefined(false)
    211         , m_isDataSizeDefined(false)
    212     {
    213     }
    214 
    215     ~SkGIFFrameContext() override
    216     {
    217     }
    218 
    219     void addLzwBlock(size_t position, size_t size)
    220     {
    221         m_lzwBlocks.push_back(SkGIFLZWBlock(position, size));
    222     }
    223 
    224     bool decode(SkStreamBuffer*, SkGifCodec* client, bool* frameDecoded);
    225 
    226     int transparentPixel() const { return m_transparentPixel; }
    227     void setTransparentPixel(int pixel) { m_transparentPixel = pixel; }
    228 
    229     unsigned delayTime() const { return m_delayTime; }
    230     void setDelayTime(unsigned delay) { m_delayTime = delay; }
    231     bool isComplete() const { return m_isComplete; }
    232     void setComplete() { m_isComplete = true; }
    233     bool isHeaderDefined() const { return m_isHeaderDefined; }
    234     void setHeaderDefined() { m_isHeaderDefined = true; }
    235     bool isDataSizeDefined() const { return m_isDataSizeDefined; }
    236     int dataSize() const { return m_dataSize; }
    237     void setDataSize(int size)
    238     {
    239         m_dataSize = size;
    240         m_isDataSizeDefined = true;
    241     }
    242     bool progressiveDisplay() const { return m_progressiveDisplay; }
    243     void setProgressiveDisplay(bool progressiveDisplay) { m_progressiveDisplay = progressiveDisplay; }
    244     bool interlaced() const { return m_interlaced; }
    245     void setInterlaced(bool interlaced) { m_interlaced = interlaced; }
    246 
    247     void clearDecodeState() { m_lzwContext.reset(); }
    248     const SkGIFColorMap& localColorMap() const { return m_localColorMap; }
    249     SkGIFColorMap& localColorMap() { return m_localColorMap; }
    250 
    251 protected:
    252     bool onReportsAlpha() const override;
    253 
    254 private:
    255     // Unowned pointer to the object that owns this frame.
    256     const SkGifImageReader* m_owner;
    257 
    258     int m_transparentPixel; // Index of transparent pixel. Value is kNotFound if there is no transparent pixel.
    259     int m_dataSize;
    260 
    261     bool m_progressiveDisplay; // If true, do Haeberli interlace hack.
    262     bool m_interlaced; // True, if scanlines arrive interlaced order.
    263 
    264     unsigned m_delayTime; // Display time, in milliseconds, for this image in a multi-image GIF.
    265 
    266     std::unique_ptr<SkGIFLZWContext> m_lzwContext;
    267     // LZW blocks for this frame.
    268     std::vector<SkGIFLZWBlock> m_lzwBlocks;
    269 
    270     SkGIFColorMap m_localColorMap;
    271 
    272     int m_currentLzwBlock;
    273     bool m_isComplete;
    274     bool m_isHeaderDefined;
    275     bool m_isDataSizeDefined;
    276 
    277     typedef SkFrame INHERITED;
    278 };
    279 
    280 class SkGifImageReader final : public SkFrameHolder {
    281 public:
    282     // This takes ownership of stream.
    283     SkGifImageReader(SkStream* stream)
    284         : m_client(nullptr)
    285         , m_state(SkGIFType)
    286         , m_bytesToConsume(6) // Number of bytes for GIF type, either "GIF87a" or "GIF89a".
    287         , m_version(0)
    288         , m_loopCount(cLoopCountNotSeen)
    289         , m_streamBuffer(stream)
    290         , m_parseCompleted(false)
    291         , m_firstFrameHasAlpha(false)
    292     {
    293     }
    294 
    295     ~SkGifImageReader() override
    296     {
    297     }
    298 
    299     void setClient(SkGifCodec* client) { m_client = client; }
    300 
    301     // Option to pass to parse(). All enums are negative, because a non-negative value is used to
    302     // indicate that the Reader should parse up to and including the frame indicated.
    303     enum SkGIFParseQuery {
    304         // Parse enough to determine the size. Note that this parses the first frame's header,
    305         // since we may decide to expand based on the frame's dimensions.
    306         SkGIFSizeQuery        = -1,
    307         // Parse to the end, so we know about all frames.
    308         SkGIFFrameCountQuery  = -2,
    309         // Parse until we see the loop count.
    310         SkGIFLoopCountQuery   = -3,
    311     };
    312 
    313     // Parse incoming GIF data stream into internal data structures.
    314     // Non-negative values are used to indicate to parse through that frame.
    315     SkCodec::Result parse(SkGIFParseQuery);
    316 
    317     // Decode the frame indicated by frameIndex.
    318     // frameComplete will be set to true if the frame is completely decoded.
    319     // The method returns false if there is an error.
    320     bool decode(int frameIndex, bool* frameComplete);
    321 
    322     int imagesCount() const
    323     {
    324         const size_t frames = m_frames.size();
    325         if (!frames) {
    326             return 0;
    327         }
    328 
    329         // This avoids counting an empty frame when the file is truncated (or
    330         // simply not yet complete) after receiving SkGIFControlExtension (and
    331         // possibly SkGIFImageHeader) but before reading the color table. This
    332         // ensures that we do not count a frame before we know its required
    333         // frame.
    334         return static_cast<int>(m_frames.back()->reachedStartOfData() ? frames : frames - 1);
    335     }
    336     int loopCount() const {
    337         if (cLoopCountNotSeen == m_loopCount) {
    338             return 0;
    339         }
    340         return m_loopCount;
    341     }
    342 
    343     const SkGIFColorMap& globalColorMap() const
    344     {
    345         return m_globalColorMap;
    346     }
    347 
    348     const SkGIFFrameContext* frameContext(int index) const
    349     {
    350         return index >= 0 && index < static_cast<int>(m_frames.size())
    351                 ? m_frames[index].get() : 0;
    352     }
    353 
    354     void clearDecodeState() {
    355         for (size_t index = 0; index < m_frames.size(); index++) {
    356             m_frames[index]->clearDecodeState();
    357         }
    358     }
    359 
    360     // Return the color table for frame index (which may be the global color table).
    361     sk_sp<SkColorTable> getColorTable(SkColorType dstColorType, int index);
    362 
    363     bool firstFrameHasAlpha() const { return m_firstFrameHasAlpha; }
    364 
    365     // Helper function that returns whether an SkGIFFrameContext has transparency.
    366     // This method is sometimes called before creating one/parsing its color map,
    367     // so it cannot rely on SkGIFFrameContext::transparentPixel or ::localColorMap().
    368     bool hasTransparency(int transPix, bool hasLocalColorMap, int localMapColors) const;
    369 
    370 protected:
    371     const SkFrame* onGetFrame(int i) const override {
    372         return static_cast<const SkFrame*>(this->frameContext(i));
    373     }
    374 
    375 private:
    376     // Requires that one byte has been buffered into m_streamBuffer.
    377     unsigned char getOneByte() const {
    378         return reinterpret_cast<const unsigned char*>(m_streamBuffer.get())[0];
    379     }
    380 
    381     void addFrameIfNecessary();
    382     bool currentFrameIsFirstFrame() const
    383     {
    384         return m_frames.empty() || (m_frames.size() == 1u && !m_frames[0]->isComplete());
    385     }
    386 
    387     // Unowned pointer
    388     SkGifCodec* m_client;
    389 
    390     // Parsing state machine.
    391     SkGIFState m_state; // Current decoder master state.
    392     size_t m_bytesToConsume; // Number of bytes to consume for next stage of parsing.
    393 
    394     // Global (multi-image) state.
    395     int m_version; // Either 89 for GIF89 or 87 for GIF87.
    396     SkGIFColorMap m_globalColorMap;
    397 
    398     static constexpr int cLoopCountNotSeen = -2;
    399     int m_loopCount; // Netscape specific extension block to control the number of animation loops a GIF renders.
    400 
    401     std::vector<std::unique_ptr<SkGIFFrameContext>> m_frames;
    402 
    403     SkStreamBuffer m_streamBuffer;
    404     bool m_parseCompleted;
    405 
    406     // This value can be computed before we create a SkGIFFrameContext, so we
    407     // store it here instead of on m_frames[0].
    408     bool m_firstFrameHasAlpha;
    409 };
    410 
    411 #endif
    412