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@gmail.com)
13 
14 #ifndef WEBP_DEC_VP8I_H_
15 #define WEBP_DEC_VP8I_H_
16 
17 #include <string.h>     // for memcpy()
18 #include "./vp8li.h"
19 #include "../utils/bit_reader.h"
20 #include "../utils/thread.h"
21 #include "../dsp/dsp.h"
22 
23 #if defined(__cplusplus) || defined(c_plusplus)
24 extern "C" {
25 #endif
26 
27 //------------------------------------------------------------------------------
28 // Various defines and enums
29 
30 // version numbers
31 #define DEC_MAJ_VERSION 0
32 #define DEC_MIN_VERSION 3
33 #define DEC_REV_VERSION 1
34 
35 #define ONLY_KEYFRAME_CODE      // to remove any code related to P-Frames
36 
37 // intra prediction modes
38 enum { B_DC_PRED = 0,   // 4x4 modes
39        B_TM_PRED,
40        B_VE_PRED,
41        B_HE_PRED,
42        B_RD_PRED,
43        B_VR_PRED,
44        B_LD_PRED,
45        B_VL_PRED,
46        B_HD_PRED,
47        B_HU_PRED,
48        NUM_BMODES = B_HU_PRED + 1 - B_DC_PRED,  // = 10
49 
50        // Luma16 or UV modes
51        DC_PRED = B_DC_PRED, V_PRED = B_VE_PRED,
52        H_PRED = B_HE_PRED, TM_PRED = B_TM_PRED,
53        B_PRED = NUM_BMODES,   // refined I4x4 mode
54 
55        // special modes
56        B_DC_PRED_NOTOP = 4,
57        B_DC_PRED_NOLEFT = 5,
58        B_DC_PRED_NOTOPLEFT = 6,
59        NUM_B_DC_MODES = 7 };
60 
61 enum { MB_FEATURE_TREE_PROBS = 3,
62        NUM_MB_SEGMENTS = 4,
63        NUM_REF_LF_DELTAS = 4,
64        NUM_MODE_LF_DELTAS = 4,    // I4x4, ZERO, *, SPLIT
65        MAX_NUM_PARTITIONS = 8,
66        // Probabilities
67        NUM_TYPES = 4,
68        NUM_BANDS = 8,
69        NUM_CTX = 3,
70        NUM_PROBAS = 11,
71        NUM_MV_PROBAS = 19 };
72 
73 // YUV-cache parameters.
74 // Constraints are: We need to store one 16x16 block of luma samples (y),
75 // and two 8x8 chroma blocks (u/v). These are better be 16-bytes aligned,
76 // in order to be SIMD-friendly. We also need to store the top, left and
77 // top-left samples (from previously decoded blocks), along with four
78 // extra top-right samples for luma (intra4x4 prediction only).
79 // One possible layout is, using 32 * (17 + 9) bytes:
80 //
81 //   .+------   <- only 1 pixel high
82 //   .|yyyyt.
83 //   .|yyyyt.
84 //   .|yyyyt.
85 //   .|yyyy..
86 //   .+--.+--   <- only 1 pixel high
87 //   .|uu.|vv
88 //   .|uu.|vv
89 //
90 // Every character is a 4x4 block, with legend:
91 //  '.' = unused
92 //  'y' = y-samples   'u' = u-samples     'v' = u-samples
93 //  '|' = left sample,   '-' = top sample,    '+' = top-left sample
94 //  't' = extra top-right sample for 4x4 modes
95 // With this layout, BPS (=Bytes Per Scan-line) is one cacheline size.
96 #define BPS       32    // this is the common stride used by yuv[]
97 #define YUV_SIZE (BPS * 17 + BPS * 9)
98 #define Y_SIZE   (BPS * 17)
99 #define Y_OFF    (BPS * 1 + 8)
100 #define U_OFF    (Y_OFF + BPS * 16 + BPS)
101 #define V_OFF    (U_OFF + 16)
102 
103 //------------------------------------------------------------------------------
104 // Headers
105 
106 typedef struct {
107   uint8_t key_frame_;
108   uint8_t profile_;
109   uint8_t show_;
110   uint32_t partition_length_;
111 } VP8FrameHeader;
112 
113 typedef struct {
114   uint16_t width_;
115   uint16_t height_;
116   uint8_t xscale_;
117   uint8_t yscale_;
118   uint8_t colorspace_;   // 0 = YCbCr
119   uint8_t clamp_type_;
120 } VP8PictureHeader;
121 
122 // segment features
123 typedef struct {
124   int use_segment_;
125   int update_map_;        // whether to update the segment map or not
126   int absolute_delta_;    // absolute or delta values for quantizer and filter
127   int8_t quantizer_[NUM_MB_SEGMENTS];        // quantization changes
128   int8_t filter_strength_[NUM_MB_SEGMENTS];  // filter strength for segments
129 } VP8SegmentHeader;
130 
131 // Struct collecting all frame-persistent probabilities.
132 typedef struct {
133   uint8_t segments_[MB_FEATURE_TREE_PROBS];
134   // Type: 0:Intra16-AC  1:Intra16-DC   2:Chroma   3:Intra4
135   uint8_t coeffs_[NUM_TYPES][NUM_BANDS][NUM_CTX][NUM_PROBAS];
136 #ifndef ONLY_KEYFRAME_CODE
137   uint8_t ymode_[4], uvmode_[3];
138   uint8_t mv_[2][NUM_MV_PROBAS];
139 #endif
140 } VP8Proba;
141 
142 // Filter parameters
143 typedef struct {
144   int simple_;                  // 0=complex, 1=simple
145   int level_;                   // [0..63]
146   int sharpness_;               // [0..7]
147   int use_lf_delta_;
148   int ref_lf_delta_[NUM_REF_LF_DELTAS];
149   int mode_lf_delta_[NUM_MODE_LF_DELTAS];
150 } VP8FilterHeader;
151 
152 //------------------------------------------------------------------------------
153 // Informations about the macroblocks.
154 
155 typedef struct {  // filter specs
156   unsigned int f_level_:6;      // filter strength: 0..63
157   unsigned int f_ilevel_:6;     // inner limit: 1..63
158   unsigned int f_inner_:1;      // do inner filtering?
159 } VP8FInfo;
160 
161 typedef struct {  // used for syntax-parsing
162   unsigned int nz_:24;       // non-zero AC/DC coeffs (24bit)
163   unsigned int dc_nz_:1;     // non-zero DC coeffs
164   unsigned int skip_:1;      // block type
165 } VP8MB;
166 
167 // Dequantization matrices
168 typedef int quant_t[2];      // [DC / AC].  Can be 'uint16_t[2]' too (~slower).
169 typedef struct {
170   quant_t y1_mat_, y2_mat_, uv_mat_;
171 } VP8QuantMatrix;
172 
173 // Persistent information needed by the parallel processing
174 typedef struct {
175   int id_;            // cache row to process (in [0..2])
176   int mb_y_;          // macroblock position of the row
177   int filter_row_;    // true if row-filtering is needed
178   VP8FInfo* f_info_;  // filter strengths
179   VP8Io io_;          // copy of the VP8Io to pass to put()
180 } VP8ThreadContext;
181 
182 //------------------------------------------------------------------------------
183 // VP8Decoder: the main opaque structure handed over to user
184 
185 struct VP8Decoder {
186   VP8StatusCode status_;
187   int ready_;     // true if ready to decode a picture with VP8Decode()
188   const char* error_msg_;  // set when status_ is not OK.
189 
190   // Main data source
191   VP8BitReader br_;
192 
193   // headers
194   VP8FrameHeader   frm_hdr_;
195   VP8PictureHeader pic_hdr_;
196   VP8FilterHeader  filter_hdr_;
197   VP8SegmentHeader segment_hdr_;
198 
199   // Worker
200   WebPWorker worker_;
201   int use_threads_;    // use multi-thread
202   int cache_id_;       // current cache row
203   int num_caches_;     // number of cached rows of 16 pixels (1, 2 or 3)
204   VP8ThreadContext thread_ctx_;  // Thread context
205 
206   // dimension, in macroblock units.
207   int mb_w_, mb_h_;
208 
209   // Macroblock to process/filter, depending on cropping and filter_type.
210   int tl_mb_x_, tl_mb_y_;  // top-left MB that must be in-loop filtered
211   int br_mb_x_, br_mb_y_;  // last bottom-right MB that must be decoded
212 
213   // number of partitions.
214   int num_parts_;
215   // per-partition boolean decoders.
216   VP8BitReader parts_[MAX_NUM_PARTITIONS];
217 
218   // buffer refresh flags
219   //   bit 0: refresh Gold, bit 1: refresh Alt
220   //   bit 2-3: copy to Gold, bit 4-5: copy to Alt
221   //   bit 6: Gold sign bias, bit 7: Alt sign bias
222   //   bit 8: refresh last frame
223   uint32_t buffer_flags_;
224 
225   // dequantization (one set of DC/AC dequant factor per segment)
226   VP8QuantMatrix dqm_[NUM_MB_SEGMENTS];
227 
228   // probabilities
229   VP8Proba proba_;
230   int use_skip_proba_;
231   uint8_t skip_p_;
232 #ifndef ONLY_KEYFRAME_CODE
233   uint8_t intra_p_, last_p_, golden_p_;
234   VP8Proba proba_saved_;
235   int update_proba_;
236 #endif
237 
238   // Boundary data cache and persistent buffers.
239   uint8_t* intra_t_;     // top intra modes values: 4 * mb_w_
240   uint8_t  intra_l_[4];  // left intra modes values
241   uint8_t* y_t_;         // top luma samples: 16 * mb_w_
242   uint8_t* u_t_, *v_t_;  // top u/v samples: 8 * mb_w_ each
243 
244   VP8MB* mb_info_;       // contextual macroblock info (mb_w_ + 1)
245   VP8FInfo* f_info_;     // filter strength info
246   uint8_t* yuv_b_;       // main block for Y/U/V (size = YUV_SIZE)
247   int16_t* coeffs_;      // 384 coeffs = (16+8+8) * 4*4
248 
249   uint8_t* cache_y_;     // macroblock row for storing unfiltered samples
250   uint8_t* cache_u_;
251   uint8_t* cache_v_;
252   int cache_y_stride_;
253   int cache_uv_stride_;
254 
255   // main memory chunk for the above data. Persistent.
256   void* mem_;
257   size_t mem_size_;
258 
259   // Per macroblock non-persistent infos.
260   int mb_x_, mb_y_;       // current position, in macroblock units
261   uint8_t is_i4x4_;       // true if intra4x4
262   uint8_t imodes_[16];    // one 16x16 mode (#0) or sixteen 4x4 modes
263   uint8_t uvmode_;        // chroma prediction mode
264   uint8_t segment_;       // block's segment
265 
266   // bit-wise info about the content of each sub-4x4 blocks: there are 16 bits
267   // for luma (bits #0->#15), then 4 bits for chroma-u (#16->#19) and 4 bits for
268   // chroma-v (#20->#23), each corresponding to one 4x4 block in decoding order.
269   // If the bit is set, the 4x4 block contains some non-zero coefficients.
270   uint32_t non_zero_;
271   uint32_t non_zero_ac_;
272 
273   // Filtering side-info
274   int filter_type_;                          // 0=off, 1=simple, 2=complex
275   int filter_row_;                           // per-row flag
276   VP8FInfo fstrengths_[NUM_MB_SEGMENTS][2];  // precalculated per-segment/type
277 
278   // extensions
279   const uint8_t* alpha_data_;   // compressed alpha data (if present)
280   size_t alpha_data_size_;
281   int is_alpha_decoded_;  // true if alpha_data_ is decoded in alpha_plane_
282   uint8_t* alpha_plane_;        // output. Persistent, contains the whole data.
283 
284   int layer_colorspace_;
285   const uint8_t* layer_data_;   // compressed layer data (if present)
286   size_t layer_data_size_;
287 };
288 
289 //------------------------------------------------------------------------------
290 // internal functions. Not public.
291 
292 // in vp8.c
293 int VP8SetError(VP8Decoder* const dec,
294                 VP8StatusCode error, const char* const msg);
295 
296 // in tree.c
297 void VP8ResetProba(VP8Proba* const proba);
298 void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec);
299 void VP8ParseIntraMode(VP8BitReader* const br,  VP8Decoder* const dec);
300 
301 // in quant.c
302 void VP8ParseQuant(VP8Decoder* const dec);
303 
304 // in frame.c
305 int VP8InitFrame(VP8Decoder* const dec, VP8Io* io);
306 // Predict a block and add residual
307 void VP8ReconstructBlock(VP8Decoder* const dec);
308 // Call io->setup() and finish setting up scan parameters.
309 // After this call returns, one must always call VP8ExitCritical() with the
310 // same parameters. Both functions should be used in pair. Returns VP8_STATUS_OK
311 // if ok, otherwise sets and returns the error status on *dec.
312 VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io);
313 // Must always be called in pair with VP8EnterCritical().
314 // Returns false in case of error.
315 int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io);
316 // Process the last decoded row (filtering + output)
317 int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io);
318 // To be called at the start of a new scanline, to initialize predictors.
319 void VP8InitScanline(VP8Decoder* const dec);
320 // Decode one macroblock. Returns false if there is not enough data.
321 int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br);
322 
323 // in alpha.c
324 const uint8_t* VP8DecompressAlphaRows(VP8Decoder* const dec,
325                                       int row, int num_rows);
326 
327 // in layer.c
328 int VP8DecodeLayer(VP8Decoder* const dec);
329 
330 //------------------------------------------------------------------------------
331 
332 #if defined(__cplusplus) || defined(c_plusplus)
333 }    // extern "C"
334 #endif
335 
336 #endif  /* WEBP_DEC_VP8I_H_ */
337