Home | History | Annotate | Download | only in dec
      1 // Copyright 2010 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 // VP8 decoder: internal header.
     11 //
     12 // Author: Skal (pascal.massimino (at) gmail.com)
     13 
     14 #ifndef WEBP_DEC_VP8I_H_
     15 #define WEBP_DEC_VP8I_H_
     16 
     17 #include <string.h>     // for memcpy()
     18 #include "./common.h"
     19 #include "./vp8li.h"
     20 #include "../utils/bit_reader.h"
     21 #include "../utils/random.h"
     22 #include "../utils/thread.h"
     23 #include "../dsp/dsp.h"
     24 
     25 #ifdef __cplusplus
     26 extern "C" {
     27 #endif
     28 
     29 //------------------------------------------------------------------------------
     30 // Various defines and enums
     31 
     32 // version numbers
     33 #define DEC_MAJ_VERSION 0
     34 #define DEC_MIN_VERSION 5
     35 #define DEC_REV_VERSION 0
     36 
     37 // YUV-cache parameters. Cache is 32-bytes wide (= one cacheline).
     38 // Constraints are: We need to store one 16x16 block of luma samples (y),
     39 // and two 8x8 chroma blocks (u/v). These are better be 16-bytes aligned,
     40 // in order to be SIMD-friendly. We also need to store the top, left and
     41 // top-left samples (from previously decoded blocks), along with four
     42 // extra top-right samples for luma (intra4x4 prediction only).
     43 // One possible layout is, using 32 * (17 + 9) bytes:
     44 //
     45 //   .+------   <- only 1 pixel high
     46 //   .|yyyyt.
     47 //   .|yyyyt.
     48 //   .|yyyyt.
     49 //   .|yyyy..
     50 //   .+--.+--   <- only 1 pixel high
     51 //   .|uu.|vv
     52 //   .|uu.|vv
     53 //
     54 // Every character is a 4x4 block, with legend:
     55 //  '.' = unused
     56 //  'y' = y-samples   'u' = u-samples     'v' = u-samples
     57 //  '|' = left sample,   '-' = top sample,    '+' = top-left sample
     58 //  't' = extra top-right sample for 4x4 modes
     59 #define YUV_SIZE (BPS * 17 + BPS * 9)
     60 #define Y_SIZE   (BPS * 17)
     61 #define Y_OFF    (BPS * 1 + 8)
     62 #define U_OFF    (Y_OFF + BPS * 16 + BPS)
     63 #define V_OFF    (U_OFF + 16)
     64 
     65 // minimal width under which lossy multi-threading is always disabled
     66 #define MIN_WIDTH_FOR_THREADS 512
     67 
     68 //------------------------------------------------------------------------------
     69 // Headers
     70 
     71 typedef struct {
     72   uint8_t key_frame_;
     73   uint8_t profile_;
     74   uint8_t show_;
     75   uint32_t partition_length_;
     76 } VP8FrameHeader;
     77 
     78 typedef struct {
     79   uint16_t width_;
     80   uint16_t height_;
     81   uint8_t xscale_;
     82   uint8_t yscale_;
     83   uint8_t colorspace_;   // 0 = YCbCr
     84   uint8_t clamp_type_;
     85 } VP8PictureHeader;
     86 
     87 // segment features
     88 typedef struct {
     89   int use_segment_;
     90   int update_map_;        // whether to update the segment map or not
     91   int absolute_delta_;    // absolute or delta values for quantizer and filter
     92   int8_t quantizer_[NUM_MB_SEGMENTS];        // quantization changes
     93   int8_t filter_strength_[NUM_MB_SEGMENTS];  // filter strength for segments
     94 } VP8SegmentHeader;
     95 
     96 // probas associated to one of the contexts
     97 typedef uint8_t VP8ProbaArray[NUM_PROBAS];
     98 
     99 typedef struct {   // all the probas associated to one band
    100   VP8ProbaArray probas_[NUM_CTX];
    101 } VP8BandProbas;
    102 
    103 // Struct collecting all frame-persistent probabilities.
    104 typedef struct {
    105   uint8_t segments_[MB_FEATURE_TREE_PROBS];
    106   // Type: 0:Intra16-AC  1:Intra16-DC   2:Chroma   3:Intra4
    107   VP8BandProbas bands_[NUM_TYPES][NUM_BANDS];
    108   const VP8BandProbas* bands_ptr_[NUM_TYPES][16 + 1];
    109 } VP8Proba;
    110 
    111 // Filter parameters
    112 typedef struct {
    113   int simple_;                  // 0=complex, 1=simple
    114   int level_;                   // [0..63]
    115   int sharpness_;               // [0..7]
    116   int use_lf_delta_;
    117   int ref_lf_delta_[NUM_REF_LF_DELTAS];
    118   int mode_lf_delta_[NUM_MODE_LF_DELTAS];
    119 } VP8FilterHeader;
    120 
    121 //------------------------------------------------------------------------------
    122 // Informations about the macroblocks.
    123 
    124 typedef struct {  // filter specs
    125   uint8_t f_limit_;      // filter limit in [3..189], or 0 if no filtering
    126   uint8_t f_ilevel_;     // inner limit in [1..63]
    127   uint8_t f_inner_;      // do inner filtering?
    128   uint8_t hev_thresh_;   // high edge variance threshold in [0..2]
    129 } VP8FInfo;
    130 
    131 typedef struct {  // Top/Left Contexts used for syntax-parsing
    132   uint8_t nz_;        // non-zero AC/DC coeffs (4bit for luma + 4bit for chroma)
    133   uint8_t nz_dc_;     // non-zero DC coeff (1bit)
    134 } VP8MB;
    135 
    136 // Dequantization matrices
    137 typedef int quant_t[2];      // [DC / AC].  Can be 'uint16_t[2]' too (~slower).
    138 typedef struct {
    139   quant_t y1_mat_, y2_mat_, uv_mat_;
    140 
    141   int uv_quant_;   // U/V quantizer value
    142   int dither_;     // dithering amplitude (0 = off, max=255)
    143 } VP8QuantMatrix;
    144 
    145 // Data needed to reconstruct a macroblock
    146 typedef struct {
    147   int16_t coeffs_[384];   // 384 coeffs = (16+4+4) * 4*4
    148   uint8_t is_i4x4_;       // true if intra4x4
    149   uint8_t imodes_[16];    // one 16x16 mode (#0) or sixteen 4x4 modes
    150   uint8_t uvmode_;        // chroma prediction mode
    151   // bit-wise info about the content of each sub-4x4 blocks (in decoding order).
    152   // Each of the 4x4 blocks for y/u/v is associated with a 2b code according to:
    153   //   code=0 -> no coefficient
    154   //   code=1 -> only DC
    155   //   code=2 -> first three coefficients are non-zero
    156   //   code=3 -> more than three coefficients are non-zero
    157   // This allows to call specialized transform functions.
    158   uint32_t non_zero_y_;
    159   uint32_t non_zero_uv_;
    160   uint8_t dither_;      // local dithering strength (deduced from non_zero_*)
    161   uint8_t skip_;
    162   uint8_t segment_;
    163 } VP8MBData;
    164 
    165 // Persistent information needed by the parallel processing
    166 typedef struct {
    167   int id_;              // cache row to process (in [0..2])
    168   int mb_y_;            // macroblock position of the row
    169   int filter_row_;      // true if row-filtering is needed
    170   VP8FInfo* f_info_;    // filter strengths (swapped with dec->f_info_)
    171   VP8MBData* mb_data_;  // reconstruction data (swapped with dec->mb_data_)
    172   VP8Io io_;            // copy of the VP8Io to pass to put()
    173 } VP8ThreadContext;
    174 
    175 // Saved top samples, per macroblock. Fits into a cache-line.
    176 typedef struct {
    177   uint8_t y[16], u[8], v[8];
    178 } VP8TopSamples;
    179 
    180 //------------------------------------------------------------------------------
    181 // VP8Decoder: the main opaque structure handed over to user
    182 
    183 struct VP8Decoder {
    184   VP8StatusCode status_;
    185   int ready_;     // true if ready to decode a picture with VP8Decode()
    186   const char* error_msg_;  // set when status_ is not OK.
    187 
    188   // Main data source
    189   VP8BitReader br_;
    190 
    191   // headers
    192   VP8FrameHeader   frm_hdr_;
    193   VP8PictureHeader pic_hdr_;
    194   VP8FilterHeader  filter_hdr_;
    195   VP8SegmentHeader segment_hdr_;
    196 
    197   // Worker
    198   WebPWorker worker_;
    199   int mt_method_;      // multi-thread method: 0=off, 1=[parse+recon][filter]
    200                        // 2=[parse][recon+filter]
    201   int cache_id_;       // current cache row
    202   int num_caches_;     // number of cached rows of 16 pixels (1, 2 or 3)
    203   VP8ThreadContext thread_ctx_;  // Thread context
    204 
    205   // dimension, in macroblock units.
    206   int mb_w_, mb_h_;
    207 
    208   // Macroblock to process/filter, depending on cropping and filter_type.
    209   int tl_mb_x_, tl_mb_y_;  // top-left MB that must be in-loop filtered
    210   int br_mb_x_, br_mb_y_;  // last bottom-right MB that must be decoded
    211 
    212   // number of partitions.
    213   int num_parts_;
    214   // per-partition boolean decoders.
    215   VP8BitReader parts_[MAX_NUM_PARTITIONS];
    216 
    217   // Dithering strength, deduced from decoding options
    218   int dither_;                // whether to use dithering or not
    219   VP8Random dithering_rg_;    // random generator for dithering
    220 
    221   // dequantization (one set of DC/AC dequant factor per segment)
    222   VP8QuantMatrix dqm_[NUM_MB_SEGMENTS];
    223 
    224   // probabilities
    225   VP8Proba proba_;
    226   int use_skip_proba_;
    227   uint8_t skip_p_;
    228 
    229   // Boundary data cache and persistent buffers.
    230   uint8_t* intra_t_;      // top intra modes values: 4 * mb_w_
    231   uint8_t  intra_l_[4];   // left intra modes values
    232 
    233   VP8TopSamples* yuv_t_;  // top y/u/v samples
    234 
    235   VP8MB* mb_info_;        // contextual macroblock info (mb_w_ + 1)
    236   VP8FInfo* f_info_;      // filter strength info
    237   uint8_t* yuv_b_;        // main block for Y/U/V (size = YUV_SIZE)
    238 
    239   uint8_t* cache_y_;      // macroblock row for storing unfiltered samples
    240   uint8_t* cache_u_;
    241   uint8_t* cache_v_;
    242   int cache_y_stride_;
    243   int cache_uv_stride_;
    244 
    245   // main memory chunk for the above data. Persistent.
    246   void* mem_;
    247   size_t mem_size_;
    248 
    249   // Per macroblock non-persistent infos.
    250   int mb_x_, mb_y_;       // current position, in macroblock units
    251   VP8MBData* mb_data_;    // parsed reconstruction data
    252 
    253   // Filtering side-info
    254   int filter_type_;                          // 0=off, 1=simple, 2=complex
    255   VP8FInfo fstrengths_[NUM_MB_SEGMENTS][2];  // precalculated per-segment/type
    256 
    257   // Alpha
    258   struct ALPHDecoder* alph_dec_;  // alpha-plane decoder object
    259   const uint8_t* alpha_data_;     // compressed alpha data (if present)
    260   size_t alpha_data_size_;
    261   int is_alpha_decoded_;  // true if alpha_data_ is decoded in alpha_plane_
    262   uint8_t* alpha_plane_;  // output. Persistent, contains the whole data.
    263   int alpha_dithering_;   // derived from decoding options (0=off, 100=full).
    264 };
    265 
    266 //------------------------------------------------------------------------------
    267 // internal functions. Not public.
    268 
    269 // in vp8.c
    270 int VP8SetError(VP8Decoder* const dec,
    271                 VP8StatusCode error, const char* const msg);
    272 
    273 // in tree.c
    274 void VP8ResetProba(VP8Proba* const proba);
    275 void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec);
    276 // parses one row of intra mode data in partition 0, returns !eof
    277 int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec);
    278 
    279 // in quant.c
    280 void VP8ParseQuant(VP8Decoder* const dec);
    281 
    282 // in frame.c
    283 int VP8InitFrame(VP8Decoder* const dec, VP8Io* const io);
    284 // Call io->setup() and finish setting up scan parameters.
    285 // After this call returns, one must always call VP8ExitCritical() with the
    286 // same parameters. Both functions should be used in pair. Returns VP8_STATUS_OK
    287 // if ok, otherwise sets and returns the error status on *dec.
    288 VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io);
    289 // Must always be called in pair with VP8EnterCritical().
    290 // Returns false in case of error.
    291 int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io);
    292 // Return the multi-threading method to use (0=off), depending
    293 // on options and bitstream size. Only for lossy decoding.
    294 int VP8GetThreadMethod(const WebPDecoderOptions* const options,
    295                        const WebPHeaderStructure* const headers,
    296                        int width, int height);
    297 // Initialize dithering post-process if needed.
    298 void VP8InitDithering(const WebPDecoderOptions* const options,
    299                       VP8Decoder* const dec);
    300 // Process the last decoded row (filtering + output).
    301 int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io);
    302 // To be called at the start of a new scanline, to initialize predictors.
    303 void VP8InitScanline(VP8Decoder* const dec);
    304 // Decode one macroblock. Returns false if there is not enough data.
    305 int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br);
    306 
    307 // in alpha.c
    308 const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
    309                                       int row, int num_rows);
    310 
    311 //------------------------------------------------------------------------------
    312 
    313 #ifdef __cplusplus
    314 }    // extern "C"
    315 #endif
    316 
    317 #endif  /* WEBP_DEC_VP8I_H_ */
    318