Commit | Line | Data |
---|---|---|
d86053a4 | 1 | /* |
67335dbc | 2 | * Copyright (C) 2003-2004 the ffmpeg project |
d86053a4 | 3 | * |
b78e7197 DB |
4 | * This file is part of FFmpeg. |
5 | * | |
6 | * FFmpeg is free software; you can redistribute it and/or | |
d86053a4 MM |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either | |
b78e7197 | 9 | * version 2.1 of the License, or (at your option) any later version. |
d86053a4 | 10 | * |
b78e7197 | 11 | * FFmpeg is distributed in the hope that it will be useful, |
d86053a4 MM |
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 | |
b78e7197 | 17 | * License along with FFmpeg; if not, write to the Free Software |
5509bffa | 18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
d86053a4 MM |
19 | */ |
20 | ||
21 | /** | |
bad5537e | 22 | * @file libavcodec/vp3.c |
d86053a4 | 23 | * On2 VP3 Video Decoder |
0ad72bdd MM |
24 | * |
25 | * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx) | |
26 | * For more information about the VP3 coding process, visit: | |
9db5bdfa | 27 | * http://wiki.multimedia.cx/index.php?title=On2_VP3 |
0ad72bdd MM |
28 | * |
29 | * Theora decoder by Alex Beregszaszi | |
d86053a4 MM |
30 | */ |
31 | ||
32 | #include <stdio.h> | |
33 | #include <stdlib.h> | |
34 | #include <string.h> | |
d86053a4 | 35 | |
d86053a4 MM |
36 | #include "avcodec.h" |
37 | #include "dsputil.h" | |
9106a698 | 38 | #include "get_bits.h" |
d86053a4 MM |
39 | |
40 | #include "vp3data.h" | |
da91ed59 | 41 | #include "xiph.h" |
d86053a4 MM |
42 | |
43 | #define FRAGMENT_PIXELS 8 | |
44 | ||
0efbd068 MM |
45 | static av_cold int vp3_decode_end(AVCodecContext *avctx); |
46 | ||
7beddb12 | 47 | //FIXME split things out into their own arrays |
d86053a4 | 48 | typedef struct Vp3Fragment { |
c72625f2 | 49 | int16_t dc; |
288774bb | 50 | uint8_t coding_method; |
288774bb MN |
51 | int8_t motion_x; |
52 | int8_t motion_y; | |
f2264fa5 | 53 | uint8_t qpi; |
d86053a4 MM |
54 | } Vp3Fragment; |
55 | ||
56 | #define SB_NOT_CODED 0 | |
57 | #define SB_PARTIALLY_CODED 1 | |
58 | #define SB_FULLY_CODED 2 | |
59 | ||
ecb51b25 DC |
60 | // This is the maximum length of a single long bit run that can be encoded |
61 | // for superblock coding or block qps. Theora special-cases this to read a | |
62 | // bit instead of flipping the current bit to allow for runs longer than 4129. | |
63 | #define MAXIMUM_LONG_BIT_RUN 4129 | |
64 | ||
d86053a4 MM |
65 | #define MODE_INTER_NO_MV 0 |
66 | #define MODE_INTRA 1 | |
67 | #define MODE_INTER_PLUS_MV 2 | |
68 | #define MODE_INTER_LAST_MV 3 | |
69 | #define MODE_INTER_PRIOR_LAST 4 | |
70 | #define MODE_USING_GOLDEN 5 | |
71 | #define MODE_GOLDEN_MV 6 | |
72 | #define MODE_INTER_FOURMV 7 | |
73 | #define CODING_MODE_COUNT 8 | |
74 | ||
75 | /* special internal mode */ | |
76 | #define MODE_COPY 8 | |
77 | ||
78 | /* There are 6 preset schemes, plus a free-form scheme */ | |
e8e47435 | 79 | static const int ModeAlphabet[6][CODING_MODE_COUNT] = |
d86053a4 | 80 | { |
d86053a4 | 81 | /* scheme 1: Last motion vector dominates */ |
115329f1 | 82 | { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
d86053a4 | 83 | MODE_INTER_PLUS_MV, MODE_INTER_NO_MV, |
115329f1 | 84 | MODE_INTRA, MODE_USING_GOLDEN, |
d86053a4 MM |
85 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
86 | ||
87 | /* scheme 2 */ | |
115329f1 | 88 | { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
d86053a4 | 89 | MODE_INTER_NO_MV, MODE_INTER_PLUS_MV, |
115329f1 | 90 | MODE_INTRA, MODE_USING_GOLDEN, |
d86053a4 MM |
91 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
92 | ||
93 | /* scheme 3 */ | |
115329f1 | 94 | { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV, |
d86053a4 | 95 | MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV, |
115329f1 | 96 | MODE_INTRA, MODE_USING_GOLDEN, |
d86053a4 MM |
97 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
98 | ||
99 | /* scheme 4 */ | |
115329f1 | 100 | { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV, |
d86053a4 | 101 | MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST, |
115329f1 | 102 | MODE_INTRA, MODE_USING_GOLDEN, |
d86053a4 MM |
103 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
104 | ||
105 | /* scheme 5: No motion vector dominates */ | |
115329f1 | 106 | { MODE_INTER_NO_MV, MODE_INTER_LAST_MV, |
d86053a4 | 107 | MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV, |
115329f1 | 108 | MODE_INTRA, MODE_USING_GOLDEN, |
d86053a4 MM |
109 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
110 | ||
111 | /* scheme 6 */ | |
115329f1 | 112 | { MODE_INTER_NO_MV, MODE_USING_GOLDEN, |
d86053a4 | 113 | MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST, |
115329f1 | 114 | MODE_INTER_PLUS_MV, MODE_INTRA, |
d86053a4 MM |
115 | MODE_GOLDEN_MV, MODE_INTER_FOURMV }, |
116 | ||
117 | }; | |
118 | ||
7a095ea6 DC |
119 | static const uint8_t hilbert_offset[16][2] = { |
120 | {0,0}, {1,0}, {1,1}, {0,1}, | |
121 | {0,2}, {0,3}, {1,3}, {1,2}, | |
122 | {2,2}, {2,3}, {3,3}, {3,2}, | |
123 | {3,1}, {2,1}, {2,0}, {3,0} | |
124 | }; | |
125 | ||
d86053a4 MM |
126 | #define MIN_DEQUANT_VAL 2 |
127 | ||
128 | typedef struct Vp3DecodeContext { | |
129 | AVCodecContext *avctx; | |
f44ee2c3 | 130 | int theora, theora_tables; |
3c3f113e | 131 | int version; |
d86053a4 | 132 | int width, height; |
1e76a1da | 133 | int chroma_x_shift, chroma_y_shift; |
d86053a4 MM |
134 | AVFrame golden_frame; |
135 | AVFrame last_frame; | |
136 | AVFrame current_frame; | |
137 | int keyframe; | |
138 | DSPContext dsp; | |
9a7ad925 | 139 | int flipped_image; |
a8de3901 | 140 | int last_slice_end; |
d86053a4 | 141 | |
f2264fa5 DC |
142 | int qps[3]; |
143 | int nqps; | |
144 | int last_qps[3]; | |
d86053a4 MM |
145 | |
146 | int superblock_count; | |
892fc83e MM |
147 | int y_superblock_width; |
148 | int y_superblock_height; | |
35c28d23 | 149 | int y_superblock_count; |
892fc83e MM |
150 | int c_superblock_width; |
151 | int c_superblock_height; | |
35c28d23 | 152 | int c_superblock_count; |
d86053a4 MM |
153 | int u_superblock_start; |
154 | int v_superblock_start; | |
155 | unsigned char *superblock_coding; | |
156 | ||
157 | int macroblock_count; | |
158 | int macroblock_width; | |
159 | int macroblock_height; | |
160 | ||
161 | int fragment_count; | |
57783884 DC |
162 | int fragment_width[2]; |
163 | int fragment_height[2]; | |
d86053a4 MM |
164 | |
165 | Vp3Fragment *all_fragments; | |
1abbf64e | 166 | int fragment_start[3]; |
735acf56 | 167 | int data_offset[3]; |
115329f1 | 168 | |
36af0c95 | 169 | ScanTable scantable; |
115329f1 | 170 | |
f44ee2c3 AB |
171 | /* tables */ |
172 | uint16_t coded_dc_scale_factor[64]; | |
67335dbc | 173 | uint32_t coded_ac_scale_factor[64]; |
ae1dd8e1 MN |
174 | uint8_t base_matrix[384][64]; |
175 | uint8_t qr_count[2][3]; | |
176 | uint8_t qr_size [2][3][64]; | |
177 | uint16_t qr_base[2][3][64]; | |
d86053a4 | 178 | |
c72625f2 DC |
179 | /** |
180 | * This is a list of all tokens in bitstream order. Reordering takes place | |
181 | * by pulling from each level during IDCT. As a consequence, IDCT must be | |
182 | * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32 | |
183 | * otherwise. The 32 different tokens with up to 12 bits of extradata are | |
184 | * collapsed into 3 types, packed as follows: | |
185 | * (from the low to high bits) | |
186 | * | |
187 | * 2 bits: type (0,1,2) | |
188 | * 0: EOB run, 14 bits for run length (12 needed) | |
189 | * 1: zero run, 7 bits for run length | |
190 | * 7 bits for the next coefficient (3 needed) | |
191 | * 2: coefficient, 14 bits (11 needed) | |
192 | * | |
193 | * Coefficients are signed, so are packed in the highest bits for automatic | |
194 | * sign extension. | |
195 | */ | |
196 | int16_t *dct_tokens[3][64]; | |
197 | int16_t *dct_tokens_base; | |
198 | #define TOKEN_EOB(eob_run) ((eob_run) << 2) | |
199 | #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1) | |
200 | #define TOKEN_COEFF(coeff) (((coeff) << 2) + 2) | |
201 | ||
202 | /** | |
203 | * number of blocks that contain DCT coefficients at the given level or higher | |
204 | */ | |
205 | int num_coded_frags[3][64]; | |
206 | int total_num_coded_frags; | |
207 | ||
f4433de9 | 208 | /* this is a list of indexes into the all_fragments array indicating |
d86053a4 | 209 | * which of the fragments are coded */ |
c72625f2 | 210 | int *coded_fragment_list[3]; |
098523eb | 211 | |
d86053a4 MM |
212 | VLC dc_vlc[16]; |
213 | VLC ac_vlc_1[16]; | |
214 | VLC ac_vlc_2[16]; | |
215 | VLC ac_vlc_3[16]; | |
216 | VLC ac_vlc_4[16]; | |
217 | ||
0ad72bdd MM |
218 | VLC superblock_run_length_vlc; |
219 | VLC fragment_run_length_vlc; | |
220 | VLC mode_code_vlc; | |
221 | VLC motion_vector_vlc; | |
222 | ||
38acbc3c MM |
223 | /* these arrays need to be on 16-byte boundaries since SSE2 operations |
224 | * index into them */ | |
84dc2d8a | 225 | DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64]; //<qmat[qpi][is_inter][plane] |
d86053a4 MM |
226 | |
227 | /* This table contains superblock_count * 16 entries. Each set of 16 | |
f4433de9 | 228 | * numbers corresponds to the fragment indexes 0..15 of the superblock. |
d86053a4 MM |
229 | * An entry will be -1 to indicate that no entry corresponds to that |
230 | * index. */ | |
231 | int *superblock_fragments; | |
232 | ||
115329f1 | 233 | /* This is an array that indicates how a particular macroblock |
74c0ac12 | 234 | * is coded. */ |
96a7e73b | 235 | unsigned char *macroblock_coding; |
d86053a4 | 236 | |
a2f11b3c | 237 | uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc |
191e8ca7 | 238 | int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16 |
39922395 | 239 | |
f44b08a5 MM |
240 | /* Huffman decode */ |
241 | int hti; | |
242 | unsigned int hbits; | |
243 | int entries; | |
244 | int huff_code_size; | |
245 | uint16_t huffman_table[80][32][2]; | |
246 | ||
51ace577 | 247 | uint8_t filter_limit_values[64]; |
84dc2d8a | 248 | DECLARE_ALIGNED(8, int, bounding_values_array)[256+2]; |
d86053a4 MM |
249 | } Vp3DecodeContext; |
250 | ||
251 | /************************************************************************ | |
252 | * VP3 specific functions | |
253 | ************************************************************************/ | |
254 | ||
255 | /* | |
256 | * This function sets up all of the various blocks mappings: | |
257 | * superblocks <-> fragments, macroblocks <-> fragments, | |
258 | * superblocks <-> macroblocks | |
892fc83e MM |
259 | * |
260 | * Returns 0 is successful; returns 1 if *anything* went wrong. | |
d86053a4 | 261 | */ |
115329f1 | 262 | static int init_block_mapping(Vp3DecodeContext *s) |
d86053a4 | 263 | { |
a16389c1 DC |
264 | int sb_x, sb_y, plane; |
265 | int x, y, i, j = 0; | |
266 | ||
267 | for (plane = 0; plane < 3; plane++) { | |
268 | int sb_width = plane ? s->c_superblock_width : s->y_superblock_width; | |
269 | int sb_height = plane ? s->c_superblock_height : s->y_superblock_height; | |
57783884 DC |
270 | int frag_width = s->fragment_width[!!plane]; |
271 | int frag_height = s->fragment_height[!!plane]; | |
a16389c1 DC |
272 | |
273 | for (sb_y = 0; sb_y < sb_height; sb_y++) | |
274 | for (sb_x = 0; sb_x < sb_width; sb_x++) | |
275 | for (i = 0; i < 16; i++) { | |
276 | x = 4*sb_x + hilbert_offset[i][0]; | |
277 | y = 4*sb_y + hilbert_offset[i][1]; | |
278 | ||
279 | if (x < frag_width && y < frag_height) | |
280 | s->superblock_fragments[j++] = s->fragment_start[plane] + y*frag_width + x; | |
281 | else | |
282 | s->superblock_fragments[j++] = -1; | |
283 | } | |
d86053a4 MM |
284 | } |
285 | ||
892fc83e | 286 | return 0; /* successful path out */ |
d86053a4 MM |
287 | } |
288 | ||
289 | /* | |
f44b08a5 | 290 | * This function sets up the dequantization tables used for a particular |
d86053a4 MM |
291 | * frame. |
292 | */ | |
f2264fa5 | 293 | static void init_dequantizer(Vp3DecodeContext *s, int qpi) |
d86053a4 | 294 | { |
f2264fa5 DC |
295 | int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]]; |
296 | int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]]; | |
36c32bdd | 297 | int i, plane, inter, qri, bmi, bmj, qistart; |
d86053a4 | 298 | |
ae1dd8e1 MN |
299 | for(inter=0; inter<2; inter++){ |
300 | for(plane=0; plane<3; plane++){ | |
301 | int sum=0; | |
302 | for(qri=0; qri<s->qr_count[inter][plane]; qri++){ | |
303 | sum+= s->qr_size[inter][plane][qri]; | |
f2264fa5 | 304 | if(s->qps[qpi] <= sum) |
ae1dd8e1 MN |
305 | break; |
306 | } | |
307 | qistart= sum - s->qr_size[inter][plane][qri]; | |
308 | bmi= s->qr_base[inter][plane][qri ]; | |
309 | bmj= s->qr_base[inter][plane][qri+1]; | |
310 | for(i=0; i<64; i++){ | |
f2264fa5 DC |
311 | int coeff= ( 2*(sum -s->qps[qpi])*s->base_matrix[bmi][i] |
312 | - 2*(qistart-s->qps[qpi])*s->base_matrix[bmj][i] | |
ae1dd8e1 MN |
313 | + s->qr_size[inter][plane][qri]) |
314 | / (2*s->qr_size[inter][plane][qri]); | |
315 | ||
a14ab4e4 | 316 | int qmin= 8<<(inter + !i); |
ae1dd8e1 MN |
317 | int qscale= i ? ac_scale_factor : dc_scale_factor; |
318 | ||
f2264fa5 | 319 | s->qmat[qpi][inter][plane][s->dsp.idct_permutation[i]]= av_clip((qscale * coeff)/100 * 4, qmin, 4096); |
ae1dd8e1 | 320 | } |
f2264fa5 DC |
321 | // all DC coefficients use the same quant so as not to interfere with DC prediction |
322 | s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0]; | |
ae1dd8e1 | 323 | } |
d86053a4 | 324 | } |
115329f1 | 325 | |
f2264fa5 | 326 | memset(s->qscale_table, (FFMAX(s->qmat[0][0][0][1], s->qmat[0][0][1][1])+8)/16, 512); //FIXME finetune |
d86053a4 MM |
327 | } |
328 | ||
329 | /* | |
f44b08a5 MM |
330 | * This function initializes the loop filter boundary limits if the frame's |
331 | * quality index is different from the previous frame's. | |
7fa5f999 RD |
332 | * |
333 | * The filter_limit_values may not be larger than 127. | |
f44b08a5 MM |
334 | */ |
335 | static void init_loop_filter(Vp3DecodeContext *s) | |
336 | { | |
337 | int *bounding_values= s->bounding_values_array+127; | |
338 | int filter_limit; | |
339 | int x; | |
7fa5f999 | 340 | int value; |
f44b08a5 | 341 | |
f2264fa5 | 342 | filter_limit = s->filter_limit_values[s->qps[0]]; |
f44b08a5 MM |
343 | |
344 | /* set up the bounding values */ | |
345 | memset(s->bounding_values_array, 0, 256 * sizeof(int)); | |
346 | for (x = 0; x < filter_limit; x++) { | |
f44b08a5 MM |
347 | bounding_values[-x] = -x; |
348 | bounding_values[x] = x; | |
f44b08a5 | 349 | } |
7fa5f999 RD |
350 | for (x = value = filter_limit; x < 128 && value; x++, value--) { |
351 | bounding_values[ x] = value; | |
352 | bounding_values[-x] = -value; | |
353 | } | |
354 | if (value) | |
355 | bounding_values[128] = value; | |
357f45d9 | 356 | bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202; |
f44b08a5 MM |
357 | } |
358 | ||
359 | /* | |
115329f1 | 360 | * This function unpacks all of the superblock/macroblock/fragment coding |
d86053a4 MM |
361 | * information from the bitstream. |
362 | */ | |
892fc83e | 363 | static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb) |
d86053a4 | 364 | { |
e2720b6b | 365 | int superblock_starts[3] = { 0, s->u_superblock_start, s->v_superblock_start }; |
d86053a4 MM |
366 | int bit = 0; |
367 | int current_superblock = 0; | |
368 | int current_run = 0; | |
855c720c | 369 | int num_partial_superblocks = 0; |
d86053a4 MM |
370 | |
371 | int i, j; | |
372 | int current_fragment; | |
35c28d23 | 373 | int plane; |
d86053a4 | 374 | |
d86053a4 | 375 | if (s->keyframe) { |
d86053a4 MM |
376 | memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count); |
377 | ||
378 | } else { | |
379 | ||
380 | /* unpack the list of partially-coded superblocks */ | |
5fc32c27 | 381 | bit = get_bits1(gb); |
d86053a4 | 382 | while (current_superblock < s->superblock_count) { |
115329f1 | 383 | current_run = get_vlc2(gb, |
33dbc1b7 DC |
384 | s->superblock_run_length_vlc.table, 6, 2) + 1; |
385 | if (current_run == 34) | |
d8278bab | 386 | current_run += get_bits(gb, 12); |
d86053a4 | 387 | |
33dbc1b7 DC |
388 | if (current_superblock + current_run > s->superblock_count) { |
389 | av_log(s->avctx, AV_LOG_ERROR, "Invalid partially coded superblock run length\n"); | |
390 | return -1; | |
391 | } | |
392 | ||
393 | memset(s->superblock_coding + current_superblock, bit, current_run); | |
394 | ||
395 | current_superblock += current_run; | |
855c720c DC |
396 | if (bit) |
397 | num_partial_superblocks += current_run; | |
33dbc1b7 | 398 | |
a8926476 DC |
399 | if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN) |
400 | bit = get_bits1(gb); | |
401 | else | |
33dbc1b7 | 402 | bit ^= 1; |
d86053a4 MM |
403 | } |
404 | ||
405 | /* unpack the list of fully coded superblocks if any of the blocks were | |
406 | * not marked as partially coded in the previous step */ | |
855c720c DC |
407 | if (num_partial_superblocks < s->superblock_count) { |
408 | int superblocks_decoded = 0; | |
d86053a4 MM |
409 | |
410 | current_superblock = 0; | |
5fc32c27 | 411 | bit = get_bits1(gb); |
855c720c | 412 | while (superblocks_decoded < s->superblock_count - num_partial_superblocks) { |
115329f1 | 413 | current_run = get_vlc2(gb, |
855c720c DC |
414 | s->superblock_run_length_vlc.table, 6, 2) + 1; |
415 | if (current_run == 34) | |
d8278bab | 416 | current_run += get_bits(gb, 12); |
855c720c DC |
417 | |
418 | for (j = 0; j < current_run; current_superblock++) { | |
419 | if (current_superblock >= s->superblock_count) { | |
420 | av_log(s->avctx, AV_LOG_ERROR, "Invalid fully coded superblock run length\n"); | |
421 | return -1; | |
d86053a4 | 422 | } |
855c720c DC |
423 | |
424 | /* skip any superblocks already marked as partially coded */ | |
425 | if (s->superblock_coding[current_superblock] == SB_NOT_CODED) { | |
b5da3635 | 426 | s->superblock_coding[current_superblock] = 2*bit; |
855c720c DC |
427 | j++; |
428 | } | |
d86053a4 | 429 | } |
855c720c DC |
430 | superblocks_decoded += current_run; |
431 | ||
a8926476 DC |
432 | if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN) |
433 | bit = get_bits1(gb); | |
434 | else | |
855c720c | 435 | bit ^= 1; |
d86053a4 MM |
436 | } |
437 | } | |
438 | ||
439 | /* if there were partial blocks, initialize bitstream for | |
440 | * unpacking fragment codings */ | |
855c720c | 441 | if (num_partial_superblocks) { |
d86053a4 MM |
442 | |
443 | current_run = 0; | |
5fc32c27 | 444 | bit = get_bits1(gb); |
115329f1 | 445 | /* toggle the bit because as soon as the first run length is |
d86053a4 MM |
446 | * fetched the bit will be toggled again */ |
447 | bit ^= 1; | |
448 | } | |
449 | } | |
450 | ||
451 | /* figure out which fragments are coded; iterate through each | |
452 | * superblock (all planes) */ | |
c72625f2 | 453 | s->total_num_coded_frags = 0; |
96a7e73b | 454 | memset(s->macroblock_coding, MODE_COPY, s->macroblock_count); |
35c28d23 DC |
455 | |
456 | for (plane = 0; plane < 3; plane++) { | |
e2720b6b | 457 | int sb_start = superblock_starts[plane]; |
35c28d23 | 458 | int sb_end = sb_start + (plane ? s->c_superblock_count : s->y_superblock_count); |
c72625f2 | 459 | int num_coded_frags = 0; |
35c28d23 DC |
460 | |
461 | for (i = sb_start; i < sb_end; i++) { | |
d86053a4 MM |
462 | |
463 | /* iterate through all 16 fragments in a superblock */ | |
464 | for (j = 0; j < 16; j++) { | |
465 | ||
466 | /* if the fragment is in bounds, check its coding status */ | |
467 | current_fragment = s->superblock_fragments[i * 16 + j]; | |
468 | if (current_fragment != -1) { | |
6cb35b45 | 469 | int coded = s->superblock_coding[i]; |
d86053a4 | 470 | |
6cb35b45 | 471 | if (s->superblock_coding[i] == SB_PARTIALLY_CODED) { |
d86053a4 MM |
472 | |
473 | /* fragment may or may not be coded; this is the case | |
474 | * that cares about the fragment coding runs */ | |
b5da3635 | 475 | if (current_run-- == 0) { |
d86053a4 | 476 | bit ^= 1; |
115329f1 | 477 | current_run = get_vlc2(gb, |
b5da3635 | 478 | s->fragment_run_length_vlc.table, 5, 2); |
d86053a4 | 479 | } |
6cb35b45 DC |
480 | coded = bit; |
481 | } | |
d86053a4 | 482 | |
6cb35b45 | 483 | if (coded) { |
115329f1 | 484 | /* default mode; actual mode will be decoded in |
22493ab9 | 485 | * the next phase */ |
115329f1 | 486 | s->all_fragments[current_fragment].coding_method = |
d86053a4 | 487 | MODE_INTER_NO_MV; |
c72625f2 | 488 | s->coded_fragment_list[plane][num_coded_frags++] = |
d86053a4 | 489 | current_fragment; |
d86053a4 MM |
490 | } else { |
491 | /* not coded; copy this fragment from the prior frame */ | |
492 | s->all_fragments[current_fragment].coding_method = | |
493 | MODE_COPY; | |
d86053a4 | 494 | } |
d86053a4 MM |
495 | } |
496 | } | |
497 | } | |
c72625f2 DC |
498 | s->total_num_coded_frags += num_coded_frags; |
499 | for (i = 0; i < 64; i++) | |
500 | s->num_coded_frags[plane][i] = num_coded_frags; | |
501 | if (plane < 2) | |
502 | s->coded_fragment_list[plane+1] = s->coded_fragment_list[plane] + num_coded_frags; | |
35c28d23 | 503 | } |
892fc83e | 504 | return 0; |
d86053a4 MM |
505 | } |
506 | ||
507 | /* | |
508 | * This function unpacks all the coding mode data for individual macroblocks | |
509 | * from the bitstream. | |
510 | */ | |
892fc83e | 511 | static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb) |
d86053a4 | 512 | { |
19cd517d | 513 | int i, j, k, sb_x, sb_y; |
d86053a4 MM |
514 | int scheme; |
515 | int current_macroblock; | |
516 | int current_fragment; | |
517 | int coding_mode; | |
e8e47435 | 518 | int custom_mode_alphabet[CODING_MODE_COUNT]; |
7c2e31d1 | 519 | const int *alphabet; |
1e76a1da | 520 | Vp3Fragment *frag; |
d86053a4 | 521 | |
d86053a4 | 522 | if (s->keyframe) { |
d86053a4 MM |
523 | for (i = 0; i < s->fragment_count; i++) |
524 | s->all_fragments[i].coding_method = MODE_INTRA; | |
525 | ||
526 | } else { | |
527 | ||
528 | /* fetch the mode coding scheme for this frame */ | |
529 | scheme = get_bits(gb, 3); | |
d86053a4 MM |
530 | |
531 | /* is it a custom coding scheme? */ | |
532 | if (scheme == 0) { | |
d86053a4 | 533 | for (i = 0; i < 8; i++) |
2c823b3c AC |
534 | custom_mode_alphabet[i] = MODE_INTER_NO_MV; |
535 | for (i = 0; i < 8; i++) | |
e8e47435 | 536 | custom_mode_alphabet[get_bits(gb, 3)] = i; |
7c2e31d1 DC |
537 | alphabet = custom_mode_alphabet; |
538 | } else | |
539 | alphabet = ModeAlphabet[scheme-1]; | |
d86053a4 | 540 | |
d86053a4 MM |
541 | /* iterate through all of the macroblocks that contain 1 or more |
542 | * coded fragments */ | |
19cd517d DC |
543 | for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) { |
544 | for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) { | |
d86053a4 MM |
545 | |
546 | for (j = 0; j < 4; j++) { | |
19cd517d DC |
547 | int mb_x = 2*sb_x + (j>>1); |
548 | int mb_y = 2*sb_y + (((j>>1)+j)&1); | |
549 | current_macroblock = mb_y * s->macroblock_width + mb_x; | |
550 | ||
15675ce6 | 551 | if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height) |
d86053a4 MM |
552 | continue; |
553 | ||
ea676144 DC |
554 | #define BLOCK_X (2*mb_x + (k&1)) |
555 | #define BLOCK_Y (2*mb_y + (k>>1)) | |
15675ce6 DC |
556 | /* coding modes are only stored if the macroblock has at least one |
557 | * luma block coded, otherwise it must be INTER_NO_MV */ | |
558 | for (k = 0; k < 4; k++) { | |
57783884 | 559 | current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
15675ce6 DC |
560 | if (s->all_fragments[current_fragment].coding_method != MODE_COPY) |
561 | break; | |
562 | } | |
563 | if (k == 4) { | |
564 | s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV; | |
565 | continue; | |
566 | } | |
ea676144 | 567 | |
d86053a4 MM |
568 | /* mode 7 means get 3 bits for each coding mode */ |
569 | if (scheme == 7) | |
570 | coding_mode = get_bits(gb, 3); | |
571 | else | |
7c2e31d1 | 572 | coding_mode = alphabet |
0ad72bdd | 573 | [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)]; |
d86053a4 | 574 | |
96a7e73b | 575 | s->macroblock_coding[current_macroblock] = coding_mode; |
ea676144 | 576 | for (k = 0; k < 4; k++) { |
1e76a1da DC |
577 | frag = s->all_fragments + BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
578 | if (frag->coding_method != MODE_COPY) | |
579 | frag->coding_method = coding_mode; | |
ea676144 | 580 | } |
1e76a1da DC |
581 | |
582 | #define SET_CHROMA_MODES \ | |
583 | if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \ | |
584 | frag[s->fragment_start[1]].coding_method = coding_mode;\ | |
585 | if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \ | |
586 | frag[s->fragment_start[2]].coding_method = coding_mode; | |
587 | ||
588 | if (s->chroma_y_shift) { | |
589 | frag = s->all_fragments + mb_y*s->fragment_width[1] + mb_x; | |
590 | SET_CHROMA_MODES | |
591 | } else if (s->chroma_x_shift) { | |
592 | frag = s->all_fragments + 2*mb_y*s->fragment_width[1] + mb_x; | |
593 | for (k = 0; k < 2; k++) { | |
594 | SET_CHROMA_MODES | |
595 | frag += s->fragment_width[1]; | |
596 | } | |
597 | } else { | |
598 | for (k = 0; k < 4; k++) { | |
599 | frag = s->all_fragments + BLOCK_Y*s->fragment_width[1] + BLOCK_X; | |
600 | SET_CHROMA_MODES | |
601 | } | |
d86053a4 | 602 | } |
d86053a4 | 603 | } |
19cd517d | 604 | } |
d86053a4 MM |
605 | } |
606 | } | |
892fc83e MM |
607 | |
608 | return 0; | |
44ae98dd MM |
609 | } |
610 | ||
611 | /* | |
d86053a4 MM |
612 | * This function unpacks all the motion vectors for the individual |
613 | * macroblocks from the bitstream. | |
614 | */ | |
892fc83e | 615 | static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb) |
d86053a4 | 616 | { |
eb691ef2 | 617 | int j, k, sb_x, sb_y; |
d86053a4 | 618 | int coding_mode; |
1c183aa4 DC |
619 | int motion_x[4]; |
620 | int motion_y[4]; | |
d86053a4 MM |
621 | int last_motion_x = 0; |
622 | int last_motion_y = 0; | |
623 | int prior_last_motion_x = 0; | |
624 | int prior_last_motion_y = 0; | |
625 | int current_macroblock; | |
626 | int current_fragment; | |
1e76a1da | 627 | Vp3Fragment *frag; |
d86053a4 | 628 | |
6599e2a7 | 629 | if (s->keyframe) |
6298f49f | 630 | return 0; |
10f38380 | 631 | |
1ae4518d DC |
632 | /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */ |
633 | coding_mode = get_bits1(gb); | |
d86053a4 | 634 | |
1ae4518d DC |
635 | /* iterate through all of the macroblocks that contain 1 or more |
636 | * coded fragments */ | |
19cd517d DC |
637 | for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) { |
638 | for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) { | |
d86053a4 | 639 | |
1ae4518d | 640 | for (j = 0; j < 4; j++) { |
19cd517d DC |
641 | int mb_x = 2*sb_x + (j>>1); |
642 | int mb_y = 2*sb_y + (((j>>1)+j)&1); | |
643 | current_macroblock = mb_y * s->macroblock_width + mb_x; | |
644 | ||
645 | if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height || | |
1ae4518d DC |
646 | (s->macroblock_coding[current_macroblock] == MODE_COPY)) |
647 | continue; | |
d86053a4 | 648 | |
1ae4518d DC |
649 | switch (s->macroblock_coding[current_macroblock]) { |
650 | ||
651 | case MODE_INTER_PLUS_MV: | |
652 | case MODE_GOLDEN_MV: | |
653 | /* all 6 fragments use the same motion vector */ | |
654 | if (coding_mode == 0) { | |
655 | motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
656 | motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
657 | } else { | |
658 | motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
659 | motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
892fc83e | 660 | } |
7f9926a4 | 661 | |
1ae4518d DC |
662 | /* vector maintenance, only on MODE_INTER_PLUS_MV */ |
663 | if (s->macroblock_coding[current_macroblock] == | |
664 | MODE_INTER_PLUS_MV) { | |
e32e2d56 AJ |
665 | prior_last_motion_x = last_motion_x; |
666 | prior_last_motion_y = last_motion_y; | |
1ae4518d DC |
667 | last_motion_x = motion_x[0]; |
668 | last_motion_y = motion_y[0]; | |
669 | } | |
670 | break; | |
671 | ||
672 | case MODE_INTER_FOURMV: | |
673 | /* vector maintenance */ | |
674 | prior_last_motion_x = last_motion_x; | |
675 | prior_last_motion_y = last_motion_y; | |
676 | ||
677 | /* fetch 4 vectors from the bitstream, one for each | |
678 | * Y fragment, then average for the C fragment vectors */ | |
1ae4518d | 679 | for (k = 0; k < 4; k++) { |
57783884 | 680 | current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
eb691ef2 | 681 | if (s->all_fragments[current_fragment].coding_method != MODE_COPY) { |
1ae4518d DC |
682 | if (coding_mode == 0) { |
683 | motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
684 | motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)]; | |
feaf1a73 | 685 | } else { |
1ae4518d DC |
686 | motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)]; |
687 | motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)]; | |
feaf1a73 | 688 | } |
1ae4518d DC |
689 | last_motion_x = motion_x[k]; |
690 | last_motion_y = motion_y[k]; | |
691 | } else { | |
692 | motion_x[k] = 0; | |
693 | motion_y[k] = 0; | |
d86053a4 | 694 | } |
1ae4518d | 695 | } |
1ae4518d DC |
696 | break; |
697 | ||
698 | case MODE_INTER_LAST_MV: | |
699 | /* all 6 fragments use the last motion vector */ | |
700 | motion_x[0] = last_motion_x; | |
701 | motion_y[0] = last_motion_y; | |
d86053a4 | 702 | |
1ae4518d DC |
703 | /* no vector maintenance (last vector remains the |
704 | * last vector) */ | |
705 | break; | |
706 | ||
707 | case MODE_INTER_PRIOR_LAST: | |
708 | /* all 6 fragments use the motion vector prior to the | |
709 | * last motion vector */ | |
710 | motion_x[0] = prior_last_motion_x; | |
711 | motion_y[0] = prior_last_motion_y; | |
d86053a4 | 712 | |
1ae4518d DC |
713 | /* vector maintenance */ |
714 | prior_last_motion_x = last_motion_x; | |
715 | prior_last_motion_y = last_motion_y; | |
716 | last_motion_x = motion_x[0]; | |
717 | last_motion_y = motion_y[0]; | |
718 | break; | |
44ae98dd | 719 | |
1ae4518d DC |
720 | default: |
721 | /* covers intra, inter without MV, golden without MV */ | |
e6e32bdc MM |
722 | motion_x[0] = 0; |
723 | motion_y[0] = 0; | |
44ae98dd | 724 | |
1ae4518d DC |
725 | /* no vector maintenance */ |
726 | break; | |
727 | } | |
d86053a4 | 728 | |
1ae4518d | 729 | /* assign the motion vectors to the correct fragments */ |
ea676144 | 730 | for (k = 0; k < 4; k++) { |
1ae4518d | 731 | current_fragment = |
57783884 | 732 | BLOCK_Y*s->fragment_width[0] + BLOCK_X; |
e6e32bdc | 733 | if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
da8af938 MM |
734 | s->all_fragments[current_fragment].motion_x = motion_x[k]; |
735 | s->all_fragments[current_fragment].motion_y = motion_y[k]; | |
e6e32bdc MM |
736 | } else { |
737 | s->all_fragments[current_fragment].motion_x = motion_x[0]; | |
738 | s->all_fragments[current_fragment].motion_y = motion_y[0]; | |
739 | } | |
d86053a4 | 740 | } |
1e76a1da DC |
741 | |
742 | #define SET_CHROMA_MV(mx, my) \ | |
743 | frag[s->fragment_start[1]].motion_x = mx; \ | |
744 | frag[s->fragment_start[1]].motion_y = my; \ | |
745 | frag[s->fragment_start[2]].motion_x = mx; \ | |
746 | frag[s->fragment_start[2]].motion_y = my | |
747 | ||
748 | if (s->chroma_y_shift) { | |
1c183aa4 DC |
749 | if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { |
750 | motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2); | |
751 | motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2); | |
752 | } | |
1e76a1da DC |
753 | motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1); |
754 | motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1); | |
755 | frag = s->all_fragments + mb_y*s->fragment_width[1] + mb_x; | |
756 | SET_CHROMA_MV(motion_x[0], motion_y[0]); | |
757 | } else if (s->chroma_x_shift) { | |
758 | if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { | |
759 | motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1); | |
760 | motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1); | |
761 | motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1); | |
762 | motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1); | |
763 | } else { | |
764 | motion_x[1] = motion_x[0]; | |
765 | motion_y[1] = motion_y[0]; | |
766 | } | |
767 | motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1); | |
768 | motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1); | |
769 | ||
770 | frag = s->all_fragments + 2*mb_y*s->fragment_width[1] + mb_x; | |
771 | for (k = 0; k < 2; k++) { | |
772 | SET_CHROMA_MV(motion_x[k], motion_y[k]); | |
773 | frag += s->fragment_width[1]; | |
774 | } | |
775 | } else { | |
776 | for (k = 0; k < 4; k++) { | |
777 | frag = s->all_fragments + BLOCK_Y*s->fragment_width[1] + BLOCK_X; | |
778 | if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) { | |
779 | SET_CHROMA_MV(motion_x[k], motion_y[k]); | |
780 | } else { | |
781 | SET_CHROMA_MV(motion_x[0], motion_y[0]); | |
782 | } | |
783 | } | |
ea676144 | 784 | } |
d86053a4 | 785 | } |
19cd517d | 786 | } |
1ae4518d | 787 | } |
892fc83e MM |
788 | |
789 | return 0; | |
d86053a4 MM |
790 | } |
791 | ||
f2264fa5 DC |
792 | static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb) |
793 | { | |
794 | int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi; | |
c72625f2 | 795 | int num_blocks = s->total_num_coded_frags; |
f2264fa5 DC |
796 | |
797 | for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) { | |
798 | i = blocks_decoded = num_blocks_at_qpi = 0; | |
799 | ||
800 | bit = get_bits1(gb); | |
801 | ||
802 | do { | |
803 | run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1; | |
804 | if (run_length == 34) | |
805 | run_length += get_bits(gb, 12); | |
806 | blocks_decoded += run_length; | |
807 | ||
808 | if (!bit) | |
809 | num_blocks_at_qpi += run_length; | |
810 | ||
811 | for (j = 0; j < run_length; i++) { | |
c72625f2 | 812 | if (i >= s->total_num_coded_frags) |
f2264fa5 DC |
813 | return -1; |
814 | ||
c72625f2 DC |
815 | if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) { |
816 | s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit; | |
f2264fa5 DC |
817 | j++; |
818 | } | |
819 | } | |
820 | ||
ecb51b25 | 821 | if (run_length == MAXIMUM_LONG_BIT_RUN) |
f2264fa5 DC |
822 | bit = get_bits1(gb); |
823 | else | |
824 | bit ^= 1; | |
825 | } while (blocks_decoded < num_blocks); | |
826 | ||
827 | num_blocks -= num_blocks_at_qpi; | |
828 | } | |
829 | ||
830 | return 0; | |
831 | } | |
832 | ||
115329f1 | 833 | /* |
d86053a4 MM |
834 | * This function is called by unpack_dct_coeffs() to extract the VLCs from |
835 | * the bitstream. The VLCs encode tokens which are used to unpack DCT | |
836 | * data. This function unpacks all the VLCs for either the Y plane or both | |
837 | * C planes, and is called for DC coefficients or different AC coefficient | |
838 | * levels (since different coefficient types require different VLC tables. | |
839 | * | |
840 | * This function returns a residual eob run. E.g, if a particular token gave | |
841 | * instructions to EOB the next 5 fragments and there were only 2 fragments | |
842 | * left in the current fragment range, 3 would be returned so that it could | |
843 | * be passed into the next call to this same function. | |
844 | */ | |
845 | static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb, | |
846 | VLC *table, int coeff_index, | |
c72625f2 | 847 | int plane, |
d86053a4 MM |
848 | int eob_run) |
849 | { | |
c72625f2 | 850 | int i, j = 0; |
d86053a4 | 851 | int token; |
d3076955 MM |
852 | int zero_run = 0; |
853 | DCTELEM coeff = 0; | |
d3076955 | 854 | int bits_to_get; |
c72625f2 DC |
855 | int blocks_ended; |
856 | int coeff_i = 0; | |
857 | int num_coeffs = s->num_coded_frags[plane][coeff_index]; | |
858 | int16_t *dct_tokens = s->dct_tokens[plane][coeff_index]; | |
d86053a4 | 859 | |
ee3d7f58 | 860 | /* local references to structure members to avoid repeated deferences */ |
c72625f2 | 861 | int *coded_fragment_list = s->coded_fragment_list[plane]; |
ee3d7f58 | 862 | Vp3Fragment *all_fragments = s->all_fragments; |
ee3d7f58 MM |
863 | VLC_TYPE (*vlc_table)[2] = table->table; |
864 | ||
c72625f2 DC |
865 | if (num_coeffs < 0) |
866 | av_log(s->avctx, AV_LOG_ERROR, "Invalid number of coefficents at level %d\n", coeff_index); | |
867 | ||
868 | if (eob_run > num_coeffs) { | |
869 | coeff_i = blocks_ended = num_coeffs; | |
870 | eob_run -= num_coeffs; | |
098523eb | 871 | } else { |
c72625f2 DC |
872 | coeff_i = blocks_ended = eob_run; |
873 | eob_run = 0; | |
74c0ac12 MM |
874 | } |
875 | ||
c72625f2 DC |
876 | // insert fake EOB token to cover the split between planes or zzi |
877 | if (blocks_ended) | |
878 | dct_tokens[j++] = blocks_ended << 2; | |
d86053a4 | 879 | |
f50dafa8 | 880 | while (coeff_i < num_coeffs && get_bits_left(gb) > 0) { |
d86053a4 | 881 | /* decode a VLC into a token */ |
ee3d7f58 | 882 | token = get_vlc2(gb, vlc_table, 5, 3); |
d86053a4 | 883 | /* use the token to get a zero run, a coefficient, and an eob run */ |
d3076955 MM |
884 | if (token <= 6) { |
885 | eob_run = eob_run_base[token]; | |
886 | if (eob_run_get_bits[token]) | |
887 | eob_run += get_bits(gb, eob_run_get_bits[token]); | |
c72625f2 DC |
888 | |
889 | // record only the number of blocks ended in this plane, | |
890 | // any spill will be recorded in the next plane. | |
891 | if (eob_run > num_coeffs - coeff_i) { | |
892 | dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i); | |
893 | blocks_ended += num_coeffs - coeff_i; | |
894 | eob_run -= num_coeffs - coeff_i; | |
895 | coeff_i = num_coeffs; | |
896 | } else { | |
897 | dct_tokens[j++] = TOKEN_EOB(eob_run); | |
898 | blocks_ended += eob_run; | |
899 | coeff_i += eob_run; | |
900 | eob_run = 0; | |
901 | } | |
d3076955 MM |
902 | } else { |
903 | bits_to_get = coeff_get_bits[token]; | |
428984b0 MM |
904 | if (bits_to_get) |
905 | bits_to_get = get_bits(gb, bits_to_get); | |
906 | coeff = coeff_tables[token][bits_to_get]; | |
d3076955 MM |
907 | |
908 | zero_run = zero_run_base[token]; | |
909 | if (zero_run_get_bits[token]) | |
910 | zero_run += get_bits(gb, zero_run_get_bits[token]); | |
d86053a4 | 911 | |
c72625f2 DC |
912 | if (zero_run) { |
913 | dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run); | |
914 | } else { | |
915 | // Save DC into the fragment structure. DC prediction is | |
916 | // done in raster order, so the actual DC can't be in with | |
917 | // other tokens. We still need the token in dct_tokens[] | |
918 | // however, or else the structure collapses on itself. | |
919 | if (!coeff_index) | |
920 | all_fragments[coded_fragment_list[coeff_i]].dc = coeff; | |
921 | ||
922 | dct_tokens[j++] = TOKEN_COEFF(coeff); | |
923 | } | |
924 | ||
925 | if (coeff_index + zero_run > 64) { | |
01f9640b | 926 | av_log(s->avctx, AV_LOG_DEBUG, "Invalid zero run of %d with" |
c72625f2 DC |
927 | " %d coeffs left\n", zero_run, 64-coeff_index); |
928 | zero_run = 64 - coeff_index; | |
929 | } | |
098523eb | 930 | |
c72625f2 DC |
931 | // zero runs code multiple coefficients, |
932 | // so don't try to decode coeffs for those higher levels | |
933 | for (i = coeff_index+1; i <= coeff_index+zero_run; i++) | |
934 | s->num_coded_frags[plane][i]--; | |
935 | coeff_i++; | |
936 | } | |
d86053a4 MM |
937 | } |
938 | ||
c72625f2 DC |
939 | if (blocks_ended > s->num_coded_frags[plane][coeff_index]) |
940 | av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n"); | |
941 | ||
942 | // decrement the number of blocks that have higher coeffecients for each | |
943 | // EOB run at this level | |
944 | if (blocks_ended) | |
945 | for (i = coeff_index+1; i < 64; i++) | |
946 | s->num_coded_frags[plane][i] -= blocks_ended; | |
947 | ||
948 | // setup the next buffer | |
949 | if (plane < 2) | |
950 | s->dct_tokens[plane+1][coeff_index] = dct_tokens + j; | |
951 | else if (coeff_index < 63) | |
952 | s->dct_tokens[0][coeff_index+1] = dct_tokens + j; | |
953 | ||
d86053a4 MM |
954 | return eob_run; |
955 | } | |
956 | ||
138fe832 MM |
957 | static void reverse_dc_prediction(Vp3DecodeContext *s, |
958 | int first_fragment, | |
959 | int fragment_width, | |
960 | int fragment_height); | |
d86053a4 MM |
961 | /* |
962 | * This function unpacks all of the DCT coefficient data from the | |
963 | * bitstream. | |
964 | */ | |
892fc83e | 965 | static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb) |
d86053a4 MM |
966 | { |
967 | int i; | |
968 | int dc_y_table; | |
969 | int dc_c_table; | |
970 | int ac_y_table; | |
971 | int ac_c_table; | |
972 | int residual_eob_run = 0; | |
9d8bb031 MM |
973 | VLC *y_tables[64]; |
974 | VLC *c_tables[64]; | |
d86053a4 | 975 | |
c72625f2 DC |
976 | s->dct_tokens[0][0] = s->dct_tokens_base; |
977 | ||
f4433de9 | 978 | /* fetch the DC table indexes */ |
d86053a4 MM |
979 | dc_y_table = get_bits(gb, 4); |
980 | dc_c_table = get_bits(gb, 4); | |
981 | ||
982 | /* unpack the Y plane DC coefficients */ | |
115329f1 | 983 | residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, |
c72625f2 | 984 | 0, residual_eob_run); |
d86053a4 | 985 | |
138fe832 | 986 | /* reverse prediction of the Y-plane DC coefficients */ |
57783884 | 987 | reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]); |
138fe832 | 988 | |
d86053a4 | 989 | /* unpack the C plane DC coefficients */ |
d86053a4 | 990 | residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0, |
c72625f2 DC |
991 | 1, residual_eob_run); |
992 | residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0, | |
993 | 2, residual_eob_run); | |
d86053a4 | 994 | |
138fe832 MM |
995 | /* reverse prediction of the C-plane DC coefficients */ |
996 | if (!(s->avctx->flags & CODEC_FLAG_GRAY)) | |
997 | { | |
998 | reverse_dc_prediction(s, s->fragment_start[1], | |
57783884 | 999 | s->fragment_width[1], s->fragment_height[1]); |
138fe832 | 1000 | reverse_dc_prediction(s, s->fragment_start[2], |
57783884 | 1001 | s->fragment_width[1], s->fragment_height[1]); |
138fe832 MM |
1002 | } |
1003 | ||
f4433de9 | 1004 | /* fetch the AC table indexes */ |
d86053a4 MM |
1005 | ac_y_table = get_bits(gb, 4); |
1006 | ac_c_table = get_bits(gb, 4); | |
1007 | ||
9d8bb031 | 1008 | /* build tables of AC VLC tables */ |
d86053a4 | 1009 | for (i = 1; i <= 5; i++) { |
9d8bb031 MM |
1010 | y_tables[i] = &s->ac_vlc_1[ac_y_table]; |
1011 | c_tables[i] = &s->ac_vlc_1[ac_c_table]; | |
d86053a4 | 1012 | } |
d86053a4 | 1013 | for (i = 6; i <= 14; i++) { |
9d8bb031 MM |
1014 | y_tables[i] = &s->ac_vlc_2[ac_y_table]; |
1015 | c_tables[i] = &s->ac_vlc_2[ac_c_table]; | |
d86053a4 | 1016 | } |
d86053a4 | 1017 | for (i = 15; i <= 27; i++) { |
9d8bb031 MM |
1018 | y_tables[i] = &s->ac_vlc_3[ac_y_table]; |
1019 | c_tables[i] = &s->ac_vlc_3[ac_c_table]; | |
d86053a4 | 1020 | } |
d86053a4 | 1021 | for (i = 28; i <= 63; i++) { |
9d8bb031 MM |
1022 | y_tables[i] = &s->ac_vlc_4[ac_y_table]; |
1023 | c_tables[i] = &s->ac_vlc_4[ac_c_table]; | |
1024 | } | |
1025 | ||
1026 | /* decode all AC coefficents */ | |
1027 | for (i = 1; i <= 63; i++) { | |
9d8bb031 | 1028 | residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i, |
c72625f2 | 1029 | 0, residual_eob_run); |
d86053a4 | 1030 | |
9d8bb031 | 1031 | residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i, |
c72625f2 DC |
1032 | 1, residual_eob_run); |
1033 | residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i, | |
1034 | 2, residual_eob_run); | |
d86053a4 | 1035 | } |
892fc83e MM |
1036 | |
1037 | return 0; | |
d86053a4 MM |
1038 | } |
1039 | ||
1040 | /* | |
1041 | * This function reverses the DC prediction for each coded fragment in | |
115329f1 | 1042 | * the frame. Much of this function is adapted directly from the original |
d86053a4 MM |
1043 | * VP3 source code. |
1044 | */ | |
1045 | #define COMPATIBLE_FRAME(x) \ | |
1046 | (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type) | |
c72625f2 | 1047 | #define DC_COEFF(u) s->all_fragments[u].dc |
d86053a4 MM |
1048 | |
1049 | static void reverse_dc_prediction(Vp3DecodeContext *s, | |
1050 | int first_fragment, | |
1051 | int fragment_width, | |
115329f1 | 1052 | int fragment_height) |
d86053a4 MM |
1053 | { |
1054 | ||
1055 | #define PUL 8 | |
1056 | #define PU 4 | |
1057 | #define PUR 2 | |
1058 | #define PL 1 | |
1059 | ||
1060 | int x, y; | |
1061 | int i = first_fragment; | |
1062 | ||
59ef342b | 1063 | int predicted_dc; |
d86053a4 | 1064 | |
d86053a4 MM |
1065 | /* DC values for the left, up-left, up, and up-right fragments */ |
1066 | int vl, vul, vu, vur; | |
1067 | ||
f4433de9 | 1068 | /* indexes for the left, up-left, up, and up-right fragments */ |
d86053a4 MM |
1069 | int l, ul, u, ur; |
1070 | ||
115329f1 | 1071 | /* |
d86053a4 MM |
1072 | * The 6 fields mean: |
1073 | * 0: up-left multiplier | |
1074 | * 1: up multiplier | |
1075 | * 2: up-right multiplier | |
1076 | * 3: left multiplier | |
d86053a4 | 1077 | */ |
bb991087 | 1078 | static const int predictor_transform[16][4] = { |
006ff1ca MN |
1079 | { 0, 0, 0, 0}, |
1080 | { 0, 0, 0,128}, // PL | |
1081 | { 0, 0,128, 0}, // PUR | |
1082 | { 0, 0, 53, 75}, // PUR|PL | |
1083 | { 0,128, 0, 0}, // PU | |
1084 | { 0, 64, 0, 64}, // PU|PL | |
1085 | { 0,128, 0, 0}, // PU|PUR | |
1086 | { 0, 0, 53, 75}, // PU|PUR|PL | |
1087 | {128, 0, 0, 0}, // PUL | |
1088 | { 0, 0, 0,128}, // PUL|PL | |
1089 | { 64, 0, 64, 0}, // PUL|PUR | |
1090 | { 0, 0, 53, 75}, // PUL|PUR|PL | |
1091 | { 0,128, 0, 0}, // PUL|PU | |
1092 | {-104,116, 0,116}, // PUL|PU|PL | |
1093 | { 24, 80, 24, 0}, // PUL|PU|PUR | |
1094 | {-104,116, 0,116} // PUL|PU|PUR|PL | |
d86053a4 MM |
1095 | }; |
1096 | ||
1097 | /* This table shows which types of blocks can use other blocks for | |
1098 | * prediction. For example, INTRA is the only mode in this table to | |
1099 | * have a frame number of 0. That means INTRA blocks can only predict | |
115329f1 | 1100 | * from other INTRA blocks. There are 2 golden frame coding types; |
d86053a4 MM |
1101 | * blocks encoding in these modes can only predict from other blocks |
1102 | * that were encoded with these 1 of these 2 modes. */ | |
50ba3fd7 | 1103 | static const unsigned char compatible_frame[9] = { |
d86053a4 MM |
1104 | 1, /* MODE_INTER_NO_MV */ |
1105 | 0, /* MODE_INTRA */ | |
1106 | 1, /* MODE_INTER_PLUS_MV */ | |
1107 | 1, /* MODE_INTER_LAST_MV */ | |
1108 | 1, /* MODE_INTER_PRIOR_MV */ | |
1109 | 2, /* MODE_USING_GOLDEN */ | |
1110 | 2, /* MODE_GOLDEN_MV */ | |
50ba3fd7 JGG |
1111 | 1, /* MODE_INTER_FOUR_MV */ |
1112 | 3 /* MODE_COPY */ | |
d86053a4 MM |
1113 | }; |
1114 | int current_frame_type; | |
1115 | ||
1116 | /* there is a last DC predictor for each of the 3 frame types */ | |
1117 | short last_dc[3]; | |
1118 | ||
1119 | int transform = 0; | |
1120 | ||
d86053a4 MM |
1121 | vul = vu = vur = vl = 0; |
1122 | last_dc[0] = last_dc[1] = last_dc[2] = 0; | |
1123 | ||
1124 | /* for each fragment row... */ | |
1125 | for (y = 0; y < fragment_height; y++) { | |
1126 | ||
1127 | /* for each fragment in a row... */ | |
1128 | for (x = 0; x < fragment_width; x++, i++) { | |
1129 | ||
1130 | /* reverse prediction if this block was coded */ | |
1131 | if (s->all_fragments[i].coding_method != MODE_COPY) { | |
1132 | ||
115329f1 | 1133 | current_frame_type = |
d86053a4 | 1134 | compatible_frame[s->all_fragments[i].coding_method]; |
d86053a4 | 1135 | |
f72f8a77 MN |
1136 | transform= 0; |
1137 | if(x){ | |
1138 | l= i-1; | |
7beddb12 | 1139 | vl = DC_COEFF(l); |
50ba3fd7 | 1140 | if(COMPATIBLE_FRAME(l)) |
006ff1ca | 1141 | transform |= PL; |
f72f8a77 MN |
1142 | } |
1143 | if(y){ | |
1144 | u= i-fragment_width; | |
7beddb12 | 1145 | vu = DC_COEFF(u); |
50ba3fd7 | 1146 | if(COMPATIBLE_FRAME(u)) |
006ff1ca | 1147 | transform |= PU; |
f72f8a77 MN |
1148 | if(x){ |
1149 | ul= i-fragment_width-1; | |
1150 | vul = DC_COEFF(ul); | |
50ba3fd7 | 1151 | if(COMPATIBLE_FRAME(ul)) |
006ff1ca | 1152 | transform |= PUL; |
f72f8a77 MN |
1153 | } |
1154 | if(x + 1 < fragment_width){ | |
1155 | ur= i-fragment_width+1; | |
1156 | vur = DC_COEFF(ur); | |
50ba3fd7 | 1157 | if(COMPATIBLE_FRAME(ur)) |
006ff1ca | 1158 | transform |= PUR; |
f72f8a77 | 1159 | } |
d86053a4 MM |
1160 | } |
1161 | ||
d86053a4 MM |
1162 | if (transform == 0) { |
1163 | ||
1164 | /* if there were no fragments to predict from, use last | |
1165 | * DC saved */ | |
7beddb12 | 1166 | predicted_dc = last_dc[current_frame_type]; |
d86053a4 MM |
1167 | } else { |
1168 | ||
1169 | /* apply the appropriate predictor transform */ | |
1170 | predicted_dc = | |
1171 | (predictor_transform[transform][0] * vul) + | |
1172 | (predictor_transform[transform][1] * vu) + | |
1173 | (predictor_transform[transform][2] * vur) + | |
1174 | (predictor_transform[transform][3] * vl); | |
1175 | ||
684d9e36 | 1176 | predicted_dc /= 128; |
d86053a4 MM |
1177 | |
1178 | /* check for outranging on the [ul u l] and | |
1179 | * [ul u ur l] predictors */ | |
c11cb375 | 1180 | if ((transform == 15) || (transform == 13)) { |
c26abfa5 | 1181 | if (FFABS(predicted_dc - vu) > 128) |
d86053a4 | 1182 | predicted_dc = vu; |
c26abfa5 | 1183 | else if (FFABS(predicted_dc - vl) > 128) |
d86053a4 | 1184 | predicted_dc = vl; |
c26abfa5 | 1185 | else if (FFABS(predicted_dc - vul) > 128) |
d86053a4 MM |
1186 | predicted_dc = vul; |
1187 | } | |
d86053a4 MM |
1188 | } |
1189 | ||
7beddb12 | 1190 | /* at long last, apply the predictor */ |
c72625f2 | 1191 | DC_COEFF(i) += predicted_dc; |
d86053a4 | 1192 | /* save the DC */ |
7beddb12 | 1193 | last_dc[current_frame_type] = DC_COEFF(i); |
d86053a4 MM |
1194 | } |
1195 | } | |
1196 | } | |
1197 | } | |
1198 | ||
256c0662 | 1199 | static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend) |
fe313556 | 1200 | { |
fe313556 DC |
1201 | int x, y; |
1202 | int *bounding_values= s->bounding_values_array+127; | |
1203 | ||
57783884 DC |
1204 | int width = s->fragment_width[!!plane]; |
1205 | int height = s->fragment_height[!!plane]; | |
621f9a40 DC |
1206 | int fragment = s->fragment_start [plane] + ystart * width; |
1207 | int stride = s->current_frame.linesize[plane]; | |
1208 | uint8_t *plane_data = s->current_frame.data [plane]; | |
1209 | if (!s->flipped_image) stride = -stride; | |
735acf56 | 1210 | plane_data += s->data_offset[plane] + 8*ystart*stride; |
621f9a40 DC |
1211 | |
1212 | for (y = ystart; y < yend; y++) { | |
1213 | ||
1214 | for (x = 0; x < width; x++) { | |
1215 | /* This code basically just deblocks on the edges of coded blocks. | |
1216 | * However, it has to be much more complicated because of the | |
1217 | * braindamaged deblock ordering used in VP3/Theora. Order matters | |
1218 | * because some pixels get filtered twice. */ | |
1219 | if( s->all_fragments[fragment].coding_method != MODE_COPY ) | |
1220 | { | |
1221 | /* do not perform left edge filter for left columns frags */ | |
1222 | if (x > 0) { | |
1223 | s->dsp.vp3_h_loop_filter( | |
735acf56 | 1224 | plane_data + 8*x, |
621f9a40 DC |
1225 | stride, bounding_values); |
1226 | } | |
fe313556 | 1227 | |
621f9a40 DC |
1228 | /* do not perform top edge filter for top row fragments */ |
1229 | if (y > 0) { | |
1230 | s->dsp.vp3_v_loop_filter( | |
735acf56 | 1231 | plane_data + 8*x, |
621f9a40 DC |
1232 | stride, bounding_values); |
1233 | } | |
fe313556 | 1234 | |
621f9a40 DC |
1235 | /* do not perform right edge filter for right column |
1236 | * fragments or if right fragment neighbor is also coded | |
1237 | * in this frame (it will be filtered in next iteration) */ | |
1238 | if ((x < width - 1) && | |
1239 | (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) { | |
1240 | s->dsp.vp3_h_loop_filter( | |
735acf56 | 1241 | plane_data + 8*x + 8, |
621f9a40 | 1242 | stride, bounding_values); |
fe313556 DC |
1243 | } |
1244 | ||
621f9a40 DC |
1245 | /* do not perform bottom edge filter for bottom row |
1246 | * fragments or if bottom fragment neighbor is also coded | |
1247 | * in this frame (it will be filtered in the next row) */ | |
1248 | if ((y < height - 1) && | |
1249 | (s->all_fragments[fragment + width].coding_method == MODE_COPY)) { | |
1250 | s->dsp.vp3_v_loop_filter( | |
735acf56 | 1251 | plane_data + 8*x + 8*stride, |
621f9a40 DC |
1252 | stride, bounding_values); |
1253 | } | |
fe313556 | 1254 | } |
621f9a40 DC |
1255 | |
1256 | fragment++; | |
fe313556 | 1257 | } |
735acf56 | 1258 | plane_data += 8*stride; |
621f9a40 | 1259 | } |
fe313556 DC |
1260 | } |
1261 | ||
a8de3901 | 1262 | /** |
c72625f2 DC |
1263 | * Pulls DCT tokens from the 64 levels to decode and dequant the coefficients |
1264 | * for the next block in coding order | |
1265 | */ | |
1266 | static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag, | |
1267 | int plane, int inter, DCTELEM block[64]) | |
1268 | { | |
1269 | int16_t *dequantizer = s->qmat[frag->qpi][inter][plane]; | |
1270 | uint8_t *perm = s->scantable.permutated; | |
1271 | int i = 0; | |
1272 | ||
1273 | do { | |
1274 | int token = *s->dct_tokens[plane][i]; | |
1275 | switch (token & 3) { | |
1276 | case 0: // EOB | |
1277 | if (--token < 4) // 0-3 are token types, so the EOB run must now be 0 | |
1278 | s->dct_tokens[plane][i]++; | |
1279 | else | |
1280 | *s->dct_tokens[plane][i] = token & ~3; | |
1281 | goto end; | |
1282 | case 1: // zero run | |
1283 | s->dct_tokens[plane][i]++; | |
1284 | i += (token >> 2) & 0x7f; | |
1285 | block[perm[i]] = (token >> 9) * dequantizer[perm[i]]; | |
1286 | i++; | |
1287 | break; | |
1288 | case 2: // coeff | |
1289 | block[perm[i]] = (token >> 2) * dequantizer[perm[i]]; | |
1290 | s->dct_tokens[plane][i++]++; | |
1291 | break; | |
1292 | default: | |
1293 | av_log(s->avctx, AV_LOG_ERROR, "internal: invalid token type\n"); | |
1294 | return i; | |
1295 | } | |
1296 | } while (i < 64); | |
1297 | end: | |
1298 | // the actual DC+prediction is in the fragment structure | |
1299 | block[0] = frag->dc * s->qmat[0][inter][plane][0]; | |
1300 | return i; | |
1301 | } | |
1302 | ||
1303 | /** | |
a8de3901 DC |
1304 | * called when all pixels up to row y are complete |
1305 | */ | |
1306 | static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y) | |
1307 | { | |
1308 | int h, cy; | |
1309 | int offset[4]; | |
1310 | ||
1311 | if(s->avctx->draw_horiz_band==NULL) | |
1312 | return; | |
1313 | ||
1314 | h= y - s->last_slice_end; | |
1315 | y -= h; | |
1316 | ||
1317 | if (!s->flipped_image) { | |
1318 | if (y == 0) | |
1319 | h -= s->height - s->avctx->height; // account for non-mod16 | |
1320 | y = s->height - y - h; | |
1321 | } | |
1322 | ||
1323 | cy = y >> 1; | |
1324 | offset[0] = s->current_frame.linesize[0]*y; | |
1325 | offset[1] = s->current_frame.linesize[1]*cy; | |
1326 | offset[2] = s->current_frame.linesize[2]*cy; | |
1327 | offset[3] = 0; | |
1328 | ||
1329 | emms_c(); | |
1330 | s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h); | |
1331 | s->last_slice_end= y + h; | |
1332 | } | |
1333 | ||
d86053a4 | 1334 | /* |
dc4b78d9 | 1335 | * Perform the final rendering for a particular slice of data. |
7a095ea6 | 1336 | * The slice number ranges from 0..(c_superblock_height - 1). |
dc4b78d9 MM |
1337 | */ |
1338 | static void render_slice(Vp3DecodeContext *s, int slice) | |
1339 | { | |
7a095ea6 | 1340 | int x, y, i, j; |
40d11227 | 1341 | LOCAL_ALIGNED_16(DCTELEM, block, [64]); |
dc4b78d9 | 1342 | int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef; |
dc4b78d9 MM |
1343 | int motion_halfpel_index; |
1344 | uint8_t *motion_source; | |
7a095ea6 | 1345 | int plane, first_pixel; |
dc4b78d9 | 1346 | |
7a095ea6 | 1347 | if (slice >= s->c_superblock_height) |
dc4b78d9 MM |
1348 | return; |
1349 | ||
1350 | for (plane = 0; plane < 3; plane++) { | |
735acf56 DC |
1351 | uint8_t *output_plane = s->current_frame.data [plane] + s->data_offset[plane]; |
1352 | uint8_t * last_plane = s-> last_frame.data [plane] + s->data_offset[plane]; | |
1353 | uint8_t *golden_plane = s-> golden_frame.data [plane] + s->data_offset[plane]; | |
1abbf64e | 1354 | int stride = s->current_frame.linesize[plane]; |
1e76a1da DC |
1355 | int plane_width = s->width >> (plane && s->chroma_x_shift); |
1356 | int plane_height = s->height >> (plane && s->chroma_y_shift); | |
7a095ea6 | 1357 | |
1e76a1da DC |
1358 | int sb_x, sb_y = slice << (!plane && s->chroma_y_shift); |
1359 | int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift); | |
7a095ea6 DC |
1360 | int slice_width = plane ? s->c_superblock_width : s->y_superblock_width; |
1361 | ||
57783884 DC |
1362 | int fragment_width = s->fragment_width[!!plane]; |
1363 | int fragment_height = s->fragment_height[!!plane]; | |
7a095ea6 | 1364 | int fragment_start = s->fragment_start[plane]; |
1abbf64e MN |
1365 | |
1366 | if (!s->flipped_image) stride = -stride; | |
161e8cf4 DC |
1367 | if (CONFIG_GRAY && plane && (s->avctx->flags & CODEC_FLAG_GRAY)) |
1368 | continue; | |
dc4b78d9 | 1369 | |
115329f1 | 1370 | |
c26abfa5 | 1371 | if(FFABS(stride) > 2048) |
dc4b78d9 MM |
1372 | return; //various tables are fixed size |
1373 | ||
7a095ea6 DC |
1374 | /* for each superblock row in the slice (both of them)... */ |
1375 | for (; sb_y < slice_height; sb_y++) { | |
dc4b78d9 | 1376 | |
7a095ea6 DC |
1377 | /* for each superblock in a row... */ |
1378 | for (sb_x = 0; sb_x < slice_width; sb_x++) { | |
dc4b78d9 | 1379 | |
7a095ea6 DC |
1380 | /* for each block in a superblock... */ |
1381 | for (j = 0; j < 16; j++) { | |
1382 | x = 4*sb_x + hilbert_offset[j][0]; | |
1383 | y = 4*sb_y + hilbert_offset[j][1]; | |
1384 | ||
1385 | i = fragment_start + y*fragment_width + x; | |
1386 | ||
1387 | // bounds check | |
1388 | if (x >= fragment_width || y >= fragment_height) | |
1389 | continue; | |
1390 | ||
1391 | first_pixel = 8*y*stride + 8*x; | |
dc4b78d9 MM |
1392 | |
1393 | /* transform if this block was coded */ | |
161e8cf4 | 1394 | if (s->all_fragments[i].coding_method != MODE_COPY) { |
c72625f2 | 1395 | int intra = s->all_fragments[i].coding_method == MODE_INTRA; |
dc4b78d9 MM |
1396 | |
1397 | if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) || | |
1398 | (s->all_fragments[i].coding_method == MODE_GOLDEN_MV)) | |
1399 | motion_source= golden_plane; | |
115329f1 | 1400 | else |
dc4b78d9 MM |
1401 | motion_source= last_plane; |
1402 | ||
735acf56 | 1403 | motion_source += first_pixel; |
dc4b78d9 MM |
1404 | motion_halfpel_index = 0; |
1405 | ||
1406 | /* sort out the motion vector if this fragment is coded | |
1407 | * using a motion vector method */ | |
1408 | if ((s->all_fragments[i].coding_method > MODE_INTRA) && | |
1409 | (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) { | |
1410 | int src_x, src_y; | |
1411 | motion_x = s->all_fragments[i].motion_x; | |
1412 | motion_y = s->all_fragments[i].motion_y; | |
dc4b78d9 | 1413 | |
7a095ea6 DC |
1414 | src_x= (motion_x>>1) + 8*x; |
1415 | src_y= (motion_y>>1) + 8*y; | |
dc4b78d9 MM |
1416 | |
1417 | motion_halfpel_index = motion_x & 0x01; | |
1418 | motion_source += (motion_x >> 1); | |
1419 | ||
1420 | motion_halfpel_index |= (motion_y & 0x01) << 1; | |
1421 | motion_source += ((motion_y >> 1) * stride); | |
1422 | ||
1423 | if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){ | |
1424 | uint8_t *temp= s->edge_emu_buffer; | |
1425 | if(stride<0) temp -= 9*stride; | |
1426 | else temp += 9*stride; | |
1427 | ||
1428 | ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height); | |
1429 | motion_source= temp; | |
1430 | } | |
1431 | } | |
115329f1 | 1432 | |
dc4b78d9 MM |
1433 | |
1434 | /* first, take care of copying a block from either the | |
1435 | * previous or the golden frame */ | |
1436 | if (s->all_fragments[i].coding_method != MODE_INTRA) { | |
115329f1 DB |
1437 | /* Note, it is possible to implement all MC cases with |
1438 | put_no_rnd_pixels_l2 which would look more like the | |
1439 | VP3 source but this would be slower as | |
dc4b78d9 MM |
1440 | put_no_rnd_pixels_tab is better optimzed */ |
1441 | if(motion_halfpel_index != 3){ | |
1442 | s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index]( | |
735acf56 | 1443 | output_plane + first_pixel, |
dc4b78d9 MM |
1444 | motion_source, stride, 8); |
1445 | }else{ | |
1446 | int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1 | |
1447 | s->dsp.put_no_rnd_pixels_l2[1]( | |
735acf56 | 1448 | output_plane + first_pixel, |
115329f1 DB |
1449 | motion_source - d, |
1450 | motion_source + stride + 1 + d, | |
dc4b78d9 MM |
1451 | stride, 8); |
1452 | } | |
dc4b78d9 MM |
1453 | } |
1454 | ||
5fecfb7d | 1455 | s->dsp.clear_block(block); |
c72625f2 | 1456 | vp3_dequant(s, s->all_fragments + i, plane, !intra, block); |
dc4b78d9 MM |
1457 | |
1458 | /* invert DCT and place (or add) in final output */ | |
115329f1 | 1459 | |
dc4b78d9 MM |
1460 | if (s->all_fragments[i].coding_method == MODE_INTRA) { |
1461 | if(s->avctx->idct_algo!=FF_IDCT_VP3) | |
1462 | block[0] += 128<<3; | |
1463 | s->dsp.idct_put( | |
735acf56 | 1464 | output_plane + first_pixel, |
dc4b78d9 MM |
1465 | stride, |
1466 | block); | |
1467 | } else { | |
1468 | s->dsp.idct_add( | |
735acf56 | 1469 | output_plane + first_pixel, |
dc4b78d9 MM |
1470 | stride, |
1471 | block); | |
1472 | } | |
dc4b78d9 MM |
1473 | } else { |
1474 | ||
1475 | /* copy directly from the previous frame */ | |
1476 | s->dsp.put_pixels_tab[1][0]( | |
735acf56 DC |
1477 | output_plane + first_pixel, |
1478 | last_plane + first_pixel, | |
dc4b78d9 MM |
1479 | stride, 8); |
1480 | ||
1481 | } | |
7a095ea6 | 1482 | } |
dc4b78d9 | 1483 | } |
7a095ea6 DC |
1484 | |
1485 | // Filter up to the last row in the superblock row | |
1486 | apply_loop_filter(s, plane, 4*sb_y - !!sb_y, FFMIN(4*sb_y+3, fragment_height-1)); | |
dc4b78d9 MM |
1487 | } |
1488 | } | |
1489 | ||
dc4b78d9 MM |
1490 | /* this looks like a good place for slice dispatch... */ |
1491 | /* algorithm: | |
dc4b78d9 | 1492 | * if (slice == s->macroblock_height - 1) |
f44b08a5 MM |
1493 | * dispatch (both last slice & 2nd-to-last slice); |
1494 | * else if (slice > 0) | |
1495 | * dispatch (slice - 1); | |
dc4b78d9 MM |
1496 | */ |
1497 | ||
d63a7187 | 1498 | vp3_draw_horiz_band(s, FFMIN(64*slice + 64-16, s->height-16)); |
dc4b78d9 MM |
1499 | } |
1500 | ||
115329f1 | 1501 | /* |
d86053a4 MM |
1502 | * This is the ffmpeg/libavcodec API init function. |
1503 | */ | |
98a6fff9 | 1504 | static av_cold int vp3_decode_init(AVCodecContext *avctx) |
d86053a4 MM |
1505 | { |
1506 | Vp3DecodeContext *s = avctx->priv_data; | |
ae1dd8e1 | 1507 | int i, inter, plane; |
892fc83e MM |
1508 | int c_width; |
1509 | int c_height; | |
1e76a1da | 1510 | int y_fragment_count, c_fragment_count; |
d86053a4 | 1511 | |
3c3f113e | 1512 | if (avctx->codec_tag == MKTAG('V','P','3','0')) |
bb270c08 | 1513 | s->version = 0; |
3c3f113e | 1514 | else |
bb270c08 | 1515 | s->version = 1; |
3c3f113e | 1516 | |
d86053a4 | 1517 | s->avctx = avctx; |
ef516f73 DC |
1518 | s->width = FFALIGN(avctx->width, 16); |
1519 | s->height = FFALIGN(avctx->height, 16); | |
1e76a1da DC |
1520 | if (avctx->pix_fmt == PIX_FMT_NONE) |
1521 | avctx->pix_fmt = PIX_FMT_YUV420P; | |
580a7465 | 1522 | avctx->chroma_sample_location = AVCHROMA_LOC_CENTER; |
8b6103da MN |
1523 | if(avctx->idct_algo==FF_IDCT_AUTO) |
1524 | avctx->idct_algo=FF_IDCT_VP3; | |
d86053a4 | 1525 | dsputil_init(&s->dsp, avctx); |
115329f1 | 1526 | |
36af0c95 | 1527 | ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct); |
d86053a4 MM |
1528 | |
1529 | /* initialize to an impossible value which will force a recalculation | |
1530 | * in the first frame decode */ | |
f2264fa5 DC |
1531 | for (i = 0; i < 3; i++) |
1532 | s->qps[i] = -1; | |
d86053a4 | 1533 | |
1e76a1da DC |
1534 | avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift); |
1535 | ||
892fc83e MM |
1536 | s->y_superblock_width = (s->width + 31) / 32; |
1537 | s->y_superblock_height = (s->height + 31) / 32; | |
35c28d23 | 1538 | s->y_superblock_count = s->y_superblock_width * s->y_superblock_height; |
892fc83e MM |
1539 | |
1540 | /* work out the dimensions for the C planes */ | |
1e76a1da DC |
1541 | c_width = s->width >> s->chroma_x_shift; |
1542 | c_height = s->height >> s->chroma_y_shift; | |
892fc83e MM |
1543 | s->c_superblock_width = (c_width + 31) / 32; |
1544 | s->c_superblock_height = (c_height + 31) / 32; | |
35c28d23 | 1545 | s->c_superblock_count = s->c_superblock_width * s->c_superblock_height; |
892fc83e | 1546 | |
35c28d23 DC |
1547 | s->superblock_count = s->y_superblock_count + (s->c_superblock_count * 2); |
1548 | s->u_superblock_start = s->y_superblock_count; | |
1549 | s->v_superblock_start = s->u_superblock_start + s->c_superblock_count; | |
d86053a4 MM |
1550 | s->superblock_coding = av_malloc(s->superblock_count); |
1551 | ||
1552 | s->macroblock_width = (s->width + 15) / 16; | |
1553 | s->macroblock_height = (s->height + 15) / 16; | |
1554 | s->macroblock_count = s->macroblock_width * s->macroblock_height; | |
1555 | ||
57783884 DC |
1556 | s->fragment_width[0] = s->width / FRAGMENT_PIXELS; |
1557 | s->fragment_height[0] = s->height / FRAGMENT_PIXELS; | |
1e76a1da DC |
1558 | s->fragment_width[1] = s->fragment_width[0] >> s->chroma_x_shift; |
1559 | s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift; | |
d86053a4 MM |
1560 | |
1561 | /* fragment count covers all 8x8 blocks for all 3 planes */ | |
1e76a1da DC |
1562 | y_fragment_count = s->fragment_width[0] * s->fragment_height[0]; |
1563 | c_fragment_count = s->fragment_width[1] * s->fragment_height[1]; | |
1564 | s->fragment_count = y_fragment_count + 2*c_fragment_count; | |
1565 | s->fragment_start[1] = y_fragment_count; | |
1566 | s->fragment_start[2] = y_fragment_count + c_fragment_count; | |
d86053a4 | 1567 | |
d86053a4 | 1568 | s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment)); |
c72625f2 DC |
1569 | s->coded_fragment_list[0] = av_malloc(s->fragment_count * sizeof(int)); |
1570 | s->dct_tokens_base = av_malloc(64*s->fragment_count * sizeof(*s->dct_tokens_base)); | |
1571 | if (!s->superblock_coding || !s->all_fragments || !s->dct_tokens_base || | |
1572 | !s->coded_fragment_list[0]) { | |
0efbd068 MM |
1573 | vp3_decode_end(avctx); |
1574 | return -1; | |
1575 | } | |
d86053a4 | 1576 | |
f44ee2c3 AB |
1577 | if (!s->theora_tables) |
1578 | { | |
2287c100 | 1579 | for (i = 0; i < 64; i++) { |
bb270c08 | 1580 | s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i]; |
bb270c08 | 1581 | s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i]; |
ae1dd8e1 | 1582 | s->base_matrix[0][i] = vp31_intra_y_dequant[i]; |
ae1dd8e1 | 1583 | s->base_matrix[1][i] = vp31_intra_c_dequant[i]; |
ae1dd8e1 | 1584 | s->base_matrix[2][i] = vp31_inter_dequant[i]; |
bb270c08 | 1585 | s->filter_limit_values[i] = vp31_filter_limit_values[i]; |
2287c100 | 1586 | } |
f44ee2c3 | 1587 | |
ae1dd8e1 MN |
1588 | for(inter=0; inter<2; inter++){ |
1589 | for(plane=0; plane<3; plane++){ | |
1590 | s->qr_count[inter][plane]= 1; | |
1591 | s->qr_size [inter][plane][0]= 63; | |
1592 | s->qr_base [inter][plane][0]= | |
1593 | s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter; | |
1594 | } | |
1595 | } | |
1596 | ||
39922395 MM |
1597 | /* init VLC tables */ |
1598 | for (i = 0; i < 16; i++) { | |
1599 | ||
1600 | /* DC histograms */ | |
1601 | init_vlc(&s->dc_vlc[i], 5, 32, | |
1602 | &dc_bias[i][0][1], 4, 2, | |
1603 | &dc_bias[i][0][0], 4, 2, 0); | |
1604 | ||
1605 | /* group 1 AC histograms */ | |
1606 | init_vlc(&s->ac_vlc_1[i], 5, 32, | |
1607 | &ac_bias_0[i][0][1], 4, 2, | |
1608 | &ac_bias_0[i][0][0], 4, 2, 0); | |
1609 | ||
1610 | /* group 2 AC histograms */ | |
1611 | init_vlc(&s->ac_vlc_2[i], 5, 32, | |
1612 | &ac_bias_1[i][0][1], 4, 2, | |
1613 | &ac_bias_1[i][0][0], 4, 2, 0); | |
1614 | ||
1615 | /* group 3 AC histograms */ | |
1616 | init_vlc(&s->ac_vlc_3[i], 5, 32, | |
1617 | &ac_bias_2[i][0][1], 4, 2, | |
1618 | &ac_bias_2[i][0][0], 4, 2, 0); | |
1619 | ||
1620 | /* group 4 AC histograms */ | |
1621 | init_vlc(&s->ac_vlc_4[i], 5, 32, | |
1622 | &ac_bias_3[i][0][1], 4, 2, | |
1623 | &ac_bias_3[i][0][0], 4, 2, 0); | |
1624 | } | |
1625 | } else { | |
1626 | for (i = 0; i < 16; i++) { | |
1627 | ||
1628 | /* DC histograms */ | |
c4b7b8bf | 1629 | if (init_vlc(&s->dc_vlc[i], 5, 32, |
39922395 | 1630 | &s->huffman_table[i][0][1], 4, 2, |
c4b7b8bf RD |
1631 | &s->huffman_table[i][0][0], 4, 2, 0) < 0) |
1632 | goto vlc_fail; | |
39922395 MM |
1633 | |
1634 | /* group 1 AC histograms */ | |
c4b7b8bf | 1635 | if (init_vlc(&s->ac_vlc_1[i], 5, 32, |
39922395 | 1636 | &s->huffman_table[i+16][0][1], 4, 2, |
c4b7b8bf RD |
1637 | &s->huffman_table[i+16][0][0], 4, 2, 0) < 0) |
1638 | goto vlc_fail; | |
39922395 MM |
1639 | |
1640 | /* group 2 AC histograms */ | |
c4b7b8bf | 1641 | if (init_vlc(&s->ac_vlc_2[i], 5, 32, |
39922395 | 1642 | &s->huffman_table[i+16*2][0][1], 4, 2, |
c4b7b8bf RD |
1643 | &s->huffman_table[i+16*2][0][0], 4, 2, 0) < 0) |
1644 | goto vlc_fail; | |
39922395 MM |
1645 | |
1646 | /* group 3 AC histograms */ | |
c4b7b8bf | 1647 | if (init_vlc(&s->ac_vlc_3[i], 5, 32, |
39922395 | 1648 | &s->huffman_table[i+16*3][0][1], 4, 2, |
c4b7b8bf RD |
1649 | &s->huffman_table[i+16*3][0][0], 4, 2, 0) < 0) |
1650 | goto vlc_fail; | |
39922395 MM |
1651 | |
1652 | /* group 4 AC histograms */ | |
c4b7b8bf | 1653 | if (init_vlc(&s->ac_vlc_4[i], 5, 32, |
39922395 | 1654 | &s->huffman_table[i+16*4][0][1], 4, 2, |
c4b7b8bf RD |
1655 | &s->huffman_table[i+16*4][0][0], 4, 2, 0) < 0) |
1656 | goto vlc_fail; | |
39922395 | 1657 | } |
d86053a4 MM |
1658 | } |
1659 | ||
d8278bab MM |
1660 | init_vlc(&s->superblock_run_length_vlc, 6, 34, |
1661 | &superblock_run_length_vlc_table[0][1], 4, 2, | |
1662 | &superblock_run_length_vlc_table[0][0], 4, 2, 0); | |
1663 | ||
dd36b667 | 1664 | init_vlc(&s->fragment_run_length_vlc, 5, 30, |
0ad72bdd MM |
1665 | &fragment_run_length_vlc_table[0][1], 4, 2, |
1666 | &fragment_run_length_vlc_table[0][0], 4, 2, 0); | |
1667 | ||
1668 | init_vlc(&s->mode_code_vlc, 3, 8, | |
1669 | &mode_code_vlc_table[0][1], 2, 1, | |
1670 | &mode_code_vlc_table[0][0], 2, 1, 0); | |
1671 | ||
1672 | init_vlc(&s->motion_vector_vlc, 6, 63, | |
1673 | &motion_vector_vlc_table[0][1], 2, 1, | |
1674 | &motion_vector_vlc_table[0][0], 2, 1, 0); | |
1675 | ||
d86053a4 MM |
1676 | /* work out the block mapping tables */ |
1677 | s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int)); | |
96a7e73b | 1678 | s->macroblock_coding = av_malloc(s->macroblock_count + 1); |
ea676144 | 1679 | if (!s->superblock_fragments || !s->macroblock_coding) { |
0efbd068 MM |
1680 | vp3_decode_end(avctx); |
1681 | return -1; | |
1682 | } | |
d86053a4 MM |
1683 | init_block_mapping(s); |
1684 | ||
44ae98dd MM |
1685 | for (i = 0; i < 3; i++) { |
1686 | s->current_frame.data[i] = NULL; | |
1687 | s->last_frame.data[i] = NULL; | |
1688 | s->golden_frame.data[i] = NULL; | |
61873c4a MM |
1689 | } |
1690 | ||
d86053a4 | 1691 | return 0; |
c4b7b8bf RD |
1692 | |
1693 | vlc_fail: | |
1694 | av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n"); | |
1695 | return -1; | |
d86053a4 MM |
1696 | } |
1697 | ||
1698 | /* | |
1699 | * This is the ffmpeg/libavcodec API frame decode function. | |
1700 | */ | |
115329f1 | 1701 | static int vp3_decode_frame(AVCodecContext *avctx, |
d86053a4 | 1702 | void *data, int *data_size, |
7a00bbad | 1703 | AVPacket *avpkt) |
d86053a4 | 1704 | { |
7a00bbad TB |
1705 | const uint8_t *buf = avpkt->data; |
1706 | int buf_size = avpkt->size; | |
d86053a4 MM |
1707 | Vp3DecodeContext *s = avctx->priv_data; |
1708 | GetBitContext gb; | |
1709 | static int counter = 0; | |
dc4b78d9 | 1710 | int i; |
d86053a4 | 1711 | |
d86053a4 | 1712 | init_get_bits(&gb, buf, buf_size * 8); |
115329f1 | 1713 | |
f44ee2c3 AB |
1714 | if (s->theora && get_bits1(&gb)) |
1715 | { | |
bb270c08 DB |
1716 | av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n"); |
1717 | return -1; | |
f44ee2c3 | 1718 | } |
3c3f113e AB |
1719 | |
1720 | s->keyframe = !get_bits1(&gb); | |
1721 | if (!s->theora) | |
bb270c08 | 1722 | skip_bits(&gb, 1); |
f2264fa5 DC |
1723 | for (i = 0; i < 3; i++) |
1724 | s->last_qps[i] = s->qps[i]; | |
efea8528 | 1725 | |
f2264fa5 | 1726 | s->nqps=0; |
efea8528 | 1727 | do{ |
f2264fa5 DC |
1728 | s->qps[s->nqps++]= get_bits(&gb, 6); |
1729 | } while(s->theora >= 0x030200 && s->nqps<3 && get_bits1(&gb)); | |
1730 | for (i = s->nqps; i < 3; i++) | |
1731 | s->qps[i] = -1; | |
d86053a4 | 1732 | |
f8830383 | 1733 | if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
bb270c08 | 1734 | av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n", |
f2264fa5 | 1735 | s->keyframe?"key":"", counter, s->qps[0]); |
d86053a4 MM |
1736 | counter++; |
1737 | ||
f2264fa5 | 1738 | if (s->qps[0] != s->last_qps[0]) |
f44b08a5 | 1739 | init_loop_filter(s); |
f2264fa5 DC |
1740 | |
1741 | for (i = 0; i < s->nqps; i++) | |
1742 | // reinit all dequantizers if the first one changed, because | |
1743 | // the DC of the first quantizer must be used for all matrices | |
1744 | if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0]) | |
1745 | init_dequantizer(s, i); | |
642d7e84 | 1746 | |
068e82ba DC |
1747 | if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe) |
1748 | return buf_size; | |
1749 | ||
739b5090 | 1750 | s->current_frame.reference = 3; |
ff65969f | 1751 | s->current_frame.pict_type = s->keyframe ? FF_I_TYPE : FF_P_TYPE; |
739b5090 DC |
1752 | if (avctx->get_buffer(avctx, &s->current_frame) < 0) { |
1753 | av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
e72d2d12 | 1754 | goto error; |
739b5090 DC |
1755 | } |
1756 | ||
d86053a4 | 1757 | if (s->keyframe) { |
bb270c08 DB |
1758 | if (!s->theora) |
1759 | { | |
1760 | skip_bits(&gb, 4); /* width code */ | |
1761 | skip_bits(&gb, 4); /* height code */ | |
1762 | if (s->version) | |
1763 | { | |
1764 | s->version = get_bits(&gb, 5); | |
1765 | if (counter == 1) | |
1766 | av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version); | |
1767 | } | |
1768 | } | |
1769 | if (s->version || s->theora) | |
1770 | { | |
1771 | if (get_bits1(&gb)) | |
1772 | av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n"); | |
1773 | skip_bits(&gb, 2); /* reserved? */ | |
1774 | } | |
d86053a4 | 1775 | } else { |
735acf56 | 1776 | if (!s->golden_frame.data[0]) { |
7a4e8b59 | 1777 | av_log(s->avctx, AV_LOG_WARNING, "vp3: first frame not a keyframe\n"); |
ff65969f | 1778 | |
7a4e8b59 | 1779 | s->golden_frame.reference = 3; |
ff65969f | 1780 | s->golden_frame.pict_type = FF_I_TYPE; |
7a4e8b59 DC |
1781 | if (avctx->get_buffer(avctx, &s->golden_frame) < 0) { |
1782 | av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
1783 | goto error; | |
1784 | } | |
1785 | s->last_frame = s->golden_frame; | |
1786 | s->last_frame.type = FF_BUFFER_TYPE_COPY; | |
d86053a4 | 1787 | } |
d86053a4 MM |
1788 | } |
1789 | ||
b928ec64 MN |
1790 | s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame |
1791 | s->current_frame.qstride= 0; | |
1792 | ||
703acd54 | 1793 | memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment)); |
d86053a4 | 1794 | |
220a6f40 MN |
1795 | if (unpack_superblocks(s, &gb)){ |
1796 | av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n"); | |
e72d2d12 | 1797 | goto error; |
220a6f40 | 1798 | } |
220a6f40 MN |
1799 | if (unpack_modes(s, &gb)){ |
1800 | av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n"); | |
e72d2d12 | 1801 | goto error; |
220a6f40 | 1802 | } |
220a6f40 MN |
1803 | if (unpack_vectors(s, &gb)){ |
1804 | av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n"); | |
e72d2d12 | 1805 | goto error; |
220a6f40 | 1806 | } |
f2264fa5 DC |
1807 | if (unpack_block_qpis(s, &gb)){ |
1808 | av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n"); | |
e72d2d12 | 1809 | goto error; |
f2264fa5 | 1810 | } |
220a6f40 MN |
1811 | if (unpack_dct_coeffs(s, &gb)){ |
1812 | av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n"); | |
e72d2d12 | 1813 | goto error; |
892fc83e | 1814 | } |
735acf56 DC |
1815 | |
1816 | for (i = 0; i < 3; i++) { | |
1e76a1da | 1817 | int height = s->height >> (i && s->chroma_y_shift); |
735acf56 DC |
1818 | if (s->flipped_image) |
1819 | s->data_offset[i] = 0; | |
1820 | else | |
1e76a1da | 1821 | s->data_offset[i] = (height-1) * s->current_frame.linesize[i]; |
735acf56 | 1822 | } |
d86053a4 | 1823 | |
a8de3901 | 1824 | s->last_slice_end = 0; |
7a095ea6 | 1825 | for (i = 0; i < s->c_superblock_height; i++) |
dc4b78d9 | 1826 | render_slice(s, i); |
d86053a4 | 1827 | |
256c0662 DC |
1828 | // filter the last row |
1829 | for (i = 0; i < 3; i++) { | |
1e76a1da | 1830 | int row = (s->height >> (3+(i && s->chroma_y_shift))) - 1; |
256c0662 DC |
1831 | apply_loop_filter(s, i, row, row+1); |
1832 | } | |
a8de3901 | 1833 | vp3_draw_horiz_band(s, s->height); |
892fc83e | 1834 | |
d86053a4 MM |
1835 | *data_size=sizeof(AVFrame); |
1836 | *(AVFrame*)data= s->current_frame; | |
1837 | ||
44ae98dd MM |
1838 | /* release the last frame, if it is allocated and if it is not the |
1839 | * golden frame */ | |
0c9afacb | 1840 | if (s->last_frame.data[0] && s->last_frame.type != FF_BUFFER_TYPE_COPY) |
44ae98dd | 1841 | avctx->release_buffer(avctx, &s->last_frame); |
d86053a4 | 1842 | |
61873c4a | 1843 | /* shuffle frames (last = current) */ |
4501e678 | 1844 | s->last_frame= s->current_frame; |
739b5090 DC |
1845 | |
1846 | if (s->keyframe) { | |
1847 | if (s->golden_frame.data[0]) | |
1848 | avctx->release_buffer(avctx, &s->golden_frame); | |
1849 | s->golden_frame = s->current_frame; | |
0c9afacb | 1850 | s->last_frame.type = FF_BUFFER_TYPE_COPY; |
739b5090 DC |
1851 | } |
1852 | ||
8e39d4a7 | 1853 | s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */ |
d86053a4 MM |
1854 | |
1855 | return buf_size; | |
e72d2d12 DC |
1856 | |
1857 | error: | |
1858 | if (s->current_frame.data[0]) | |
1859 | avctx->release_buffer(avctx, &s->current_frame); | |
1860 | return -1; | |
d86053a4 MM |
1861 | } |
1862 | ||
1863 | /* | |
1864 | * This is the ffmpeg/libavcodec API module cleanup function. | |
1865 | */ | |
98a6fff9 | 1866 | static av_cold int vp3_decode_end(AVCodecContext *avctx) |
d86053a4 MM |
1867 | { |
1868 | Vp3DecodeContext *s = avctx->priv_data; | |
6f4e2b5a | 1869 | int i; |
d86053a4 | 1870 | |
6f4e2b5a | 1871 | av_free(s->superblock_coding); |
d86053a4 | 1872 | av_free(s->all_fragments); |
c72625f2 DC |
1873 | av_free(s->coded_fragment_list[0]); |
1874 | av_free(s->dct_tokens_base); | |
d86053a4 | 1875 | av_free(s->superblock_fragments); |
96a7e73b | 1876 | av_free(s->macroblock_coding); |
115329f1 | 1877 | |
6f4e2b5a MR |
1878 | for (i = 0; i < 16; i++) { |
1879 | free_vlc(&s->dc_vlc[i]); | |
1880 | free_vlc(&s->ac_vlc_1[i]); | |
1881 | free_vlc(&s->ac_vlc_2[i]); | |
1882 | free_vlc(&s->ac_vlc_3[i]); | |
1883 | free_vlc(&s->ac_vlc_4[i]); | |
1884 | } | |
1885 | ||
1886 | free_vlc(&s->superblock_run_length_vlc); | |
1887 | free_vlc(&s->fragment_run_length_vlc); | |
1888 | free_vlc(&s->mode_code_vlc); | |
1889 | free_vlc(&s->motion_vector_vlc); | |
1890 | ||
d86053a4 | 1891 | /* release all frames */ |
0c9afacb | 1892 | if (s->golden_frame.data[0]) |
892fc83e | 1893 | avctx->release_buffer(avctx, &s->golden_frame); |
0c9afacb | 1894 | if (s->last_frame.data[0] && s->last_frame.type != FF_BUFFER_TYPE_COPY) |
892fc83e MM |
1895 | avctx->release_buffer(avctx, &s->last_frame); |
1896 | /* no need to release the current_frame since it will always be pointing | |
1897 | * to the same frame as either the golden or last frame */ | |
d86053a4 MM |
1898 | |
1899 | return 0; | |
1900 | } | |
1901 | ||
39922395 MM |
1902 | static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb) |
1903 | { | |
1904 | Vp3DecodeContext *s = avctx->priv_data; | |
1905 | ||
5fc32c27 | 1906 | if (get_bits1(gb)) { |
39922395 MM |
1907 | int token; |
1908 | if (s->entries >= 32) { /* overflow */ | |
1909 | av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n"); | |
1910 | return -1; | |
1911 | } | |
1912 | token = get_bits(gb, 5); | |
1913 | //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size); | |
1914 | s->huffman_table[s->hti][token][0] = s->hbits; | |
1915 | s->huffman_table[s->hti][token][1] = s->huff_code_size; | |
1916 | s->entries++; | |
1917 | } | |
1918 | else { | |
1919 | if (s->huff_code_size >= 32) {/* overflow */ | |
1920 | av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n"); | |
1921 | return -1; | |
1922 | } | |
1923 | s->huff_code_size++; | |
1924 | s->hbits <<= 1; | |
00bbe276 AC |
1925 | if (read_huffman_tree(avctx, gb)) |
1926 | return -1; | |
39922395 | 1927 | s->hbits |= 1; |
00bbe276 AC |
1928 | if (read_huffman_tree(avctx, gb)) |
1929 | return -1; | |
39922395 MM |
1930 | s->hbits >>= 1; |
1931 | s->huff_code_size--; | |
1932 | } | |
1933 | return 0; | |
1934 | } | |
1935 | ||
b250f9c6 | 1936 | #if CONFIG_THEORA_DECODER |
1e76a1da DC |
1937 | static const enum PixelFormat theora_pix_fmts[4] = { |
1938 | PIX_FMT_YUV420P, PIX_FMT_NONE, PIX_FMT_YUV422P, PIX_FMT_YUV444P | |
1939 | }; | |
1940 | ||
e278056f | 1941 | static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb) |
f44ee2c3 AB |
1942 | { |
1943 | Vp3DecodeContext *s = avctx->priv_data; | |
ea3c2d53 | 1944 | int visible_width, visible_height, colorspace; |
9a7ad925 | 1945 | |
e278056f | 1946 | s->theora = get_bits_long(gb, 24); |
356306ac | 1947 | av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora); |
105c3d25 | 1948 | |
ba7ee4a4 | 1949 | /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */ |
9a7ad925 | 1950 | /* but previous versions have the image flipped relative to vp3 */ |
ba7ee4a4 | 1951 | if (s->theora < 0x030200) |
9a7ad925 | 1952 | { |
bb270c08 | 1953 | s->flipped_image = 1; |
9a7ad925 AB |
1954 | av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n"); |
1955 | } | |
f44ee2c3 | 1956 | |
277e3e53 DC |
1957 | visible_width = s->width = get_bits(gb, 16) << 4; |
1958 | visible_height = s->height = get_bits(gb, 16) << 4; | |
115329f1 | 1959 | |
0ecca7a4 | 1960 | if(avcodec_check_dimensions(avctx, s->width, s->height)){ |
7146d2c2 | 1961 | av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height); |
0ecca7a4 MN |
1962 | s->width= s->height= 0; |
1963 | return -1; | |
1964 | } | |
7146d2c2 | 1965 | |
277e3e53 | 1966 | if (s->theora >= 0x030200) { |
a0ce2d1b DC |
1967 | visible_width = get_bits_long(gb, 24); |
1968 | visible_height = get_bits_long(gb, 24); | |
c0f716b8 | 1969 | |
ba4816a0 AJ |
1970 | skip_bits(gb, 8); /* offset x */ |
1971 | skip_bits(gb, 8); /* offset y */ | |
1972 | } | |
f44ee2c3 | 1973 | |
e278056f MN |
1974 | skip_bits(gb, 32); /* fps numerator */ |
1975 | skip_bits(gb, 32); /* fps denumerator */ | |
1976 | skip_bits(gb, 24); /* aspect numerator */ | |
1977 | skip_bits(gb, 24); /* aspect denumerator */ | |
115329f1 | 1978 | |
ba7ee4a4 | 1979 | if (s->theora < 0x030200) |
e278056f | 1980 | skip_bits(gb, 5); /* keyframe frequency force */ |
ea3c2d53 | 1981 | colorspace = get_bits(gb, 8); |
e278056f | 1982 | skip_bits(gb, 24); /* bitrate */ |
f44ee2c3 | 1983 | |
e278056f | 1984 | skip_bits(gb, 6); /* quality hint */ |
115329f1 | 1985 | |
ba7ee4a4 | 1986 | if (s->theora >= 0x030200) |
105c3d25 | 1987 | { |
e278056f | 1988 | skip_bits(gb, 5); /* keyframe frequency force */ |
1e76a1da | 1989 | avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)]; |
337f5c6e | 1990 | skip_bits(gb, 3); /* reserved */ |
105c3d25 | 1991 | } |
115329f1 | 1992 | |
e278056f | 1993 | // align_get_bits(gb); |
115329f1 | 1994 | |
c0f716b8 AJ |
1995 | if ( visible_width <= s->width && visible_width > s->width-16 |
1996 | && visible_height <= s->height && visible_height > s->height-16) | |
1997 | avcodec_set_dimensions(avctx, visible_width, visible_height); | |
1998 | else | |
1999 | avcodec_set_dimensions(avctx, s->width, s->height); | |
f44ee2c3 | 2000 | |
ea3c2d53 DC |
2001 | if (colorspace == 1) { |
2002 | avctx->color_primaries = AVCOL_PRI_BT470M; | |
2003 | } else if (colorspace == 2) { | |
2004 | avctx->color_primaries = AVCOL_PRI_BT470BG; | |
2005 | } | |
2006 | if (colorspace == 1 || colorspace == 2) { | |
2007 | avctx->colorspace = AVCOL_SPC_BT470BG; | |
2008 | avctx->color_trc = AVCOL_TRC_BT709; | |
2009 | } | |
2010 | ||
f44ee2c3 AB |
2011 | return 0; |
2012 | } | |
2013 | ||
e278056f | 2014 | static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb) |
f44ee2c3 AB |
2015 | { |
2016 | Vp3DecodeContext *s = avctx->priv_data; | |
ae1dd8e1 | 2017 | int i, n, matrices, inter, plane; |
ba7ee4a4 MC |
2018 | |
2019 | if (s->theora >= 0x030200) { | |
e278056f | 2020 | n = get_bits(gb, 3); |
9c7154c7 | 2021 | /* loop filter limit values table */ |
e13cca4b | 2022 | for (i = 0; i < 64; i++) { |
e278056f | 2023 | s->filter_limit_values[i] = get_bits(gb, n); |
e13cca4b RD |
2024 | if (s->filter_limit_values[i] > 127) { |
2025 | av_log(avctx, AV_LOG_ERROR, "filter limit value too large (%i > 127), clamping\n", s->filter_limit_values[i]); | |
2026 | s->filter_limit_values[i] = 127; | |
2027 | } | |
2028 | } | |
ba7ee4a4 | 2029 | } |
115329f1 | 2030 | |
ba7ee4a4 | 2031 | if (s->theora >= 0x030200) |
e278056f | 2032 | n = get_bits(gb, 4) + 1; |
ba7ee4a4 MC |
2033 | else |
2034 | n = 16; | |
f44ee2c3 AB |
2035 | /* quality threshold table */ |
2036 | for (i = 0; i < 64; i++) | |
e278056f | 2037 | s->coded_ac_scale_factor[i] = get_bits(gb, n); |
f44ee2c3 | 2038 | |
ba7ee4a4 | 2039 | if (s->theora >= 0x030200) |
e278056f | 2040 | n = get_bits(gb, 4) + 1; |
ba7ee4a4 MC |
2041 | else |
2042 | n = 16; | |
f44ee2c3 AB |
2043 | /* dc scale factor table */ |
2044 | for (i = 0; i < 64; i++) | |
e278056f | 2045 | s->coded_dc_scale_factor[i] = get_bits(gb, n); |
f44ee2c3 | 2046 | |
ba7ee4a4 | 2047 | if (s->theora >= 0x030200) |
e278056f | 2048 | matrices = get_bits(gb, 9) + 1; |
ba7ee4a4 | 2049 | else |
2da2ba03 | 2050 | matrices = 3; |
f44ee2c3 | 2051 | |
ae1dd8e1 MN |
2052 | if(matrices > 384){ |
2053 | av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n"); | |
2054 | return -1; | |
2055 | } | |
3c3f113e | 2056 | |
ae1dd8e1 | 2057 | for(n=0; n<matrices; n++){ |
bb270c08 | 2058 | for (i = 0; i < 64; i++) |
ae1dd8e1 MN |
2059 | s->base_matrix[n][i]= get_bits(gb, 8); |
2060 | } | |
2da2ba03 | 2061 | |
ae1dd8e1 MN |
2062 | for (inter = 0; inter <= 1; inter++) { |
2063 | for (plane = 0; plane <= 2; plane++) { | |
2064 | int newqr= 1; | |
2065 | if (inter || plane > 0) | |
5fc32c27 | 2066 | newqr = get_bits1(gb); |
39922395 | 2067 | if (!newqr) { |
ae1dd8e1 | 2068 | int qtj, plj; |
5fc32c27 | 2069 | if(inter && get_bits1(gb)){ |
ae1dd8e1 MN |
2070 | qtj = 0; |
2071 | plj = plane; | |
2072 | }else{ | |
2073 | qtj= (3*inter + plane - 1) / 3; | |
2074 | plj= (plane + 2) % 3; | |
2075 | } | |
2076 | s->qr_count[inter][plane]= s->qr_count[qtj][plj]; | |
2077 | memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0])); | |
2078 | memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0])); | |
2079 | } else { | |
2080 | int qri= 0; | |
39922395 | 2081 | int qi = 0; |
ae1dd8e1 MN |
2082 | |
2083 | for(;;){ | |
2084 | i= get_bits(gb, av_log2(matrices-1)+1); | |
2085 | if(i>= matrices){ | |
2086 | av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n"); | |
2087 | return -1; | |
2088 | } | |
2089 | s->qr_base[inter][plane][qri]= i; | |
2090 | if(qi >= 63) | |
2091 | break; | |
2092 | i = get_bits(gb, av_log2(63-qi)+1) + 1; | |
2093 | s->qr_size[inter][plane][qri++]= i; | |
2094 | qi += i; | |
39922395 | 2095 | } |
ae1dd8e1 | 2096 | |
2da2ba03 | 2097 | if (qi > 63) { |
7146d2c2 | 2098 | av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi); |
bb270c08 DB |
2099 | return -1; |
2100 | } | |
ae1dd8e1 | 2101 | s->qr_count[inter][plane]= qri; |
39922395 MM |
2102 | } |
2103 | } | |
2104 | } | |
2105 | ||
2da2ba03 | 2106 | /* Huffman tables */ |
39922395 MM |
2107 | for (s->hti = 0; s->hti < 80; s->hti++) { |
2108 | s->entries = 0; | |
2109 | s->huff_code_size = 1; | |
5fc32c27 | 2110 | if (!get_bits1(gb)) { |
39922395 | 2111 | s->hbits = 0; |
00bbe276 AC |
2112 | if(read_huffman_tree(avctx, gb)) |
2113 | return -1; | |
39922395 | 2114 | s->hbits = 1; |
00bbe276 AC |
2115 | if(read_huffman_tree(avctx, gb)) |
2116 | return -1; | |
39922395 MM |
2117 | } |
2118 | } | |
115329f1 | 2119 | |
f44ee2c3 | 2120 | s->theora_tables = 1; |
115329f1 | 2121 | |
f44ee2c3 AB |
2122 | return 0; |
2123 | } | |
2124 | ||
5ef251e5 | 2125 | static av_cold int theora_decode_init(AVCodecContext *avctx) |
f44ee2c3 AB |
2126 | { |
2127 | Vp3DecodeContext *s = avctx->priv_data; | |
2128 | GetBitContext gb; | |
2129 | int ptype; | |
da91ed59 AJ |
2130 | uint8_t *header_start[3]; |
2131 | int header_len[3]; | |
2132 | int i; | |
115329f1 | 2133 | |
f44ee2c3 AB |
2134 | s->theora = 1; |
2135 | ||
2136 | if (!avctx->extradata_size) | |
7146d2c2 AB |
2137 | { |
2138 | av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n"); | |
bb270c08 | 2139 | return -1; |
7146d2c2 | 2140 | } |
f44ee2c3 | 2141 | |
da91ed59 AJ |
2142 | if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size, |
2143 | 42, header_start, header_len) < 0) { | |
2144 | av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n"); | |
2145 | return -1; | |
2146 | } | |
ee89b2b9 | 2147 | |
da91ed59 | 2148 | for(i=0;i<3;i++) { |
fa6f2751 | 2149 | init_get_bits(&gb, header_start[i], header_len[i] * 8); |
f44ee2c3 AB |
2150 | |
2151 | ptype = get_bits(&gb, 8); | |
115329f1 | 2152 | |
7146d2c2 AB |
2153 | if (!(ptype & 0x80)) |
2154 | { | |
2155 | av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n"); | |
e278056f | 2156 | // return -1; |
115329f1 | 2157 | } |
7146d2c2 | 2158 | |
3700dab4 | 2159 | // FIXME: Check for this as well. |
0a8dedc9 | 2160 | skip_bits_long(&gb, 6*8); /* "theora" */ |
115329f1 | 2161 | |
f44ee2c3 AB |
2162 | switch(ptype) |
2163 | { | |
2164 | case 0x80: | |
e278056f | 2165 | theora_decode_header(avctx, &gb); |
bb270c08 DB |
2166 | break; |
2167 | case 0x81: | |
2da2ba03 | 2168 | // FIXME: is this needed? it breaks sometimes |
bb270c08 DB |
2169 | // theora_decode_comments(avctx, gb); |
2170 | break; | |
2171 | case 0x82: | |
00bbe276 AC |
2172 | if (theora_decode_tables(avctx, &gb)) |
2173 | return -1; | |
bb270c08 DB |
2174 | break; |
2175 | default: | |
2176 | av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80); | |
2177 | break; | |
f44ee2c3 | 2178 | } |
12ce1f3f DC |
2179 | if(ptype != 0x81 && 8*header_len[i] != get_bits_count(&gb)) |
2180 | av_log(avctx, AV_LOG_WARNING, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype); | |
116d866c MC |
2181 | if (s->theora < 0x030200) |
2182 | break; | |
ee89b2b9 | 2183 | } |
f44ee2c3 | 2184 | |
c79c960a | 2185 | return vp3_decode_init(avctx); |
f44ee2c3 AB |
2186 | } |
2187 | ||
6f6a3e2a DB |
2188 | AVCodec theora_decoder = { |
2189 | "theora", | |
d86053a4 | 2190 | CODEC_TYPE_VIDEO, |
6f6a3e2a | 2191 | CODEC_ID_THEORA, |
d86053a4 | 2192 | sizeof(Vp3DecodeContext), |
6f6a3e2a | 2193 | theora_decode_init, |
d86053a4 MM |
2194 | NULL, |
2195 | vp3_decode_end, | |
2196 | vp3_decode_frame, | |
a8de3901 | 2197 | CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND, |
d5202e4f | 2198 | NULL, |
fe4bf374 | 2199 | .long_name = NULL_IF_CONFIG_SMALL("Theora"), |
d86053a4 | 2200 | }; |
6f6a3e2a | 2201 | #endif |
f44ee2c3 | 2202 | |
6f6a3e2a DB |
2203 | AVCodec vp3_decoder = { |
2204 | "vp3", | |
f44ee2c3 | 2205 | CODEC_TYPE_VIDEO, |
6f6a3e2a | 2206 | CODEC_ID_VP3, |
f44ee2c3 | 2207 | sizeof(Vp3DecodeContext), |
6f6a3e2a | 2208 | vp3_decode_init, |
f44ee2c3 AB |
2209 | NULL, |
2210 | vp3_decode_end, | |
2211 | vp3_decode_frame, | |
a8de3901 | 2212 | CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND, |
d5202e4f | 2213 | NULL, |
fe4bf374 | 2214 | .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"), |
f44ee2c3 | 2215 | }; |