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
26extern "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
70typedef struct {
71 uint8_t key_frame_;
72 uint8_t profile_;
73 uint8_t show_;
74 uint32_t partition_length_;
75} VP8FrameHeader;
76
77typedef 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} VP8PictureHeader;
85
86// segment features
87typedef 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} VP8SegmentHeader;
94
95// probas associated to one of the contexts
96typedef uint8_t VP8ProbaArray[NUM_PROBAS];
97
98typedef struct { // all the probas associated to one band
99 VP8ProbaArray probas_[NUM_CTX];
100} VP8BandProbas;
101
102// Struct collecting all frame-persistent probabilities.
103typedef 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
111typedef 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} VP8FilterHeader;
119
120//------------------------------------------------------------------------------
121// Informations about the macroblocks.
122
123typedef 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
130typedef 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
136typedef int quant_t[2]; // [DC / AC]. Can be 'uint16_t[2]' too (~slower).
137typedef 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
145typedef 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
165typedef 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.
175typedef 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
182struct 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
271int VP8SetError(VP8Decoder* const dec,
272 VP8StatusCode error, const char* const msg);
273
274// in tree.c
275void VP8ResetProba(VP8Proba* const proba);
276void VP8ParseProba(VP8BitReader* const br, VP8Decoder* const dec);
277// parses one row of intra mode data in partition 0, returns !eof
278int VP8ParseIntraModeRow(VP8BitReader* const br, VP8Decoder* const dec);
279
280// in quant.c
281void VP8ParseQuant(VP8Decoder* const dec);
282
283// in frame.c
284int 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.
289VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io);
290// Must always be called in pair with VP8EnterCritical().
291// Returns false in case of error.
292int 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.
295int VP8GetThreadMethod(const WebPDecoderOptions* const options,
296 const WebPHeaderStructure* const headers,
297 int width, int height);
298// Initialize dithering post-process if needed.
299void VP8InitDithering(const WebPDecoderOptions* const options,
300 VP8Decoder* const dec);
301// Process the last decoded row (filtering + output).
302int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io);
303// To be called at the start of a new scanline, to initialize predictors.
304void VP8InitScanline(VP8Decoder* const dec);
305// Decode one macroblock. Returns false if there is not enough data.
306int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br);
307
308// in alpha.c
309const 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