third_party/libwebp/dec/vp8li.h

   1 // Copyright 2012 Google Inc. All Rights Reserved.
   2 //
   3 // Use of this source code is governed by a BSD-style license
   4 // that can be found in the COPYING file in the root of the source
   5 // tree. An additional intellectual property rights grant can be found
   6 // in the file PATENTS. All contributing project authors may
   7 // be found in the AUTHORS file in the root of the source tree.
   8 // -----------------------------------------------------------------------------
   9 //
  10 // Lossless decoder: internal header.
  11 //
  12 // Author: Skal (pascal.massimino@gmail.com)
  13 //         Vikas Arora(vikaas.arora@gmail.com)
  14
  15 #ifndef WEBP_DEC_VP8LI_H_
  16 #define WEBP_DEC_VP8LI_H_
  17
  18 #include <string.h>     // for memcpy()
  19 #include "./webpi.h"
  20 #include "../utils/bit_reader.h"
  21 #include "../utils/color_cache.h"
  22 #include "../utils/huffman.h"
  23 #include "../webp/format_constants.h"
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif
  28
  29 typedef enum {
  30   READ_DATA = 0,
  31   READ_HDR = 1,
  32   READ_DIM = 2
  33 } VP8LDecodeState;
  34
  35 typedef struct VP8LTransform VP8LTransform;
  36 struct VP8LTransform {
  37   VP8LImageTransformType type_;   // transform type.
  38   int                    bits_;   // subsampling bits defining transform window.
  39   int                    xsize_;  // transform window X index.
  40   int                    ysize_;  // transform window Y index.
  41   uint32_t              *data_;   // transform data.
  42 };
  43
  44 typedef struct {
  45   HuffmanTree htrees_[HUFFMAN_CODES_PER_META_CODE];
  46 } HTreeGroup;
  47
  48 typedef struct {
  49   int             color_cache_size_;
  50   VP8LColorCache  color_cache_;
  51
  52   int             huffman_mask_;
  53   int             huffman_subsample_bits_;
  54   int             huffman_xsize_;
  55   uint32_t       *huffman_image_;
  56   int             num_htree_groups_;
  57   HTreeGroup     *htree_groups_;
  58 } VP8LMetadata;
  59
  60 typedef struct VP8LDecoder VP8LDecoder;
  61 struct VP8LDecoder {
  62   VP8StatusCode    status_;
  63   VP8LDecodeState  action_;
  64   VP8LDecodeState  state_;
  65   VP8Io           *io_;
  66
  67   const WebPDecBuffer *output_;    // shortcut to io->opaque->output
  68
  69   uint32_t        *pixels_;        // Internal data: either uint8_t* for alpha
  70                                    // or uint32_t* for BGRA.
  71   uint32_t        *argb_cache_;    // Scratch buffer for temporary BGRA storage.
  72
  73   VP8LBitReader    br_;
  74
  75   int              width_;
  76   int              height_;
  77   int              last_row_;      // last input row decoded so far.
  78   int              last_pixel_;    // last pixel decoded so far. However, it may
  79                                    // not be transformed, scaled and
  80                                    // color-converted yet.
  81   int              last_out_row_;  // last row output so far.
  82
  83   VP8LMetadata     hdr_;
  84
  85   int              next_transform_;
  86   VP8LTransform    transforms_[NUM_TRANSFORMS];
  87   // or'd bitset storing the transforms types.
  88   uint32_t         transforms_seen_;
  89
  90   uint8_t         *rescaler_memory;  // Working memory for rescaling work.
  91   WebPRescaler    *rescaler;         // Common rescaler for all channels.
  92 };
  93
  94 //------------------------------------------------------------------------------
  95 // internal functions. Not public.
  96
  97 struct ALPHDecoder;  // Defined in dec/alphai.h.
  98
  99 // in vp8l.c
 100
 101 // Decodes image header for alpha data stored using lossless compression.
 102 // Returns false in case of error.
 103 int VP8LDecodeAlphaHeader(struct ALPHDecoder* const alph_dec,
 104                           const uint8_t* const data, size_t data_size,
 105                           uint8_t* const output);
 106
 107 // Decodes *at least* 'last_row' rows of alpha. If some of the initial rows are
 108 // already decoded in previous call(s), it will resume decoding from where it
 109 // was paused.
 110 // Returns false in case of bitstream error.
 111 int VP8LDecodeAlphaImageStream(struct ALPHDecoder* const alph_dec,
 112                                int last_row);
 113
 114 // Allocates and initialize a new lossless decoder instance.
 115 VP8LDecoder* VP8LNew(void);
 116
 117 // Decodes the image header. Returns false in case of error.
 118 int VP8LDecodeHeader(VP8LDecoder* const dec, VP8Io* const io);
 119
 120 // Decodes an image. It's required to decode the lossless header before calling
 121 // this function. Returns false in case of error, with updated dec->status_.
 122 int VP8LDecodeImage(VP8LDecoder* const dec);
 123
 124 // Resets the decoder in its initial state, reclaiming memory.
 125 // Preserves the dec->status_ value.
 126 void VP8LClear(VP8LDecoder* const dec);
 127
 128 // Clears and deallocate a lossless decoder instance.
 129 void VP8LDelete(VP8LDecoder* const dec);
 130
 131 //------------------------------------------------------------------------------
 132
 133 #ifdef __cplusplus
 134 }    // extern "C"
 135 #endif
 136
 137 #endif  /* WEBP_DEC_VP8LI_H_ */