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