Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * VP8 compatible video decoder | |
3 | * | |
4 | * Copyright (C) 2010 David Conrad | |
5 | * Copyright (C) 2010 Ronald S. Bultje | |
6 | * Copyright (C) 2010 Fiona Glaser | |
7 | * Copyright (C) 2012 Daniel Kang | |
8 | * | |
9 | * This file is part of FFmpeg. | |
10 | * | |
11 | * FFmpeg is free software; you can redistribute it and/or | |
12 | * modify it under the terms of the GNU Lesser General Public | |
13 | * License as published by the Free Software Foundation; either | |
14 | * version 2.1 of the License, or (at your option) any later version. | |
15 | * | |
16 | * FFmpeg is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
19 | * Lesser General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU Lesser General Public | |
22 | * License along with FFmpeg; if not, write to the Free Software | |
23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
24 | */ | |
25 | ||
26 | #ifndef AVCODEC_VP8_H | |
27 | #define AVCODEC_VP8_H | |
28 | ||
29 | #include "libavutil/buffer.h" | |
30 | ||
31 | #include "h264pred.h" | |
32 | #include "thread.h" | |
33 | #include "vp56.h" | |
34 | #include "vp8dsp.h" | |
35 | ||
36 | #if HAVE_PTHREADS | |
37 | # include <pthread.h> | |
38 | #elif HAVE_OS2THREADS | |
39 | # include "compat/os2threads.h" | |
40 | #elif HAVE_W32THREADS | |
41 | # include "compat/w32pthreads.h" | |
42 | #endif | |
43 | ||
44 | #define VP8_MAX_QUANT 127 | |
45 | ||
46 | enum dct_token { | |
47 | DCT_0, | |
48 | DCT_1, | |
49 | DCT_2, | |
50 | DCT_3, | |
51 | DCT_4, | |
52 | DCT_CAT1, | |
53 | DCT_CAT2, | |
54 | DCT_CAT3, | |
55 | DCT_CAT4, | |
56 | DCT_CAT5, | |
57 | DCT_CAT6, | |
58 | DCT_EOB, | |
59 | ||
60 | NUM_DCT_TOKENS | |
61 | }; | |
62 | ||
63 | // used to signal 4x4 intra pred in luma MBs | |
64 | #define MODE_I4x4 4 | |
65 | ||
66 | enum inter_mvmode { | |
67 | VP8_MVMODE_ZERO = MODE_I4x4 + 1, | |
68 | VP8_MVMODE_MV, | |
69 | VP8_MVMODE_SPLIT | |
70 | }; | |
71 | ||
72 | enum inter_splitmvmode { | |
73 | VP8_SPLITMVMODE_16x8 = 0, ///< 2 16x8 blocks (vertical) | |
74 | VP8_SPLITMVMODE_8x16, ///< 2 8x16 blocks (horizontal) | |
75 | VP8_SPLITMVMODE_8x8, ///< 2x2 blocks of 8x8px each | |
76 | VP8_SPLITMVMODE_4x4, ///< 4x4 blocks of 4x4px each | |
77 | VP8_SPLITMVMODE_NONE, ///< (only used in prediction) no split MVs | |
78 | }; | |
79 | ||
80 | typedef struct VP8FilterStrength { | |
81 | uint8_t filter_level; | |
82 | uint8_t inner_limit; | |
83 | uint8_t inner_filter; | |
84 | } VP8FilterStrength; | |
85 | ||
86 | typedef struct VP8Macroblock { | |
87 | uint8_t skip; | |
88 | // TODO: make it possible to check for at least (i4x4 or split_mv) | |
89 | // in one op. are others needed? | |
90 | uint8_t mode; | |
91 | uint8_t ref_frame; | |
92 | uint8_t partitioning; | |
93 | uint8_t chroma_pred_mode; | |
94 | uint8_t segment; | |
95 | uint8_t intra4x4_pred_mode_mb[16]; | |
96 | DECLARE_ALIGNED(4, uint8_t, intra4x4_pred_mode_top)[4]; | |
97 | VP56mv mv; | |
98 | VP56mv bmv[16]; | |
99 | } VP8Macroblock; | |
100 | ||
101 | typedef struct VP8ThreadData { | |
102 | DECLARE_ALIGNED(16, int16_t, block)[6][4][16]; | |
103 | DECLARE_ALIGNED(16, int16_t, block_dc)[16]; | |
104 | /** | |
105 | * This is the index plus one of the last non-zero coeff | |
106 | * for each of the blocks in the current macroblock. | |
107 | * So, 0 -> no coeffs | |
108 | * 1 -> dc-only (special transform) | |
109 | * 2+-> full transform | |
110 | */ | |
111 | DECLARE_ALIGNED(16, uint8_t, non_zero_count_cache)[6][4]; | |
112 | /** | |
113 | * For coeff decode, we need to know whether the above block had non-zero | |
114 | * coefficients. This means for each macroblock, we need data for 4 luma | |
115 | * blocks, 2 u blocks, 2 v blocks, and the luma dc block, for a total of 9 | |
116 | * per macroblock. We keep the last row in top_nnz. | |
117 | */ | |
118 | DECLARE_ALIGNED(8, uint8_t, left_nnz)[9]; | |
119 | int thread_nr; | |
120 | #if HAVE_THREADS | |
121 | pthread_mutex_t lock; | |
122 | pthread_cond_t cond; | |
123 | #endif | |
124 | int thread_mb_pos; // (mb_y << 16) | (mb_x & 0xFFFF) | |
125 | int wait_mb_pos; // What the current thread is waiting on. | |
126 | ||
127 | #define EDGE_EMU_LINESIZE 32 | |
128 | DECLARE_ALIGNED(16, uint8_t, edge_emu_buffer)[21 * EDGE_EMU_LINESIZE]; | |
129 | VP8FilterStrength *filter_strength; | |
130 | } VP8ThreadData; | |
131 | ||
132 | typedef struct VP8Frame { | |
133 | ThreadFrame tf; | |
134 | AVBufferRef *seg_map; | |
135 | } VP8Frame; | |
136 | ||
137 | #define MAX_THREADS 8 | |
138 | typedef struct VP8Context { | |
139 | VP8ThreadData *thread_data; | |
140 | AVCodecContext *avctx; | |
141 | VP8Frame *framep[4]; | |
142 | VP8Frame *next_framep[4]; | |
143 | VP8Frame *curframe; | |
144 | VP8Frame *prev_frame; | |
145 | ||
146 | uint16_t mb_width; /* number of horizontal MB */ | |
147 | uint16_t mb_height; /* number of vertical MB */ | |
148 | int linesize; | |
149 | int uvlinesize; | |
150 | ||
151 | uint8_t keyframe; | |
152 | uint8_t deblock_filter; | |
153 | uint8_t mbskip_enabled; | |
154 | uint8_t profile; | |
155 | VP56mv mv_min; | |
156 | VP56mv mv_max; | |
157 | ||
158 | int8_t sign_bias[4]; ///< one state [0, 1] per ref frame type | |
159 | int ref_count[3]; | |
160 | ||
161 | /** | |
162 | * Base parameters for segmentation, i.e. per-macroblock parameters. | |
163 | * These must be kept unchanged even if segmentation is not used for | |
164 | * a frame, since the values persist between interframes. | |
165 | */ | |
166 | struct { | |
167 | uint8_t enabled; | |
168 | uint8_t absolute_vals; | |
169 | uint8_t update_map; | |
170 | int8_t base_quant[4]; | |
171 | int8_t filter_level[4]; ///< base loop filter level | |
172 | } segmentation; | |
173 | ||
174 | struct { | |
175 | uint8_t simple; | |
176 | uint8_t level; | |
177 | uint8_t sharpness; | |
178 | } filter; | |
179 | ||
180 | VP8Macroblock *macroblocks; | |
181 | ||
182 | uint8_t *intra4x4_pred_mode_top; | |
183 | uint8_t intra4x4_pred_mode_left[4]; | |
184 | ||
185 | /** | |
186 | * Macroblocks can have one of 4 different quants in a frame when | |
187 | * segmentation is enabled. | |
188 | * If segmentation is disabled, only the first segment's values are used. | |
189 | */ | |
190 | struct { | |
191 | // [0] - DC qmul [1] - AC qmul | |
192 | int16_t luma_qmul[2]; | |
193 | int16_t luma_dc_qmul[2]; ///< luma dc-only block quant | |
194 | int16_t chroma_qmul[2]; | |
195 | } qmat[4]; | |
196 | ||
197 | struct { | |
198 | uint8_t enabled; ///< whether each mb can have a different strength based on mode/ref | |
199 | ||
200 | /** | |
201 | * filter strength adjustment for the following macroblock modes: | |
202 | * [0-3] - i16x16 (always zero) | |
203 | * [4] - i4x4 | |
204 | * [5] - zero mv | |
205 | * [6] - inter modes except for zero or split mv | |
206 | * [7] - split mv | |
207 | * i16x16 modes never have any adjustment | |
208 | */ | |
209 | int8_t mode[VP8_MVMODE_SPLIT + 1]; | |
210 | ||
211 | /** | |
212 | * filter strength adjustment for macroblocks that reference: | |
213 | * [0] - intra / VP56_FRAME_CURRENT | |
214 | * [1] - VP56_FRAME_PREVIOUS | |
215 | * [2] - VP56_FRAME_GOLDEN | |
216 | * [3] - altref / VP56_FRAME_GOLDEN2 | |
217 | */ | |
218 | int8_t ref[4]; | |
219 | } lf_delta; | |
220 | ||
221 | uint8_t (*top_border)[16 + 8 + 8]; | |
222 | uint8_t (*top_nnz)[9]; | |
223 | ||
224 | VP56RangeCoder c; ///< header context, includes mb modes and motion vectors | |
225 | ||
226 | /** | |
227 | * These are all of the updatable probabilities for binary decisions. | |
228 | * They are only implictly reset on keyframes, making it quite likely | |
229 | * for an interframe to desync if a prior frame's header was corrupt | |
230 | * or missing outright! | |
231 | */ | |
232 | struct { | |
233 | uint8_t segmentid[3]; | |
234 | uint8_t mbskip; | |
235 | uint8_t intra; | |
236 | uint8_t last; | |
237 | uint8_t golden; | |
238 | uint8_t pred16x16[4]; | |
239 | uint8_t pred8x8c[3]; | |
240 | uint8_t token[4][16][3][NUM_DCT_TOKENS - 1]; | |
241 | uint8_t mvc[2][19]; | |
242 | uint8_t scan[16]; | |
243 | } prob[2]; | |
244 | ||
245 | VP8Macroblock *macroblocks_base; | |
246 | int invisible; | |
247 | int update_last; ///< update VP56_FRAME_PREVIOUS with the current one | |
248 | int update_golden; ///< VP56_FRAME_NONE if not updated, or which frame to copy if so | |
249 | int update_altref; | |
250 | ||
251 | /** | |
252 | * If this flag is not set, all the probability updates | |
253 | * are discarded after this frame is decoded. | |
254 | */ | |
255 | int update_probabilities; | |
256 | ||
257 | /** | |
258 | * All coefficients are contained in separate arith coding contexts. | |
259 | * There can be 1, 2, 4, or 8 of these after the header context. | |
260 | */ | |
261 | int num_coeff_partitions; | |
262 | VP56RangeCoder coeff_partition[8]; | |
263 | VideoDSPContext vdsp; | |
264 | VP8DSPContext vp8dsp; | |
265 | H264PredContext hpc; | |
266 | vp8_mc_func put_pixels_tab[3][3][3]; | |
267 | VP8Frame frames[5]; | |
268 | ||
f6fa7814 DM |
269 | uint8_t colorspace; ///< 0 is the only value allowed (meaning bt601) |
270 | uint8_t fullrange; ///< whether we can skip clamping in dsp functions | |
271 | ||
2ba45a60 DM |
272 | int num_jobs; |
273 | /** | |
274 | * This describes the macroblock memory layout. | |
275 | * 0 -> Only width+height*2+1 macroblocks allocated (frame/single thread). | |
276 | * 1 -> Macroblocks for entire frame alloced (sliced thread). | |
277 | */ | |
278 | int mb_layout; | |
279 | ||
280 | void (*decode_mb_row_no_filter)(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr); | |
281 | void (*filter_mb_row)(AVCodecContext *avctx, void *tdata, int jobnr, int threadnr); | |
282 | ||
283 | int vp7; | |
284 | ||
285 | /** | |
286 | * Fade bit present in bitstream (VP7) | |
287 | */ | |
288 | int fade_present; | |
289 | ||
290 | /** | |
291 | * Interframe DC prediction (VP7) | |
292 | * [0] VP56_FRAME_PREVIOUS | |
293 | * [1] VP56_FRAME_GOLDEN | |
294 | */ | |
295 | uint16_t inter_dc_pred[2][2]; | |
296 | ||
297 | /** | |
298 | * Macroblock features (VP7) | |
299 | */ | |
300 | uint8_t feature_enabled[4]; | |
301 | uint8_t feature_present_prob[4]; | |
302 | uint8_t feature_index_prob[4][3]; | |
303 | uint8_t feature_value[4][4]; | |
304 | } VP8Context; | |
305 | ||
306 | int ff_vp8_decode_init(AVCodecContext *avctx); | |
307 | ||
308 | int ff_vp8_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, | |
309 | AVPacket *avpkt); | |
310 | ||
311 | int ff_vp8_decode_free(AVCodecContext *avctx); | |
312 | ||
313 | #endif /* AVCODEC_VP8_H */ |