aboutsummaryrefslogtreecommitdiff
path: root/src/plugins/ffmpeg/libavcodec/vp3.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/ffmpeg/libavcodec/vp3.c')
-rw-r--r--src/plugins/ffmpeg/libavcodec/vp3.c2645
1 files changed, 0 insertions, 2645 deletions
diff --git a/src/plugins/ffmpeg/libavcodec/vp3.c b/src/plugins/ffmpeg/libavcodec/vp3.c
deleted file mode 100644
index 3c06fe4..0000000
--- a/src/plugins/ffmpeg/libavcodec/vp3.c
+++ /dev/null
@@ -1,2645 +0,0 @@
1/*
2 * Copyright (C) 2003-2004 the ffmpeg project
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 vp3.c
23 * On2 VP3 Video Decoder
24 *
25 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
26 * For more information about the VP3 coding process, visit:
27 * http://wiki.multimedia.cx/index.php?title=On2_VP3
28 *
29 * Theora decoder by Alex Beregszaszi
30 */
31
32#include <stdio.h>
33#include <stdlib.h>
34#include <string.h>
35#include <unistd.h>
36
37#include "avcodec.h"
38#include "dsputil.h"
39#include "bitstream.h"
40
41#include "vp3data.h"
42#include "xiph.h"
43
44#define FRAGMENT_PIXELS 8
45
46/*
47 * Debugging Variables
48 *
49 * Define one or more of the following compile-time variables to 1 to obtain
50 * elaborate information about certain aspects of the decoding process.
51 *
52 * KEYFRAMES_ONLY: set this to 1 to only see keyframes (VP3 slideshow mode)
53 * DEBUG_VP3: high-level decoding flow
54 * DEBUG_INIT: initialization parameters
55 * DEBUG_DEQUANTIZERS: display how the dequanization tables are built
56 * DEBUG_BLOCK_CODING: unpacking the superblock/macroblock/fragment coding
57 * DEBUG_MODES: unpacking the coding modes for individual fragments
58 * DEBUG_VECTORS: display the motion vectors
59 * DEBUG_TOKEN: display exhaustive information about each DCT token
60 * DEBUG_VLC: display the VLCs as they are extracted from the stream
61 * DEBUG_DC_PRED: display the process of reversing DC prediction
62 * DEBUG_IDCT: show every detail of the IDCT process
63 */
64
65#define KEYFRAMES_ONLY 0
66
67#define DEBUG_VP3 0
68#define DEBUG_INIT 0
69#define DEBUG_DEQUANTIZERS 0
70#define DEBUG_BLOCK_CODING 0
71#define DEBUG_MODES 0
72#define DEBUG_VECTORS 0
73#define DEBUG_TOKEN 0
74#define DEBUG_VLC 0
75#define DEBUG_DC_PRED 0
76#define DEBUG_IDCT 0
77
78#if DEBUG_VP3
79#define debug_vp3(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
80#else
81static inline void debug_vp3(const char *format, ...) { }
82#endif
83
84#if DEBUG_INIT
85#define debug_init(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
86#else
87static inline void debug_init(const char *format, ...) { }
88#endif
89
90#if DEBUG_DEQUANTIZERS
91#define debug_dequantizers(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
92#else
93static inline void debug_dequantizers(const char *format, ...) { }
94#endif
95
96#if DEBUG_BLOCK_CODING
97#define debug_block_coding(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
98#else
99static inline void debug_block_coding(const char *format, ...) { }
100#endif
101
102#if DEBUG_MODES
103#define debug_modes(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
104#else
105static inline void debug_modes(const char *format, ...) { }
106#endif
107
108#if DEBUG_VECTORS
109#define debug_vectors(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
110#else
111static inline void debug_vectors(const char *format, ...) { }
112#endif
113
114#if DEBUG_TOKEN
115#define debug_token(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
116#else
117static inline void debug_token(const char *format, ...) { }
118#endif
119
120#if DEBUG_VLC
121#define debug_vlc(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
122#else
123static inline void debug_vlc(const char *format, ...) { }
124#endif
125
126#if DEBUG_DC_PRED
127#define debug_dc_pred(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
128#else
129static inline void debug_dc_pred(const char *format, ...) { }
130#endif
131
132#if DEBUG_IDCT
133#define debug_idct(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
134#else
135static inline void debug_idct(const char *format, ...) { }
136#endif
137
138typedef struct Coeff {
139 struct Coeff *next;
140 DCTELEM coeff;
141 uint8_t index;
142} Coeff;
143
144//FIXME split things out into their own arrays
145typedef struct Vp3Fragment {
146 Coeff *next_coeff;
147 /* address of first pixel taking into account which plane the fragment
148 * lives on as well as the plane stride */
149 int first_pixel;
150 /* this is the macroblock that the fragment belongs to */
151 uint16_t macroblock;
152 uint8_t coding_method;
153 int8_t motion_x;
154 int8_t motion_y;
155} Vp3Fragment;
156
157#define SB_NOT_CODED 0
158#define SB_PARTIALLY_CODED 1
159#define SB_FULLY_CODED 2
160
161#define MODE_INTER_NO_MV 0
162#define MODE_INTRA 1
163#define MODE_INTER_PLUS_MV 2
164#define MODE_INTER_LAST_MV 3
165#define MODE_INTER_PRIOR_LAST 4
166#define MODE_USING_GOLDEN 5
167#define MODE_GOLDEN_MV 6
168#define MODE_INTER_FOURMV 7
169#define CODING_MODE_COUNT 8
170
171/* special internal mode */
172#define MODE_COPY 8
173
174/* There are 6 preset schemes, plus a free-form scheme */
175static const int ModeAlphabet[6][CODING_MODE_COUNT] =
176{
177 /* scheme 1: Last motion vector dominates */
178 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
179 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,
180 MODE_INTRA, MODE_USING_GOLDEN,
181 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
182
183 /* scheme 2 */
184 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
185 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,
186 MODE_INTRA, MODE_USING_GOLDEN,
187 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
188
189 /* scheme 3 */
190 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
191 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
192 MODE_INTRA, MODE_USING_GOLDEN,
193 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
194
195 /* scheme 4 */
196 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
197 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,
198 MODE_INTRA, MODE_USING_GOLDEN,
199 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
200
201 /* scheme 5: No motion vector dominates */
202 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV,
203 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
204 MODE_INTRA, MODE_USING_GOLDEN,
205 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
206
207 /* scheme 6 */
208 { MODE_INTER_NO_MV, MODE_USING_GOLDEN,
209 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
210 MODE_INTER_PLUS_MV, MODE_INTRA,
211 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
212
213};
214
215#define MIN_DEQUANT_VAL 2
216
217typedef struct Vp3DecodeContext {
218 AVCodecContext *avctx;
219 int theora, theora_tables;
220 int version;
221 int width, height;
222 AVFrame golden_frame;
223 AVFrame last_frame;
224 AVFrame current_frame;
225 int keyframe;
226 DSPContext dsp;
227 int flipped_image;
228
229 int qis[3];
230 int nqis;
231 int quality_index;
232 int last_quality_index;
233
234 int superblock_count;
235 int superblock_width;
236 int superblock_height;
237 int y_superblock_width;
238 int y_superblock_height;
239 int c_superblock_width;
240 int c_superblock_height;
241 int u_superblock_start;
242 int v_superblock_start;
243 unsigned char *superblock_coding;
244
245 int macroblock_count;
246 int macroblock_width;
247 int macroblock_height;
248
249 int fragment_count;
250 int fragment_width;
251 int fragment_height;
252
253 Vp3Fragment *all_fragments;
254 uint8_t *coeff_counts;
255 Coeff *coeffs;
256 Coeff *next_coeff;
257 int fragment_start[3];
258
259 ScanTable scantable;
260
261 /* tables */
262 uint16_t coded_dc_scale_factor[64];
263 uint32_t coded_ac_scale_factor[64];
264 uint8_t base_matrix[384][64];
265 uint8_t qr_count[2][3];
266 uint8_t qr_size [2][3][64];
267 uint16_t qr_base[2][3][64];
268
269 /* this is a list of indexes into the all_fragments array indicating
270 * which of the fragments are coded */
271 int *coded_fragment_list;
272 int coded_fragment_list_index;
273 int pixel_addresses_initialized;
274
275 VLC dc_vlc[16];
276 VLC ac_vlc_1[16];
277 VLC ac_vlc_2[16];
278 VLC ac_vlc_3[16];
279 VLC ac_vlc_4[16];
280
281 VLC superblock_run_length_vlc;
282 VLC fragment_run_length_vlc;
283 VLC mode_code_vlc;
284 VLC motion_vector_vlc;
285
286 /* these arrays need to be on 16-byte boundaries since SSE2 operations
287 * index into them */
288 DECLARE_ALIGNED_16(int16_t, qmat[2][4][64]); //<qmat[is_inter][plane]
289
290 /* This table contains superblock_count * 16 entries. Each set of 16
291 * numbers corresponds to the fragment indexes 0..15 of the superblock.
292 * An entry will be -1 to indicate that no entry corresponds to that
293 * index. */
294 int *superblock_fragments;
295
296 /* This table contains superblock_count * 4 entries. Each set of 4
297 * numbers corresponds to the macroblock indexes 0..3 of the superblock.
298 * An entry will be -1 to indicate that no entry corresponds to that
299 * index. */
300 int *superblock_macroblocks;
301
302 /* This table contains macroblock_count * 6 entries. Each set of 6
303 * numbers corresponds to the fragment indexes 0..5 which comprise
304 * the macroblock (4 Y fragments and 2 C fragments). */
305 int *macroblock_fragments;
306 /* This is an array that indicates how a particular macroblock
307 * is coded. */
308 unsigned char *macroblock_coding;
309
310 int first_coded_y_fragment;
311 int first_coded_c_fragment;
312 int last_coded_y_fragment;
313 int last_coded_c_fragment;
314
315 uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
316 int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
317
318 /* Huffman decode */
319 int hti;
320 unsigned int hbits;
321 int entries;
322 int huff_code_size;
323 uint16_t huffman_table[80][32][2];
324
325 uint32_t filter_limit_values[64];
326 int bounding_values_array[256];
327} Vp3DecodeContext;
328
329/************************************************************************
330 * VP3 specific functions
331 ************************************************************************/
332
333/*
334 * This function sets up all of the various blocks mappings:
335 * superblocks <-> fragments, macroblocks <-> fragments,
336 * superblocks <-> macroblocks
337 *
338 * Returns 0 is successful; returns 1 if *anything* went wrong.
339 */
340static int init_block_mapping(Vp3DecodeContext *s)
341{
342 int i, j;
343 signed int hilbert_walk_mb[4];
344
345 int current_fragment = 0;
346 int current_width = 0;
347 int current_height = 0;
348 int right_edge = 0;
349 int bottom_edge = 0;
350 int superblock_row_inc = 0;
351 int *hilbert = NULL;
352 int mapping_index = 0;
353
354 int current_macroblock;
355 int c_fragment;
356
357 signed char travel_width[16] = {
358 1, 1, 0, -1,
359 0, 0, 1, 0,
360 1, 0, 1, 0,
361 0, -1, 0, 1
362 };
363
364 signed char travel_height[16] = {
365 0, 0, 1, 0,
366 1, 1, 0, -1,
367 0, 1, 0, -1,
368 -1, 0, -1, 0
369 };
370
371 signed char travel_width_mb[4] = {
372 1, 0, 1, 0
373 };
374
375 signed char travel_height_mb[4] = {
376 0, 1, 0, -1
377 };
378
379 debug_vp3(" vp3: initialize block mapping tables\n");
380
381 hilbert_walk_mb[0] = 1;
382 hilbert_walk_mb[1] = s->macroblock_width;
383 hilbert_walk_mb[2] = 1;
384 hilbert_walk_mb[3] = -s->macroblock_width;
385
386 /* iterate through each superblock (all planes) and map the fragments */
387 for (i = 0; i < s->superblock_count; i++) {
388 debug_init(" superblock %d (u starts @ %d, v starts @ %d)\n",
389 i, s->u_superblock_start, s->v_superblock_start);
390
391 /* time to re-assign the limits? */
392 if (i == 0) {
393
394 /* start of Y superblocks */
395 right_edge = s->fragment_width;
396 bottom_edge = s->fragment_height;
397 current_width = -1;
398 current_height = 0;
399 superblock_row_inc = 3 * s->fragment_width -
400 (s->y_superblock_width * 4 - s->fragment_width);
401
402 /* the first operation for this variable is to advance by 1 */
403 current_fragment = -1;
404
405 } else if (i == s->u_superblock_start) {
406
407 /* start of U superblocks */
408 right_edge = s->fragment_width / 2;
409 bottom_edge = s->fragment_height / 2;
410 current_width = -1;
411 current_height = 0;
412 superblock_row_inc = 3 * (s->fragment_width / 2) -
413 (s->c_superblock_width * 4 - s->fragment_width / 2);
414
415 /* the first operation for this variable is to advance by 1 */
416 current_fragment = s->fragment_start[1] - 1;
417
418 } else if (i == s->v_superblock_start) {
419
420 /* start of V superblocks */
421 right_edge = s->fragment_width / 2;
422 bottom_edge = s->fragment_height / 2;
423 current_width = -1;
424 current_height = 0;
425 superblock_row_inc = 3 * (s->fragment_width / 2) -
426 (s->c_superblock_width * 4 - s->fragment_width / 2);
427
428 /* the first operation for this variable is to advance by 1 */
429 current_fragment = s->fragment_start[2] - 1;
430
431 }
432
433 if (current_width >= right_edge - 1) {
434 /* reset width and move to next superblock row */
435 current_width = -1;
436 current_height += 4;
437
438 /* fragment is now at the start of a new superblock row */
439 current_fragment += superblock_row_inc;
440 }
441
442 /* iterate through all 16 fragments in a superblock */
443 for (j = 0; j < 16; j++) {
444 current_fragment += travel_width[j] + right_edge * travel_height[j];
445 current_width += travel_width[j];
446 current_height += travel_height[j];
447
448 /* check if the fragment is in bounds */
449 if ((current_width < right_edge) &&
450 (current_height < bottom_edge)) {
451 s->superblock_fragments[mapping_index] = current_fragment;
452 debug_init(" mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n",
453 s->superblock_fragments[mapping_index], i, j,
454 current_width, right_edge, current_height, bottom_edge);
455 } else {
456 s->superblock_fragments[mapping_index] = -1;
457 debug_init(" superblock %d, position %d has no fragment (%d/%d x %d/%d)\n",
458 i, j,
459 current_width, right_edge, current_height, bottom_edge);
460 }
461
462 mapping_index++;
463 }
464 }
465
466 /* initialize the superblock <-> macroblock mapping; iterate through
467 * all of the Y plane superblocks to build this mapping */
468 right_edge = s->macroblock_width;
469 bottom_edge = s->macroblock_height;
470 current_width = -1;
471 current_height = 0;
472 superblock_row_inc = s->macroblock_width -
473 (s->y_superblock_width * 2 - s->macroblock_width);
474 hilbert = hilbert_walk_mb;
475 mapping_index = 0;
476 current_macroblock = -1;
477 for (i = 0; i < s->u_superblock_start; i++) {
478
479 if (current_width >= right_edge - 1) {
480 /* reset width and move to next superblock row */
481 current_width = -1;
482 current_height += 2;
483
484 /* macroblock is now at the start of a new superblock row */
485 current_macroblock += superblock_row_inc;
486 }
487
488 /* iterate through each potential macroblock in the superblock */
489 for (j = 0; j < 4; j++) {
490 current_macroblock += hilbert_walk_mb[j];
491 current_width += travel_width_mb[j];
492 current_height += travel_height_mb[j];
493
494 /* check if the macroblock is in bounds */
495 if ((current_width < right_edge) &&
496 (current_height < bottom_edge)) {
497 s->superblock_macroblocks[mapping_index] = current_macroblock;
498 debug_init(" mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
499 s->superblock_macroblocks[mapping_index], i, j,
500 current_width, right_edge, current_height, bottom_edge);
501 } else {
502 s->superblock_macroblocks[mapping_index] = -1;
503 debug_init(" superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
504 i, j,
505 current_width, right_edge, current_height, bottom_edge);
506 }
507
508 mapping_index++;
509 }
510 }
511
512 /* initialize the macroblock <-> fragment mapping */
513 current_fragment = 0;
514 current_macroblock = 0;
515 mapping_index = 0;
516 for (i = 0; i < s->fragment_height; i += 2) {
517
518 for (j = 0; j < s->fragment_width; j += 2) {
519
520 debug_init(" macroblock %d contains fragments: ", current_macroblock);
521 s->all_fragments[current_fragment].macroblock = current_macroblock;
522 s->macroblock_fragments[mapping_index++] = current_fragment;
523 debug_init("%d ", current_fragment);
524
525 if (j + 1 < s->fragment_width) {
526 s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
527 s->macroblock_fragments[mapping_index++] = current_fragment + 1;
528 debug_init("%d ", current_fragment + 1);
529 } else
530 s->macroblock_fragments[mapping_index++] = -1;
531
532 if (i + 1 < s->fragment_height) {
533 s->all_fragments[current_fragment + s->fragment_width].macroblock =
534 current_macroblock;
535 s->macroblock_fragments[mapping_index++] =
536 current_fragment + s->fragment_width;
537 debug_init("%d ", current_fragment + s->fragment_width);
538 } else
539 s->macroblock_fragments[mapping_index++] = -1;
540
541 if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
542 s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
543 current_macroblock;
544 s->macroblock_fragments[mapping_index++] =
545 current_fragment + s->fragment_width + 1;
546 debug_init("%d ", current_fragment + s->fragment_width + 1);
547 } else
548 s->macroblock_fragments[mapping_index++] = -1;
549
550 /* C planes */
551 c_fragment = s->fragment_start[1] +
552 (i * s->fragment_width / 4) + (j / 2);
553 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
554 s->macroblock_fragments[mapping_index++] = c_fragment;
555 debug_init("%d ", c_fragment);
556
557 c_fragment = s->fragment_start[2] +
558 (i * s->fragment_width / 4) + (j / 2);
559 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
560 s->macroblock_fragments[mapping_index++] = c_fragment;
561 debug_init("%d ", c_fragment);
562
563 debug_init("\n");
564
565 if (j + 2 <= s->fragment_width)
566 current_fragment += 2;
567 else
568 current_fragment++;
569 current_macroblock++;
570 }
571
572 current_fragment += s->fragment_width;
573 }
574
575 return 0; /* successful path out */
576}
577
578/*
579 * This function wipes out all of the fragment data.
580 */
581static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
582{
583 int i;
584
585 /* zero out all of the fragment information */
586 s->coded_fragment_list_index = 0;
587 for (i = 0; i < s->fragment_count; i++) {
588 s->coeff_counts[i] = 0;
589 s->all_fragments[i].motion_x = 127;
590 s->all_fragments[i].motion_y = 127;
591 s->all_fragments[i].next_coeff= NULL;
592 s->coeffs[i].index=
593 s->coeffs[i].coeff=0;
594 s->coeffs[i].next= NULL;
595 }
596}
597
598/*
599 * This function sets up the dequantization tables used for a particular
600 * frame.
601 */
602static void init_dequantizer(Vp3DecodeContext *s)
603{
604 int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
605 int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
606 int i, plane, inter, qri, bmi, bmj, qistart;
607
608 debug_vp3(" vp3: initializing dequantization tables\n");
609
610 for(inter=0; inter<2; inter++){
611 for(plane=0; plane<3; plane++){
612 int sum=0;
613 for(qri=0; qri<s->qr_count[inter][plane]; qri++){
614 sum+= s->qr_size[inter][plane][qri];
615 if(s->quality_index <= sum)
616 break;
617 }
618 qistart= sum - s->qr_size[inter][plane][qri];
619 bmi= s->qr_base[inter][plane][qri ];
620 bmj= s->qr_base[inter][plane][qri+1];
621 for(i=0; i<64; i++){
622 int coeff= ( 2*(sum -s->quality_index)*s->base_matrix[bmi][i]
623 - 2*(qistart-s->quality_index)*s->base_matrix[bmj][i]
624 + s->qr_size[inter][plane][qri])
625 / (2*s->qr_size[inter][plane][qri]);
626
627 int qmin= 8<<(inter + !i);
628 int qscale= i ? ac_scale_factor : dc_scale_factor;
629
630 s->qmat[inter][plane][i]= av_clip((qscale * coeff)/100 * 4, qmin, 4096);
631 }
632 }
633 }
634
635 memset(s->qscale_table, (FFMAX(s->qmat[0][0][1], s->qmat[0][1][1])+8)/16, 512); //FIXME finetune
636}
637
638/*
639 * This function initializes the loop filter boundary limits if the frame's
640 * quality index is different from the previous frame's.
641 */
642static void init_loop_filter(Vp3DecodeContext *s)
643{
644 int *bounding_values= s->bounding_values_array+127;
645 int filter_limit;
646 int x;
647
648 filter_limit = s->filter_limit_values[s->quality_index];
649
650 /* set up the bounding values */
651 memset(s->bounding_values_array, 0, 256 * sizeof(int));
652 for (x = 0; x < filter_limit; x++) {
653 bounding_values[-x - filter_limit] = -filter_limit + x;
654 bounding_values[-x] = -x;
655 bounding_values[x] = x;
656 bounding_values[x + filter_limit] = filter_limit - x;
657 }
658}
659
660/*
661 * This function unpacks all of the superblock/macroblock/fragment coding
662 * information from the bitstream.
663 */
664static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
665{
666 int bit = 0;
667 int current_superblock = 0;
668 int current_run = 0;
669 int decode_fully_flags = 0;
670 int decode_partial_blocks = 0;
671 int first_c_fragment_seen;
672
673 int i, j;
674 int current_fragment;
675
676 debug_vp3(" vp3: unpacking superblock coding\n");
677
678 if (s->keyframe) {
679
680 debug_vp3(" keyframe-- all superblocks are fully coded\n");
681 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
682
683 } else {
684
685 /* unpack the list of partially-coded superblocks */
686 bit = get_bits1(gb);
687 /* toggle the bit because as soon as the first run length is
688 * fetched the bit will be toggled again */
689 bit ^= 1;
690 while (current_superblock < s->superblock_count) {
691 if (current_run-- == 0) {
692 bit ^= 1;
693 current_run = get_vlc2(gb,
694 s->superblock_run_length_vlc.table, 6, 2);
695 if (current_run == 33)
696 current_run += get_bits(gb, 12);
697 debug_block_coding(" setting superblocks %d..%d to %s\n",
698 current_superblock,
699 current_superblock + current_run - 1,
700 (bit) ? "partially coded" : "not coded");
701
702 /* if any of the superblocks are not partially coded, flag
703 * a boolean to decode the list of fully-coded superblocks */
704 if (bit == 0) {
705 decode_fully_flags = 1;
706 } else {
707
708 /* make a note of the fact that there are partially coded
709 * superblocks */
710 decode_partial_blocks = 1;
711 }
712 }
713 s->superblock_coding[current_superblock++] = bit;
714 }
715
716 /* unpack the list of fully coded superblocks if any of the blocks were
717 * not marked as partially coded in the previous step */
718 if (decode_fully_flags) {
719
720 current_superblock = 0;
721 current_run = 0;
722 bit = get_bits1(gb);
723 /* toggle the bit because as soon as the first run length is
724 * fetched the bit will be toggled again */
725 bit ^= 1;
726 while (current_superblock < s->superblock_count) {
727
728 /* skip any superblocks already marked as partially coded */
729 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
730
731 if (current_run-- == 0) {
732 bit ^= 1;
733 current_run = get_vlc2(gb,
734 s->superblock_run_length_vlc.table, 6, 2);
735 if (current_run == 33)
736 current_run += get_bits(gb, 12);
737 }
738
739 debug_block_coding(" setting superblock %d to %s\n",
740 current_superblock,
741 (bit) ? "fully coded" : "not coded");
742 s->superblock_coding[current_superblock] = 2*bit;
743 }
744 current_superblock++;
745 }
746 }
747
748 /* if there were partial blocks, initialize bitstream for
749 * unpacking fragment codings */
750 if (decode_partial_blocks) {
751
752 current_run = 0;
753 bit = get_bits1(gb);
754 /* toggle the bit because as soon as the first run length is
755 * fetched the bit will be toggled again */
756 bit ^= 1;
757 }
758 }
759
760 /* figure out which fragments are coded; iterate through each
761 * superblock (all planes) */
762 s->coded_fragment_list_index = 0;
763 s->next_coeff= s->coeffs + s->fragment_count;
764 s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
765 s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
766 first_c_fragment_seen = 0;
767 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
768 for (i = 0; i < s->superblock_count; i++) {
769
770 /* iterate through all 16 fragments in a superblock */
771 for (j = 0; j < 16; j++) {
772
773 /* if the fragment is in bounds, check its coding status */
774 current_fragment = s->superblock_fragments[i * 16 + j];
775 if (current_fragment >= s->fragment_count) {
776 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
777 current_fragment, s->fragment_count);
778 return 1;
779 }
780 if (current_fragment != -1) {
781 if (s->superblock_coding[i] == SB_NOT_CODED) {
782
783 /* copy all the fragments from the prior frame */
784 s->all_fragments[current_fragment].coding_method =
785 MODE_COPY;
786
787 } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
788
789 /* fragment may or may not be coded; this is the case
790 * that cares about the fragment coding runs */
791 if (current_run-- == 0) {
792 bit ^= 1;
793 current_run = get_vlc2(gb,
794 s->fragment_run_length_vlc.table, 5, 2);
795 }
796
797 if (bit) {
798 /* default mode; actual mode will be decoded in
799 * the next phase */
800 s->all_fragments[current_fragment].coding_method =
801 MODE_INTER_NO_MV;
802 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
803 s->coded_fragment_list[s->coded_fragment_list_index] =
804 current_fragment;
805 if ((current_fragment >= s->fragment_start[1]) &&
806 (s->last_coded_y_fragment == -1) &&
807 (!first_c_fragment_seen)) {
808 s->first_coded_c_fragment = s->coded_fragment_list_index;
809 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
810 first_c_fragment_seen = 1;
811 }
812 s->coded_fragment_list_index++;
813 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
814 debug_block_coding(" superblock %d is partially coded, fragment %d is coded\n",
815 i, current_fragment);
816 } else {
817 /* not coded; copy this fragment from the prior frame */
818 s->all_fragments[current_fragment].coding_method =
819 MODE_COPY;
820 debug_block_coding(" superblock %d is partially coded, fragment %d is not coded\n",
821 i, current_fragment);
822 }
823
824 } else {
825
826 /* fragments are fully coded in this superblock; actual
827 * coding will be determined in next step */
828 s->all_fragments[current_fragment].coding_method =
829 MODE_INTER_NO_MV;
830 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
831 s->coded_fragment_list[s->coded_fragment_list_index] =
832 current_fragment;
833 if ((current_fragment >= s->fragment_start[1]) &&
834 (s->last_coded_y_fragment == -1) &&
835 (!first_c_fragment_seen)) {
836 s->first_coded_c_fragment = s->coded_fragment_list_index;
837 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
838 first_c_fragment_seen = 1;
839 }
840 s->coded_fragment_list_index++;
841 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
842 debug_block_coding(" superblock %d is fully coded, fragment %d is coded\n",
843 i, current_fragment);
844 }
845 }
846 }
847 }
848
849 if (!first_c_fragment_seen)
850 /* only Y fragments coded in this frame */
851 s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
852 else
853 /* end the list of coded C fragments */
854 s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
855
856 debug_block_coding(" %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
857 s->coded_fragment_list_index,
858 s->first_coded_y_fragment,
859 s->last_coded_y_fragment,
860 s->first_coded_c_fragment,
861 s->last_coded_c_fragment);
862
863 return 0;
864}
865
866/*
867 * This function unpacks all the coding mode data for individual macroblocks
868 * from the bitstream.
869 */
870static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
871{
872 int i, j, k;
873 int scheme;
874 int current_macroblock;
875 int current_fragment;
876 int coding_mode;
877 int custom_mode_alphabet[CODING_MODE_COUNT];
878
879 debug_vp3(" vp3: unpacking encoding modes\n");
880
881 if (s->keyframe) {
882 debug_vp3(" keyframe-- all blocks are coded as INTRA\n");
883
884 for (i = 0; i < s->fragment_count; i++)
885 s->all_fragments[i].coding_method = MODE_INTRA;
886
887 } else {
888
889 /* fetch the mode coding scheme for this frame */
890 scheme = get_bits(gb, 3);
891 debug_modes(" using mode alphabet %d\n", scheme);
892
893 /* is it a custom coding scheme? */
894 if (scheme == 0) {
895 debug_modes(" custom mode alphabet ahead:\n");
896 for (i = 0; i < 8; i++)
897 custom_mode_alphabet[get_bits(gb, 3)] = i;
898 }
899
900 for (i = 0; i < 8; i++) {
901 if(scheme)
902 debug_modes(" mode[%d][%d] = %d\n", scheme, i,
903 ModeAlphabet[scheme-1][i]);
904 else
905 debug_modes(" mode[0][%d] = %d\n", i,
906 custom_mode_alphabet[i]);
907 }
908
909 /* iterate through all of the macroblocks that contain 1 or more
910 * coded fragments */
911 for (i = 0; i < s->u_superblock_start; i++) {
912
913 for (j = 0; j < 4; j++) {
914 current_macroblock = s->superblock_macroblocks[i * 4 + j];
915 if ((current_macroblock == -1) ||
916 (s->macroblock_coding[current_macroblock] == MODE_COPY))
917 continue;
918 if (current_macroblock >= s->macroblock_count) {
919 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
920 current_macroblock, s->macroblock_count);
921 return 1;
922 }
923
924 /* mode 7 means get 3 bits for each coding mode */
925 if (scheme == 7)
926 coding_mode = get_bits(gb, 3);
927 else if(scheme == 0)
928 coding_mode = custom_mode_alphabet
929 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
930 else
931 coding_mode = ModeAlphabet[scheme-1]
932 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
933
934 s->macroblock_coding[current_macroblock] = coding_mode;
935 for (k = 0; k < 6; k++) {
936 current_fragment =
937 s->macroblock_fragments[current_macroblock * 6 + k];
938 if (current_fragment == -1)
939 continue;
940 if (current_fragment >= s->fragment_count) {
941 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
942 current_fragment, s->fragment_count);
943 return 1;
944 }
945 if (s->all_fragments[current_fragment].coding_method !=
946 MODE_COPY)
947 s->all_fragments[current_fragment].coding_method =
948 coding_mode;
949 }
950
951 debug_modes(" coding method for macroblock starting @ fragment %d = %d\n",
952 s->macroblock_fragments[current_macroblock * 6], coding_mode);
953 }
954 }
955 }
956
957 return 0;
958}
959
960/*
961 * This function unpacks all the motion vectors for the individual
962 * macroblocks from the bitstream.
963 */
964static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
965{
966 int i, j, k;
967 int coding_mode;
968 int motion_x[6];
969 int motion_y[6];
970 int last_motion_x = 0;
971 int last_motion_y = 0;
972 int prior_last_motion_x = 0;
973 int prior_last_motion_y = 0;
974 int current_macroblock;
975 int current_fragment;
976
977 debug_vp3(" vp3: unpacking motion vectors\n");
978 if (s->keyframe) {
979
980 debug_vp3(" keyframe-- there are no motion vectors\n");
981
982 } else {
983
984 memset(motion_x, 0, 6 * sizeof(int));
985 memset(motion_y, 0, 6 * sizeof(int));
986
987 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
988 coding_mode = get_bits1(gb);
989 debug_vectors(" using %s scheme for unpacking motion vectors\n",
990 (coding_mode == 0) ? "VLC" : "fixed-length");
991
992 /* iterate through all of the macroblocks that contain 1 or more
993 * coded fragments */
994 for (i = 0; i < s->u_superblock_start; i++) {
995
996 for (j = 0; j < 4; j++) {
997 current_macroblock = s->superblock_macroblocks[i * 4 + j];
998 if ((current_macroblock == -1) ||
999 (s->macroblock_coding[current_macroblock] == MODE_COPY))
1000 continue;
1001 if (current_macroblock >= s->macroblock_count) {
1002 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1003 current_macroblock, s->macroblock_count);
1004 return 1;
1005 }
1006
1007 current_fragment = s->macroblock_fragments[current_macroblock * 6];
1008 if (current_fragment >= s->fragment_count) {
1009 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1010 current_fragment, s->fragment_count);
1011 return 1;
1012 }
1013 switch (s->macroblock_coding[current_macroblock]) {
1014
1015 case MODE_INTER_PLUS_MV:
1016 case MODE_GOLDEN_MV:
1017 /* all 6 fragments use the same motion vector */
1018 if (coding_mode == 0) {
1019 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1020 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1021 } else {
1022 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1023 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1024 }
1025
1026 for (k = 1; k < 6; k++) {
1027 motion_x[k] = motion_x[0];
1028 motion_y[k] = motion_y[0];
1029 }
1030
1031 /* vector maintenance, only on MODE_INTER_PLUS_MV */
1032 if (s->macroblock_coding[current_macroblock] ==
1033 MODE_INTER_PLUS_MV) {
1034 prior_last_motion_x = last_motion_x;
1035 prior_last_motion_y = last_motion_y;
1036 last_motion_x = motion_x[0];
1037 last_motion_y = motion_y[0];
1038 }
1039 break;
1040
1041 case MODE_INTER_FOURMV:
1042 /* fetch 4 vectors from the bitstream, one for each
1043 * Y fragment, then average for the C fragment vectors */
1044 motion_x[4] = motion_y[4] = 0;
1045 for (k = 0; k < 4; k++) {
1046 if (coding_mode == 0) {
1047 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1048 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1049 } else {
1050 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1051 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1052 }
1053 motion_x[4] += motion_x[k];
1054 motion_y[4] += motion_y[k];
1055 }
1056
1057 motion_x[5]=
1058 motion_x[4]= RSHIFT(motion_x[4], 2);
1059 motion_y[5]=
1060 motion_y[4]= RSHIFT(motion_y[4], 2);
1061
1062 /* vector maintenance; vector[3] is treated as the
1063 * last vector in this case */
1064 prior_last_motion_x = last_motion_x;
1065 prior_last_motion_y = last_motion_y;
1066 last_motion_x = motion_x[3];
1067 last_motion_y = motion_y[3];
1068 break;
1069
1070 case MODE_INTER_LAST_MV:
1071 /* all 6 fragments use the last motion vector */
1072 motion_x[0] = last_motion_x;
1073 motion_y[0] = last_motion_y;
1074 for (k = 1; k < 6; k++) {
1075 motion_x[k] = motion_x[0];
1076 motion_y[k] = motion_y[0];
1077 }
1078
1079 /* no vector maintenance (last vector remains the
1080 * last vector) */
1081 break;
1082
1083 case MODE_INTER_PRIOR_LAST:
1084 /* all 6 fragments use the motion vector prior to the
1085 * last motion vector */
1086 motion_x[0] = prior_last_motion_x;
1087 motion_y[0] = prior_last_motion_y;
1088 for (k = 1; k < 6; k++) {
1089 motion_x[k] = motion_x[0];
1090 motion_y[k] = motion_y[0];
1091 }
1092
1093 /* vector maintenance */
1094 prior_last_motion_x = last_motion_x;
1095 prior_last_motion_y = last_motion_y;
1096 last_motion_x = motion_x[0];
1097 last_motion_y = motion_y[0];
1098 break;
1099
1100 default:
1101 /* covers intra, inter without MV, golden without MV */
1102 memset(motion_x, 0, 6 * sizeof(int));
1103 memset(motion_y, 0, 6 * sizeof(int));
1104
1105 /* no vector maintenance */
1106 break;
1107 }
1108
1109 /* assign the motion vectors to the correct fragments */
1110 debug_vectors(" vectors for macroblock starting @ fragment %d (coding method %d):\n",
1111 current_fragment,
1112 s->macroblock_coding[current_macroblock]);
1113 for (k = 0; k < 6; k++) {
1114 current_fragment =
1115 s->macroblock_fragments[current_macroblock * 6 + k];
1116 if (current_fragment == -1)
1117 continue;
1118 if (current_fragment >= s->fragment_count) {
1119 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1120 current_fragment, s->fragment_count);
1121 return 1;
1122 }
1123 s->all_fragments[current_fragment].motion_x = motion_x[k];
1124 s->all_fragments[current_fragment].motion_y = motion_y[k];
1125 debug_vectors(" vector %d: fragment %d = (%d, %d)\n",
1126 k, current_fragment, motion_x[k], motion_y[k]);
1127 }
1128 }
1129 }
1130 }
1131
1132 return 0;
1133}
1134
1135/*
1136 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1137 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1138 * data. This function unpacks all the VLCs for either the Y plane or both
1139 * C planes, and is called for DC coefficients or different AC coefficient
1140 * levels (since different coefficient types require different VLC tables.
1141 *
1142 * This function returns a residual eob run. E.g, if a particular token gave
1143 * instructions to EOB the next 5 fragments and there were only 2 fragments
1144 * left in the current fragment range, 3 would be returned so that it could
1145 * be passed into the next call to this same function.
1146 */
1147static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1148 VLC *table, int coeff_index,
1149 int first_fragment, int last_fragment,
1150 int eob_run)
1151{
1152 int i;
1153 int token;
1154 int zero_run = 0;
1155 DCTELEM coeff = 0;
1156 Vp3Fragment *fragment;
1157 uint8_t *perm= s->scantable.permutated;
1158 int bits_to_get;
1159
1160 if ((first_fragment >= s->fragment_count) ||
1161 (last_fragment >= s->fragment_count)) {
1162
1163 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1164 first_fragment, last_fragment);
1165 return 0;
1166 }
1167
1168 for (i = first_fragment; i <= last_fragment; i++) {
1169 int fragment_num = s->coded_fragment_list[i];
1170
1171 if (s->coeff_counts[fragment_num] > coeff_index)
1172 continue;
1173 fragment = &s->all_fragments[fragment_num];
1174
1175 if (!eob_run) {
1176 /* decode a VLC into a token */
1177 token = get_vlc2(gb, table->table, 5, 3);
1178 debug_vlc(" token = %2d, ", token);
1179 /* use the token to get a zero run, a coefficient, and an eob run */
1180 if (token <= 6) {
1181 eob_run = eob_run_base[token];
1182 if (eob_run_get_bits[token])
1183 eob_run += get_bits(gb, eob_run_get_bits[token]);
1184 coeff = zero_run = 0;
1185 } else {
1186 bits_to_get = coeff_get_bits[token];
1187 if (!bits_to_get)
1188 coeff = coeff_tables[token][0];
1189 else
1190 coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
1191
1192 zero_run = zero_run_base[token];
1193 if (zero_run_get_bits[token])
1194 zero_run += get_bits(gb, zero_run_get_bits[token]);
1195 }
1196 }
1197
1198 if (!eob_run) {
1199 s->coeff_counts[fragment_num] += zero_run;
1200 if (s->coeff_counts[fragment_num] < 64){
1201 fragment->next_coeff->coeff= coeff;
1202 fragment->next_coeff->index= perm[s->coeff_counts[fragment_num]++]; //FIXME perm here already?
1203 fragment->next_coeff->next= s->next_coeff;
1204 s->next_coeff->next=NULL;
1205 fragment->next_coeff= s->next_coeff++;
1206 }
1207 debug_vlc(" fragment %d coeff = %d\n",
1208 s->coded_fragment_list[i], fragment->next_coeff[coeff_index]);
1209 } else {
1210 s->coeff_counts[fragment_num] |= 128;
1211 debug_vlc(" fragment %d eob with %d coefficients\n",
1212 s->coded_fragment_list[i], s->coeff_counts[fragment_num]&127);
1213 eob_run--;
1214 }
1215 }
1216
1217 return eob_run;
1218}
1219
1220/*
1221 * This function unpacks all of the DCT coefficient data from the
1222 * bitstream.
1223 */
1224static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1225{
1226 int i;
1227 int dc_y_table;
1228 int dc_c_table;
1229 int ac_y_table;
1230 int ac_c_table;
1231 int residual_eob_run = 0;
1232
1233 /* fetch the DC table indexes */
1234 dc_y_table = get_bits(gb, 4);
1235 dc_c_table = get_bits(gb, 4);
1236
1237 /* unpack the Y plane DC coefficients */
1238 debug_vp3(" vp3: unpacking Y plane DC coefficients using table %d\n",
1239 dc_y_table);
1240 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1241 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1242
1243 /* unpack the C plane DC coefficients */
1244 debug_vp3(" vp3: unpacking C plane DC coefficients using table %d\n",
1245 dc_c_table);
1246 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1247 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1248
1249 /* fetch the AC table indexes */
1250 ac_y_table = get_bits(gb, 4);
1251 ac_c_table = get_bits(gb, 4);
1252
1253 /* unpack the group 1 AC coefficients (coeffs 1-5) */
1254 for (i = 1; i <= 5; i++) {
1255
1256 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1257 i, ac_y_table);
1258 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i,
1259 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1260
1261 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1262 i, ac_c_table);
1263 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i,
1264 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1265 }
1266
1267 /* unpack the group 2 AC coefficients (coeffs 6-14) */
1268 for (i = 6; i <= 14; i++) {
1269
1270 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1271 i, ac_y_table);
1272 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i,
1273 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1274
1275 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1276 i, ac_c_table);
1277 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i,
1278 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1279 }
1280
1281 /* unpack the group 3 AC coefficients (coeffs 15-27) */
1282 for (i = 15; i <= 27; i++) {
1283
1284 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1285 i, ac_y_table);
1286 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i,
1287 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1288
1289 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1290 i, ac_c_table);
1291 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i,
1292 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1293 }
1294
1295 /* unpack the group 4 AC coefficients (coeffs 28-63) */
1296 for (i = 28; i <= 63; i++) {
1297
1298 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1299 i, ac_y_table);
1300 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i,
1301 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1302
1303 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1304 i, ac_c_table);
1305 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i,
1306 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1307 }
1308
1309 return 0;
1310}
1311
1312/*
1313 * This function reverses the DC prediction for each coded fragment in
1314 * the frame. Much of this function is adapted directly from the original
1315 * VP3 source code.
1316 */
1317#define COMPATIBLE_FRAME(x) \
1318 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1319#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
1320#define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1321
1322static void reverse_dc_prediction(Vp3DecodeContext *s,
1323 int first_fragment,
1324 int fragment_width,
1325 int fragment_height)
1326{
1327
1328#define PUL 8
1329#define PU 4
1330#define PUR 2
1331#define PL 1
1332
1333 int x, y;
1334 int i = first_fragment;
1335
1336 int predicted_dc;
1337
1338 /* DC values for the left, up-left, up, and up-right fragments */
1339 int vl, vul, vu, vur;
1340
1341 /* indexes for the left, up-left, up, and up-right fragments */
1342 int l, ul, u, ur;
1343
1344 /*
1345 * The 6 fields mean:
1346 * 0: up-left multiplier
1347 * 1: up multiplier
1348 * 2: up-right multiplier
1349 * 3: left multiplier
1350 */
1351 int predictor_transform[16][4] = {
1352 { 0, 0, 0, 0},
1353 { 0, 0, 0,128}, // PL
1354 { 0, 0,128, 0}, // PUR
1355 { 0, 0, 53, 75}, // PUR|PL
1356 { 0,128, 0, 0}, // PU
1357 { 0, 64, 0, 64}, // PU|PL
1358 { 0,128, 0, 0}, // PU|PUR
1359 { 0, 0, 53, 75}, // PU|PUR|PL
1360 {128, 0, 0, 0}, // PUL
1361 { 0, 0, 0,128}, // PUL|PL
1362 { 64, 0, 64, 0}, // PUL|PUR
1363 { 0, 0, 53, 75}, // PUL|PUR|PL
1364 { 0,128, 0, 0}, // PUL|PU
1365 {-104,116, 0,116}, // PUL|PU|PL
1366 { 24, 80, 24, 0}, // PUL|PU|PUR
1367 {-104,116, 0,116} // PUL|PU|PUR|PL
1368 };
1369
1370 /* This table shows which types of blocks can use other blocks for
1371 * prediction. For example, INTRA is the only mode in this table to
1372 * have a frame number of 0. That means INTRA blocks can only predict
1373 * from other INTRA blocks. There are 2 golden frame coding types;
1374 * blocks encoding in these modes can only predict from other blocks
1375 * that were encoded with these 1 of these 2 modes. */
1376 unsigned char compatible_frame[8] = {
1377 1, /* MODE_INTER_NO_MV */
1378 0, /* MODE_INTRA */
1379 1, /* MODE_INTER_PLUS_MV */
1380 1, /* MODE_INTER_LAST_MV */
1381 1, /* MODE_INTER_PRIOR_MV */
1382 2, /* MODE_USING_GOLDEN */
1383 2, /* MODE_GOLDEN_MV */
1384 1 /* MODE_INTER_FOUR_MV */
1385 };
1386 int current_frame_type;
1387
1388 /* there is a last DC predictor for each of the 3 frame types */
1389 short last_dc[3];
1390
1391 int transform = 0;
1392
1393 debug_vp3(" vp3: reversing DC prediction\n");
1394
1395 vul = vu = vur = vl = 0;
1396 last_dc[0] = last_dc[1] = last_dc[2] = 0;
1397
1398 /* for each fragment row... */
1399 for (y = 0; y < fragment_height; y++) {
1400
1401 /* for each fragment in a row... */
1402 for (x = 0; x < fragment_width; x++, i++) {
1403
1404 /* reverse prediction if this block was coded */
1405 if (s->all_fragments[i].coding_method != MODE_COPY) {
1406
1407 current_frame_type =
1408 compatible_frame[s->all_fragments[i].coding_method];
1409 debug_dc_pred(" frag %d: orig DC = %d, ",
1410 i, DC_COEFF(i));
1411
1412 transform= 0;
1413 if(x){
1414 l= i-1;
1415 vl = DC_COEFF(l);
1416 if(FRAME_CODED(l) && COMPATIBLE_FRAME(l))
1417 transform |= PL;
1418 }
1419 if(y){
1420 u= i-fragment_width;
1421 vu = DC_COEFF(u);
1422 if(FRAME_CODED(u) && COMPATIBLE_FRAME(u))
1423 transform |= PU;
1424 if(x){
1425 ul= i-fragment_width-1;
1426 vul = DC_COEFF(ul);
1427 if(FRAME_CODED(ul) && COMPATIBLE_FRAME(ul))
1428 transform |= PUL;
1429 }
1430 if(x + 1 < fragment_width){
1431 ur= i-fragment_width+1;
1432 vur = DC_COEFF(ur);
1433 if(FRAME_CODED(ur) && COMPATIBLE_FRAME(ur))
1434 transform |= PUR;
1435 }
1436 }
1437
1438 debug_dc_pred("transform = %d, ", transform);
1439
1440 if (transform == 0) {
1441
1442 /* if there were no fragments to predict from, use last
1443 * DC saved */
1444 predicted_dc = last_dc[current_frame_type];
1445 debug_dc_pred("from last DC (%d) = %d\n",
1446 current_frame_type, DC_COEFF(i));
1447
1448 } else {
1449
1450 /* apply the appropriate predictor transform */
1451 predicted_dc =
1452 (predictor_transform[transform][0] * vul) +
1453 (predictor_transform[transform][1] * vu) +
1454 (predictor_transform[transform][2] * vur) +
1455 (predictor_transform[transform][3] * vl);
1456
1457 predicted_dc /= 128;
1458
1459 /* check for outranging on the [ul u l] and
1460 * [ul u ur l] predictors */
1461 if ((transform == 13) || (transform == 15)) {
1462 if (FFABS(predicted_dc - vu) > 128)
1463 predicted_dc = vu;
1464 else if (FFABS(predicted_dc - vl) > 128)
1465 predicted_dc = vl;
1466 else if (FFABS(predicted_dc - vul) > 128)
1467 predicted_dc = vul;
1468 }
1469
1470 debug_dc_pred("from pred DC = %d\n",
1471 DC_COEFF(i));
1472 }
1473
1474 /* at long last, apply the predictor */
1475 if(s->coeffs[i].index){
1476 *s->next_coeff= s->coeffs[i];
1477 s->coeffs[i].index=0;
1478 s->coeffs[i].coeff=0;
1479 s->coeffs[i].next= s->next_coeff++;
1480 }
1481 s->coeffs[i].coeff += predicted_dc;
1482 /* save the DC */
1483 last_dc[current_frame_type] = DC_COEFF(i);
1484 if(DC_COEFF(i) && !(s->coeff_counts[i]&127)){
1485 s->coeff_counts[i]= 129;
1486// s->all_fragments[i].next_coeff= s->next_coeff;
1487 s->coeffs[i].next= s->next_coeff;
1488 (s->next_coeff++)->next=NULL;
1489 }
1490 }
1491 }
1492 }
1493}
1494
1495
1496static void horizontal_filter(unsigned char *first_pixel, int stride,
1497 int *bounding_values);
1498static void vertical_filter(unsigned char *first_pixel, int stride,
1499 int *bounding_values);
1500
1501/*
1502 * Perform the final rendering for a particular slice of data.
1503 * The slice number ranges from 0..(macroblock_height - 1).
1504 */
1505static void render_slice(Vp3DecodeContext *s, int slice)
1506{
1507 int x;
1508 int m, n;
1509 int16_t *dequantizer;
1510 DECLARE_ALIGNED_16(DCTELEM, block[64]);
1511 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1512 int motion_halfpel_index;
1513 uint8_t *motion_source;
1514 int plane;
1515 int current_macroblock_entry = slice * s->macroblock_width * 6;
1516
1517 if (slice >= s->macroblock_height)
1518 return;
1519
1520 for (plane = 0; plane < 3; plane++) {
1521 uint8_t *output_plane = s->current_frame.data [plane];
1522 uint8_t * last_plane = s-> last_frame.data [plane];
1523 uint8_t *golden_plane = s-> golden_frame.data [plane];
1524 int stride = s->current_frame.linesize[plane];
1525 int plane_width = s->width >> !!plane;
1526 int plane_height = s->height >> !!plane;
1527 int y = slice * FRAGMENT_PIXELS << !plane ;
1528 int slice_height = y + (FRAGMENT_PIXELS << !plane);
1529 int i = s->macroblock_fragments[current_macroblock_entry + plane + 3*!!plane];
1530
1531 if (!s->flipped_image) stride = -stride;
1532
1533
1534 if(FFABS(stride) > 2048)
1535 return; //various tables are fixed size
1536
1537 /* for each fragment row in the slice (both of them)... */
1538 for (; y < slice_height; y += 8) {
1539
1540 /* for each fragment in a row... */
1541 for (x = 0; x < plane_width; x += 8, i++) {
1542
1543 if ((i < 0) || (i >= s->fragment_count)) {
1544 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_slice(): bad fragment number (%d)\n", i);
1545 return;
1546 }
1547
1548 /* transform if this block was coded */
1549 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
1550 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
1551
1552 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
1553 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
1554 motion_source= golden_plane;
1555 else
1556 motion_source= last_plane;
1557
1558 motion_source += s->all_fragments[i].first_pixel;
1559 motion_halfpel_index = 0;
1560
1561 /* sort out the motion vector if this fragment is coded
1562 * using a motion vector method */
1563 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
1564 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
1565 int src_x, src_y;
1566 motion_x = s->all_fragments[i].motion_x;
1567 motion_y = s->all_fragments[i].motion_y;
1568 if(plane){
1569 motion_x= (motion_x>>1) | (motion_x&1);
1570 motion_y= (motion_y>>1) | (motion_y&1);
1571 }
1572
1573 src_x= (motion_x>>1) + x;
1574 src_y= (motion_y>>1) + y;
1575 if ((motion_x == 127) || (motion_y == 127))
1576 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
1577
1578 motion_halfpel_index = motion_x & 0x01;
1579 motion_source += (motion_x >> 1);
1580
1581 motion_halfpel_index |= (motion_y & 0x01) << 1;
1582 motion_source += ((motion_y >> 1) * stride);
1583
1584 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
1585 uint8_t *temp= s->edge_emu_buffer;
1586 if(stride<0) temp -= 9*stride;
1587 else temp += 9*stride;
1588
1589 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
1590 motion_source= temp;
1591 }
1592 }
1593
1594
1595 /* first, take care of copying a block from either the
1596 * previous or the golden frame */
1597 if (s->all_fragments[i].coding_method != MODE_INTRA) {
1598 /* Note, it is possible to implement all MC cases with
1599 put_no_rnd_pixels_l2 which would look more like the
1600 VP3 source but this would be slower as
1601 put_no_rnd_pixels_tab is better optimzed */
1602 if(motion_halfpel_index != 3){
1603 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
1604 output_plane + s->all_fragments[i].first_pixel,
1605 motion_source, stride, 8);
1606 }else{
1607 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
1608 s->dsp.put_no_rnd_pixels_l2[1](
1609 output_plane + s->all_fragments[i].first_pixel,
1610 motion_source - d,
1611 motion_source + stride + 1 + d,
1612 stride, 8);
1613 }
1614 dequantizer = s->qmat[1][plane];
1615 }else{
1616 dequantizer = s->qmat[0][plane];
1617 }
1618
1619 /* dequantize the DCT coefficients */
1620 debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
1621 i, s->all_fragments[i].coding_method,
1622 DC_COEFF(i), dequantizer[0]);
1623
1624 if(s->avctx->idct_algo==FF_IDCT_VP3){
1625 Coeff *coeff= s->coeffs + i;
1626 memset(block, 0, sizeof(block));
1627 while(coeff->next){
1628 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
1629 coeff= coeff->next;
1630 }
1631 }else{
1632 Coeff *coeff= s->coeffs + i;
1633 memset(block, 0, sizeof(block));
1634 while(coeff->next){
1635 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
1636 coeff= coeff->next;
1637 }
1638 }
1639
1640 /* invert DCT and place (or add) in final output */
1641
1642 if (s->all_fragments[i].coding_method == MODE_INTRA) {
1643 if(s->avctx->idct_algo!=FF_IDCT_VP3)
1644 block[0] += 128<<3;
1645 s->dsp.idct_put(
1646 output_plane + s->all_fragments[i].first_pixel,
1647 stride,
1648 block);
1649 } else {
1650 s->dsp.idct_add(
1651 output_plane + s->all_fragments[i].first_pixel,
1652 stride,
1653 block);
1654 }
1655
1656 debug_idct("block after idct_%s():\n",
1657 (s->all_fragments[i].coding_method == MODE_INTRA)?
1658 "put" : "add");
1659 for (m = 0; m < 8; m++) {
1660 for (n = 0; n < 8; n++) {
1661 debug_idct(" %3d", *(output_plane +
1662 s->all_fragments[i].first_pixel + (m * stride + n)));
1663 }
1664 debug_idct("\n");
1665 }
1666 debug_idct("\n");
1667
1668 } else {
1669
1670 /* copy directly from the previous frame */
1671 s->dsp.put_pixels_tab[1][0](
1672 output_plane + s->all_fragments[i].first_pixel,
1673 last_plane + s->all_fragments[i].first_pixel,
1674 stride, 8);
1675
1676 }
1677#if 0
1678 /* perform the left edge filter if:
1679 * - the fragment is not on the left column
1680 * - the fragment is coded in this frame
1681 * - the fragment is not coded in this frame but the left
1682 * fragment is coded in this frame (this is done instead
1683 * of a right edge filter when rendering the left fragment
1684 * since this fragment is not available yet) */
1685 if ((x > 0) &&
1686 ((s->all_fragments[i].coding_method != MODE_COPY) ||
1687 ((s->all_fragments[i].coding_method == MODE_COPY) &&
1688 (s->all_fragments[i - 1].coding_method != MODE_COPY)) )) {
1689 horizontal_filter(
1690 output_plane + s->all_fragments[i].first_pixel + 7*stride,
1691 -stride, s->bounding_values_array + 127);
1692 }
1693
1694 /* perform the top edge filter if:
1695 * - the fragment is not on the top row
1696 * - the fragment is coded in this frame
1697 * - the fragment is not coded in this frame but the above
1698 * fragment is coded in this frame (this is done instead
1699 * of a bottom edge filter when rendering the above
1700 * fragment since this fragment is not available yet) */
1701 if ((y > 0) &&
1702 ((s->all_fragments[i].coding_method != MODE_COPY) ||
1703 ((s->all_fragments[i].coding_method == MODE_COPY) &&
1704 (s->all_fragments[i - fragment_width].coding_method != MODE_COPY)) )) {
1705 vertical_filter(
1706 output_plane + s->all_fragments[i].first_pixel - stride,
1707 -stride, s->bounding_values_array + 127);
1708 }
1709#endif
1710 }
1711 }
1712 }
1713
1714 /* this looks like a good place for slice dispatch... */
1715 /* algorithm:
1716 * if (slice == s->macroblock_height - 1)
1717 * dispatch (both last slice & 2nd-to-last slice);
1718 * else if (slice > 0)
1719 * dispatch (slice - 1);
1720 */
1721
1722 emms_c();
1723}
1724
1725static void horizontal_filter(unsigned char *first_pixel, int stride,
1726 int *bounding_values)
1727{
1728 unsigned char *end;
1729 int filter_value;
1730
1731 for (end= first_pixel + 8*stride; first_pixel != end; first_pixel += stride) {
1732 filter_value =
1733 (first_pixel[-2] - first_pixel[ 1])
1734 +3*(first_pixel[ 0] - first_pixel[-1]);
1735 filter_value = bounding_values[(filter_value + 4) >> 3];
1736 first_pixel[-1] = av_clip_uint8(first_pixel[-1] + filter_value);
1737 first_pixel[ 0] = av_clip_uint8(first_pixel[ 0] - filter_value);
1738 }
1739}
1740
1741static void vertical_filter(unsigned char *first_pixel, int stride,
1742 int *bounding_values)
1743{
1744 unsigned char *end;
1745 int filter_value;
1746 const int nstride= -stride;
1747
1748 for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
1749 filter_value =
1750 (first_pixel[2 * nstride] - first_pixel[ stride])
1751 +3*(first_pixel[0 ] - first_pixel[nstride]);
1752 filter_value = bounding_values[(filter_value + 4) >> 3];
1753 first_pixel[nstride] = av_clip_uint8(first_pixel[nstride] + filter_value);
1754 first_pixel[0] = av_clip_uint8(first_pixel[0] - filter_value);
1755 }
1756}
1757
1758static void apply_loop_filter(Vp3DecodeContext *s)
1759{
1760 int plane;
1761 int x, y;
1762 int *bounding_values= s->bounding_values_array+127;
1763
1764#if 0
1765 int bounding_values_array[256];
1766 int filter_limit;
1767
1768 /* find the right loop limit value */
1769 for (x = 63; x >= 0; x--) {
1770 if (vp31_ac_scale_factor[x] >= s->quality_index)
1771 break;
1772 }
1773 filter_limit = vp31_filter_limit_values[s->quality_index];
1774
1775 /* set up the bounding values */
1776 memset(bounding_values_array, 0, 256 * sizeof(int));
1777 for (x = 0; x < filter_limit; x++) {
1778 bounding_values[-x - filter_limit] = -filter_limit + x;
1779 bounding_values[-x] = -x;
1780 bounding_values[x] = x;
1781 bounding_values[x + filter_limit] = filter_limit - x;
1782 }
1783#endif
1784
1785 for (plane = 0; plane < 3; plane++) {
1786 int width = s->fragment_width >> !!plane;
1787 int height = s->fragment_height >> !!plane;
1788 int fragment = s->fragment_start [plane];
1789 int stride = s->current_frame.linesize[plane];
1790 uint8_t *plane_data = s->current_frame.data [plane];
1791 if (!s->flipped_image) stride = -stride;
1792
1793 for (y = 0; y < height; y++) {
1794
1795 for (x = 0; x < width; x++) {
1796 /* do not perform left edge filter for left columns frags */
1797 if ((x > 0) &&
1798 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
1799 horizontal_filter(
1800 plane_data + s->all_fragments[fragment].first_pixel,
1801 stride, bounding_values);
1802 }
1803
1804 /* do not perform top edge filter for top row fragments */
1805 if ((y > 0) &&
1806 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
1807 vertical_filter(
1808 plane_data + s->all_fragments[fragment].first_pixel,
1809 stride, bounding_values);
1810 }
1811
1812 /* do not perform right edge filter for right column
1813 * fragments or if right fragment neighbor is also coded
1814 * in this frame (it will be filtered in next iteration) */
1815 if ((x < width - 1) &&
1816 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
1817 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
1818 horizontal_filter(
1819 plane_data + s->all_fragments[fragment + 1].first_pixel,
1820 stride, bounding_values);
1821 }
1822
1823 /* do not perform bottom edge filter for bottom row
1824 * fragments or if bottom fragment neighbor is also coded
1825 * in this frame (it will be filtered in the next row) */
1826 if ((y < height - 1) &&
1827 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
1828 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
1829 vertical_filter(
1830 plane_data + s->all_fragments[fragment + width].first_pixel,
1831 stride, bounding_values);
1832 }
1833
1834 fragment++;
1835 }
1836 }
1837 }
1838}
1839
1840/*
1841 * This function computes the first pixel addresses for each fragment.
1842 * This function needs to be invoked after the first frame is allocated
1843 * so that it has access to the plane strides.
1844 */
1845static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
1846{
1847
1848 int i, x, y;
1849
1850 /* figure out the first pixel addresses for each of the fragments */
1851 /* Y plane */
1852 i = 0;
1853 for (y = s->fragment_height; y > 0; y--) {
1854 for (x = 0; x < s->fragment_width; x++) {
1855 s->all_fragments[i++].first_pixel =
1856 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
1857 s->golden_frame.linesize[0] +
1858 x * FRAGMENT_PIXELS;
1859 debug_init(" fragment %d, first pixel @ %d\n",
1860 i-1, s->all_fragments[i-1].first_pixel);
1861 }
1862 }
1863
1864 /* U plane */
1865 i = s->fragment_start[1];
1866 for (y = s->fragment_height / 2; y > 0; y--) {
1867 for (x = 0; x < s->fragment_width / 2; x++) {
1868 s->all_fragments[i++].first_pixel =
1869 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
1870 s->golden_frame.linesize[1] +
1871 x * FRAGMENT_PIXELS;
1872 debug_init(" fragment %d, first pixel @ %d\n",
1873 i-1, s->all_fragments[i-1].first_pixel);
1874 }
1875 }
1876
1877 /* V plane */
1878 i = s->fragment_start[2];
1879 for (y = s->fragment_height / 2; y > 0; y--) {
1880 for (x = 0; x < s->fragment_width / 2; x++) {
1881 s->all_fragments[i++].first_pixel =
1882 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
1883 s->golden_frame.linesize[2] +
1884 x * FRAGMENT_PIXELS;
1885 debug_init(" fragment %d, first pixel @ %d\n",
1886 i-1, s->all_fragments[i-1].first_pixel);
1887 }
1888 }
1889}
1890
1891/* FIXME: this should be merged with the above! */
1892static void theora_calculate_pixel_addresses(Vp3DecodeContext *s)
1893{
1894
1895 int i, x, y;
1896
1897 /* figure out the first pixel addresses for each of the fragments */
1898 /* Y plane */
1899 i = 0;
1900 for (y = 1; y <= s->fragment_height; y++) {
1901 for (x = 0; x < s->fragment_width; x++) {
1902 s->all_fragments[i++].first_pixel =
1903 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
1904 s->golden_frame.linesize[0] +
1905 x * FRAGMENT_PIXELS;
1906 debug_init(" fragment %d, first pixel @ %d\n",
1907 i-1, s->all_fragments[i-1].first_pixel);
1908 }
1909 }
1910
1911 /* U plane */
1912 i = s->fragment_start[1];
1913 for (y = 1; y <= s->fragment_height / 2; y++) {
1914 for (x = 0; x < s->fragment_width / 2; x++) {
1915 s->all_fragments[i++].first_pixel =
1916 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
1917 s->golden_frame.linesize[1] +
1918 x * FRAGMENT_PIXELS;
1919 debug_init(" fragment %d, first pixel @ %d\n",
1920 i-1, s->all_fragments[i-1].first_pixel);
1921 }
1922 }
1923
1924 /* V plane */
1925 i = s->fragment_start[2];
1926 for (y = 1; y <= s->fragment_height / 2; y++) {
1927 for (x = 0; x < s->fragment_width / 2; x++) {
1928 s->all_fragments[i++].first_pixel =
1929 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
1930 s->golden_frame.linesize[2] +
1931 x * FRAGMENT_PIXELS;
1932 debug_init(" fragment %d, first pixel @ %d\n",
1933 i-1, s->all_fragments[i-1].first_pixel);
1934 }
1935 }
1936}
1937
1938/*
1939 * This is the ffmpeg/libavcodec API init function.
1940 */
1941static av_cold int vp3_decode_init(AVCodecContext *avctx)
1942{
1943 Vp3DecodeContext *s = avctx->priv_data;
1944 int i, inter, plane;
1945 int c_width;
1946 int c_height;
1947 int y_superblock_count;
1948 int c_superblock_count;
1949
1950 if (avctx->codec_tag == MKTAG('V','P','3','0'))
1951 s->version = 0;
1952 else
1953 s->version = 1;
1954
1955 s->avctx = avctx;
1956 s->width = (avctx->width + 15) & 0xFFFFFFF0;
1957 s->height = (avctx->height + 15) & 0xFFFFFFF0;
1958 avctx->pix_fmt = PIX_FMT_YUV420P;
1959 if(avctx->idct_algo==FF_IDCT_AUTO)
1960 avctx->idct_algo=FF_IDCT_VP3;
1961 dsputil_init(&s->dsp, avctx);
1962
1963 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1964
1965 /* initialize to an impossible value which will force a recalculation
1966 * in the first frame decode */
1967 s->quality_index = -1;
1968
1969 s->y_superblock_width = (s->width + 31) / 32;
1970 s->y_superblock_height = (s->height + 31) / 32;
1971 y_superblock_count = s->y_superblock_width * s->y_superblock_height;
1972
1973 /* work out the dimensions for the C planes */
1974 c_width = s->width / 2;
1975 c_height = s->height / 2;
1976 s->c_superblock_width = (c_width + 31) / 32;
1977 s->c_superblock_height = (c_height + 31) / 32;
1978 c_superblock_count = s->c_superblock_width * s->c_superblock_height;
1979
1980 s->superblock_count = y_superblock_count + (c_superblock_count * 2);
1981 s->u_superblock_start = y_superblock_count;
1982 s->v_superblock_start = s->u_superblock_start + c_superblock_count;
1983 s->superblock_coding = av_malloc(s->superblock_count);
1984
1985 s->macroblock_width = (s->width + 15) / 16;
1986 s->macroblock_height = (s->height + 15) / 16;
1987 s->macroblock_count = s->macroblock_width * s->macroblock_height;
1988
1989 s->fragment_width = s->width / FRAGMENT_PIXELS;
1990 s->fragment_height = s->height / FRAGMENT_PIXELS;
1991
1992 /* fragment count covers all 8x8 blocks for all 3 planes */
1993 s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
1994 s->fragment_start[1] = s->fragment_width * s->fragment_height;
1995 s->fragment_start[2] = s->fragment_width * s->fragment_height * 5 / 4;
1996
1997 debug_init(" Y plane: %d x %d\n", s->width, s->height);
1998 debug_init(" C plane: %d x %d\n", c_width, c_height);
1999 debug_init(" Y superblocks: %d x %d, %d total\n",
2000 s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2001 debug_init(" C superblocks: %d x %d, %d total\n",
2002 s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2003 debug_init(" total superblocks = %d, U starts @ %d, V starts @ %d\n",
2004 s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2005 debug_init(" macroblocks: %d x %d, %d total\n",
2006 s->macroblock_width, s->macroblock_height, s->macroblock_count);
2007 debug_init(" %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2008 s->fragment_count,
2009 s->fragment_width,
2010 s->fragment_height,
2011 s->fragment_start[1],
2012 s->fragment_start[2]);
2013
2014 s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2015 s->coeff_counts = av_malloc(s->fragment_count * sizeof(*s->coeff_counts));
2016 s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
2017 s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2018 s->pixel_addresses_initialized = 0;
2019
2020 if (!s->theora_tables)
2021 {
2022 for (i = 0; i < 64; i++) {
2023 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2024 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
2025 s->base_matrix[0][i] = vp31_intra_y_dequant[i];
2026 s->base_matrix[1][i] = vp31_intra_c_dequant[i];
2027 s->base_matrix[2][i] = vp31_inter_dequant[i];
2028 s->filter_limit_values[i] = vp31_filter_limit_values[i];
2029 }
2030
2031 for(inter=0; inter<2; inter++){
2032 for(plane=0; plane<3; plane++){
2033 s->qr_count[inter][plane]= 1;
2034 s->qr_size [inter][plane][0]= 63;
2035 s->qr_base [inter][plane][0]=
2036 s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
2037 }
2038 }
2039
2040 /* init VLC tables */
2041 for (i = 0; i < 16; i++) {
2042
2043 /* DC histograms */
2044 init_vlc(&s->dc_vlc[i], 5, 32,
2045 &dc_bias[i][0][1], 4, 2,
2046 &dc_bias[i][0][0], 4, 2, 0);
2047
2048 /* group 1 AC histograms */
2049 init_vlc(&s->ac_vlc_1[i], 5, 32,
2050 &ac_bias_0[i][0][1], 4, 2,
2051 &ac_bias_0[i][0][0], 4, 2, 0);
2052
2053 /* group 2 AC histograms */
2054 init_vlc(&s->ac_vlc_2[i], 5, 32,
2055 &ac_bias_1[i][0][1], 4, 2,
2056 &ac_bias_1[i][0][0], 4, 2, 0);
2057
2058 /* group 3 AC histograms */
2059 init_vlc(&s->ac_vlc_3[i], 5, 32,
2060 &ac_bias_2[i][0][1], 4, 2,
2061 &ac_bias_2[i][0][0], 4, 2, 0);
2062
2063 /* group 4 AC histograms */
2064 init_vlc(&s->ac_vlc_4[i], 5, 32,
2065 &ac_bias_3[i][0][1], 4, 2,
2066 &ac_bias_3[i][0][0], 4, 2, 0);
2067 }
2068 } else {
2069 for (i = 0; i < 16; i++) {
2070
2071 /* DC histograms */
2072 init_vlc(&s->dc_vlc[i], 5, 32,
2073 &s->huffman_table[i][0][1], 4, 2,
2074 &s->huffman_table[i][0][0], 4, 2, 0);
2075
2076 /* group 1 AC histograms */
2077 init_vlc(&s->ac_vlc_1[i], 5, 32,
2078 &s->huffman_table[i+16][0][1], 4, 2,
2079 &s->huffman_table[i+16][0][0], 4, 2, 0);
2080
2081 /* group 2 AC histograms */
2082 init_vlc(&s->ac_vlc_2[i], 5, 32,
2083 &s->huffman_table[i+16*2][0][1], 4, 2,
2084 &s->huffman_table[i+16*2][0][0], 4, 2, 0);
2085
2086 /* group 3 AC histograms */
2087 init_vlc(&s->ac_vlc_3[i], 5, 32,
2088 &s->huffman_table[i+16*3][0][1], 4, 2,
2089 &s->huffman_table[i+16*3][0][0], 4, 2, 0);
2090
2091 /* group 4 AC histograms */
2092 init_vlc(&s->ac_vlc_4[i], 5, 32,
2093 &s->huffman_table[i+16*4][0][1], 4, 2,
2094 &s->huffman_table[i+16*4][0][0], 4, 2, 0);
2095 }
2096 }
2097
2098 init_vlc(&s->superblock_run_length_vlc, 6, 34,
2099 &superblock_run_length_vlc_table[0][1], 4, 2,
2100 &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2101
2102 init_vlc(&s->fragment_run_length_vlc, 5, 30,
2103 &fragment_run_length_vlc_table[0][1], 4, 2,
2104 &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2105
2106 init_vlc(&s->mode_code_vlc, 3, 8,
2107 &mode_code_vlc_table[0][1], 2, 1,
2108 &mode_code_vlc_table[0][0], 2, 1, 0);
2109
2110 init_vlc(&s->motion_vector_vlc, 6, 63,
2111 &motion_vector_vlc_table[0][1], 2, 1,
2112 &motion_vector_vlc_table[0][0], 2, 1, 0);
2113
2114 /* work out the block mapping tables */
2115 s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2116 s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2117 s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
2118 s->macroblock_coding = av_malloc(s->macroblock_count + 1);
2119 init_block_mapping(s);
2120
2121 for (i = 0; i < 3; i++) {
2122 s->current_frame.data[i] = NULL;
2123 s->last_frame.data[i] = NULL;
2124 s->golden_frame.data[i] = NULL;
2125 }
2126
2127 return 0;
2128}
2129
2130/*
2131 * This is the ffmpeg/libavcodec API frame decode function.
2132 */
2133static int vp3_decode_frame(AVCodecContext *avctx,
2134 void *data, int *data_size,
2135 const uint8_t *buf, int buf_size)
2136{
2137 Vp3DecodeContext *s = avctx->priv_data;
2138 GetBitContext gb;
2139 static int counter = 0;
2140 int i;
2141
2142 init_get_bits(&gb, buf, buf_size * 8);
2143
2144 if (s->theora && get_bits1(&gb))
2145 {
2146 av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n");
2147 return -1;
2148 }
2149
2150 s->keyframe = !get_bits1(&gb);
2151 if (!s->theora)
2152 skip_bits(&gb, 1);
2153 s->last_quality_index = s->quality_index;
2154
2155 s->nqis=0;
2156 do{
2157 s->qis[s->nqis++]= get_bits(&gb, 6);
2158 } while(s->theora >= 0x030200 && s->nqis<3 && get_bits1(&gb));
2159
2160 s->quality_index= s->qis[0];
2161
2162 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2163 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2164 s->keyframe?"key":"", counter, s->quality_index);
2165 counter++;
2166
2167 if (s->quality_index != s->last_quality_index) {
2168 init_dequantizer(s);
2169 init_loop_filter(s);
2170 }
2171
2172 if (s->keyframe) {
2173 if (!s->theora)
2174 {
2175 skip_bits(&gb, 4); /* width code */
2176 skip_bits(&gb, 4); /* height code */
2177 if (s->version)
2178 {
2179 s->version = get_bits(&gb, 5);
2180 if (counter == 1)
2181 av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
2182 }
2183 }
2184 if (s->version || s->theora)
2185 {
2186 if (get_bits1(&gb))
2187 av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
2188 skip_bits(&gb, 2); /* reserved? */
2189 }
2190
2191 if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2192 if (s->golden_frame.data[0])
2193 avctx->release_buffer(avctx, &s->golden_frame);
2194 s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
2195 } else {
2196 if (s->golden_frame.data[0])
2197 avctx->release_buffer(avctx, &s->golden_frame);
2198 if (s->last_frame.data[0])
2199 avctx->release_buffer(avctx, &s->last_frame);
2200 }
2201
2202 s->golden_frame.reference = 3;
2203 if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2204 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2205 return -1;
2206 }
2207
2208 /* golden frame is also the current frame */
2209 s->current_frame= s->golden_frame;
2210
2211 /* time to figure out pixel addresses? */
2212 if (!s->pixel_addresses_initialized)
2213 {
2214 if (!s->flipped_image)
2215 vp3_calculate_pixel_addresses(s);
2216 else
2217 theora_calculate_pixel_addresses(s);
2218 s->pixel_addresses_initialized = 1;
2219 }
2220 } else {
2221 /* allocate a new current frame */
2222 s->current_frame.reference = 3;
2223 if (!s->pixel_addresses_initialized) {
2224 av_log(s->avctx, AV_LOG_ERROR, "vp3: first frame not a keyframe\n");
2225 return -1;
2226 }
2227 if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2228 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2229 return -1;
2230 }
2231 }
2232
2233 s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2234 s->current_frame.qstride= 0;
2235
2236 init_frame(s, &gb);
2237
2238#if KEYFRAMES_ONLY
2239if (!s->keyframe) {
2240
2241 memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2242 s->current_frame.linesize[0] * s->height);
2243 memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2244 s->current_frame.linesize[1] * s->height / 2);
2245 memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2246 s->current_frame.linesize[2] * s->height / 2);
2247
2248} else {
2249#endif
2250
2251 if (unpack_superblocks(s, &gb)){
2252 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2253 return -1;
2254 }
2255 if (unpack_modes(s, &gb)){
2256 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2257 return -1;
2258 }
2259 if (unpack_vectors(s, &gb)){
2260 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2261 return -1;
2262 }
2263 if (unpack_dct_coeffs(s, &gb)){
2264 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2265 return -1;
2266 }
2267
2268 reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2269 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2270 reverse_dc_prediction(s, s->fragment_start[1],
2271 s->fragment_width / 2, s->fragment_height / 2);
2272 reverse_dc_prediction(s, s->fragment_start[2],
2273 s->fragment_width / 2, s->fragment_height / 2);
2274 }
2275
2276 for (i = 0; i < s->macroblock_height; i++)
2277 render_slice(s, i);
2278
2279 apply_loop_filter(s);
2280#if KEYFRAMES_ONLY
2281}
2282#endif
2283
2284 *data_size=sizeof(AVFrame);
2285 *(AVFrame*)data= s->current_frame;
2286
2287 /* release the last frame, if it is allocated and if it is not the
2288 * golden frame */
2289 if ((s->last_frame.data[0]) &&
2290 (s->last_frame.data[0] != s->golden_frame.data[0]))
2291 avctx->release_buffer(avctx, &s->last_frame);
2292
2293 /* shuffle frames (last = current) */
2294 s->last_frame= s->current_frame;
2295 s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
2296
2297 return buf_size;
2298}
2299
2300/*
2301 * This is the ffmpeg/libavcodec API module cleanup function.
2302 */
2303static av_cold int vp3_decode_end(AVCodecContext *avctx)
2304{
2305 Vp3DecodeContext *s = avctx->priv_data;
2306 int i;
2307
2308 av_free(s->superblock_coding);
2309 av_free(s->all_fragments);
2310 av_free(s->coeff_counts);
2311 av_free(s->coeffs);
2312 av_free(s->coded_fragment_list);
2313 av_free(s->superblock_fragments);
2314 av_free(s->superblock_macroblocks);
2315 av_free(s->macroblock_fragments);
2316 av_free(s->macroblock_coding);
2317
2318 for (i = 0; i < 16; i++) {
2319 free_vlc(&s->dc_vlc[i]);
2320 free_vlc(&s->ac_vlc_1[i]);
2321 free_vlc(&s->ac_vlc_2[i]);
2322 free_vlc(&s->ac_vlc_3[i]);
2323 free_vlc(&s->ac_vlc_4[i]);
2324 }
2325
2326 free_vlc(&s->superblock_run_length_vlc);
2327 free_vlc(&s->fragment_run_length_vlc);
2328 free_vlc(&s->mode_code_vlc);
2329 free_vlc(&s->motion_vector_vlc);
2330
2331 /* release all frames */
2332 if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2333 avctx->release_buffer(avctx, &s->golden_frame);
2334 if (s->last_frame.data[0])
2335 avctx->release_buffer(avctx, &s->last_frame);
2336 /* no need to release the current_frame since it will always be pointing
2337 * to the same frame as either the golden or last frame */
2338
2339 return 0;
2340}
2341
2342static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
2343{
2344 Vp3DecodeContext *s = avctx->priv_data;
2345
2346 if (get_bits1(gb)) {
2347 int token;
2348 if (s->entries >= 32) { /* overflow */
2349 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2350 return -1;
2351 }
2352 token = get_bits(gb, 5);
2353 //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);
2354 s->huffman_table[s->hti][token][0] = s->hbits;
2355 s->huffman_table[s->hti][token][1] = s->huff_code_size;
2356 s->entries++;
2357 }
2358 else {
2359 if (s->huff_code_size >= 32) {/* overflow */
2360 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2361 return -1;
2362 }
2363 s->huff_code_size++;
2364 s->hbits <<= 1;
2365 read_huffman_tree(avctx, gb);
2366 s->hbits |= 1;
2367 read_huffman_tree(avctx, gb);
2368 s->hbits >>= 1;
2369 s->huff_code_size--;
2370 }
2371 return 0;
2372}
2373
2374#ifdef CONFIG_THEORA_DECODER
2375static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
2376{
2377 Vp3DecodeContext *s = avctx->priv_data;
2378 int visible_width, visible_height;
2379
2380 s->theora = get_bits_long(gb, 24);
2381 av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
2382
2383 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
2384 /* but previous versions have the image flipped relative to vp3 */
2385 if (s->theora < 0x030200)
2386 {
2387 s->flipped_image = 1;
2388 av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
2389 }
2390
2391 s->width = get_bits(gb, 16) << 4;
2392 s->height = get_bits(gb, 16) << 4;
2393
2394 if(avcodec_check_dimensions(avctx, s->width, s->height)){
2395 av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);
2396 s->width= s->height= 0;
2397 return -1;
2398 }
2399
2400 if (s->theora >= 0x030400)
2401 {
2402 skip_bits(gb, 32); /* total number of superblocks in a frame */
2403 // fixme, the next field is 36bits long
2404 skip_bits(gb, 32); /* total number of blocks in a frame */
2405 skip_bits(gb, 4); /* total number of blocks in a frame */
2406 skip_bits(gb, 32); /* total number of macroblocks in a frame */
2407 }
2408
2409 visible_width = get_bits_long(gb, 24);
2410 visible_height = get_bits_long(gb, 24);
2411
2412 if (s->theora >= 0x030200) {
2413 skip_bits(gb, 8); /* offset x */
2414 skip_bits(gb, 8); /* offset y */
2415 }
2416
2417 skip_bits(gb, 32); /* fps numerator */
2418 skip_bits(gb, 32); /* fps denumerator */
2419 skip_bits(gb, 24); /* aspect numerator */
2420 skip_bits(gb, 24); /* aspect denumerator */
2421
2422 if (s->theora < 0x030200)
2423 skip_bits(gb, 5); /* keyframe frequency force */
2424 skip_bits(gb, 8); /* colorspace */
2425 if (s->theora >= 0x030400)
2426 skip_bits(gb, 2); /* pixel format: 420,res,422,444 */
2427 skip_bits(gb, 24); /* bitrate */
2428
2429 skip_bits(gb, 6); /* quality hint */
2430
2431 if (s->theora >= 0x030200)
2432 {
2433 skip_bits(gb, 5); /* keyframe frequency force */
2434
2435 if (s->theora < 0x030400)
2436 skip_bits(gb, 5); /* spare bits */
2437 }
2438
2439// align_get_bits(gb);
2440
2441 if ( visible_width <= s->width && visible_width > s->width-16
2442 && visible_height <= s->height && visible_height > s->height-16)
2443 avcodec_set_dimensions(avctx, visible_width, visible_height);
2444 else
2445 avcodec_set_dimensions(avctx, s->width, s->height);
2446
2447 return 0;
2448}
2449
2450static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
2451{
2452 Vp3DecodeContext *s = avctx->priv_data;
2453 int i, n, matrices, inter, plane;
2454
2455 if (s->theora >= 0x030200) {
2456 n = get_bits(gb, 3);
2457 /* loop filter limit values table */
2458 for (i = 0; i < 64; i++)
2459 s->filter_limit_values[i] = get_bits(gb, n);
2460 }
2461
2462 if (s->theora >= 0x030200)
2463 n = get_bits(gb, 4) + 1;
2464 else
2465 n = 16;
2466 /* quality threshold table */
2467 for (i = 0; i < 64; i++)
2468 s->coded_ac_scale_factor[i] = get_bits(gb, n);
2469
2470 if (s->theora >= 0x030200)
2471 n = get_bits(gb, 4) + 1;
2472 else
2473 n = 16;
2474 /* dc scale factor table */
2475 for (i = 0; i < 64; i++)
2476 s->coded_dc_scale_factor[i] = get_bits(gb, n);
2477
2478 if (s->theora >= 0x030200)
2479 matrices = get_bits(gb, 9) + 1;
2480 else
2481 matrices = 3;
2482
2483 if(matrices > 384){
2484 av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
2485 return -1;
2486 }
2487
2488 for(n=0; n<matrices; n++){
2489 for (i = 0; i < 64; i++)
2490 s->base_matrix[n][i]= get_bits(gb, 8);
2491 }
2492
2493 for (inter = 0; inter <= 1; inter++) {
2494 for (plane = 0; plane <= 2; plane++) {
2495 int newqr= 1;
2496 if (inter || plane > 0)
2497 newqr = get_bits1(gb);
2498 if (!newqr) {
2499 int qtj, plj;
2500 if(inter && get_bits1(gb)){
2501 qtj = 0;
2502 plj = plane;
2503 }else{
2504 qtj= (3*inter + plane - 1) / 3;
2505 plj= (plane + 2) % 3;
2506 }
2507 s->qr_count[inter][plane]= s->qr_count[qtj][plj];
2508 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0]));
2509 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0]));
2510 } else {
2511 int qri= 0;
2512 int qi = 0;
2513
2514 for(;;){
2515 i= get_bits(gb, av_log2(matrices-1)+1);
2516 if(i>= matrices){
2517 av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n");
2518 return -1;
2519 }
2520 s->qr_base[inter][plane][qri]= i;
2521 if(qi >= 63)
2522 break;
2523 i = get_bits(gb, av_log2(63-qi)+1) + 1;
2524 s->qr_size[inter][plane][qri++]= i;
2525 qi += i;
2526 }
2527
2528 if (qi > 63) {
2529 av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
2530 return -1;
2531 }
2532 s->qr_count[inter][plane]= qri;
2533 }
2534 }
2535 }
2536
2537 /* Huffman tables */
2538 for (s->hti = 0; s->hti < 80; s->hti++) {
2539 s->entries = 0;
2540 s->huff_code_size = 1;
2541 if (!get_bits1(gb)) {
2542 s->hbits = 0;
2543 read_huffman_tree(avctx, gb);
2544 s->hbits = 1;
2545 read_huffman_tree(avctx, gb);
2546 }
2547 }
2548
2549 s->theora_tables = 1;
2550
2551 return 0;
2552}
2553
2554static int theora_decode_init(AVCodecContext *avctx)
2555{
2556 Vp3DecodeContext *s = avctx->priv_data;
2557 GetBitContext gb;
2558 int ptype;
2559 uint8_t *header_start[3];
2560 int header_len[3];
2561 int i;
2562
2563 s->theora = 1;
2564
2565 if (!avctx->extradata_size)
2566 {
2567 av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
2568 return -1;
2569 }
2570
2571 if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size,
2572 42, header_start, header_len) < 0) {
2573 av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
2574 return -1;
2575 }
2576
2577 for(i=0;i<3;i++) {
2578 init_get_bits(&gb, header_start[i], header_len[i]);
2579
2580 ptype = get_bits(&gb, 8);
2581 debug_vp3("Theora headerpacket type: %x\n", ptype);
2582
2583 if (!(ptype & 0x80))
2584 {
2585 av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
2586// return -1;
2587 }
2588
2589 // FIXME: Check for this as well.
2590 skip_bits(&gb, 6*8); /* "theora" */
2591
2592 switch(ptype)
2593 {
2594 case 0x80:
2595 theora_decode_header(avctx, &gb);
2596 break;
2597 case 0x81:
2598// FIXME: is this needed? it breaks sometimes
2599// theora_decode_comments(avctx, gb);
2600 break;
2601 case 0x82:
2602 theora_decode_tables(avctx, &gb);
2603 break;
2604 default:
2605 av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80);
2606 break;
2607 }
2608 if(8*header_len[i] != get_bits_count(&gb))
2609 av_log(avctx, AV_LOG_ERROR, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype);
2610 if (s->theora < 0x030200)
2611 break;
2612 }
2613
2614 vp3_decode_init(avctx);
2615 return 0;
2616}
2617
2618AVCodec theora_decoder = {
2619 "theora",
2620 CODEC_TYPE_VIDEO,
2621 CODEC_ID_THEORA,
2622 sizeof(Vp3DecodeContext),
2623 theora_decode_init,
2624 NULL,
2625 vp3_decode_end,
2626 vp3_decode_frame,
2627 0,
2628 NULL,
2629 .long_name = NULL_IF_CONFIG_SMALL("Theora"),
2630};
2631#endif
2632
2633AVCodec vp3_decoder = {
2634 "vp3",
2635 CODEC_TYPE_VIDEO,
2636 CODEC_ID_VP3,
2637 sizeof(Vp3DecodeContext),
2638 vp3_decode_init,
2639 NULL,
2640 vp3_decode_end,
2641 vp3_decode_frame,
2642 0,
2643 NULL,
2644 .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
2645};
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-07 08:34:09 +0000