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