2 * Copyright (C) 2003-2004 the ffmpeg project
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 * On2 VP3 Video Decoder
24 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
25 * For more information about the VP3 coding process, visit:
26 * http://multimedia.cx/
28 * Theora decoder by Alex Beregszaszi
39 #include "mpegvideo.h"
43 #define FRAGMENT_PIXELS 8
48 * Define one or more of the following compile-time variables to 1 to obtain
49 * elaborate information about certain aspects of the decoding process.
51 * KEYFRAMES_ONLY: set this to 1 to only see keyframes (VP3 slideshow mode)
52 * DEBUG_VP3: high-level decoding flow
53 * DEBUG_INIT: initialization parameters
54 * DEBUG_DEQUANTIZERS: display how the dequanization tables are built
55 * DEBUG_BLOCK_CODING: unpacking the superblock/macroblock/fragment coding
56 * DEBUG_MODES: unpacking the coding modes for individual fragments
57 * DEBUG_VECTORS: display the motion vectors
58 * DEBUG_TOKEN: display exhaustive information about each DCT token
59 * DEBUG_VLC: display the VLCs as they are extracted from the stream
60 * DEBUG_DC_PRED: display the process of reversing DC prediction
61 * DEBUG_IDCT: show every detail of the IDCT process
64 #define KEYFRAMES_ONLY 0
68 #define DEBUG_DEQUANTIZERS 0
69 #define DEBUG_BLOCK_CODING 0
71 #define DEBUG_VECTORS 0
74 #define DEBUG_DC_PRED 0
78 #define debug_vp3 printf
80 static inline void debug_vp3(const char *format, ...) { }
84 #define debug_init printf
86 static inline void debug_init(const char *format, ...) { }
89 #if DEBUG_DEQUANTIZERS
90 #define debug_dequantizers printf
92 static inline void debug_dequantizers(const char *format, ...) { }
95 #if DEBUG_BLOCK_CODING
96 #define debug_block_coding printf
98 static inline void debug_block_coding(const char *format, ...) { }
102 #define debug_modes printf
104 static inline void debug_modes(const char *format, ...) { }
108 #define debug_vectors printf
110 static inline void debug_vectors(const char *format, ...) { }
114 #define debug_token printf
116 static inline void debug_token(const char *format, ...) { }
120 #define debug_vlc printf
122 static inline void debug_vlc(const char *format, ...) { }
126 #define debug_dc_pred printf
128 static inline void debug_dc_pred(const char *format, ...) { }
132 #define debug_idct printf
134 static inline void debug_idct(const char *format, ...) { }
137 typedef struct Coeff {
143 //FIXME split things out into their own arrays
144 typedef struct Vp3Fragment {
146 /* address of first pixel taking into account which plane the fragment
147 * lives on as well as the plane stride */
149 /* this is the macroblock that the fragment belongs to */
151 uint8_t coding_method;
157 #define SB_NOT_CODED 0
158 #define SB_PARTIALLY_CODED 1
159 #define SB_FULLY_CODED 2
161 #define MODE_INTER_NO_MV 0
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
171 /* special internal mode */
174 /* There are 6 preset schemes, plus a free-form scheme */
175 static int ModeAlphabet[7][CODING_MODE_COUNT] =
177 /* this is the custom scheme */
178 { 0, 0, 0, 0, 0, 0, 0, 0 },
180 /* scheme 1: Last motion vector dominates */
181 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
182 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,
183 MODE_INTRA, MODE_USING_GOLDEN,
184 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
187 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
188 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,
189 MODE_INTRA, MODE_USING_GOLDEN,
190 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
193 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
194 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
195 MODE_INTRA, MODE_USING_GOLDEN,
196 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
199 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
200 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,
201 MODE_INTRA, MODE_USING_GOLDEN,
202 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
204 /* scheme 5: No motion vector dominates */
205 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV,
206 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
207 MODE_INTRA, MODE_USING_GOLDEN,
208 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
211 { MODE_INTER_NO_MV, MODE_USING_GOLDEN,
212 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
213 MODE_INTER_PLUS_MV, MODE_INTRA,
214 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
218 #define MIN_DEQUANT_VAL 2
220 typedef struct Vp3DecodeContext {
221 AVCodecContext *avctx;
222 int theora, theora_tables;
225 AVFrame golden_frame;
227 AVFrame current_frame;
233 int last_quality_index;
235 int superblock_count;
236 int superblock_width;
237 int superblock_height;
238 int y_superblock_width;
239 int y_superblock_height;
240 int c_superblock_width;
241 int c_superblock_height;
242 int u_superblock_start;
243 int v_superblock_start;
244 unsigned char *superblock_coding;
246 int macroblock_count;
247 int macroblock_width;
248 int macroblock_height;
254 Vp3Fragment *all_fragments;
257 int u_fragment_start;
258 int v_fragment_start;
263 uint16_t coded_dc_scale_factor[64];
264 uint32_t coded_ac_scale_factor[64];
265 uint16_t coded_intra_y_dequant[64];
266 uint16_t coded_intra_c_dequant[64];
267 uint16_t coded_inter_dequant[64];
269 /* this is a list of indices 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_inited;
281 VLC superblock_run_length_vlc;
282 VLC fragment_run_length_vlc;
284 VLC motion_vector_vlc;
286 /* these arrays need to be on 16-byte boundaries since SSE2 operations
288 int16_t __align16 intra_y_dequant[64];
289 int16_t __align16 intra_c_dequant[64];
290 int16_t __align16 inter_dequant[64];
292 /* This table contains superblock_count * 16 entries. Each set of 16
293 * numbers corresponds to the fragment indices 0..15 of the superblock.
294 * An entry will be -1 to indicate that no entry corresponds to that
296 int *superblock_fragments;
298 /* This table contains superblock_count * 4 entries. Each set of 4
299 * numbers corresponds to the macroblock indices 0..3 of the superblock.
300 * An entry will be -1 to indicate that no entry corresponds to that
302 int *superblock_macroblocks;
304 /* This table contains macroblock_count * 6 entries. Each set of 6
305 * numbers corresponds to the fragment indices 0..5 which comprise
306 * the macroblock (4 Y fragments and 2 C fragments). */
307 int *macroblock_fragments;
308 /* This is an array that indicates how a particular macroblock
310 unsigned char *macroblock_coding;
312 int first_coded_y_fragment;
313 int first_coded_c_fragment;
314 int last_coded_y_fragment;
315 int last_coded_c_fragment;
317 uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
318 uint8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
325 uint16_t huffman_table[80][32][2];
327 uint32_t filter_limit_values[64];
328 int bounding_values_array[256];
331 static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb);
332 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb);
334 /************************************************************************
335 * VP3 specific functions
336 ************************************************************************/
339 * This function sets up all of the various blocks mappings:
340 * superblocks <-> fragments, macroblocks <-> fragments,
341 * superblocks <-> macroblocks
343 * Returns 0 is successful; returns 1 if *anything* went wrong.
345 static int init_block_mapping(Vp3DecodeContext *s)
348 signed int hilbert_walk_y[16];
349 signed int hilbert_walk_c[16];
350 signed int hilbert_walk_mb[4];
352 int current_fragment = 0;
353 int current_width = 0;
354 int current_height = 0;
357 int superblock_row_inc = 0;
359 int mapping_index = 0;
361 int current_macroblock;
364 signed char travel_width[16] = {
371 signed char travel_height[16] = {
378 signed char travel_width_mb[4] = {
382 signed char travel_height_mb[4] = {
386 debug_vp3(" vp3: initialize block mapping tables\n");
388 /* figure out hilbert pattern per these frame dimensions */
389 hilbert_walk_y[0] = 1;
390 hilbert_walk_y[1] = 1;
391 hilbert_walk_y[2] = s->fragment_width;
392 hilbert_walk_y[3] = -1;
393 hilbert_walk_y[4] = s->fragment_width;
394 hilbert_walk_y[5] = s->fragment_width;
395 hilbert_walk_y[6] = 1;
396 hilbert_walk_y[7] = -s->fragment_width;
397 hilbert_walk_y[8] = 1;
398 hilbert_walk_y[9] = s->fragment_width;
399 hilbert_walk_y[10] = 1;
400 hilbert_walk_y[11] = -s->fragment_width;
401 hilbert_walk_y[12] = -s->fragment_width;
402 hilbert_walk_y[13] = -1;
403 hilbert_walk_y[14] = -s->fragment_width;
404 hilbert_walk_y[15] = 1;
406 hilbert_walk_c[0] = 1;
407 hilbert_walk_c[1] = 1;
408 hilbert_walk_c[2] = s->fragment_width / 2;
409 hilbert_walk_c[3] = -1;
410 hilbert_walk_c[4] = s->fragment_width / 2;
411 hilbert_walk_c[5] = s->fragment_width / 2;
412 hilbert_walk_c[6] = 1;
413 hilbert_walk_c[7] = -s->fragment_width / 2;
414 hilbert_walk_c[8] = 1;
415 hilbert_walk_c[9] = s->fragment_width / 2;
416 hilbert_walk_c[10] = 1;
417 hilbert_walk_c[11] = -s->fragment_width / 2;
418 hilbert_walk_c[12] = -s->fragment_width / 2;
419 hilbert_walk_c[13] = -1;
420 hilbert_walk_c[14] = -s->fragment_width / 2;
421 hilbert_walk_c[15] = 1;
423 hilbert_walk_mb[0] = 1;
424 hilbert_walk_mb[1] = s->macroblock_width;
425 hilbert_walk_mb[2] = 1;
426 hilbert_walk_mb[3] = -s->macroblock_width;
428 /* iterate through each superblock (all planes) and map the fragments */
429 for (i = 0; i < s->superblock_count; i++) {
430 debug_init(" superblock %d (u starts @ %d, v starts @ %d)\n",
431 i, s->u_superblock_start, s->v_superblock_start);
433 /* time to re-assign the limits? */
436 /* start of Y superblocks */
437 right_edge = s->fragment_width;
438 bottom_edge = s->fragment_height;
441 superblock_row_inc = 3 * s->fragment_width -
442 (s->y_superblock_width * 4 - s->fragment_width);
443 hilbert = hilbert_walk_y;
445 /* the first operation for this variable is to advance by 1 */
446 current_fragment = -1;
448 } else if (i == s->u_superblock_start) {
450 /* start of U superblocks */
451 right_edge = s->fragment_width / 2;
452 bottom_edge = s->fragment_height / 2;
455 superblock_row_inc = 3 * (s->fragment_width / 2) -
456 (s->c_superblock_width * 4 - s->fragment_width / 2);
457 hilbert = hilbert_walk_c;
459 /* the first operation for this variable is to advance by 1 */
460 current_fragment = s->u_fragment_start - 1;
462 } else if (i == s->v_superblock_start) {
464 /* start of V superblocks */
465 right_edge = s->fragment_width / 2;
466 bottom_edge = s->fragment_height / 2;
469 superblock_row_inc = 3 * (s->fragment_width / 2) -
470 (s->c_superblock_width * 4 - s->fragment_width / 2);
471 hilbert = hilbert_walk_c;
473 /* the first operation for this variable is to advance by 1 */
474 current_fragment = s->v_fragment_start - 1;
478 if (current_width >= right_edge - 1) {
479 /* reset width and move to next superblock row */
483 /* fragment is now at the start of a new superblock row */
484 current_fragment += superblock_row_inc;
487 /* iterate through all 16 fragments in a superblock */
488 for (j = 0; j < 16; j++) {
489 current_fragment += hilbert[j];
490 current_width += travel_width[j];
491 current_height += travel_height[j];
493 /* check if the fragment is in bounds */
494 if ((current_width < right_edge) &&
495 (current_height < bottom_edge)) {
496 s->superblock_fragments[mapping_index] = current_fragment;
497 debug_init(" mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n",
498 s->superblock_fragments[mapping_index], i, j,
499 current_width, right_edge, current_height, bottom_edge);
501 s->superblock_fragments[mapping_index] = -1;
502 debug_init(" superblock %d, position %d has no fragment (%d/%d x %d/%d)\n",
504 current_width, right_edge, current_height, bottom_edge);
511 /* initialize the superblock <-> macroblock mapping; iterate through
512 * all of the Y plane superblocks to build this mapping */
513 right_edge = s->macroblock_width;
514 bottom_edge = s->macroblock_height;
517 superblock_row_inc = s->macroblock_width -
518 (s->y_superblock_width * 2 - s->macroblock_width);;
519 hilbert = hilbert_walk_mb;
521 current_macroblock = -1;
522 for (i = 0; i < s->u_superblock_start; i++) {
524 if (current_width >= right_edge - 1) {
525 /* reset width and move to next superblock row */
529 /* macroblock is now at the start of a new superblock row */
530 current_macroblock += superblock_row_inc;
533 /* iterate through each potential macroblock in the superblock */
534 for (j = 0; j < 4; j++) {
535 current_macroblock += hilbert_walk_mb[j];
536 current_width += travel_width_mb[j];
537 current_height += travel_height_mb[j];
539 /* check if the macroblock is in bounds */
540 if ((current_width < right_edge) &&
541 (current_height < bottom_edge)) {
542 s->superblock_macroblocks[mapping_index] = current_macroblock;
543 debug_init(" mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
544 s->superblock_macroblocks[mapping_index], i, j,
545 current_width, right_edge, current_height, bottom_edge);
547 s->superblock_macroblocks[mapping_index] = -1;
548 debug_init(" superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
550 current_width, right_edge, current_height, bottom_edge);
557 /* initialize the macroblock <-> fragment mapping */
558 current_fragment = 0;
559 current_macroblock = 0;
561 for (i = 0; i < s->fragment_height; i += 2) {
563 for (j = 0; j < s->fragment_width; j += 2) {
565 debug_init(" macroblock %d contains fragments: ", current_macroblock);
566 s->all_fragments[current_fragment].macroblock = current_macroblock;
567 s->macroblock_fragments[mapping_index++] = current_fragment;
568 debug_init("%d ", current_fragment);
570 if (j + 1 < s->fragment_width) {
571 s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
572 s->macroblock_fragments[mapping_index++] = current_fragment + 1;
573 debug_init("%d ", current_fragment + 1);
575 s->macroblock_fragments[mapping_index++] = -1;
577 if (i + 1 < s->fragment_height) {
578 s->all_fragments[current_fragment + s->fragment_width].macroblock =
580 s->macroblock_fragments[mapping_index++] =
581 current_fragment + s->fragment_width;
582 debug_init("%d ", current_fragment + s->fragment_width);
584 s->macroblock_fragments[mapping_index++] = -1;
586 if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
587 s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
589 s->macroblock_fragments[mapping_index++] =
590 current_fragment + s->fragment_width + 1;
591 debug_init("%d ", current_fragment + s->fragment_width + 1);
593 s->macroblock_fragments[mapping_index++] = -1;
596 c_fragment = s->u_fragment_start +
597 (i * s->fragment_width / 4) + (j / 2);
598 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
599 s->macroblock_fragments[mapping_index++] = c_fragment;
600 debug_init("%d ", c_fragment);
602 c_fragment = s->v_fragment_start +
603 (i * s->fragment_width / 4) + (j / 2);
604 s->all_fragments[c_fragment].macroblock = s->macroblock_count;
605 s->macroblock_fragments[mapping_index++] = c_fragment;
606 debug_init("%d ", c_fragment);
610 if (j + 2 <= s->fragment_width)
611 current_fragment += 2;
614 current_macroblock++;
617 current_fragment += s->fragment_width;
620 return 0; /* successful path out */
624 * This function unpacks a single token (which should be in the range 0..31)
625 * and returns a zero run (number of zero coefficients in current DCT matrix
626 * before next non-zero coefficient), the next DCT coefficient, and the
627 * number of consecutive, non-EOB'd DCT blocks to EOB.
629 static void unpack_token(GetBitContext *gb, int token, int *zero_run,
630 DCTELEM *coeff, int *eob_run)
638 debug_token(" vp3 token %d: ", token);
642 debug_token("DCT_EOB_TOKEN, EOB next block\n");
647 debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
652 debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
657 debug_token("DCT_REPEAT_RUN_TOKEN, ");
658 *eob_run = get_bits(gb, 2) + 4;
659 debug_token("EOB the next %d blocks\n", *eob_run);
663 debug_token("DCT_REPEAT_RUN2_TOKEN, ");
664 *eob_run = get_bits(gb, 3) + 8;
665 debug_token("EOB the next %d blocks\n", *eob_run);
669 debug_token("DCT_REPEAT_RUN3_TOKEN, ");
670 *eob_run = get_bits(gb, 4) + 16;
671 debug_token("EOB the next %d blocks\n", *eob_run);
675 debug_token("DCT_REPEAT_RUN4_TOKEN, ");
676 *eob_run = get_bits(gb, 12);
677 debug_token("EOB the next %d blocks\n", *eob_run);
681 debug_token("DCT_SHORT_ZRL_TOKEN, ");
682 /* note that this token actually indicates that (3 extra bits) + 1 0s
683 * should be output; this case specifies a run of (3 EBs) 0s and a
684 * coefficient of 0. */
685 *zero_run = get_bits(gb, 3);
687 debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
691 debug_token("DCT_ZRL_TOKEN, ");
692 /* note that this token actually indicates that (6 extra bits) + 1 0s
693 * should be output; this case specifies a run of (6 EBs) 0s and a
694 * coefficient of 0. */
695 *zero_run = get_bits(gb, 6);
697 debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
701 debug_token("ONE_TOKEN, output 1\n");
706 debug_token("MINUS_ONE_TOKEN, output -1\n");
711 debug_token("TWO_TOKEN, output 2\n");
716 debug_token("MINUS_TWO_TOKEN, output -2\n");
724 debug_token("LOW_VAL_TOKENS, ");
726 *coeff = -(3 + (token - 13));
728 *coeff = 3 + (token - 13);
729 debug_token("output %d\n", *coeff);
733 debug_token("DCT_VAL_CATEGORY3, ");
734 sign = get_bits(gb, 1);
735 *coeff = 7 + get_bits(gb, 1);
738 debug_token("output %d\n", *coeff);
742 debug_token("DCT_VAL_CATEGORY4, ");
743 sign = get_bits(gb, 1);
744 *coeff = 9 + get_bits(gb, 2);
747 debug_token("output %d\n", *coeff);
751 debug_token("DCT_VAL_CATEGORY5, ");
752 sign = get_bits(gb, 1);
753 *coeff = 13 + get_bits(gb, 3);
756 debug_token("output %d\n", *coeff);
760 debug_token("DCT_VAL_CATEGORY6, ");
761 sign = get_bits(gb, 1);
762 *coeff = 21 + get_bits(gb, 4);
765 debug_token("output %d\n", *coeff);
769 debug_token("DCT_VAL_CATEGORY7, ");
770 sign = get_bits(gb, 1);
771 *coeff = 37 + get_bits(gb, 5);
774 debug_token("output %d\n", *coeff);
778 debug_token("DCT_VAL_CATEGORY8, ");
779 sign = get_bits(gb, 1);
780 *coeff = 69 + get_bits(gb, 9);
783 debug_token("output %d\n", *coeff);
791 debug_token("DCT_RUN_CATEGORY1, ");
792 *zero_run = token - 22;
797 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
801 debug_token("DCT_RUN_CATEGORY1B, ");
806 *zero_run = 6 + get_bits(gb, 2);
807 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
811 debug_token("DCT_RUN_CATEGORY1C, ");
816 *zero_run = 10 + get_bits(gb, 3);
817 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
821 debug_token("DCT_RUN_CATEGORY2, ");
822 sign = get_bits(gb, 1);
823 *coeff = 2 + get_bits(gb, 1);
827 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
831 debug_token("DCT_RUN_CATEGORY2, ");
832 sign = get_bits(gb, 1);
833 *coeff = 2 + get_bits(gb, 1);
836 *zero_run = 2 + get_bits(gb, 1);
837 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
841 av_log(NULL, AV_LOG_ERROR, " vp3: help! Got a bad token: %d > 31\n", token);
848 * This function wipes out all of the fragment data.
850 static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
854 /* zero out all of the fragment information */
855 s->coded_fragment_list_index = 0;
856 for (i = 0; i < s->fragment_count; i++) {
857 s->all_fragments[i].coeff_count = 0;
858 s->all_fragments[i].motion_x = 127;
859 s->all_fragments[i].motion_y = 127;
860 s->all_fragments[i].next_coeff= NULL;
862 s->coeffs[i].coeff=0;
863 s->coeffs[i].next= NULL;
868 * This function sets up the dequantization tables used for a particular
871 static void init_dequantizer(Vp3DecodeContext *s)
874 int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
875 int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
878 debug_vp3(" vp3: initializing dequantization tables\n");
881 * Scale dequantizers:
887 * where sf = dc_scale_factor for DC quantizer
888 * or ac_scale_factor for AC quantizer
890 * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
894 /* scale DC quantizers */
895 s->intra_y_dequant[0] = s->coded_intra_y_dequant[0] * dc_scale_factor / 100;
896 if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
897 s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
898 s->intra_y_dequant[0] *= SCALER;
900 s->intra_c_dequant[0] = s->coded_intra_c_dequant[0] * dc_scale_factor / 100;
901 if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
902 s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
903 s->intra_c_dequant[0] *= SCALER;
905 s->inter_dequant[0] = s->coded_inter_dequant[0] * dc_scale_factor / 100;
906 if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
907 s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
908 s->inter_dequant[0] *= SCALER;
910 /* scale AC quantizers, zigzag at the same time in preparation for
911 * the dequantization phase */
912 for (i = 1; i < 64; i++) {
913 int k= s->scantable.scantable[i];
914 j = s->scantable.permutated[i];
916 s->intra_y_dequant[j] = s->coded_intra_y_dequant[k] * ac_scale_factor / 100;
917 if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
918 s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
919 s->intra_y_dequant[j] *= SCALER;
921 s->intra_c_dequant[j] = s->coded_intra_c_dequant[k] * ac_scale_factor / 100;
922 if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
923 s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
924 s->intra_c_dequant[j] *= SCALER;
926 s->inter_dequant[j] = s->coded_inter_dequant[k] * ac_scale_factor / 100;
927 if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
928 s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
929 s->inter_dequant[j] *= SCALER;
932 memset(s->qscale_table, (FFMAX(s->intra_y_dequant[1], s->intra_c_dequant[1])+8)/16, 512); //FIXME finetune
934 /* print debug information as requested */
935 debug_dequantizers("intra Y dequantizers:\n");
936 for (i = 0; i < 8; i++) {
937 for (j = i * 8; j < i * 8 + 8; j++) {
938 debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
940 debug_dequantizers("\n");
942 debug_dequantizers("\n");
944 debug_dequantizers("intra C dequantizers:\n");
945 for (i = 0; i < 8; i++) {
946 for (j = i * 8; j < i * 8 + 8; j++) {
947 debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
949 debug_dequantizers("\n");
951 debug_dequantizers("\n");
953 debug_dequantizers("interframe dequantizers:\n");
954 for (i = 0; i < 8; i++) {
955 for (j = i * 8; j < i * 8 + 8; j++) {
956 debug_dequantizers(" %4d,", s->inter_dequant[j]);
958 debug_dequantizers("\n");
960 debug_dequantizers("\n");
964 * This function initializes the loop filter boundary limits if the frame's
965 * quality index is different from the previous frame's.
967 static void init_loop_filter(Vp3DecodeContext *s)
969 int *bounding_values= s->bounding_values_array+127;
973 filter_limit = s->filter_limit_values[s->quality_index];
975 /* set up the bounding values */
976 memset(s->bounding_values_array, 0, 256 * sizeof(int));
977 for (x = 0; x < filter_limit; x++) {
978 bounding_values[-x - filter_limit] = -filter_limit + x;
979 bounding_values[-x] = -x;
980 bounding_values[x] = x;
981 bounding_values[x + filter_limit] = filter_limit - x;
986 * This function is used to fetch runs of 1s or 0s from the bitstream for
987 * use in determining which superblocks are fully and partially coded.
996 * 111111xxxxxxxxxxxx 34-4129
998 static int get_superblock_run_length(GetBitContext *gb)
1001 if (get_bits(gb, 1) == 0)
1004 else if (get_bits(gb, 1) == 0)
1005 return (2 + get_bits(gb, 1));
1007 else if (get_bits(gb, 1) == 0)
1008 return (4 + get_bits(gb, 1));
1010 else if (get_bits(gb, 1) == 0)
1011 return (6 + get_bits(gb, 2));
1013 else if (get_bits(gb, 1) == 0)
1014 return (10 + get_bits(gb, 3));
1016 else if (get_bits(gb, 1) == 0)
1017 return (18 + get_bits(gb, 4));
1020 return (34 + get_bits(gb, 12));
1025 * This function is used to fetch runs of 1s or 0s from the bitstream for
1026 * use in determining which particular fragments are coded.
1028 * Codeword RunLength
1036 static int get_fragment_run_length(GetBitContext *gb)
1039 if (get_bits(gb, 1) == 0)
1040 return (1 + get_bits(gb, 1));
1042 else if (get_bits(gb, 1) == 0)
1043 return (3 + get_bits(gb, 1));
1045 else if (get_bits(gb, 1) == 0)
1046 return (5 + get_bits(gb, 1));
1048 else if (get_bits(gb, 1) == 0)
1049 return (7 + get_bits(gb, 2));
1051 else if (get_bits(gb, 1) == 0)
1052 return (11 + get_bits(gb, 2));
1055 return (15 + get_bits(gb, 4));
1060 * This function decodes a VLC from the bitstream and returns a number
1061 * that ranges from 0..7. The number indicates which of the 8 coding
1075 static int get_mode_code(GetBitContext *gb)
1078 if (get_bits(gb, 1) == 0)
1081 else if (get_bits(gb, 1) == 0)
1084 else if (get_bits(gb, 1) == 0)
1087 else if (get_bits(gb, 1) == 0)
1090 else if (get_bits(gb, 1) == 0)
1093 else if (get_bits(gb, 1) == 0)
1096 else if (get_bits(gb, 1) == 0)
1105 * This function extracts a motion vector from the bitstream using a VLC
1106 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1107 * taken depending on the value on those 3 bits:
1112 * 3: if (next bit is 1) return -2, else return 2
1113 * 4: if (next bit is 1) return -3, else return 3
1114 * 5: return 4 + (next 2 bits), next bit is sign
1115 * 6: return 8 + (next 3 bits), next bit is sign
1116 * 7: return 16 + (next 4 bits), next bit is sign
1118 static int get_motion_vector_vlc(GetBitContext *gb)
1122 bits = get_bits(gb, 3);
1139 if (get_bits(gb, 1) == 0)
1146 if (get_bits(gb, 1) == 0)
1153 bits = 4 + get_bits(gb, 2);
1154 if (get_bits(gb, 1) == 1)
1159 bits = 8 + get_bits(gb, 3);
1160 if (get_bits(gb, 1) == 1)
1165 bits = 16 + get_bits(gb, 4);
1166 if (get_bits(gb, 1) == 1)
1176 * This function fetches a 5-bit number from the stream followed by
1177 * a sign and calls it a motion vector.
1179 static int get_motion_vector_fixed(GetBitContext *gb)
1184 bits = get_bits(gb, 5);
1186 if (get_bits(gb, 1) == 1)
1193 * This function unpacks all of the superblock/macroblock/fragment coding
1194 * information from the bitstream.
1196 static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1199 int current_superblock = 0;
1200 int current_run = 0;
1201 int decode_fully_flags = 0;
1202 int decode_partial_blocks = 0;
1203 int first_c_fragment_seen;
1206 int current_fragment;
1208 debug_vp3(" vp3: unpacking superblock coding\n");
1212 debug_vp3(" keyframe-- all superblocks are fully coded\n");
1213 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1217 /* unpack the list of partially-coded superblocks */
1218 bit = get_bits(gb, 1);
1219 /* toggle the bit because as soon as the first run length is
1220 * fetched the bit will be toggled again */
1222 while (current_superblock < s->superblock_count) {
1223 if (current_run-- == 0) {
1226 current_run = get_vlc2(gb,
1227 s->superblock_run_length_vlc.table, 6, 2);
1228 if (current_run == 33)
1229 current_run += get_bits(gb, 12);
1231 current_run = get_superblock_run_length(gb);
1233 debug_block_coding(" setting superblocks %d..%d to %s\n",
1235 current_superblock + current_run - 1,
1236 (bit) ? "partially coded" : "not coded");
1238 /* if any of the superblocks are not partially coded, flag
1239 * a boolean to decode the list of fully-coded superblocks */
1241 decode_fully_flags = 1;
1244 /* make a note of the fact that there are partially coded
1246 decode_partial_blocks = 1;
1249 s->superblock_coding[current_superblock++] = bit;
1252 /* unpack the list of fully coded superblocks if any of the blocks were
1253 * not marked as partially coded in the previous step */
1254 if (decode_fully_flags) {
1256 current_superblock = 0;
1258 bit = get_bits(gb, 1);
1259 /* toggle the bit because as soon as the first run length is
1260 * fetched the bit will be toggled again */
1262 while (current_superblock < s->superblock_count) {
1264 /* skip any superblocks already marked as partially coded */
1265 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1267 if (current_run-- == 0) {
1270 current_run = get_vlc2(gb,
1271 s->superblock_run_length_vlc.table, 6, 2);
1272 if (current_run == 33)
1273 current_run += get_bits(gb, 12);
1275 current_run = get_superblock_run_length(gb);
1279 debug_block_coding(" setting superblock %d to %s\n",
1281 (bit) ? "fully coded" : "not coded");
1282 s->superblock_coding[current_superblock] = 2*bit;
1284 current_superblock++;
1288 /* if there were partial blocks, initialize bitstream for
1289 * unpacking fragment codings */
1290 if (decode_partial_blocks) {
1293 bit = get_bits(gb, 1);
1294 /* toggle the bit because as soon as the first run length is
1295 * fetched the bit will be toggled again */
1300 /* figure out which fragments are coded; iterate through each
1301 * superblock (all planes) */
1302 s->coded_fragment_list_index = 0;
1303 s->next_coeff= s->coeffs + s->fragment_count;
1304 s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1305 s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1306 first_c_fragment_seen = 0;
1307 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1308 for (i = 0; i < s->superblock_count; i++) {
1310 /* iterate through all 16 fragments in a superblock */
1311 for (j = 0; j < 16; j++) {
1313 /* if the fragment is in bounds, check its coding status */
1314 current_fragment = s->superblock_fragments[i * 16 + j];
1315 if (current_fragment >= s->fragment_count) {
1316 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1317 current_fragment, s->fragment_count);
1320 if (current_fragment != -1) {
1321 if (s->superblock_coding[i] == SB_NOT_CODED) {
1323 /* copy all the fragments from the prior frame */
1324 s->all_fragments[current_fragment].coding_method =
1327 } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1329 /* fragment may or may not be coded; this is the case
1330 * that cares about the fragment coding runs */
1331 if (current_run-- == 0) {
1334 current_run = get_vlc2(gb,
1335 s->fragment_run_length_vlc.table, 5, 2);
1337 current_run = get_fragment_run_length(gb);
1342 /* default mode; actual mode will be decoded in
1344 s->all_fragments[current_fragment].coding_method =
1346 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
1347 s->coded_fragment_list[s->coded_fragment_list_index] =
1349 if ((current_fragment >= s->u_fragment_start) &&
1350 (s->last_coded_y_fragment == -1) &&
1351 (!first_c_fragment_seen)) {
1352 s->first_coded_c_fragment = s->coded_fragment_list_index;
1353 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1354 first_c_fragment_seen = 1;
1356 s->coded_fragment_list_index++;
1357 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1358 debug_block_coding(" superblock %d is partially coded, fragment %d is coded\n",
1359 i, current_fragment);
1361 /* not coded; copy this fragment from the prior frame */
1362 s->all_fragments[current_fragment].coding_method =
1364 debug_block_coding(" superblock %d is partially coded, fragment %d is not coded\n",
1365 i, current_fragment);
1370 /* fragments are fully coded in this superblock; actual
1371 * coding will be determined in next step */
1372 s->all_fragments[current_fragment].coding_method =
1374 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
1375 s->coded_fragment_list[s->coded_fragment_list_index] =
1377 if ((current_fragment >= s->u_fragment_start) &&
1378 (s->last_coded_y_fragment == -1) &&
1379 (!first_c_fragment_seen)) {
1380 s->first_coded_c_fragment = s->coded_fragment_list_index;
1381 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1382 first_c_fragment_seen = 1;
1384 s->coded_fragment_list_index++;
1385 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1386 debug_block_coding(" superblock %d is fully coded, fragment %d is coded\n",
1387 i, current_fragment);
1393 if (!first_c_fragment_seen)
1394 /* only Y fragments coded in this frame */
1395 s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
1397 /* end the list of coded C fragments */
1398 s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1400 debug_block_coding(" %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1401 s->coded_fragment_list_index,
1402 s->first_coded_y_fragment,
1403 s->last_coded_y_fragment,
1404 s->first_coded_c_fragment,
1405 s->last_coded_c_fragment);
1411 * This function unpacks all the coding mode data for individual macroblocks
1412 * from the bitstream.
1414 static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1418 int current_macroblock;
1419 int current_fragment;
1422 debug_vp3(" vp3: unpacking encoding modes\n");
1425 debug_vp3(" keyframe-- all blocks are coded as INTRA\n");
1427 for (i = 0; i < s->fragment_count; i++)
1428 s->all_fragments[i].coding_method = MODE_INTRA;
1432 /* fetch the mode coding scheme for this frame */
1433 scheme = get_bits(gb, 3);
1434 debug_modes(" using mode alphabet %d\n", scheme);
1436 /* is it a custom coding scheme? */
1438 debug_modes(" custom mode alphabet ahead:\n");
1439 for (i = 0; i < 8; i++)
1440 ModeAlphabet[scheme][get_bits(gb, 3)] = i;
1443 for (i = 0; i < 8; i++)
1444 debug_modes(" mode[%d][%d] = %d\n", scheme, i,
1445 ModeAlphabet[scheme][i]);
1447 /* iterate through all of the macroblocks that contain 1 or more
1448 * coded fragments */
1449 for (i = 0; i < s->u_superblock_start; i++) {
1451 for (j = 0; j < 4; j++) {
1452 current_macroblock = s->superblock_macroblocks[i * 4 + j];
1453 if ((current_macroblock == -1) ||
1454 (s->macroblock_coding[current_macroblock] == MODE_COPY))
1456 if (current_macroblock >= s->macroblock_count) {
1457 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1458 current_macroblock, s->macroblock_count);
1462 /* mode 7 means get 3 bits for each coding mode */
1464 coding_mode = get_bits(gb, 3);
1468 coding_mode = ModeAlphabet[scheme]
1469 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1471 coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
1475 s->macroblock_coding[current_macroblock] = coding_mode;
1476 for (k = 0; k < 6; k++) {
1478 s->macroblock_fragments[current_macroblock * 6 + k];
1479 if (current_fragment == -1)
1481 if (current_fragment >= s->fragment_count) {
1482 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1483 current_fragment, s->fragment_count);
1486 if (s->all_fragments[current_fragment].coding_method !=
1488 s->all_fragments[current_fragment].coding_method =
1492 debug_modes(" coding method for macroblock starting @ fragment %d = %d\n",
1493 s->macroblock_fragments[current_macroblock * 6], coding_mode);
1502 * This function unpacks all the motion vectors for the individual
1503 * macroblocks from the bitstream.
1505 static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1511 int last_motion_x = 0;
1512 int last_motion_y = 0;
1513 int prior_last_motion_x = 0;
1514 int prior_last_motion_y = 0;
1515 int current_macroblock;
1516 int current_fragment;
1518 debug_vp3(" vp3: unpacking motion vectors\n");
1521 debug_vp3(" keyframe-- there are no motion vectors\n");
1525 memset(motion_x, 0, 6 * sizeof(int));
1526 memset(motion_y, 0, 6 * sizeof(int));
1528 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1529 coding_mode = get_bits(gb, 1);
1530 debug_vectors(" using %s scheme for unpacking motion vectors\n",
1531 (coding_mode == 0) ? "VLC" : "fixed-length");
1533 /* iterate through all of the macroblocks that contain 1 or more
1534 * coded fragments */
1535 for (i = 0; i < s->u_superblock_start; i++) {
1537 for (j = 0; j < 4; j++) {
1538 current_macroblock = s->superblock_macroblocks[i * 4 + j];
1539 if ((current_macroblock == -1) ||
1540 (s->macroblock_coding[current_macroblock] == MODE_COPY))
1542 if (current_macroblock >= s->macroblock_count) {
1543 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1544 current_macroblock, s->macroblock_count);
1548 current_fragment = s->macroblock_fragments[current_macroblock * 6];
1549 if (current_fragment >= s->fragment_count) {
1550 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1551 current_fragment, s->fragment_count);
1554 switch (s->macroblock_coding[current_macroblock]) {
1556 case MODE_INTER_PLUS_MV:
1557 case MODE_GOLDEN_MV:
1558 /* all 6 fragments use the same motion vector */
1559 if (coding_mode == 0) {
1561 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1562 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1564 motion_x[0] = get_motion_vector_vlc(gb);
1565 motion_y[0] = get_motion_vector_vlc(gb);
1569 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1570 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1572 motion_x[0] = get_motion_vector_fixed(gb);
1573 motion_y[0] = get_motion_vector_fixed(gb);
1577 for (k = 1; k < 6; k++) {
1578 motion_x[k] = motion_x[0];
1579 motion_y[k] = motion_y[0];
1582 /* vector maintenance, only on MODE_INTER_PLUS_MV */
1583 if (s->macroblock_coding[current_macroblock] ==
1584 MODE_INTER_PLUS_MV) {
1585 prior_last_motion_x = last_motion_x;
1586 prior_last_motion_y = last_motion_y;
1587 last_motion_x = motion_x[0];
1588 last_motion_y = motion_y[0];
1592 case MODE_INTER_FOURMV:
1593 /* fetch 4 vectors from the bitstream, one for each
1594 * Y fragment, then average for the C fragment vectors */
1595 motion_x[4] = motion_y[4] = 0;
1596 for (k = 0; k < 4; k++) {
1597 if (coding_mode == 0) {
1599 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1600 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1602 motion_x[k] = get_motion_vector_vlc(gb);
1603 motion_y[k] = get_motion_vector_vlc(gb);
1607 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1608 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1610 motion_x[k] = get_motion_vector_fixed(gb);
1611 motion_y[k] = get_motion_vector_fixed(gb);
1614 motion_x[4] += motion_x[k];
1615 motion_y[4] += motion_y[k];
1618 if (motion_x[4] >= 0)
1619 motion_x[4] = (motion_x[4] + 2) / 4;
1621 motion_x[4] = (motion_x[4] - 2) / 4;
1622 motion_x[5] = motion_x[4];
1624 if (motion_y[4] >= 0)
1625 motion_y[4] = (motion_y[4] + 2) / 4;
1627 motion_y[4] = (motion_y[4] - 2) / 4;
1628 motion_y[5] = motion_y[4];
1630 /* vector maintenance; vector[3] is treated as the
1631 * last vector in this case */
1632 prior_last_motion_x = last_motion_x;
1633 prior_last_motion_y = last_motion_y;
1634 last_motion_x = motion_x[3];
1635 last_motion_y = motion_y[3];
1638 case MODE_INTER_LAST_MV:
1639 /* all 6 fragments use the last motion vector */
1640 motion_x[0] = last_motion_x;
1641 motion_y[0] = last_motion_y;
1642 for (k = 1; k < 6; k++) {
1643 motion_x[k] = motion_x[0];
1644 motion_y[k] = motion_y[0];
1647 /* no vector maintenance (last vector remains the
1651 case MODE_INTER_PRIOR_LAST:
1652 /* all 6 fragments use the motion vector prior to the
1653 * last motion vector */
1654 motion_x[0] = prior_last_motion_x;
1655 motion_y[0] = prior_last_motion_y;
1656 for (k = 1; k < 6; k++) {
1657 motion_x[k] = motion_x[0];
1658 motion_y[k] = motion_y[0];
1661 /* vector maintenance */
1662 prior_last_motion_x = last_motion_x;
1663 prior_last_motion_y = last_motion_y;
1664 last_motion_x = motion_x[0];
1665 last_motion_y = motion_y[0];
1669 /* covers intra, inter without MV, golden without MV */
1670 memset(motion_x, 0, 6 * sizeof(int));
1671 memset(motion_y, 0, 6 * sizeof(int));
1673 /* no vector maintenance */
1677 /* assign the motion vectors to the correct fragments */
1678 debug_vectors(" vectors for macroblock starting @ fragment %d (coding method %d):\n",
1680 s->macroblock_coding[current_macroblock]);
1681 for (k = 0; k < 6; k++) {
1683 s->macroblock_fragments[current_macroblock * 6 + k];
1684 if (current_fragment == -1)
1686 if (current_fragment >= s->fragment_count) {
1687 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1688 current_fragment, s->fragment_count);
1691 s->all_fragments[current_fragment].motion_x = motion_x[k];
1692 s->all_fragments[current_fragment].motion_y = motion_y[k];
1693 debug_vectors(" vector %d: fragment %d = (%d, %d)\n",
1694 k, current_fragment, motion_x[k], motion_y[k]);
1704 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1705 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1706 * data. This function unpacks all the VLCs for either the Y plane or both
1707 * C planes, and is called for DC coefficients or different AC coefficient
1708 * levels (since different coefficient types require different VLC tables.
1710 * This function returns a residual eob run. E.g, if a particular token gave
1711 * instructions to EOB the next 5 fragments and there were only 2 fragments
1712 * left in the current fragment range, 3 would be returned so that it could
1713 * be passed into the next call to this same function.
1715 static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1716 VLC *table, int coeff_index,
1717 int first_fragment, int last_fragment,
1724 Vp3Fragment *fragment;
1725 uint8_t *perm= s->scantable.permutated;
1728 if ((first_fragment >= s->fragment_count) ||
1729 (last_fragment >= s->fragment_count)) {
1731 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1732 first_fragment, last_fragment);
1736 for (i = first_fragment; i <= last_fragment; i++) {
1738 fragment = &s->all_fragments[s->coded_fragment_list[i]];
1739 if (fragment->coeff_count > coeff_index)
1743 /* decode a VLC into a token */
1744 token = get_vlc2(gb, table->table, 5, 3);
1745 debug_vlc(" token = %2d, ", token);
1746 /* use the token to get a zero run, a coefficient, and an eob run */
1749 eob_run = eob_run_base[token];
1750 if (eob_run_get_bits[token])
1751 eob_run += get_bits(gb, eob_run_get_bits[token]);
1752 coeff = zero_run = 0;
1754 bits_to_get = coeff_get_bits[token];
1756 coeff = coeff_tables[token][0];
1758 coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
1760 zero_run = zero_run_base[token];
1761 if (zero_run_get_bits[token])
1762 zero_run += get_bits(gb, zero_run_get_bits[token]);
1765 unpack_token(gb, token, &zero_run, &coeff, &eob_run);
1770 fragment->coeff_count += zero_run;
1771 if (fragment->coeff_count < 64){
1772 fragment->next_coeff->coeff= coeff;
1773 fragment->next_coeff->index= perm[fragment->coeff_count++]; //FIXME perm here already?
1774 fragment->next_coeff->next= s->next_coeff;
1775 s->next_coeff->next=NULL;
1776 fragment->next_coeff= s->next_coeff++;
1778 debug_vlc(" fragment %d coeff = %d\n",
1779 s->coded_fragment_list[i], fragment->next_coeff[coeff_index]);
1781 fragment->coeff_count |= 128;
1782 debug_vlc(" fragment %d eob with %d coefficients\n",
1783 s->coded_fragment_list[i], fragment->coeff_count&127);
1792 * This function unpacks all of the DCT coefficient data from the
1795 static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1802 int residual_eob_run = 0;
1804 /* fetch the DC table indices */
1805 dc_y_table = get_bits(gb, 4);
1806 dc_c_table = get_bits(gb, 4);
1808 /* unpack the Y plane DC coefficients */
1809 debug_vp3(" vp3: unpacking Y plane DC coefficients using table %d\n",
1811 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1812 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1814 /* unpack the C plane DC coefficients */
1815 debug_vp3(" vp3: unpacking C plane DC coefficients using table %d\n",
1817 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1818 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1820 /* fetch the AC table indices */
1821 ac_y_table = get_bits(gb, 4);
1822 ac_c_table = get_bits(gb, 4);
1824 /* unpack the group 1 AC coefficients (coeffs 1-5) */
1825 for (i = 1; i <= 5; i++) {
1827 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1829 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i,
1830 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1832 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1834 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i,
1835 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1838 /* unpack the group 2 AC coefficients (coeffs 6-14) */
1839 for (i = 6; i <= 14; i++) {
1841 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1843 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i,
1844 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1846 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1848 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i,
1849 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1852 /* unpack the group 3 AC coefficients (coeffs 15-27) */
1853 for (i = 15; i <= 27; i++) {
1855 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1857 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i,
1858 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1860 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1862 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i,
1863 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1866 /* unpack the group 4 AC coefficients (coeffs 28-63) */
1867 for (i = 28; i <= 63; i++) {
1869 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1871 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i,
1872 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1874 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1876 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i,
1877 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1884 * This function reverses the DC prediction for each coded fragment in
1885 * the frame. Much of this function is adapted directly from the original
1888 #define COMPATIBLE_FRAME(x) \
1889 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1890 #define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
1891 #define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1892 static inline int iabs (int x) { return ((x < 0) ? -x : x); }
1894 static void reverse_dc_prediction(Vp3DecodeContext *s,
1897 int fragment_height)
1906 int i = first_fragment;
1909 * Fragment prediction groups:
1917 * Note: Groups 5 and 7 do not exist as it would mean that the
1918 * fragment's x coordinate is both 0 and (width - 1) at the same time.
1920 int predictor_group;
1923 /* validity flags for the left, up-left, up, and up-right fragments */
1924 int fl, ful, fu, fur;
1926 /* DC values for the left, up-left, up, and up-right fragments */
1927 int vl, vul, vu, vur;
1929 /* indices for the left, up-left, up, and up-right fragments */
1933 * The 6 fields mean:
1934 * 0: up-left multiplier
1936 * 2: up-right multiplier
1937 * 3: left multiplier
1939 * 5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
1941 int predictor_transform[16][6] = {
1942 { 0, 0, 0, 0, 0, 0 },
1943 { 0, 0, 0, 1, 0, 0 }, // PL
1944 { 0, 0, 1, 0, 0, 0 }, // PUR
1945 { 0, 0, 53, 75, 127, 7 }, // PUR|PL
1946 { 0, 1, 0, 0, 0, 0 }, // PU
1947 { 0, 1, 0, 1, 1, 1 }, // PU|PL
1948 { 0, 1, 0, 0, 0, 0 }, // PU|PUR
1949 { 0, 0, 53, 75, 127, 7 }, // PU|PUR|PL
1950 { 1, 0, 0, 0, 0, 0 }, // PUL
1951 { 0, 0, 0, 1, 0, 0 }, // PUL|PL
1952 { 1, 0, 1, 0, 1, 1 }, // PUL|PUR
1953 { 0, 0, 53, 75, 127, 7 }, // PUL|PUR|PL
1954 { 0, 1, 0, 0, 0, 0 }, // PUL|PU
1955 {-26, 29, 0, 29, 31, 5 }, // PUL|PU|PL
1956 { 3, 10, 3, 0, 15, 4 }, // PUL|PU|PUR
1957 {-26, 29, 0, 29, 31, 5 } // PUL|PU|PUR|PL
1960 /* This table shows which types of blocks can use other blocks for
1961 * prediction. For example, INTRA is the only mode in this table to
1962 * have a frame number of 0. That means INTRA blocks can only predict
1963 * from other INTRA blocks. There are 2 golden frame coding types;
1964 * blocks encoding in these modes can only predict from other blocks
1965 * that were encoded with these 1 of these 2 modes. */
1966 unsigned char compatible_frame[8] = {
1967 1, /* MODE_INTER_NO_MV */
1969 1, /* MODE_INTER_PLUS_MV */
1970 1, /* MODE_INTER_LAST_MV */
1971 1, /* MODE_INTER_PRIOR_MV */
1972 2, /* MODE_USING_GOLDEN */
1973 2, /* MODE_GOLDEN_MV */
1974 1 /* MODE_INTER_FOUR_MV */
1976 int current_frame_type;
1978 /* there is a last DC predictor for each of the 3 frame types */
1983 debug_vp3(" vp3: reversing DC prediction\n");
1985 vul = vu = vur = vl = 0;
1986 last_dc[0] = last_dc[1] = last_dc[2] = 0;
1988 /* for each fragment row... */
1989 for (y = 0; y < fragment_height; y++) {
1991 /* for each fragment in a row... */
1992 for (x = 0; x < fragment_width; x++, i++) {
1994 /* reverse prediction if this block was coded */
1995 if (s->all_fragments[i].coding_method != MODE_COPY) {
1997 current_frame_type =
1998 compatible_frame[s->all_fragments[i].coding_method];
1999 predictor_group = (x == 0) + ((y == 0) << 1) +
2000 ((x + 1 == fragment_width) << 2);
2001 debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
2002 i, predictor_group, DC_COEFF(i));
2004 switch (predictor_group) {
2007 /* main body of fragments; consider all 4 possible
2008 * fragments for prediction */
2010 /* calculate the indices of the predicting fragments */
2011 ul = i - fragment_width - 1;
2012 u = i - fragment_width;
2013 ur = i - fragment_width + 1;
2016 /* fetch the DC values for the predicting fragments */
2022 /* figure out which fragments are valid */
2023 ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2024 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2025 fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2026 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2028 /* decide which predictor transform to use */
2029 transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
2034 /* left column of fragments, not including top corner;
2035 * only consider up and up-right fragments */
2037 /* calculate the indices of the predicting fragments */
2038 u = i - fragment_width;
2039 ur = i - fragment_width + 1;
2041 /* fetch the DC values for the predicting fragments */
2045 /* figure out which fragments are valid */
2046 fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2047 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2049 /* decide which predictor transform to use */
2050 transform = (fu*PU) | (fur*PUR);
2056 /* top row of fragments, not including top-left frag;
2057 * only consider the left fragment for prediction */
2059 /* calculate the indices of the predicting fragments */
2062 /* fetch the DC values for the predicting fragments */
2065 /* figure out which fragments are valid */
2066 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2068 /* decide which predictor transform to use */
2069 transform = (fl*PL);
2074 /* top-left fragment */
2076 /* nothing to predict from in this case */
2082 /* right column of fragments, not including top corner;
2083 * consider up-left, up, and left fragments for
2086 /* calculate the indices of the predicting fragments */
2087 ul = i - fragment_width - 1;
2088 u = i - fragment_width;
2091 /* fetch the DC values for the predicting fragments */
2096 /* figure out which fragments are valid */
2097 ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2098 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2099 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2101 /* decide which predictor transform to use */
2102 transform = (fl*PL) | (fu*PU) | (ful*PUL);
2108 debug_dc_pred("transform = %d, ", transform);
2110 if (transform == 0) {
2112 /* if there were no fragments to predict from, use last
2114 predicted_dc = last_dc[current_frame_type];
2115 debug_dc_pred("from last DC (%d) = %d\n",
2116 current_frame_type, DC_COEFF(i));
2120 /* apply the appropriate predictor transform */
2122 (predictor_transform[transform][0] * vul) +
2123 (predictor_transform[transform][1] * vu) +
2124 (predictor_transform[transform][2] * vur) +
2125 (predictor_transform[transform][3] * vl);
2127 /* if there is a shift value in the transform, add
2128 * the sign bit before the shift */
2129 if (predictor_transform[transform][5] != 0) {
2130 predicted_dc += ((predicted_dc >> 15) &
2131 predictor_transform[transform][4]);
2132 predicted_dc >>= predictor_transform[transform][5];
2135 /* check for outranging on the [ul u l] and
2136 * [ul u ur l] predictors */
2137 if ((transform == 13) || (transform == 15)) {
2138 if (iabs(predicted_dc - vu) > 128)
2140 else if (iabs(predicted_dc - vl) > 128)
2142 else if (iabs(predicted_dc - vul) > 128)
2146 debug_dc_pred("from pred DC = %d\n",
2150 /* at long last, apply the predictor */
2151 if(s->coeffs[i].index){
2152 *s->next_coeff= s->coeffs[i];
2153 s->coeffs[i].index=0;
2154 s->coeffs[i].coeff=0;
2155 s->coeffs[i].next= s->next_coeff++;
2157 s->coeffs[i].coeff += predicted_dc;
2159 last_dc[current_frame_type] = DC_COEFF(i);
2160 if(DC_COEFF(i) && !(s->all_fragments[i].coeff_count&127)){
2161 s->all_fragments[i].coeff_count= 129;
2162 // s->all_fragments[i].next_coeff= s->next_coeff;
2163 s->coeffs[i].next= s->next_coeff;
2164 (s->next_coeff++)->next=NULL;
2172 static void horizontal_filter(unsigned char *first_pixel, int stride,
2173 int *bounding_values);
2174 static void vertical_filter(unsigned char *first_pixel, int stride,
2175 int *bounding_values);
2178 * Perform the final rendering for a particular slice of data.
2179 * The slice number ranges from 0..(macroblock_height - 1).
2181 static void render_slice(Vp3DecodeContext *s, int slice)
2185 int i; /* indicates current fragment */
2186 int16_t *dequantizer;
2187 DCTELEM __align16 block[64];
2188 unsigned char *output_plane;
2189 unsigned char *last_plane;
2190 unsigned char *golden_plane;
2192 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2193 int upper_motion_limit, lower_motion_limit;
2194 int motion_halfpel_index;
2195 uint8_t *motion_source;
2200 int current_macroblock_entry = slice * s->macroblock_width * 6;
2201 int *bounding_values= s->bounding_values_array+127;
2204 if (slice >= s->macroblock_height)
2207 for (plane = 0; plane < 3; plane++) {
2209 /* set up plane-specific parameters */
2211 output_plane = s->current_frame.data[0];
2212 last_plane = s->last_frame.data[0];
2213 golden_plane = s->golden_frame.data[0];
2214 stride = s->current_frame.linesize[0];
2215 if (!s->flipped_image) stride = -stride;
2216 upper_motion_limit = 7 * s->current_frame.linesize[0];
2217 lower_motion_limit = s->height * s->current_frame.linesize[0] + s->width - 8;
2218 y = slice * FRAGMENT_PIXELS * 2;
2219 plane_width = s->width;
2220 plane_height = s->height;
2221 slice_height = y + FRAGMENT_PIXELS * 2;
2222 i = s->macroblock_fragments[current_macroblock_entry + 0];
2223 } else if (plane == 1) {
2224 output_plane = s->current_frame.data[1];
2225 last_plane = s->last_frame.data[1];
2226 golden_plane = s->golden_frame.data[1];
2227 stride = s->current_frame.linesize[1];
2228 if (!s->flipped_image) stride = -stride;
2229 upper_motion_limit = 7 * s->current_frame.linesize[1];
2230 lower_motion_limit = (s->height / 2) * s->current_frame.linesize[1] + (s->width / 2) - 8;
2231 y = slice * FRAGMENT_PIXELS;
2232 plane_width = s->width / 2;
2233 plane_height = s->height / 2;
2234 slice_height = y + FRAGMENT_PIXELS;
2235 i = s->macroblock_fragments[current_macroblock_entry + 4];
2237 output_plane = s->current_frame.data[2];
2238 last_plane = s->last_frame.data[2];
2239 golden_plane = s->golden_frame.data[2];
2240 stride = s->current_frame.linesize[2];
2241 if (!s->flipped_image) stride = -stride;
2242 upper_motion_limit = 7 * s->current_frame.linesize[2];
2243 lower_motion_limit = (s->height / 2) * s->current_frame.linesize[2] + (s->width / 2) - 8;
2244 y = slice * FRAGMENT_PIXELS;
2245 plane_width = s->width / 2;
2246 plane_height = s->height / 2;
2247 slice_height = y + FRAGMENT_PIXELS;
2248 i = s->macroblock_fragments[current_macroblock_entry + 5];
2250 fragment_width = plane_width / 2;
2252 if(ABS(stride) > 2048)
2253 return; //various tables are fixed size
2255 /* for each fragment row in the slice (both of them)... */
2256 for (; y < slice_height; y += 8) {
2258 /* for each fragment in a row... */
2259 for (x = 0; x < plane_width; x += 8, i++) {
2261 if ((i < 0) || (i >= s->fragment_count)) {
2262 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_slice(): bad fragment number (%d)\n", i);
2266 /* transform if this block was coded */
2267 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2268 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
2270 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2271 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2272 motion_source= golden_plane;
2274 motion_source= last_plane;
2276 motion_source += s->all_fragments[i].first_pixel;
2277 motion_halfpel_index = 0;
2279 /* sort out the motion vector if this fragment is coded
2280 * using a motion vector method */
2281 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2282 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2284 motion_x = s->all_fragments[i].motion_x;
2285 motion_y = s->all_fragments[i].motion_y;
2287 motion_x= (motion_x>>1) | (motion_x&1);
2288 motion_y= (motion_y>>1) | (motion_y&1);
2291 src_x= (motion_x>>1) + x;
2292 src_y= (motion_y>>1) + y;
2293 if ((motion_x == 127) || (motion_y == 127))
2294 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
2296 motion_halfpel_index = motion_x & 0x01;
2297 motion_source += (motion_x >> 1);
2299 motion_halfpel_index |= (motion_y & 0x01) << 1;
2300 motion_source += ((motion_y >> 1) * stride);
2302 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
2303 uint8_t *temp= s->edge_emu_buffer;
2304 if(stride<0) temp -= 9*stride;
2305 else temp += 9*stride;
2307 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
2308 motion_source= temp;
2313 /* first, take care of copying a block from either the
2314 * previous or the golden frame */
2315 if (s->all_fragments[i].coding_method != MODE_INTRA) {
2316 /* Note, it is possible to implement all MC cases with
2317 put_no_rnd_pixels_l2 which would look more like the
2318 VP3 source but this would be slower as
2319 put_no_rnd_pixels_tab is better optimzed */
2320 if(motion_halfpel_index != 3){
2321 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2322 output_plane + s->all_fragments[i].first_pixel,
2323 motion_source, stride, 8);
2325 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2326 s->dsp.put_no_rnd_pixels_l2[1](
2327 output_plane + s->all_fragments[i].first_pixel,
2329 motion_source + stride + 1 + d,
2332 dequantizer = s->inter_dequant;
2335 dequantizer = s->intra_y_dequant;
2337 dequantizer = s->intra_c_dequant;
2340 /* dequantize the DCT coefficients */
2341 debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
2342 i, s->all_fragments[i].coding_method,
2343 DC_COEFF(i), dequantizer[0]);
2345 if(s->avctx->idct_algo==FF_IDCT_VP3){
2346 Coeff *coeff= s->coeffs + i;
2347 memset(block, 0, sizeof(block));
2349 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
2353 Coeff *coeff= s->coeffs + i;
2354 memset(block, 0, sizeof(block));
2356 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
2361 /* invert DCT and place (or add) in final output */
2363 if (s->all_fragments[i].coding_method == MODE_INTRA) {
2364 if(s->avctx->idct_algo!=FF_IDCT_VP3)
2367 output_plane + s->all_fragments[i].first_pixel,
2372 output_plane + s->all_fragments[i].first_pixel,
2377 debug_idct("block after idct_%s():\n",
2378 (s->all_fragments[i].coding_method == MODE_INTRA)?
2380 for (m = 0; m < 8; m++) {
2381 for (n = 0; n < 8; n++) {
2382 debug_idct(" %3d", *(output_plane +
2383 s->all_fragments[i].first_pixel + (m * stride + n)));
2391 /* copy directly from the previous frame */
2392 s->dsp.put_pixels_tab[1][0](
2393 output_plane + s->all_fragments[i].first_pixel,
2394 last_plane + s->all_fragments[i].first_pixel,
2399 /* do not perform left edge filter for left columns frags */
2401 (s->all_fragments[i].coding_method != MODE_COPY)) {
2403 output_plane + s->all_fragments[i].first_pixel - 7*stride,
2404 stride, bounding_values);
2407 /* do not perform top edge filter for top row fragments */
2409 (s->all_fragments[i].coding_method != MODE_COPY)) {
2411 output_plane + s->all_fragments[i].first_pixel + stride,
2412 stride, bounding_values);
2415 /* do not perform right edge filter for right column
2416 * fragments or if right fragment neighbor is also coded
2417 * in this frame (it will be filtered for next fragment) */
2418 if ((x < plane_width - 1) &&
2419 (s->all_fragments[i].coding_method != MODE_COPY) &&
2420 (s->all_fragments[i + 1].coding_method == MODE_COPY)) {
2422 output_plane + s->all_fragments[i + 1].first_pixel - 7*stride,
2423 stride, bounding_values);
2426 /* do not perform bottom edge filter for bottom row
2427 * fragments or if bottom fragment neighbor is also coded
2428 * in this frame (it will be filtered in the next row) */
2429 if ((y < plane_height - 1) &&
2430 (s->all_fragments[i].coding_method != MODE_COPY) &&
2431 (s->all_fragments[i + fragment_width].coding_method == MODE_COPY)) {
2433 output_plane + s->all_fragments[i + fragment_width].first_pixel + stride,
2434 stride, bounding_values);
2440 /* this looks like a good place for slice dispatch... */
2442 * if (slice == s->macroblock_height - 1)
2443 * dispatch (both last slice & 2nd-to-last slice);
2444 * else if (slice > 0)
2445 * dispatch (slice - 1);
2452 * This function performs the final rendering of each fragment's data
2453 * onto the output frame.
2455 static void render_fragments(Vp3DecodeContext *s,
2459 int plane /* 0 = Y, 1 = U, 2 = V */)
2463 int i = first_fragment;
2464 int16_t *dequantizer;
2465 DCTELEM __align16 block[64];
2466 unsigned char *output_plane;
2467 unsigned char *last_plane;
2468 unsigned char *golden_plane;
2470 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2471 int upper_motion_limit, lower_motion_limit;
2472 int motion_halfpel_index;
2473 uint8_t *motion_source;
2475 debug_vp3(" vp3: rendering final fragments for %s\n",
2476 (plane == 0) ? "Y plane" : (plane == 1) ? "U plane" : "V plane");
2478 /* set up plane-specific parameters */
2480 output_plane = s->current_frame.data[0];
2481 last_plane = s->last_frame.data[0];
2482 golden_plane = s->golden_frame.data[0];
2483 stride = s->current_frame.linesize[0];
2484 if (!s->flipped_image) stride = -stride;
2485 upper_motion_limit = 7 * s->current_frame.linesize[0];
2486 lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
2487 } else if (plane == 1) {
2488 output_plane = s->current_frame.data[1];
2489 last_plane = s->last_frame.data[1];
2490 golden_plane = s->golden_frame.data[1];
2491 stride = s->current_frame.linesize[1];
2492 if (!s->flipped_image) stride = -stride;
2493 upper_motion_limit = 7 * s->current_frame.linesize[1];
2494 lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
2496 output_plane = s->current_frame.data[2];
2497 last_plane = s->last_frame.data[2];
2498 golden_plane = s->golden_frame.data[2];
2499 stride = s->current_frame.linesize[2];
2500 if (!s->flipped_image) stride = -stride;
2501 upper_motion_limit = 7 * s->current_frame.linesize[2];
2502 lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
2505 if(ABS(stride) > 2048)
2506 return; //various tables are fixed size
2508 /* for each fragment row... */
2509 for (y = 0; y < height; y += 8) {
2511 /* for each fragment in a row... */
2512 for (x = 0; x < width; x += 8, i++) {
2514 if ((i < 0) || (i >= s->fragment_count)) {
2515 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_fragments(): bad fragment number (%d)\n", i);
2519 /* transform if this block was coded */
2520 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2521 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
2523 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2524 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2525 motion_source= golden_plane;
2527 motion_source= last_plane;
2529 motion_source += s->all_fragments[i].first_pixel;
2530 motion_halfpel_index = 0;
2532 /* sort out the motion vector if this fragment is coded
2533 * using a motion vector method */
2534 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2535 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2537 motion_x = s->all_fragments[i].motion_x;
2538 motion_y = s->all_fragments[i].motion_y;
2540 motion_x= (motion_x>>1) | (motion_x&1);
2541 motion_y= (motion_y>>1) | (motion_y&1);
2544 src_x= (motion_x>>1) + x;
2545 src_y= (motion_y>>1) + y;
2546 if ((motion_x == 127) || (motion_y == 127))
2547 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
2549 motion_halfpel_index = motion_x & 0x01;
2550 motion_source += (motion_x >> 1);
2552 motion_halfpel_index |= (motion_y & 0x01) << 1;
2553 motion_source += ((motion_y >> 1) * stride);
2555 if(src_x<0 || src_y<0 || src_x + 9 >= width || src_y + 9 >= height){
2556 uint8_t *temp= s->edge_emu_buffer;
2557 if(stride<0) temp -= 9*stride;
2558 else temp += 9*stride;
2560 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, width, height);
2561 motion_source= temp;
2566 /* first, take care of copying a block from either the
2567 * previous or the golden frame */
2568 if (s->all_fragments[i].coding_method != MODE_INTRA) {
2569 //Note, it is possible to implement all MC cases with put_no_rnd_pixels_l2 which would look more like the VP3 source but this would be slower as put_no_rnd_pixels_tab is better optimzed
2570 if(motion_halfpel_index != 3){
2571 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2572 output_plane + s->all_fragments[i].first_pixel,
2573 motion_source, stride, 8);
2575 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2576 s->dsp.put_no_rnd_pixels_l2[1](
2577 output_plane + s->all_fragments[i].first_pixel,
2579 motion_source + stride + 1 + d,
2582 dequantizer = s->inter_dequant;
2585 dequantizer = s->intra_y_dequant;
2587 dequantizer = s->intra_c_dequant;
2590 /* dequantize the DCT coefficients */
2591 debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
2592 i, s->all_fragments[i].coding_method,
2593 DC_COEFF(i), dequantizer[0]);
2595 if(s->avctx->idct_algo==FF_IDCT_VP3){
2596 Coeff *coeff= s->coeffs + i;
2597 memset(block, 0, sizeof(block));
2599 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
2603 Coeff *coeff= s->coeffs + i;
2604 memset(block, 0, sizeof(block));
2606 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
2611 /* invert DCT and place (or add) in final output */
2613 if (s->all_fragments[i].coding_method == MODE_INTRA) {
2614 if(s->avctx->idct_algo!=FF_IDCT_VP3)
2617 output_plane + s->all_fragments[i].first_pixel,
2622 output_plane + s->all_fragments[i].first_pixel,
2627 debug_idct("block after idct_%s():\n",
2628 (s->all_fragments[i].coding_method == MODE_INTRA)?
2630 for (m = 0; m < 8; m++) {
2631 for (n = 0; n < 8; n++) {
2632 debug_idct(" %3d", *(output_plane +
2633 s->all_fragments[i].first_pixel + (m * stride + n)));
2641 /* copy directly from the previous frame */
2642 s->dsp.put_pixels_tab[1][0](
2643 output_plane + s->all_fragments[i].first_pixel,
2644 last_plane + s->all_fragments[i].first_pixel,
2654 static void horizontal_filter(unsigned char *first_pixel, int stride,
2655 int *bounding_values)
2660 for (end= first_pixel + 8*stride; first_pixel < end; first_pixel += stride) {
2662 (first_pixel[-2] - first_pixel[ 1])
2663 +3*(first_pixel[ 0] - first_pixel[-1]);
2664 filter_value = bounding_values[(filter_value + 4) >> 3];
2665 first_pixel[-1] = clip_uint8(first_pixel[-1] + filter_value);
2666 first_pixel[ 0] = clip_uint8(first_pixel[ 0] - filter_value);
2670 static void vertical_filter(unsigned char *first_pixel, int stride,
2671 int *bounding_values)
2675 const int nstride= -stride;
2677 for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
2679 (first_pixel[2 * nstride] - first_pixel[ stride])
2680 +3*(first_pixel[0 ] - first_pixel[nstride]);
2681 filter_value = bounding_values[(filter_value + 4) >> 3];
2682 first_pixel[nstride] = clip_uint8(first_pixel[nstride] + filter_value);
2683 first_pixel[0] = clip_uint8(first_pixel[0] - filter_value);
2687 static void apply_loop_filter(Vp3DecodeContext *s)
2693 unsigned char *plane_data;
2694 int *bounding_values= s->bounding_values_array+127;
2697 int bounding_values_array[256];
2700 /* find the right loop limit value */
2701 for (x = 63; x >= 0; x--) {
2702 if (vp31_ac_scale_factor[x] >= s->quality_index)
2705 filter_limit = vp31_filter_limit_values[s->quality_index];
2707 /* set up the bounding values */
2708 memset(bounding_values_array, 0, 256 * sizeof(int));
2709 for (x = 0; x < filter_limit; x++) {
2710 bounding_values[-x - filter_limit] = -filter_limit + x;
2711 bounding_values[-x] = -x;
2712 bounding_values[x] = x;
2713 bounding_values[x + filter_limit] = filter_limit - x;
2717 for (plane = 0; plane < 3; plane++) {
2720 /* Y plane parameters */
2722 width = s->fragment_width;
2723 height = s->fragment_height;
2724 stride = s->current_frame.linesize[0];
2725 plane_data = s->current_frame.data[0];
2726 } else if (plane == 1) {
2727 /* U plane parameters */
2728 fragment = s->u_fragment_start;
2729 width = s->fragment_width / 2;
2730 height = s->fragment_height / 2;
2731 stride = s->current_frame.linesize[1];
2732 plane_data = s->current_frame.data[1];
2734 /* V plane parameters */
2735 fragment = s->v_fragment_start;
2736 width = s->fragment_width / 2;
2737 height = s->fragment_height / 2;
2738 stride = s->current_frame.linesize[2];
2739 plane_data = s->current_frame.data[2];
2742 for (y = 0; y < height; y++) {
2744 for (x = 0; x < width; x++) {
2746 /* do not perform left edge filter for left columns frags */
2748 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2750 plane_data + s->all_fragments[fragment].first_pixel - 7*stride,
2751 stride, bounding_values);
2754 /* do not perform top edge filter for top row fragments */
2756 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2758 plane_data + s->all_fragments[fragment].first_pixel + stride,
2759 stride, bounding_values);
2762 /* do not perform right edge filter for right column
2763 * fragments or if right fragment neighbor is also coded
2764 * in this frame (it will be filtered in next iteration) */
2765 if ((x < width - 1) &&
2766 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2767 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
2769 plane_data + s->all_fragments[fragment + 1].first_pixel - 7*stride,
2770 stride, bounding_values);
2773 /* do not perform bottom edge filter for bottom row
2774 * fragments or if bottom fragment neighbor is also coded
2775 * in this frame (it will be filtered in the next row) */
2776 if ((y < height - 1) &&
2777 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2778 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
2780 plane_data + s->all_fragments[fragment + width].first_pixel + stride,
2781 stride, bounding_values);
2785 STOP_TIMER("loop filter")
2792 * This function computes the first pixel addresses for each fragment.
2793 * This function needs to be invoked after the first frame is allocated
2794 * so that it has access to the plane strides.
2796 static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
2801 /* figure out the first pixel addresses for each of the fragments */
2804 for (y = s->fragment_height; y > 0; y--) {
2805 for (x = 0; x < s->fragment_width; x++) {
2806 s->all_fragments[i++].first_pixel =
2807 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2808 s->golden_frame.linesize[0] +
2809 x * FRAGMENT_PIXELS;
2810 debug_init(" fragment %d, first pixel @ %d\n",
2811 i-1, s->all_fragments[i-1].first_pixel);
2816 i = s->u_fragment_start;
2817 for (y = s->fragment_height / 2; y > 0; y--) {
2818 for (x = 0; x < s->fragment_width / 2; x++) {
2819 s->all_fragments[i++].first_pixel =
2820 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2821 s->golden_frame.linesize[1] +
2822 x * FRAGMENT_PIXELS;
2823 debug_init(" fragment %d, first pixel @ %d\n",
2824 i-1, s->all_fragments[i-1].first_pixel);
2829 i = s->v_fragment_start;
2830 for (y = s->fragment_height / 2; y > 0; y--) {
2831 for (x = 0; x < s->fragment_width / 2; x++) {
2832 s->all_fragments[i++].first_pixel =
2833 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2834 s->golden_frame.linesize[2] +
2835 x * FRAGMENT_PIXELS;
2836 debug_init(" fragment %d, first pixel @ %d\n",
2837 i-1, s->all_fragments[i-1].first_pixel);
2842 /* FIXME: this should be merged with the above! */
2843 static void theora_calculate_pixel_addresses(Vp3DecodeContext *s)
2848 /* figure out the first pixel addresses for each of the fragments */
2851 for (y = 1; y <= s->fragment_height; y++) {
2852 for (x = 0; x < s->fragment_width; x++) {
2853 s->all_fragments[i++].first_pixel =
2854 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2855 s->golden_frame.linesize[0] +
2856 x * FRAGMENT_PIXELS;
2857 debug_init(" fragment %d, first pixel @ %d\n",
2858 i-1, s->all_fragments[i-1].first_pixel);
2863 i = s->u_fragment_start;
2864 for (y = 1; y <= s->fragment_height / 2; y++) {
2865 for (x = 0; x < s->fragment_width / 2; x++) {
2866 s->all_fragments[i++].first_pixel =
2867 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2868 s->golden_frame.linesize[1] +
2869 x * FRAGMENT_PIXELS;
2870 debug_init(" fragment %d, first pixel @ %d\n",
2871 i-1, s->all_fragments[i-1].first_pixel);
2876 i = s->v_fragment_start;
2877 for (y = 1; y <= s->fragment_height / 2; y++) {
2878 for (x = 0; x < s->fragment_width / 2; x++) {
2879 s->all_fragments[i++].first_pixel =
2880 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2881 s->golden_frame.linesize[2] +
2882 x * FRAGMENT_PIXELS;
2883 debug_init(" fragment %d, first pixel @ %d\n",
2884 i-1, s->all_fragments[i-1].first_pixel);
2890 * This is the ffmpeg/libavcodec API init function.
2892 static int vp3_decode_init(AVCodecContext *avctx)
2894 Vp3DecodeContext *s = avctx->priv_data;
2898 int y_superblock_count;
2899 int c_superblock_count;
2901 if (avctx->codec_tag == MKTAG('V','P','3','0'))
2907 s->width = (avctx->width + 15) & 0xFFFFFFF0;
2908 s->height = (avctx->height + 15) & 0xFFFFFFF0;
2909 avctx->pix_fmt = PIX_FMT_YUV420P;
2910 avctx->has_b_frames = 0;
2911 if(avctx->idct_algo==FF_IDCT_AUTO)
2912 avctx->idct_algo=FF_IDCT_VP3;
2913 dsputil_init(&s->dsp, avctx);
2915 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
2917 /* initialize to an impossible value which will force a recalculation
2918 * in the first frame decode */
2919 s->quality_index = -1;
2921 s->y_superblock_width = (s->width + 31) / 32;
2922 s->y_superblock_height = (s->height + 31) / 32;
2923 y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2925 /* work out the dimensions for the C planes */
2926 c_width = s->width / 2;
2927 c_height = s->height / 2;
2928 s->c_superblock_width = (c_width + 31) / 32;
2929 s->c_superblock_height = (c_height + 31) / 32;
2930 c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2932 s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2933 s->u_superblock_start = y_superblock_count;
2934 s->v_superblock_start = s->u_superblock_start + c_superblock_count;
2935 s->superblock_coding = av_malloc(s->superblock_count);
2937 s->macroblock_width = (s->width + 15) / 16;
2938 s->macroblock_height = (s->height + 15) / 16;
2939 s->macroblock_count = s->macroblock_width * s->macroblock_height;
2941 s->fragment_width = s->width / FRAGMENT_PIXELS;
2942 s->fragment_height = s->height / FRAGMENT_PIXELS;
2944 /* fragment count covers all 8x8 blocks for all 3 planes */
2945 s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2946 s->u_fragment_start = s->fragment_width * s->fragment_height;
2947 s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2949 debug_init(" Y plane: %d x %d\n", s->width, s->height);
2950 debug_init(" C plane: %d x %d\n", c_width, c_height);
2951 debug_init(" Y superblocks: %d x %d, %d total\n",
2952 s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2953 debug_init(" C superblocks: %d x %d, %d total\n",
2954 s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2955 debug_init(" total superblocks = %d, U starts @ %d, V starts @ %d\n",
2956 s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2957 debug_init(" macroblocks: %d x %d, %d total\n",
2958 s->macroblock_width, s->macroblock_height, s->macroblock_count);
2959 debug_init(" %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2963 s->u_fragment_start,
2964 s->v_fragment_start);
2966 s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2967 s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
2968 s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2969 s->pixel_addresses_inited = 0;
2971 if (!s->theora_tables)
2973 for (i = 0; i < 64; i++)
2974 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2975 for (i = 0; i < 64; i++)
2976 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
2977 for (i = 0; i < 64; i++)
2978 s->coded_intra_y_dequant[i] = vp31_intra_y_dequant[i];
2979 for (i = 0; i < 64; i++)
2980 s->coded_intra_c_dequant[i] = vp31_intra_c_dequant[i];
2981 for (i = 0; i < 64; i++)
2982 s->coded_inter_dequant[i] = vp31_inter_dequant[i];
2983 for (i = 0; i < 64; i++)
2984 s->filter_limit_values[i] = vp31_filter_limit_values[i];
2986 /* init VLC tables */
2987 for (i = 0; i < 16; i++) {
2990 init_vlc(&s->dc_vlc[i], 5, 32,
2991 &dc_bias[i][0][1], 4, 2,
2992 &dc_bias[i][0][0], 4, 2, 0);
2994 /* group 1 AC histograms */
2995 init_vlc(&s->ac_vlc_1[i], 5, 32,
2996 &ac_bias_0[i][0][1], 4, 2,
2997 &ac_bias_0[i][0][0], 4, 2, 0);
2999 /* group 2 AC histograms */
3000 init_vlc(&s->ac_vlc_2[i], 5, 32,
3001 &ac_bias_1[i][0][1], 4, 2,
3002 &ac_bias_1[i][0][0], 4, 2, 0);
3004 /* group 3 AC histograms */
3005 init_vlc(&s->ac_vlc_3[i], 5, 32,
3006 &ac_bias_2[i][0][1], 4, 2,
3007 &ac_bias_2[i][0][0], 4, 2, 0);
3009 /* group 4 AC histograms */
3010 init_vlc(&s->ac_vlc_4[i], 5, 32,
3011 &ac_bias_3[i][0][1], 4, 2,
3012 &ac_bias_3[i][0][0], 4, 2, 0);
3015 for (i = 0; i < 16; i++) {
3018 init_vlc(&s->dc_vlc[i], 5, 32,
3019 &s->huffman_table[i][0][1], 4, 2,
3020 &s->huffman_table[i][0][0], 4, 2, 0);
3022 /* group 1 AC histograms */
3023 init_vlc(&s->ac_vlc_1[i], 5, 32,
3024 &s->huffman_table[i+16][0][1], 4, 2,
3025 &s->huffman_table[i+16][0][0], 4, 2, 0);
3027 /* group 2 AC histograms */
3028 init_vlc(&s->ac_vlc_2[i], 5, 32,
3029 &s->huffman_table[i+16*2][0][1], 4, 2,
3030 &s->huffman_table[i+16*2][0][0], 4, 2, 0);
3032 /* group 3 AC histograms */
3033 init_vlc(&s->ac_vlc_3[i], 5, 32,
3034 &s->huffman_table[i+16*3][0][1], 4, 2,
3035 &s->huffman_table[i+16*3][0][0], 4, 2, 0);
3037 /* group 4 AC histograms */
3038 init_vlc(&s->ac_vlc_4[i], 5, 32,
3039 &s->huffman_table[i+16*4][0][1], 4, 2,
3040 &s->huffman_table[i+16*4][0][0], 4, 2, 0);
3044 init_vlc(&s->superblock_run_length_vlc, 6, 34,
3045 &superblock_run_length_vlc_table[0][1], 4, 2,
3046 &superblock_run_length_vlc_table[0][0], 4, 2, 0);
3048 init_vlc(&s->fragment_run_length_vlc, 5, 31,
3049 &fragment_run_length_vlc_table[0][1], 4, 2,
3050 &fragment_run_length_vlc_table[0][0], 4, 2, 0);
3052 init_vlc(&s->mode_code_vlc, 3, 8,
3053 &mode_code_vlc_table[0][1], 2, 1,
3054 &mode_code_vlc_table[0][0], 2, 1, 0);
3056 init_vlc(&s->motion_vector_vlc, 6, 63,
3057 &motion_vector_vlc_table[0][1], 2, 1,
3058 &motion_vector_vlc_table[0][0], 2, 1, 0);
3060 /* work out the block mapping tables */
3061 s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
3062 s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
3063 s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
3064 s->macroblock_coding = av_malloc(s->macroblock_count + 1);
3065 init_block_mapping(s);
3067 for (i = 0; i < 3; i++) {
3068 s->current_frame.data[i] = NULL;
3069 s->last_frame.data[i] = NULL;
3070 s->golden_frame.data[i] = NULL;
3077 * This is the ffmpeg/libavcodec API frame decode function.
3079 static int vp3_decode_frame(AVCodecContext *avctx,
3080 void *data, int *data_size,
3081 uint8_t *buf, int buf_size)
3083 Vp3DecodeContext *s = avctx->priv_data;
3085 static int counter = 0;
3088 init_get_bits(&gb, buf, buf_size * 8);
3090 if (s->theora && get_bits1(&gb))
3092 int ptype = get_bits(&gb, 7);
3094 skip_bits(&gb, 6*8); /* "theora" */
3099 theora_decode_comments(avctx, gb);
3102 theora_decode_tables(avctx, gb);
3103 init_dequantizer(s);
3106 av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype);
3111 s->keyframe = !get_bits1(&gb);
3114 s->last_quality_index = s->quality_index;
3115 s->quality_index = get_bits(&gb, 6);
3116 if (s->theora >= 0x030200)
3119 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
3120 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
3121 s->keyframe?"key":"", counter, s->quality_index);
3124 if (s->quality_index != s->last_quality_index) {
3125 init_dequantizer(s);
3126 init_loop_filter(s);
3132 skip_bits(&gb, 4); /* width code */
3133 skip_bits(&gb, 4); /* height code */
3136 s->version = get_bits(&gb, 5);
3138 av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
3141 if (s->version || s->theora)
3144 av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
3145 skip_bits(&gb, 2); /* reserved? */
3148 if (s->last_frame.data[0] == s->golden_frame.data[0]) {
3149 if (s->golden_frame.data[0])
3150 avctx->release_buffer(avctx, &s->golden_frame);
3151 s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
3153 if (s->golden_frame.data[0])
3154 avctx->release_buffer(avctx, &s->golden_frame);
3155 if (s->last_frame.data[0])
3156 avctx->release_buffer(avctx, &s->last_frame);
3159 s->golden_frame.reference = 3;
3160 if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
3161 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
3165 /* golden frame is also the current frame */
3166 memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
3168 /* time to figure out pixel addresses? */
3169 if (!s->pixel_addresses_inited)
3171 if (!s->flipped_image)
3172 vp3_calculate_pixel_addresses(s);
3174 theora_calculate_pixel_addresses(s);
3177 /* allocate a new current frame */
3178 s->current_frame.reference = 3;
3179 if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
3180 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
3185 s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
3186 s->current_frame.qstride= 0;
3190 STOP_TIMER("init_frame")}
3195 memcpy(s->current_frame.data[0], s->golden_frame.data[0],
3196 s->current_frame.linesize[0] * s->height);
3197 memcpy(s->current_frame.data[1], s->golden_frame.data[1],
3198 s->current_frame.linesize[1] * s->height / 2);
3199 memcpy(s->current_frame.data[2], s->golden_frame.data[2],
3200 s->current_frame.linesize[2] * s->height / 2);
3206 if (unpack_superblocks(s, &gb)){
3207 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
3210 STOP_TIMER("unpack_superblocks")}
3212 if (unpack_modes(s, &gb)){
3213 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
3216 STOP_TIMER("unpack_modes")}
3218 if (unpack_vectors(s, &gb)){
3219 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
3222 STOP_TIMER("unpack_vectors")}
3224 if (unpack_dct_coeffs(s, &gb)){
3225 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
3228 STOP_TIMER("unpack_dct_coeffs")}
3231 reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
3232 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
3233 reverse_dc_prediction(s, s->u_fragment_start,
3234 s->fragment_width / 2, s->fragment_height / 2);
3235 reverse_dc_prediction(s, s->v_fragment_start,
3236 s->fragment_width / 2, s->fragment_height / 2);
3238 STOP_TIMER("reverse_dc_prediction")}
3242 for (i = 0; i < s->macroblock_height; i++)
3245 render_fragments(s, 0, s->width, s->height, 0);
3246 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
3247 render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
3248 render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
3250 memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
3251 memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
3254 STOP_TIMER("render_fragments")}
3257 // apply_loop_filter(s);
3258 STOP_TIMER("apply_loop_filter")}
3263 *data_size=sizeof(AVFrame);
3264 *(AVFrame*)data= s->current_frame;
3266 /* release the last frame, if it is allocated and if it is not the
3268 if ((s->last_frame.data[0]) &&
3269 (s->last_frame.data[0] != s->golden_frame.data[0]))
3270 avctx->release_buffer(avctx, &s->last_frame);
3272 /* shuffle frames (last = current) */
3273 memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));
3274 s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
3280 * This is the ffmpeg/libavcodec API module cleanup function.
3282 static int vp3_decode_end(AVCodecContext *avctx)
3284 Vp3DecodeContext *s = avctx->priv_data;
3286 av_free(s->all_fragments);
3288 av_free(s->coded_fragment_list);
3289 av_free(s->superblock_fragments);
3290 av_free(s->superblock_macroblocks);
3291 av_free(s->macroblock_fragments);
3292 av_free(s->macroblock_coding);
3294 /* release all frames */
3295 if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
3296 avctx->release_buffer(avctx, &s->golden_frame);
3297 if (s->last_frame.data[0])
3298 avctx->release_buffer(avctx, &s->last_frame);
3299 /* no need to release the current_frame since it will always be pointing
3300 * to the same frame as either the golden or last frame */
3305 static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
3307 Vp3DecodeContext *s = avctx->priv_data;
3309 if (get_bits(gb, 1)) {
3311 if (s->entries >= 32) { /* overflow */
3312 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
3315 token = get_bits(gb, 5);
3316 //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);
3317 s->huffman_table[s->hti][token][0] = s->hbits;
3318 s->huffman_table[s->hti][token][1] = s->huff_code_size;
3322 if (s->huff_code_size >= 32) {/* overflow */
3323 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
3326 s->huff_code_size++;
3328 read_huffman_tree(avctx, gb);
3330 read_huffman_tree(avctx, gb);
3332 s->huff_code_size--;
3337 static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
3339 Vp3DecodeContext *s = avctx->priv_data;
3340 int major, minor, micro;
3342 major = get_bits(&gb, 8); /* version major */
3343 minor = get_bits(&gb, 8); /* version minor */
3344 micro = get_bits(&gb, 8); /* version micro */
3345 av_log(avctx, AV_LOG_INFO, "Theora bitstream version %d.%d.%d\n",
3346 major, minor, micro);
3348 /* FIXME: endianess? */
3349 s->theora = (major << 16) | (minor << 8) | micro;
3351 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
3352 /* but previous versions have the image flipped relative to vp3 */
3353 if (s->theora < 0x030200)
3355 s->flipped_image = 1;
3356 av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
3359 s->width = get_bits(&gb, 16) << 4;
3360 s->height = get_bits(&gb, 16) << 4;
3362 if(avcodec_check_dimensions(avctx, s->width, s->height)){
3363 s->width= s->height= 0;
3367 skip_bits(&gb, 24); /* frame width */
3368 skip_bits(&gb, 24); /* frame height */
3370 skip_bits(&gb, 8); /* offset x */
3371 skip_bits(&gb, 8); /* offset y */
3373 skip_bits(&gb, 32); /* fps numerator */
3374 skip_bits(&gb, 32); /* fps denumerator */
3375 skip_bits(&gb, 24); /* aspect numerator */
3376 skip_bits(&gb, 24); /* aspect denumerator */
3378 if (s->theora < 0x030200)
3379 skip_bits(&gb, 5); /* keyframe frequency force */
3380 skip_bits(&gb, 8); /* colorspace */
3381 skip_bits(&gb, 24); /* bitrate */
3383 skip_bits(&gb, 6); /* last(?) quality index */
3385 if (s->theora >= 0x030200)
3387 skip_bits(&gb, 5); /* keyframe frequency force */
3388 skip_bits(&gb, 5); /* spare bits */
3391 // align_get_bits(&gb);
3393 avctx->width = s->width;
3394 avctx->height = s->height;
3399 static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb)
3401 int nb_comments, i, tmp;
3403 tmp = get_bits_long(&gb, 32);
3404 tmp = be2me_32(tmp);
3408 nb_comments = get_bits_long(&gb, 32);
3409 nb_comments = be2me_32(nb_comments);
3410 for (i = 0; i < nb_comments; i++)
3412 tmp = get_bits_long(&gb, 32);
3413 tmp = be2me_32(tmp);
3421 static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb)
3423 Vp3DecodeContext *s = avctx->priv_data;
3426 if (s->theora >= 0x030200) {
3427 n = get_bits(&gb, 3);
3428 /* loop filter table */
3429 for (i = 0; i < 64; i++)
3433 if (s->theora >= 0x030200)
3434 n = get_bits(&gb, 4) + 1;
3437 /* quality threshold table */
3438 for (i = 0; i < 64; i++)
3439 s->coded_ac_scale_factor[i] = get_bits(&gb, n);
3441 if (s->theora >= 0x030200)
3442 n = get_bits(&gb, 4) + 1;
3445 /* dc scale factor table */
3446 for (i = 0; i < 64; i++)
3447 s->coded_dc_scale_factor[i] = get_bits(&gb, n);
3449 if (s->theora >= 0x030200)
3450 n = get_bits(&gb, 9) + 1;
3454 av_log(NULL,AV_LOG_ERROR, "unsupported nbms : %d\n", n);
3458 for (i = 0; i < 64; i++)
3459 s->coded_intra_y_dequant[i] = get_bits(&gb, 8);
3462 for (i = 0; i < 64; i++)
3463 s->coded_intra_c_dequant[i] = get_bits(&gb, 8);
3466 for (i = 0; i < 64; i++)
3467 s->coded_inter_dequant[i] = get_bits(&gb, 8);
3469 /* Huffman tables */
3470 for (i = 0; i <= 1; i++) {
3471 for (n = 0; n <= 2; n++) {
3474 newqr = get_bits(&gb, 1);
3483 skip_bits(&gb, av_log2(2)+1);
3485 qi += get_bits(&gb, av_log2(63-qi)+1) + 1;
3486 skip_bits(&gb, av_log2(2)+1);
3489 av_log(NULL, AV_LOG_ERROR, "error...\n");
3494 for (s->hti = 0; s->hti < 80; s->hti++) {
3496 s->huff_code_size = 1;
3497 if (!get_bits(&gb, 1)) {
3499 read_huffman_tree(avctx, &gb);
3501 read_huffman_tree(avctx, &gb);
3505 /* XXX FIXME: these limit values need to come from the Theora header */
3506 for (i = 0; i < 64; i++)
3507 s->filter_limit_values[i] = vp31_filter_limit_values[i];
3509 s->theora_tables = 1;
3514 static int theora_decode_init(AVCodecContext *avctx)
3516 Vp3DecodeContext *s = avctx->priv_data;
3519 uint8_t *p= avctx->extradata;
3524 if (!avctx->extradata_size)
3528 op_bytes = *(p++)<<8;
3531 init_get_bits(&gb, p, op_bytes);
3534 ptype = get_bits(&gb, 8);
3535 debug_vp3("Theora headerpacket type: %x\n", ptype);
3537 if (!(ptype & 0x80))
3540 skip_bits(&gb, 6*8); /* "theora" */
3545 theora_decode_header(avctx, gb);
3548 theora_decode_comments(avctx, gb);
3551 theora_decode_tables(avctx, gb);
3556 vp3_decode_init(avctx);
3560 AVCodec vp3_decoder = {
3564 sizeof(Vp3DecodeContext),
3573 #ifndef CONFIG_LIBTHEORA
3574 AVCodec theora_decoder = {
3578 sizeof(Vp3DecodeContext),