1 |
|
|
/* |
2 |
|
|
* Copyright (C) 2006 Aurelien Jacobs <aurel@gnuage.org> |
3 |
|
|
* |
4 |
|
|
* This file is part of FFmpeg. |
5 |
|
|
* |
6 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
7 |
|
|
* modify it under the terms of the GNU Lesser General Public |
8 |
|
|
* License as published by the Free Software Foundation; either |
9 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
10 |
|
|
* |
11 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
12 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 |
|
|
* Lesser General Public License for more details. |
15 |
|
|
* |
16 |
|
|
* You should have received a copy of the GNU Lesser General Public |
17 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
18 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
/** |
22 |
|
|
* @file |
23 |
|
|
* VP5 and VP6 compatible video decoder (common features) |
24 |
|
|
*/ |
25 |
|
|
|
26 |
|
|
#ifndef AVCODEC_VP56_H |
27 |
|
|
#define AVCODEC_VP56_H |
28 |
|
|
|
29 |
|
|
#include "libavutil/mem_internal.h" |
30 |
|
|
|
31 |
|
|
#include "avcodec.h" |
32 |
|
|
#include "get_bits.h" |
33 |
|
|
#include "hpeldsp.h" |
34 |
|
|
#include "bytestream.h" |
35 |
|
|
#include "h264chroma.h" |
36 |
|
|
#include "videodsp.h" |
37 |
|
|
#include "vp3dsp.h" |
38 |
|
|
#include "vp56dsp.h" |
39 |
|
|
|
40 |
|
|
typedef struct vp56_context VP56Context; |
41 |
|
|
|
42 |
|
|
typedef enum { |
43 |
|
|
VP56_FRAME_NONE =-1, |
44 |
|
|
VP56_FRAME_CURRENT = 0, |
45 |
|
|
VP56_FRAME_PREVIOUS = 1, |
46 |
|
|
VP56_FRAME_GOLDEN = 2, |
47 |
|
|
VP56_FRAME_GOLDEN2 = 3, |
48 |
|
|
} VP56Frame; |
49 |
|
|
|
50 |
|
|
typedef enum { |
51 |
|
|
VP56_MB_INTER_NOVEC_PF = 0, /**< Inter MB, no vector, from previous frame */ |
52 |
|
|
VP56_MB_INTRA = 1, /**< Intra MB */ |
53 |
|
|
VP56_MB_INTER_DELTA_PF = 2, /**< Inter MB, above/left vector + delta, from previous frame */ |
54 |
|
|
VP56_MB_INTER_V1_PF = 3, /**< Inter MB, first vector, from previous frame */ |
55 |
|
|
VP56_MB_INTER_V2_PF = 4, /**< Inter MB, second vector, from previous frame */ |
56 |
|
|
VP56_MB_INTER_NOVEC_GF = 5, /**< Inter MB, no vector, from golden frame */ |
57 |
|
|
VP56_MB_INTER_DELTA_GF = 6, /**< Inter MB, above/left vector + delta, from golden frame */ |
58 |
|
|
VP56_MB_INTER_4V = 7, /**< Inter MB, 4 vectors, from previous frame */ |
59 |
|
|
VP56_MB_INTER_V1_GF = 8, /**< Inter MB, first vector, from golden frame */ |
60 |
|
|
VP56_MB_INTER_V2_GF = 9, /**< Inter MB, second vector, from golden frame */ |
61 |
|
|
} VP56mb; |
62 |
|
|
|
63 |
|
|
typedef struct VP56Tree { |
64 |
|
|
int8_t val; |
65 |
|
|
int8_t prob_idx; |
66 |
|
|
} VP56Tree; |
67 |
|
|
|
68 |
|
|
typedef struct VP56mv { |
69 |
|
|
DECLARE_ALIGNED(4, int16_t, x); |
70 |
|
|
int16_t y; |
71 |
|
|
} VP56mv; |
72 |
|
|
|
73 |
|
|
#define VP56_SIZE_CHANGE 1 |
74 |
|
|
|
75 |
|
|
typedef void (*VP56ParseVectorAdjustment)(VP56Context *s, |
76 |
|
|
VP56mv *vect); |
77 |
|
|
typedef void (*VP56Filter)(VP56Context *s, uint8_t *dst, uint8_t *src, |
78 |
|
|
int offset1, int offset2, ptrdiff_t stride, |
79 |
|
|
VP56mv mv, int mask, int select, int luma); |
80 |
|
|
typedef int (*VP56ParseCoeff)(VP56Context *s); |
81 |
|
|
typedef void (*VP56DefaultModelsInit)(VP56Context *s); |
82 |
|
|
typedef void (*VP56ParseVectorModels)(VP56Context *s); |
83 |
|
|
typedef int (*VP56ParseCoeffModels)(VP56Context *s); |
84 |
|
|
typedef int (*VP56ParseHeader)(VP56Context *s, const uint8_t *buf, |
85 |
|
|
int buf_size); |
86 |
|
|
|
87 |
|
|
typedef struct VP56RangeCoder { |
88 |
|
|
int high; |
89 |
|
|
int bits; /* stored negated (i.e. negative "bits" is a positive number of |
90 |
|
|
bits left) in order to eliminate a negate in cache refilling */ |
91 |
|
|
const uint8_t *buffer; |
92 |
|
|
const uint8_t *end; |
93 |
|
|
unsigned int code_word; |
94 |
|
|
int end_reached; |
95 |
|
|
} VP56RangeCoder; |
96 |
|
|
|
97 |
|
|
typedef struct VP56RefDc { |
98 |
|
|
uint8_t not_null_dc; |
99 |
|
|
VP56Frame ref_frame; |
100 |
|
|
int16_t dc_coeff; |
101 |
|
|
} VP56RefDc; |
102 |
|
|
|
103 |
|
|
typedef struct VP56Macroblock { |
104 |
|
|
uint8_t type; |
105 |
|
|
VP56mv mv; |
106 |
|
|
} VP56Macroblock; |
107 |
|
|
|
108 |
|
|
typedef struct VP56Model { |
109 |
|
|
uint8_t coeff_reorder[64]; /* used in vp6 only */ |
110 |
|
|
uint8_t coeff_index_to_pos[64]; /* used in vp6 only */ |
111 |
|
|
uint8_t coeff_index_to_idct_selector[64]; /* used in vp6 only */ |
112 |
|
|
uint8_t vector_sig[2]; /* delta sign */ |
113 |
|
|
uint8_t vector_dct[2]; /* delta coding types */ |
114 |
|
|
uint8_t vector_pdi[2][2]; /* predefined delta init */ |
115 |
|
|
uint8_t vector_pdv[2][7]; /* predefined delta values */ |
116 |
|
|
uint8_t vector_fdv[2][8]; /* 8 bit delta value definition */ |
117 |
|
|
uint8_t coeff_dccv[2][11]; /* DC coeff value */ |
118 |
|
|
uint8_t coeff_ract[2][3][6][11]; /* Run/AC coding type and AC coeff value */ |
119 |
|
|
uint8_t coeff_acct[2][3][3][6][5];/* vp5 only AC coding type for coding group < 3 */ |
120 |
|
|
uint8_t coeff_dcct[2][36][5]; /* DC coeff coding type */ |
121 |
|
|
uint8_t coeff_runv[2][14]; /* run value (vp6 only) */ |
122 |
|
|
uint8_t mb_type[3][10][10]; /* model for decoding MB type */ |
123 |
|
|
uint8_t mb_types_stats[3][10][2];/* contextual, next MB type stats */ |
124 |
|
|
} VP56Model; |
125 |
|
|
|
126 |
|
|
struct vp56_context { |
127 |
|
|
AVCodecContext *avctx; |
128 |
|
|
H264ChromaContext h264chroma; |
129 |
|
|
HpelDSPContext hdsp; |
130 |
|
|
VideoDSPContext vdsp; |
131 |
|
|
VP3DSPContext vp3dsp; |
132 |
|
|
VP56DSPContext vp56dsp; |
133 |
|
|
uint8_t idct_scantable[64]; |
134 |
|
|
AVFrame *frames[4]; |
135 |
|
|
uint8_t *edge_emu_buffer_alloc; |
136 |
|
|
uint8_t *edge_emu_buffer; |
137 |
|
|
VP56RangeCoder c; |
138 |
|
|
VP56RangeCoder cc; |
139 |
|
|
VP56RangeCoder *ccp; |
140 |
|
|
int sub_version; |
141 |
|
|
|
142 |
|
|
/* frame info */ |
143 |
|
|
int golden_frame; |
144 |
|
|
int plane_width[4]; |
145 |
|
|
int plane_height[4]; |
146 |
|
|
int mb_width; /* number of horizontal MB */ |
147 |
|
|
int mb_height; /* number of vertical MB */ |
148 |
|
|
int block_offset[6]; |
149 |
|
|
|
150 |
|
|
int quantizer; |
151 |
|
|
uint16_t dequant_dc; |
152 |
|
|
uint16_t dequant_ac; |
153 |
|
|
|
154 |
|
|
/* DC predictors management */ |
155 |
|
|
VP56RefDc *above_blocks; |
156 |
|
|
VP56RefDc left_block[4]; |
157 |
|
|
int above_block_idx[6]; |
158 |
|
|
int16_t prev_dc[3][3]; /* [plan][ref_frame] */ |
159 |
|
|
|
160 |
|
|
/* blocks / macroblock */ |
161 |
|
|
VP56mb mb_type; |
162 |
|
|
VP56Macroblock *macroblocks; |
163 |
|
|
DECLARE_ALIGNED(16, int16_t, block_coeff)[6][64]; |
164 |
|
|
int idct_selector[6]; |
165 |
|
|
|
166 |
|
|
/* motion vectors */ |
167 |
|
|
VP56mv mv[6]; /* vectors for each block in MB */ |
168 |
|
|
VP56mv vector_candidate[2]; |
169 |
|
|
int vector_candidate_pos; |
170 |
|
|
|
171 |
|
|
/* filtering hints */ |
172 |
|
|
int filter_header; /* used in vp6 only */ |
173 |
|
|
int deblock_filtering; |
174 |
|
|
int filter_selection; |
175 |
|
|
int filter_mode; |
176 |
|
|
int max_vector_length; |
177 |
|
|
int sample_variance_threshold; |
178 |
|
|
DECLARE_ALIGNED(8, int, bounding_values_array)[256]; |
179 |
|
|
|
180 |
|
|
uint8_t coeff_ctx[4][64]; /* used in vp5 only */ |
181 |
|
|
uint8_t coeff_ctx_last[4]; /* used in vp5 only */ |
182 |
|
|
|
183 |
|
|
int has_alpha; |
184 |
|
|
|
185 |
|
|
/* upside-down flipping hints */ |
186 |
|
|
int flip; /* are we flipping ? */ |
187 |
|
|
int frbi; /* first row block index in MB */ |
188 |
|
|
int srbi; /* second row block index in MB */ |
189 |
|
|
ptrdiff_t stride[4]; /* stride for each plan */ |
190 |
|
|
|
191 |
|
|
const uint8_t *vp56_coord_div; |
192 |
|
|
VP56ParseVectorAdjustment parse_vector_adjustment; |
193 |
|
|
VP56Filter filter; |
194 |
|
|
VP56ParseCoeff parse_coeff; |
195 |
|
|
VP56DefaultModelsInit default_models_init; |
196 |
|
|
VP56ParseVectorModels parse_vector_models; |
197 |
|
|
VP56ParseCoeffModels parse_coeff_models; |
198 |
|
|
VP56ParseHeader parse_header; |
199 |
|
|
|
200 |
|
|
/* for "slice" parallelism between YUV and A */ |
201 |
|
|
VP56Context *alpha_context; |
202 |
|
|
|
203 |
|
|
VP56Model *modelp; |
204 |
|
|
VP56Model model; |
205 |
|
|
|
206 |
|
|
/* huffman decoding */ |
207 |
|
|
int use_huffman; |
208 |
|
|
GetBitContext gb; |
209 |
|
|
VLC dccv_vlc[2]; |
210 |
|
|
VLC runv_vlc[2]; |
211 |
|
|
VLC ract_vlc[2][3][6]; |
212 |
|
|
unsigned int nb_null[2][2]; /* number of consecutive NULL DC/AC */ |
213 |
|
|
|
214 |
|
|
int have_undamaged_frame; |
215 |
|
|
int discard_frame; |
216 |
|
|
}; |
217 |
|
|
|
218 |
|
|
|
219 |
|
|
int ff_vp56_init(AVCodecContext *avctx, int flip, int has_alpha); |
220 |
|
|
int ff_vp56_init_context(AVCodecContext *avctx, VP56Context *s, |
221 |
|
|
int flip, int has_alpha); |
222 |
|
|
int ff_vp56_free(AVCodecContext *avctx); |
223 |
|
|
int ff_vp56_free_context(VP56Context *s); |
224 |
|
|
void ff_vp56_init_dequant(VP56Context *s, int quantizer); |
225 |
|
|
int ff_vp56_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, |
226 |
|
|
AVPacket *avpkt); |
227 |
|
|
|
228 |
|
|
|
229 |
|
|
/** |
230 |
|
|
* vp56 specific range coder implementation |
231 |
|
|
*/ |
232 |
|
|
|
233 |
|
|
extern const uint8_t ff_vp56_norm_shift[256]; |
234 |
|
|
int ff_vp56_init_range_decoder(VP56RangeCoder *c, const uint8_t *buf, int buf_size); |
235 |
|
|
|
236 |
|
|
/** |
237 |
|
|
* vp5689 returns 1 if the end of the stream has been reached, 0 otherwise. |
238 |
|
|
*/ |
239 |
|
739911 |
static av_always_inline int vpX_rac_is_end(VP56RangeCoder *c) |
240 |
|
|
{ |
241 |
✓✓✓✓
|
739911 |
if (c->end <= c->buffer && c->bits >= 0) |
242 |
|
11 |
c->end_reached ++; |
243 |
|
739911 |
return c->end_reached > 10; |
244 |
|
|
} |
245 |
|
|
|
246 |
|
97273225 |
static av_always_inline unsigned int vp56_rac_renorm(VP56RangeCoder *c) |
247 |
|
|
{ |
248 |
|
97273225 |
int shift = ff_vp56_norm_shift[c->high]; |
249 |
|
97273225 |
int bits = c->bits; |
250 |
|
97273225 |
unsigned int code_word = c->code_word; |
251 |
|
|
|
252 |
|
97273225 |
c->high <<= shift; |
253 |
|
97273225 |
code_word <<= shift; |
254 |
|
97273225 |
bits += shift; |
255 |
✓✓✓✓
|
97273225 |
if(bits >= 0 && c->buffer < c->end) { |
256 |
|
4198198 |
code_word |= bytestream_get_be16(&c->buffer) << bits; |
257 |
|
4198198 |
bits -= 16; |
258 |
|
|
} |
259 |
|
97273225 |
c->bits = bits; |
260 |
|
97273225 |
return code_word; |
261 |
|
|
} |
262 |
|
|
|
263 |
|
|
#if ARCH_ARM |
264 |
|
|
#include "arm/vp56_arith.h" |
265 |
|
|
#elif ARCH_X86 |
266 |
|
|
#include "x86/vp56_arith.h" |
267 |
|
|
#endif |
268 |
|
|
|
269 |
|
|
#ifndef vp56_rac_get_prob |
270 |
|
|
#define vp56_rac_get_prob vp56_rac_get_prob |
271 |
|
|
static av_always_inline int vp56_rac_get_prob(VP56RangeCoder *c, uint8_t prob) |
272 |
|
|
{ |
273 |
|
|
unsigned int code_word = vp56_rac_renorm(c); |
274 |
|
|
unsigned int low = 1 + (((c->high - 1) * prob) >> 8); |
275 |
|
|
unsigned int low_shift = low << 16; |
276 |
|
|
int bit = code_word >= low_shift; |
277 |
|
|
|
278 |
|
|
c->high = bit ? c->high - low : low; |
279 |
|
|
c->code_word = bit ? code_word - low_shift : code_word; |
280 |
|
|
|
281 |
|
|
return bit; |
282 |
|
|
} |
283 |
|
|
#endif |
284 |
|
|
|
285 |
|
|
#ifndef vp56_rac_get_prob_branchy |
286 |
|
|
// branchy variant, to be used where there's a branch based on the bit decoded |
287 |
|
66664388 |
static av_always_inline int vp56_rac_get_prob_branchy(VP56RangeCoder *c, int prob) |
288 |
|
|
{ |
289 |
|
66664388 |
unsigned long code_word = vp56_rac_renorm(c); |
290 |
|
66664388 |
unsigned low = 1 + (((c->high - 1) * prob) >> 8); |
291 |
|
66664388 |
unsigned low_shift = low << 16; |
292 |
|
|
|
293 |
✓✓ |
66664388 |
if (code_word >= low_shift) { |
294 |
|
30814739 |
c->high -= low; |
295 |
|
30814739 |
c->code_word = code_word - low_shift; |
296 |
|
30814739 |
return 1; |
297 |
|
|
} |
298 |
|
|
|
299 |
|
35849649 |
c->high = low; |
300 |
|
35849649 |
c->code_word = code_word; |
301 |
|
35849649 |
return 0; |
302 |
|
|
} |
303 |
|
|
#endif |
304 |
|
|
|
305 |
|
1303604 |
static av_always_inline int vp56_rac_get(VP56RangeCoder *c) |
306 |
|
|
{ |
307 |
|
1303604 |
unsigned int code_word = vp56_rac_renorm(c); |
308 |
|
|
/* equiprobable */ |
309 |
|
1303604 |
int low = (c->high + 1) >> 1; |
310 |
|
1303604 |
unsigned int low_shift = low << 16; |
311 |
|
1303604 |
int bit = code_word >= low_shift; |
312 |
✓✓ |
1303604 |
if (bit) { |
313 |
|
651693 |
c->high -= low; |
314 |
|
651693 |
code_word -= low_shift; |
315 |
|
|
} else { |
316 |
|
651911 |
c->high = low; |
317 |
|
|
} |
318 |
|
|
|
319 |
|
1303604 |
c->code_word = code_word; |
320 |
|
1303604 |
return bit; |
321 |
|
|
} |
322 |
|
|
|
323 |
|
|
// rounding is different than vp56_rac_get, is vp56_rac_get wrong? |
324 |
|
10177309 |
static av_always_inline int vp8_rac_get(VP56RangeCoder *c) |
325 |
|
|
{ |
326 |
|
10177309 |
return vp56_rac_get_prob(c, 128); |
327 |
|
|
} |
328 |
|
|
|
329 |
|
52237 |
static int vp56_rac_gets(VP56RangeCoder *c, int bits) |
330 |
|
|
{ |
331 |
|
52237 |
int value = 0; |
332 |
|
|
|
333 |
✓✓ |
203495 |
while (bits--) { |
334 |
|
151258 |
value = (value << 1) | vp56_rac_get(c); |
335 |
|
|
} |
336 |
|
|
|
337 |
|
52237 |
return value; |
338 |
|
|
} |
339 |
|
|
|
340 |
|
48182 |
static int vp8_rac_get_uint(VP56RangeCoder *c, int bits) |
341 |
|
|
{ |
342 |
|
48182 |
int value = 0; |
343 |
|
|
|
344 |
✓✓ |
292059 |
while (bits--) { |
345 |
|
243877 |
value = (value << 1) | vp8_rac_get(c); |
346 |
|
|
} |
347 |
|
|
|
348 |
|
48182 |
return value; |
349 |
|
|
} |
350 |
|
|
|
351 |
|
|
// fixme: add 1 bit to all the calls to this? |
352 |
|
6104 |
static av_unused int vp8_rac_get_sint(VP56RangeCoder *c, int bits) |
353 |
|
|
{ |
354 |
|
|
int v; |
355 |
|
|
|
356 |
✓✓ |
6104 |
if (!vp8_rac_get(c)) |
357 |
|
5361 |
return 0; |
358 |
|
|
|
359 |
|
743 |
v = vp8_rac_get_uint(c, bits); |
360 |
|
|
|
361 |
✓✓ |
743 |
if (vp8_rac_get(c)) |
362 |
|
98 |
v = -v; |
363 |
|
|
|
364 |
|
743 |
return v; |
365 |
|
|
} |
366 |
|
|
|
367 |
|
|
// P(7) |
368 |
|
8496 |
static av_unused int vp56_rac_gets_nn(VP56RangeCoder *c, int bits) |
369 |
|
|
{ |
370 |
|
8496 |
int v = vp56_rac_gets(c, 7) << 1; |
371 |
|
8496 |
return v + !v; |
372 |
|
|
} |
373 |
|
|
|
374 |
|
306 |
static av_unused int vp8_rac_get_nn(VP56RangeCoder *c) |
375 |
|
|
{ |
376 |
|
306 |
int v = vp8_rac_get_uint(c, 7) << 1; |
377 |
|
306 |
return v + !v; |
378 |
|
|
} |
379 |
|
|
|
380 |
|
|
static av_always_inline |
381 |
|
445510 |
int vp56_rac_get_tree(VP56RangeCoder *c, |
382 |
|
|
const VP56Tree *tree, |
383 |
|
|
const uint8_t *probs) |
384 |
|
|
{ |
385 |
✓✓ |
1764929 |
while (tree->val > 0) { |
386 |
✓✓ |
1319419 |
if (vp56_rac_get_prob_branchy(c, probs[tree->prob_idx])) |
387 |
|
450669 |
tree += tree->val; |
388 |
|
|
else |
389 |
|
868750 |
tree++; |
390 |
|
|
} |
391 |
|
445510 |
return -tree->val; |
392 |
|
|
} |
393 |
|
|
|
394 |
|
|
// how probabilities are associated with decisions is different I think |
395 |
|
|
// well, the new scheme fits in the old but this way has one fewer branches per decision |
396 |
|
4225958 |
static av_always_inline int vp8_rac_get_tree(VP56RangeCoder *c, const int8_t (*tree)[2], |
397 |
|
|
const uint8_t *probs) |
398 |
|
|
{ |
399 |
|
4225958 |
int i = 0; |
400 |
|
|
|
401 |
|
|
do { |
402 |
|
9419020 |
i = tree[i][vp56_rac_get_prob(c, probs[i])]; |
403 |
✓✓ |
9419020 |
} while (i > 0); |
404 |
|
|
|
405 |
|
4225958 |
return -i; |
406 |
|
|
} |
407 |
|
|
|
408 |
|
|
// DCTextra |
409 |
|
43890 |
static av_always_inline int vp8_rac_get_coeff(VP56RangeCoder *c, const uint8_t *prob) |
410 |
|
|
{ |
411 |
|
43890 |
int v = 0; |
412 |
|
|
|
413 |
|
|
do { |
414 |
|
163810 |
v = (v<<1) + vp56_rac_get_prob(c, *prob++); |
415 |
✓✓ |
163810 |
} while (*prob); |
416 |
|
|
|
417 |
|
43890 |
return v; |
418 |
|
|
} |
419 |
|
|
|
420 |
|
|
#endif /* AVCODEC_VP56_H */ |