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