Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ 288774bb

History | View | Annotate | Download (103 KB)

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 Vp3Fragment {
138
    DCTELEM *coeffs;
139
    /* address of first pixel taking into account which plane the fragment
140
     * lives on as well as the plane stride */
141
    int first_pixel;
142
    /* this is the macroblock that the fragment belongs to */
143
    uint16_t macroblock;
144
    uint8_t coding_method;
145
    uint8_t coeff_count;
146
    int8_t last_coeff;
147
    int8_t motion_x;
148
    int8_t motion_y;
149
} Vp3Fragment;
150

    
151
#define SB_NOT_CODED        0
152
#define SB_PARTIALLY_CODED  1
153
#define SB_FULLY_CODED      2
154

    
155
#define MODE_INTER_NO_MV      0
156
#define MODE_INTRA            1
157
#define MODE_INTER_PLUS_MV    2
158
#define MODE_INTER_LAST_MV    3
159
#define MODE_INTER_PRIOR_LAST 4
160
#define MODE_USING_GOLDEN     5
161
#define MODE_GOLDEN_MV        6
162
#define MODE_INTER_FOURMV     7
163
#define CODING_MODE_COUNT     8
164

    
165
/* special internal mode */
166
#define MODE_COPY             8
167

    
168
/* There are 6 preset schemes, plus a free-form scheme */
169
static int ModeAlphabet[7][CODING_MODE_COUNT] =
170
{
171
    /* this is the custom scheme */
172
    { 0, 0, 0, 0, 0, 0, 0, 0 },
173

    
174
    /* scheme 1: Last motion vector dominates */
175
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,  
176
         MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
177
         MODE_INTRA,            MODE_USING_GOLDEN,      
178
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
179

    
180
    /* scheme 2 */
181
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,  
182
         MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,
183
         MODE_INTRA,            MODE_USING_GOLDEN,      
184
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
185

    
186
    /* scheme 3 */
187
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,     
188
         MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
189
         MODE_INTRA,            MODE_USING_GOLDEN,      
190
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
191

    
192
    /* scheme 4 */
193
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,     
194
         MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
195
         MODE_INTRA,            MODE_USING_GOLDEN,      
196
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
197

    
198
    /* scheme 5: No motion vector dominates */
199
    {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,     
200
         MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
201
         MODE_INTRA,            MODE_USING_GOLDEN,      
202
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
203

    
204
    /* scheme 6 */
205
    {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,      
206
         MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
207
         MODE_INTER_PLUS_MV,    MODE_INTRA,             
208
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
209

    
210
};
211

    
212
#define MIN_DEQUANT_VAL 2
213

    
214
typedef struct Vp3DecodeContext {
215
    AVCodecContext *avctx;
216
    int theora, theora_tables;
217
    int version;
218
    int width, height;
219
    AVFrame golden_frame;
220
    AVFrame last_frame;
221
    AVFrame current_frame;
222
    int keyframe;
223
    DSPContext dsp;
224
    int flipped_image;
225

    
226
    int quality_index;
227
    int last_quality_index;
228

    
229
    int superblock_count;
230
    int superblock_width;
231
    int superblock_height;
232
    int y_superblock_width;
233
    int y_superblock_height;
234
    int c_superblock_width;
235
    int c_superblock_height;
236
    int u_superblock_start;
237
    int v_superblock_start;
238
    unsigned char *superblock_coding;
239

    
240
    int macroblock_count;
241
    int macroblock_width;
242
    int macroblock_height;
243

    
244
    int fragment_count;
245
    int fragment_width;
246
    int fragment_height;
247

    
248
    Vp3Fragment *all_fragments;
249
    DCTELEM *coeffs;
250
    int u_fragment_start;
251
    int v_fragment_start;
252
    
253
    ScanTable scantable;
254
    
255
    /* tables */
256
    uint16_t coded_dc_scale_factor[64];
257
    uint32_t coded_ac_scale_factor[64];
258
    uint16_t coded_intra_y_dequant[64];
259
    uint16_t coded_intra_c_dequant[64];
260
    uint16_t coded_inter_dequant[64];
261

    
262
    /* this is a list of indices into the all_fragments array indicating
263
     * which of the fragments are coded */
264
    int *coded_fragment_list;
265
    int coded_fragment_list_index;
266
    int pixel_addresses_inited;
267

    
268
    VLC dc_vlc[16];
269
    VLC ac_vlc_1[16];
270
    VLC ac_vlc_2[16];
271
    VLC ac_vlc_3[16];
272
    VLC ac_vlc_4[16];
273

    
274
    VLC superblock_run_length_vlc;
275
    VLC fragment_run_length_vlc;
276
    VLC mode_code_vlc;
277
    VLC motion_vector_vlc;
278

    
279
    /* these arrays need to be on 16-byte boundaries since SSE2 operations
280
     * index into them */
281
    int16_t __align16 intra_y_dequant[64];
282
    int16_t __align16 intra_c_dequant[64];
283
    int16_t __align16 inter_dequant[64];
284

    
285
    /* This table contains superblock_count * 16 entries. Each set of 16
286
     * numbers corresponds to the fragment indices 0..15 of the superblock.
287
     * An entry will be -1 to indicate that no entry corresponds to that
288
     * index. */
289
    int *superblock_fragments;
290

    
291
    /* This table contains superblock_count * 4 entries. Each set of 4
292
     * numbers corresponds to the macroblock indices 0..3 of the superblock.
293
     * An entry will be -1 to indicate that no entry corresponds to that
294
     * index. */
295
    int *superblock_macroblocks;
296

    
297
    /* This table contains macroblock_count * 6 entries. Each set of 6
298
     * numbers corresponds to the fragment indices 0..5 which comprise
299
     * the macroblock (4 Y fragments and 2 C fragments). */
300
    int *macroblock_fragments;
301
    /* This is an array that indicates how a particular macroblock 
302
     * is coded. */
303
    unsigned char *macroblock_coding;
304

    
305
    int first_coded_y_fragment;
306
    int first_coded_c_fragment;
307
    int last_coded_y_fragment;
308
    int last_coded_c_fragment;
309

    
310
    uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
311
    uint8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
312
} Vp3DecodeContext;
313

    
314
static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb);
315
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb);
316

    
317
/************************************************************************
318
 * VP3 specific functions
319
 ************************************************************************/
320

    
321
/*
322
 * This function sets up all of the various blocks mappings:
323
 * superblocks <-> fragments, macroblocks <-> fragments,
324
 * superblocks <-> macroblocks
325
 *
326
 * Returns 0 is successful; returns 1 if *anything* went wrong.
327
 */
328
static int init_block_mapping(Vp3DecodeContext *s) 
329
{
330
    int i, j;
331
    signed int hilbert_walk_y[16];
332
    signed int hilbert_walk_c[16];
333
    signed int hilbert_walk_mb[4];
334

    
335
    int current_fragment = 0;
336
    int current_width = 0;
337
    int current_height = 0;
338
    int right_edge = 0;
339
    int bottom_edge = 0;
340
    int superblock_row_inc = 0;
341
    int *hilbert = NULL;
342
    int mapping_index = 0;
343

    
344
    int current_macroblock;
345
    int c_fragment;
346

    
347
    signed char travel_width[16] = {
348
         1,  1,  0, -1, 
349
         0,  0,  1,  0,
350
         1,  0,  1,  0,
351
         0, -1,  0,  1
352
    };
353

    
354
    signed char travel_height[16] = {
355
         0,  0,  1,  0,
356
         1,  1,  0, -1,
357
         0,  1,  0, -1,
358
        -1,  0, -1,  0
359
    };
360

    
361
    signed char travel_width_mb[4] = {
362
         1,  0,  1,  0
363
    };
364

    
365
    signed char travel_height_mb[4] = {
366
         0,  1,  0, -1
367
    };
368

    
369
    debug_vp3("  vp3: initialize block mapping tables\n");
370

    
371
    /* figure out hilbert pattern per these frame dimensions */
372
    hilbert_walk_y[0]  = 1;
373
    hilbert_walk_y[1]  = 1;
374
    hilbert_walk_y[2]  = s->fragment_width;
375
    hilbert_walk_y[3]  = -1;
376
    hilbert_walk_y[4]  = s->fragment_width;
377
    hilbert_walk_y[5]  = s->fragment_width;
378
    hilbert_walk_y[6]  = 1;
379
    hilbert_walk_y[7]  = -s->fragment_width;
380
    hilbert_walk_y[8]  = 1;
381
    hilbert_walk_y[9]  = s->fragment_width;
382
    hilbert_walk_y[10]  = 1;
383
    hilbert_walk_y[11] = -s->fragment_width;
384
    hilbert_walk_y[12] = -s->fragment_width;
385
    hilbert_walk_y[13] = -1;
386
    hilbert_walk_y[14] = -s->fragment_width;
387
    hilbert_walk_y[15] = 1;
388

    
389
    hilbert_walk_c[0]  = 1;
390
    hilbert_walk_c[1]  = 1;
391
    hilbert_walk_c[2]  = s->fragment_width / 2;
392
    hilbert_walk_c[3]  = -1;
393
    hilbert_walk_c[4]  = s->fragment_width / 2;
394
    hilbert_walk_c[5]  = s->fragment_width / 2;
395
    hilbert_walk_c[6]  = 1;
396
    hilbert_walk_c[7]  = -s->fragment_width / 2;
397
    hilbert_walk_c[8]  = 1;
398
    hilbert_walk_c[9]  = s->fragment_width / 2;
399
    hilbert_walk_c[10]  = 1;
400
    hilbert_walk_c[11] = -s->fragment_width / 2;
401
    hilbert_walk_c[12] = -s->fragment_width / 2;
402
    hilbert_walk_c[13] = -1;
403
    hilbert_walk_c[14] = -s->fragment_width / 2;
404
    hilbert_walk_c[15] = 1;
405

    
406
    hilbert_walk_mb[0] = 1;
407
    hilbert_walk_mb[1] = s->macroblock_width;
408
    hilbert_walk_mb[2] = 1;
409
    hilbert_walk_mb[3] = -s->macroblock_width;
410

    
411
    /* iterate through each superblock (all planes) and map the fragments */
412
    for (i = 0; i < s->superblock_count; i++) {
413
        debug_init("    superblock %d (u starts @ %d, v starts @ %d)\n",
414
            i, s->u_superblock_start, s->v_superblock_start);
415

    
416
        /* time to re-assign the limits? */
417
        if (i == 0) {
418

    
419
            /* start of Y superblocks */
420
            right_edge = s->fragment_width;
421
            bottom_edge = s->fragment_height;
422
            current_width = -1;
423
            current_height = 0;
424
            superblock_row_inc = 3 * s->fragment_width - 
425
                (s->y_superblock_width * 4 - s->fragment_width);
426
            hilbert = hilbert_walk_y;
427

    
428
            /* the first operation for this variable is to advance by 1 */
429
            current_fragment = -1;
430

    
431
        } else if (i == s->u_superblock_start) {
432

    
433
            /* start of U superblocks */
434
            right_edge = s->fragment_width / 2;
435
            bottom_edge = s->fragment_height / 2;
436
            current_width = -1;
437
            current_height = 0;
438
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
439
                (s->c_superblock_width * 4 - s->fragment_width / 2);
440
            hilbert = hilbert_walk_c;
441

    
442
            /* the first operation for this variable is to advance by 1 */
443
            current_fragment = s->u_fragment_start - 1;
444

    
445
        } else if (i == s->v_superblock_start) {
446

    
447
            /* start of V 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->v_fragment_start - 1;
458

    
459
        }
460

    
461
        if (current_width >= right_edge - 1) {
462
            /* reset width and move to next superblock row */
463
            current_width = -1;
464
            current_height += 4;
465

    
466
            /* fragment is now at the start of a new superblock row */
467
            current_fragment += superblock_row_inc;
468
        }
469

    
470
        /* iterate through all 16 fragments in a superblock */
471
        for (j = 0; j < 16; j++) {
472
            current_fragment += hilbert[j];
473
            current_width += travel_width[j];
474
            current_height += travel_height[j];
475

    
476
            /* check if the fragment is in bounds */
477
            if ((current_width < right_edge) &&
478
                (current_height < bottom_edge)) {
479
                s->superblock_fragments[mapping_index] = current_fragment;
480
                debug_init("    mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n", 
481
                    s->superblock_fragments[mapping_index], i, j,
482
                    current_width, right_edge, current_height, bottom_edge);
483
            } else {
484
                s->superblock_fragments[mapping_index] = -1;
485
                debug_init("    superblock %d, position %d has no fragment (%d/%d x %d/%d)\n", 
486
                    i, j,
487
                    current_width, right_edge, current_height, bottom_edge);
488
            }
489

    
490
            mapping_index++;
491
        }
492
    }
493

    
494
    /* initialize the superblock <-> macroblock mapping; iterate through
495
     * all of the Y plane superblocks to build this mapping */
496
    right_edge = s->macroblock_width;
497
    bottom_edge = s->macroblock_height;
498
    current_width = -1;
499
    current_height = 0;
500
    superblock_row_inc = s->macroblock_width -
501
        (s->y_superblock_width * 2 - s->macroblock_width);;
502
    hilbert = hilbert_walk_mb;
503
    mapping_index = 0;
504
    current_macroblock = -1;
505
    for (i = 0; i < s->u_superblock_start; i++) {
506

    
507
        if (current_width >= right_edge - 1) {
508
            /* reset width and move to next superblock row */
509
            current_width = -1;
510
            current_height += 2;
511

    
512
            /* macroblock is now at the start of a new superblock row */
513
            current_macroblock += superblock_row_inc;
514
        }
515

    
516
        /* iterate through each potential macroblock in the superblock */
517
        for (j = 0; j < 4; j++) {
518
            current_macroblock += hilbert_walk_mb[j];
519
            current_width += travel_width_mb[j];
520
            current_height += travel_height_mb[j];
521

    
522
            /* check if the macroblock is in bounds */
523
            if ((current_width < right_edge) &&
524
                (current_height < bottom_edge)) {
525
                s->superblock_macroblocks[mapping_index] = current_macroblock;
526
                debug_init("    mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
527
                    s->superblock_macroblocks[mapping_index], i, j,
528
                    current_width, right_edge, current_height, bottom_edge);
529
            } else {
530
                s->superblock_macroblocks[mapping_index] = -1;
531
                debug_init("    superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
532
                    i, j,
533
                    current_width, right_edge, current_height, bottom_edge);
534
            }
535

    
536
            mapping_index++;
537
        }
538
    }
539

    
540
    /* initialize the macroblock <-> fragment mapping */
541
    current_fragment = 0;
542
    current_macroblock = 0;
543
    mapping_index = 0;
544
    for (i = 0; i < s->fragment_height; i += 2) {
545

    
546
        for (j = 0; j < s->fragment_width; j += 2) {
547

    
548
            debug_init("    macroblock %d contains fragments: ", current_macroblock);
549
            s->all_fragments[current_fragment].macroblock = current_macroblock;
550
            s->macroblock_fragments[mapping_index++] = current_fragment;
551
            debug_init("%d ", current_fragment);
552

    
553
            if (j + 1 < s->fragment_width) {
554
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
555
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
556
                debug_init("%d ", current_fragment + 1);
557
            } else
558
                s->macroblock_fragments[mapping_index++] = -1;
559

    
560
            if (i + 1 < s->fragment_height) {
561
                s->all_fragments[current_fragment + s->fragment_width].macroblock = 
562
                    current_macroblock;
563
                s->macroblock_fragments[mapping_index++] = 
564
                    current_fragment + s->fragment_width;
565
                debug_init("%d ", current_fragment + s->fragment_width);
566
            } else
567
                s->macroblock_fragments[mapping_index++] = -1;
568

    
569
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
570
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock = 
571
                    current_macroblock;
572
                s->macroblock_fragments[mapping_index++] = 
573
                    current_fragment + s->fragment_width + 1;
574
                debug_init("%d ", current_fragment + s->fragment_width + 1);
575
            } else
576
                s->macroblock_fragments[mapping_index++] = -1;
577

    
578
            /* C planes */
579
            c_fragment = s->u_fragment_start + 
580
                (i * s->fragment_width / 4) + (j / 2);
581
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
582
            s->macroblock_fragments[mapping_index++] = c_fragment;
583
            debug_init("%d ", c_fragment);
584

    
585
            c_fragment = s->v_fragment_start + 
586
                (i * s->fragment_width / 4) + (j / 2);
587
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
588
            s->macroblock_fragments[mapping_index++] = c_fragment;
589
            debug_init("%d ", c_fragment);
590

    
591
            debug_init("\n");
592

    
593
            if (j + 2 <= s->fragment_width)
594
                current_fragment += 2;
595
            else 
596
                current_fragment++;
597
            current_macroblock++;
598
        }
599

    
600
        current_fragment += s->fragment_width;
601
    }
602

    
603
    return 0;  /* successful path out */
604
}
605

    
606
/*
607
 * This function unpacks a single token (which should be in the range 0..31)
608
 * and returns a zero run (number of zero coefficients in current DCT matrix
609
 * before next non-zero coefficient), the next DCT coefficient, and the
610
 * number of consecutive, non-EOB'd DCT blocks to EOB.
611
 */
612
static void unpack_token(GetBitContext *gb, int token, int *zero_run,
613
                         DCTELEM *coeff, int *eob_run) 
614
{
615
    int sign;
616

    
617
    *zero_run = 0;
618
    *eob_run = 0;
619
    *coeff = 0;
620

    
621
    debug_token("    vp3 token %d: ", token);
622
    switch (token) {
623

    
624
    case 0:
625
        debug_token("DCT_EOB_TOKEN, EOB next block\n");
626
        *eob_run = 1;
627
        break;
628

    
629
    case 1:
630
        debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
631
        *eob_run = 2;
632
        break;
633

    
634
    case 2:
635
        debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
636
        *eob_run = 3;
637
        break;
638

    
639
    case 3:
640
        debug_token("DCT_REPEAT_RUN_TOKEN, ");
641
        *eob_run = get_bits(gb, 2) + 4;
642
        debug_token("EOB the next %d blocks\n", *eob_run);
643
        break;
644

    
645
    case 4:
646
        debug_token("DCT_REPEAT_RUN2_TOKEN, ");
647
        *eob_run = get_bits(gb, 3) + 8;
648
        debug_token("EOB the next %d blocks\n", *eob_run);
649
        break;
650

    
651
    case 5:
652
        debug_token("DCT_REPEAT_RUN3_TOKEN, ");
653
        *eob_run = get_bits(gb, 4) + 16;
654
        debug_token("EOB the next %d blocks\n", *eob_run);
655
        break;
656

    
657
    case 6:
658
        debug_token("DCT_REPEAT_RUN4_TOKEN, ");
659
        *eob_run = get_bits(gb, 12);
660
        debug_token("EOB the next %d blocks\n", *eob_run);
661
        break;
662

    
663
    case 7:
664
        debug_token("DCT_SHORT_ZRL_TOKEN, ");
665
        /* note that this token actually indicates that (3 extra bits) + 1 0s
666
         * should be output; this case specifies a run of (3 EBs) 0s and a
667
         * coefficient of 0. */
668
        *zero_run = get_bits(gb, 3);
669
        *coeff = 0;
670
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
671
        break;
672

    
673
    case 8:
674
        debug_token("DCT_ZRL_TOKEN, ");
675
        /* note that this token actually indicates that (6 extra bits) + 1 0s
676
         * should be output; this case specifies a run of (6 EBs) 0s and a
677
         * coefficient of 0. */
678
        *zero_run = get_bits(gb, 6);
679
        *coeff = 0;
680
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
681
        break;
682

    
683
    case 9:
684
        debug_token("ONE_TOKEN, output 1\n");
685
        *coeff = 1;
686
        break;
687

    
688
    case 10:
689
        debug_token("MINUS_ONE_TOKEN, output -1\n");
690
        *coeff = -1;
691
        break;
692

    
693
    case 11:
694
        debug_token("TWO_TOKEN, output 2\n");
695
        *coeff = 2;
696
        break;
697

    
698
    case 12:
699
        debug_token("MINUS_TWO_TOKEN, output -2\n");
700
        *coeff = -2;
701
        break;
702

    
703
    case 13:
704
    case 14:
705
    case 15:
706
    case 16:
707
        debug_token("LOW_VAL_TOKENS, ");
708
        if (get_bits(gb, 1))
709
            *coeff = -(3 + (token - 13));
710
        else
711
            *coeff = 3 + (token - 13);
712
        debug_token("output %d\n", *coeff);
713
        break;
714

    
715
    case 17:
716
        debug_token("DCT_VAL_CATEGORY3, ");
717
        sign = get_bits(gb, 1);
718
        *coeff = 7 + get_bits(gb, 1);
719
        if (sign)
720
            *coeff = -(*coeff);
721
        debug_token("output %d\n", *coeff);
722
        break;
723

    
724
    case 18:
725
        debug_token("DCT_VAL_CATEGORY4, ");
726
        sign = get_bits(gb, 1);
727
        *coeff = 9 + get_bits(gb, 2);
728
        if (sign)
729
            *coeff = -(*coeff);
730
        debug_token("output %d\n", *coeff);
731
        break;
732

    
733
    case 19:
734
        debug_token("DCT_VAL_CATEGORY5, ");
735
        sign = get_bits(gb, 1);
736
        *coeff = 13 + get_bits(gb, 3);
737
        if (sign)
738
            *coeff = -(*coeff);
739
        debug_token("output %d\n", *coeff);
740
        break;
741

    
742
    case 20:
743
        debug_token("DCT_VAL_CATEGORY6, ");
744
        sign = get_bits(gb, 1);
745
        *coeff = 21 + get_bits(gb, 4);
746
        if (sign)
747
            *coeff = -(*coeff);
748
        debug_token("output %d\n", *coeff);
749
        break;
750

    
751
    case 21:
752
        debug_token("DCT_VAL_CATEGORY7, ");
753
        sign = get_bits(gb, 1);
754
        *coeff = 37 + get_bits(gb, 5);
755
        if (sign)
756
            *coeff = -(*coeff);
757
        debug_token("output %d\n", *coeff);
758
        break;
759

    
760
    case 22:
761
        debug_token("DCT_VAL_CATEGORY8, ");
762
        sign = get_bits(gb, 1);
763
        *coeff = 69 + get_bits(gb, 9);
764
        if (sign)
765
            *coeff = -(*coeff);
766
        debug_token("output %d\n", *coeff);
767
        break;
768

    
769
    case 23:
770
    case 24:
771
    case 25:
772
    case 26:
773
    case 27:
774
        debug_token("DCT_RUN_CATEGORY1, ");
775
        *zero_run = token - 22;
776
        if (get_bits(gb, 1))
777
            *coeff = -1;
778
        else
779
            *coeff = 1;
780
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
781
        break;
782

    
783
    case 28:
784
        debug_token("DCT_RUN_CATEGORY1B, ");
785
        if (get_bits(gb, 1))
786
            *coeff = -1;
787
        else
788
            *coeff = 1;
789
        *zero_run = 6 + get_bits(gb, 2);
790
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
791
        break;
792

    
793
    case 29:
794
        debug_token("DCT_RUN_CATEGORY1C, ");
795
        if (get_bits(gb, 1))
796
            *coeff = -1;
797
        else
798
            *coeff = 1;
799
        *zero_run = 10 + get_bits(gb, 3);
800
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
801
        break;
802

    
803
    case 30:
804
        debug_token("DCT_RUN_CATEGORY2, ");
805
        sign = get_bits(gb, 1);
806
        *coeff = 2 + get_bits(gb, 1);
807
        if (sign)
808
            *coeff = -(*coeff);
809
        *zero_run = 1;
810
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
811
        break;
812

    
813
    case 31:
814
        debug_token("DCT_RUN_CATEGORY2, ");
815
        sign = get_bits(gb, 1);
816
        *coeff = 2 + get_bits(gb, 1);
817
        if (sign)
818
            *coeff = -(*coeff);
819
        *zero_run = 2 + get_bits(gb, 1);
820
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
821
        break;
822

    
823
    default:
824
        av_log(NULL, AV_LOG_ERROR, "  vp3: help! Got a bad token: %d > 31\n", token);
825
        break;
826

    
827
  }
828
}
829

    
830
/*
831
 * This function wipes out all of the fragment data.
832
 */
833
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
834
{
835
    int i;
836
    static const DCTELEM zero_block[64];
837

    
838
    /* zero out all of the fragment information */
839
    s->coded_fragment_list_index = 0;
840
    for (i = 0; i < s->fragment_count; i++) {
841
        s->all_fragments[i].coeffs = zero_block;
842
        s->all_fragments[i].coeff_count = 0;
843
        s->all_fragments[i].last_coeff = -1;
844
s->all_fragments[i].motion_x = 0xbeef;
845
s->all_fragments[i].motion_y = 0xbeef;
846
    }
847
}
848

    
849
/*
850
 * This function sets of the dequantization tables used for a particular
851
 * frame.
852
 */
853
static void init_dequantizer(Vp3DecodeContext *s)
854
{
855

    
856
    int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
857
    int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
858
    int i, j;
859

    
860
    debug_vp3("  vp3: initializing dequantization tables\n");
861

    
862
    /* 
863
     * Scale dequantizers:
864
     *
865
     *   quantizer * sf
866
     *   --------------
867
     *        100
868
     *
869
     * where sf = dc_scale_factor for DC quantizer
870
     *         or ac_scale_factor for AC quantizer
871
     *
872
     * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
873
     */
874
#define SCALER 4
875

    
876
    /* scale DC quantizers */
877
    s->intra_y_dequant[0] = s->coded_intra_y_dequant[0] * dc_scale_factor / 100;
878
    if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
879
        s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
880
    s->intra_y_dequant[0] *= SCALER;
881

    
882
    s->intra_c_dequant[0] = s->coded_intra_c_dequant[0] * dc_scale_factor / 100;
883
    if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
884
        s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
885
    s->intra_c_dequant[0] *= SCALER;
886

    
887
    s->inter_dequant[0] = s->coded_inter_dequant[0] * dc_scale_factor / 100;
888
    if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
889
        s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
890
    s->inter_dequant[0] *= SCALER;
891

    
892
    /* scale AC quantizers, zigzag at the same time in preparation for
893
     * the dequantization phase */
894
    for (i = 1; i < 64; i++) {
895
        int k= s->scantable.scantable[i];
896
        j = s->scantable.permutated[i];
897

    
898
        s->intra_y_dequant[j] = s->coded_intra_y_dequant[k] * ac_scale_factor / 100;
899
        if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
900
            s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
901
        s->intra_y_dequant[j] *= SCALER;
902

    
903
        s->intra_c_dequant[j] = s->coded_intra_c_dequant[k] * ac_scale_factor / 100;
904
        if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
905
            s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
906
        s->intra_c_dequant[j] *= SCALER;
907

    
908
        s->inter_dequant[j] = s->coded_inter_dequant[k] * ac_scale_factor / 100;
909
        if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
910
            s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
911
        s->inter_dequant[j] *= SCALER;
912
    }
913
    
914
    memset(s->qscale_table, (FFMAX(s->intra_y_dequant[1], s->intra_c_dequant[1])+8)/16, 512); //FIXME finetune
915

    
916
    /* print debug information as requested */
917
    debug_dequantizers("intra Y dequantizers:\n");
918
    for (i = 0; i < 8; i++) {
919
      for (j = i * 8; j < i * 8 + 8; j++) {
920
        debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
921
      }
922
      debug_dequantizers("\n");
923
    }
924
    debug_dequantizers("\n");
925

    
926
    debug_dequantizers("intra C dequantizers:\n");
927
    for (i = 0; i < 8; i++) {
928
      for (j = i * 8; j < i * 8 + 8; j++) {
929
        debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
930
      }
931
      debug_dequantizers("\n");
932
    }
933
    debug_dequantizers("\n");
934

    
935
    debug_dequantizers("interframe dequantizers:\n");
936
    for (i = 0; i < 8; i++) {
937
      for (j = i * 8; j < i * 8 + 8; j++) {
938
        debug_dequantizers(" %4d,", s->inter_dequant[j]);
939
      }
940
      debug_dequantizers("\n");
941
    }
942
    debug_dequantizers("\n");
943
}
944

    
945
/*
946
 * This function is used to fetch runs of 1s or 0s from the bitstream for
947
 * use in determining which superblocks are fully and partially coded.
948
 *
949
 *  Codeword                RunLength
950
 *  0                       1
951
 *  10x                     2-3
952
 *  110x                    4-5
953
 *  1110xx                  6-9
954
 *  11110xxx                10-17
955
 *  111110xxxx              18-33
956
 *  111111xxxxxxxxxxxx      34-4129
957
 */
958
static int get_superblock_run_length(GetBitContext *gb)
959
{
960

    
961
    if (get_bits(gb, 1) == 0)
962
        return 1;
963

    
964
    else if (get_bits(gb, 1) == 0)
965
        return (2 + get_bits(gb, 1));
966

    
967
    else if (get_bits(gb, 1) == 0)
968
        return (4 + get_bits(gb, 1));
969

    
970
    else if (get_bits(gb, 1) == 0)
971
        return (6 + get_bits(gb, 2));
972

    
973
    else if (get_bits(gb, 1) == 0)
974
        return (10 + get_bits(gb, 3));
975

    
976
    else if (get_bits(gb, 1) == 0)
977
        return (18 + get_bits(gb, 4));
978

    
979
    else
980
        return (34 + get_bits(gb, 12));
981

    
982
}
983

    
984
/*
985
 * This function is used to fetch runs of 1s or 0s from the bitstream for
986
 * use in determining which particular fragments are coded.
987
 *
988
 * Codeword                RunLength
989
 * 0x                      1-2
990
 * 10x                     3-4
991
 * 110x                    5-6
992
 * 1110xx                  7-10
993
 * 11110xx                 11-14
994
 * 11111xxxx               15-30
995
 */
996
static int get_fragment_run_length(GetBitContext *gb)
997
{
998

    
999
    if (get_bits(gb, 1) == 0)
1000
        return (1 + get_bits(gb, 1));
1001

    
1002
    else if (get_bits(gb, 1) == 0)
1003
        return (3 + get_bits(gb, 1));
1004

    
1005
    else if (get_bits(gb, 1) == 0)
1006
        return (5 + get_bits(gb, 1));
1007

    
1008
    else if (get_bits(gb, 1) == 0)
1009
        return (7 + get_bits(gb, 2));
1010

    
1011
    else if (get_bits(gb, 1) == 0)
1012
        return (11 + get_bits(gb, 2));
1013

    
1014
    else
1015
        return (15 + get_bits(gb, 4));
1016

    
1017
}
1018

    
1019
/*
1020
 * This function decodes a VLC from the bitstream and returns a number
1021
 * that ranges from 0..7. The number indicates which of the 8 coding
1022
 * modes to use.
1023
 *
1024
 *  VLC       Number
1025
 *  0            0
1026
 *  10           1
1027
 *  110          2
1028
 *  1110         3
1029
 *  11110        4
1030
 *  111110       5
1031
 *  1111110      6
1032
 *  1111111      7
1033
 *
1034
 */
1035
static int get_mode_code(GetBitContext *gb)
1036
{
1037

    
1038
    if (get_bits(gb, 1) == 0)
1039
        return 0;
1040

    
1041
    else if (get_bits(gb, 1) == 0)
1042
        return 1;
1043

    
1044
    else if (get_bits(gb, 1) == 0)
1045
        return 2;
1046

    
1047
    else if (get_bits(gb, 1) == 0)
1048
        return 3;
1049

    
1050
    else if (get_bits(gb, 1) == 0)
1051
        return 4;
1052

    
1053
    else if (get_bits(gb, 1) == 0)
1054
        return 5;
1055

    
1056
    else if (get_bits(gb, 1) == 0)
1057
        return 6;
1058

    
1059
    else
1060
        return 7;
1061

    
1062
}
1063

    
1064
/*
1065
 * This function extracts a motion vector from the bitstream using a VLC
1066
 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1067
 * taken depending on the value on those 3 bits:
1068
 *
1069
 *  0: return 0
1070
 *  1: return 1
1071
 *  2: return -1
1072
 *  3: if (next bit is 1) return -2, else return 2
1073
 *  4: if (next bit is 1) return -3, else return 3
1074
 *  5: return 4 + (next 2 bits), next bit is sign
1075
 *  6: return 8 + (next 3 bits), next bit is sign
1076
 *  7: return 16 + (next 4 bits), next bit is sign
1077
 */
1078
static int get_motion_vector_vlc(GetBitContext *gb)
1079
{
1080
    int bits;
1081

    
1082
    bits = get_bits(gb, 3);
1083

    
1084
    switch(bits) {
1085

    
1086
    case 0:
1087
        bits = 0;
1088
        break;
1089

    
1090
    case 1:
1091
        bits = 1;
1092
        break;
1093

    
1094
    case 2:
1095
        bits = -1;
1096
        break;
1097

    
1098
    case 3:
1099
        if (get_bits(gb, 1) == 0)
1100
            bits = 2;
1101
        else
1102
            bits = -2;
1103
        break;
1104

    
1105
    case 4:
1106
        if (get_bits(gb, 1) == 0)
1107
            bits = 3;
1108
        else
1109
            bits = -3;
1110
        break;
1111

    
1112
    case 5:
1113
        bits = 4 + get_bits(gb, 2);
1114
        if (get_bits(gb, 1) == 1)
1115
            bits = -bits;
1116
        break;
1117

    
1118
    case 6:
1119
        bits = 8 + get_bits(gb, 3);
1120
        if (get_bits(gb, 1) == 1)
1121
            bits = -bits;
1122
        break;
1123

    
1124
    case 7:
1125
        bits = 16 + get_bits(gb, 4);
1126
        if (get_bits(gb, 1) == 1)
1127
            bits = -bits;
1128
        break;
1129

    
1130
    }
1131

    
1132
    return bits;
1133
}
1134

    
1135
/*
1136
 * This function fetches a 5-bit number from the stream followed by
1137
 * a sign and calls it a motion vector.
1138
 */
1139
static int get_motion_vector_fixed(GetBitContext *gb)
1140
{
1141

    
1142
    int bits;
1143

    
1144
    bits = get_bits(gb, 5);
1145

    
1146
    if (get_bits(gb, 1) == 1)
1147
        bits = -bits;
1148

    
1149
    return bits;
1150
}
1151

    
1152
/*
1153
 * This function unpacks all of the superblock/macroblock/fragment coding 
1154
 * information from the bitstream.
1155
 */
1156
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1157
{
1158
    int bit = 0;
1159
    int current_superblock = 0;
1160
    int current_run = 0;
1161
    int decode_fully_flags = 0;
1162
    int decode_partial_blocks = 0;
1163
    int first_c_fragment_seen;
1164

    
1165
    int i, j;
1166
    int current_fragment;
1167

    
1168
    debug_vp3("  vp3: unpacking superblock coding\n");
1169

    
1170
    if (s->keyframe) {
1171

    
1172
        debug_vp3("    keyframe-- all superblocks are fully coded\n");
1173
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1174

    
1175
    } else {
1176

    
1177
        /* unpack the list of partially-coded superblocks */
1178
        bit = get_bits(gb, 1);
1179
        /* toggle the bit because as soon as the first run length is 
1180
         * fetched the bit will be toggled again */
1181
        bit ^= 1;
1182
        while (current_superblock < s->superblock_count) {
1183
            if (current_run-- == 0) {
1184
                bit ^= 1;
1185
#if 1
1186
                current_run = get_vlc2(gb, 
1187
                    s->superblock_run_length_vlc.table, 6, 2);
1188
                if (current_run == 33)
1189
                    current_run += get_bits(gb, 12);
1190
#else
1191
                current_run = get_superblock_run_length(gb);
1192
#endif
1193
                debug_block_coding("      setting superblocks %d..%d to %s\n",
1194
                    current_superblock,
1195
                    current_superblock + current_run - 1,
1196
                    (bit) ? "partially coded" : "not coded");
1197

    
1198
                /* if any of the superblocks are not partially coded, flag
1199
                 * a boolean to decode the list of fully-coded superblocks */
1200
                if (bit == 0) {
1201
                    decode_fully_flags = 1;
1202
                } else {
1203

    
1204
                    /* make a note of the fact that there are partially coded
1205
                     * superblocks */
1206
                    decode_partial_blocks = 1;
1207
                }
1208
            }
1209
            s->superblock_coding[current_superblock++] = bit;
1210
        }
1211

    
1212
        /* unpack the list of fully coded superblocks if any of the blocks were
1213
         * not marked as partially coded in the previous step */
1214
        if (decode_fully_flags) {
1215

    
1216
            current_superblock = 0;
1217
            current_run = 0;
1218
            bit = get_bits(gb, 1);
1219
            /* toggle the bit because as soon as the first run length is 
1220
             * fetched the bit will be toggled again */
1221
            bit ^= 1;
1222
            while (current_superblock < s->superblock_count) {
1223

    
1224
                /* skip any superblocks already marked as partially coded */
1225
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1226

    
1227
                    if (current_run-- == 0) {
1228
                        bit ^= 1;
1229
#if 1
1230
                        current_run = get_vlc2(gb, 
1231
                            s->superblock_run_length_vlc.table, 6, 2);
1232
                        if (current_run == 33)
1233
                            current_run += get_bits(gb, 12);
1234
#else
1235
                        current_run = get_superblock_run_length(gb);
1236
#endif
1237
                    }
1238

    
1239
                    debug_block_coding("      setting superblock %d to %s\n",
1240
                        current_superblock,
1241
                        (bit) ? "fully coded" : "not coded");
1242
                    s->superblock_coding[current_superblock] = 2*bit;
1243
                }
1244
                current_superblock++;
1245
            }
1246
        }
1247

    
1248
        /* if there were partial blocks, initialize bitstream for
1249
         * unpacking fragment codings */
1250
        if (decode_partial_blocks) {
1251

    
1252
            current_run = 0;
1253
            bit = get_bits(gb, 1);
1254
            /* toggle the bit because as soon as the first run length is 
1255
             * fetched the bit will be toggled again */
1256
            bit ^= 1;
1257
        }
1258
    }
1259

    
1260
    /* figure out which fragments are coded; iterate through each
1261
     * superblock (all planes) */
1262
    s->coded_fragment_list_index = 0;
1263
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1264
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1265
    first_c_fragment_seen = 0;
1266
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1267
    for (i = 0; i < s->superblock_count; i++) {
1268

    
1269
        /* iterate through all 16 fragments in a superblock */
1270
        for (j = 0; j < 16; j++) {
1271

    
1272
            /* if the fragment is in bounds, check its coding status */
1273
            current_fragment = s->superblock_fragments[i * 16 + j];
1274
            if (current_fragment >= s->fragment_count) {
1275
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1276
                    current_fragment, s->fragment_count);
1277
                return 1;
1278
            }
1279
            if (current_fragment != -1) {
1280
                if (s->superblock_coding[i] == SB_NOT_CODED) {
1281

    
1282
                    /* copy all the fragments from the prior frame */
1283
                    s->all_fragments[current_fragment].coding_method = 
1284
                        MODE_COPY;
1285

    
1286
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1287

    
1288
                    /* fragment may or may not be coded; this is the case
1289
                     * that cares about the fragment coding runs */
1290
                    if (current_run-- == 0) {
1291
                        bit ^= 1;
1292
#if 1
1293
                        current_run = get_vlc2(gb, 
1294
                            s->fragment_run_length_vlc.table, 5, 2);
1295
#else
1296
                        current_run = get_fragment_run_length(gb);
1297
#endif
1298
                    }
1299

    
1300
                    if (bit) {
1301
                        /* default mode; actual mode will be decoded in 
1302
                         * the next phase */
1303
                        s->all_fragments[current_fragment].coding_method = 
1304
                            MODE_INTER_NO_MV;
1305
                        s->all_fragments[current_fragment].coeffs= s->coeffs + 64*s->coded_fragment_list_index;
1306
                        s->coded_fragment_list[s->coded_fragment_list_index] = 
1307
                            current_fragment;
1308
                        if ((current_fragment >= s->u_fragment_start) &&
1309
                            (s->last_coded_y_fragment == -1) &&
1310
                            (!first_c_fragment_seen)) {
1311
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
1312
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1313
                            first_c_fragment_seen = 1;
1314
                        }
1315
                        s->coded_fragment_list_index++;
1316
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1317
                        debug_block_coding("      superblock %d is partially coded, fragment %d is coded\n",
1318
                            i, current_fragment);
1319
                    } else {
1320
                        /* not coded; copy this fragment from the prior frame */
1321
                        s->all_fragments[current_fragment].coding_method =
1322
                            MODE_COPY;
1323
                        debug_block_coding("      superblock %d is partially coded, fragment %d is not coded\n",
1324
                            i, current_fragment);
1325
                    }
1326

    
1327
                } else {
1328

    
1329
                    /* fragments are fully coded in this superblock; actual
1330
                     * coding will be determined in next step */
1331
                    s->all_fragments[current_fragment].coding_method = 
1332
                        MODE_INTER_NO_MV;
1333
                    s->all_fragments[current_fragment].coeffs= s->coeffs + 64*s->coded_fragment_list_index;
1334
                    s->coded_fragment_list[s->coded_fragment_list_index] = 
1335
                        current_fragment;
1336
                    if ((current_fragment >= s->u_fragment_start) &&
1337
                        (s->last_coded_y_fragment == -1) &&
1338
                        (!first_c_fragment_seen)) {
1339
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
1340
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1341
                        first_c_fragment_seen = 1;
1342
                    }
1343
                    s->coded_fragment_list_index++;
1344
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1345
                    debug_block_coding("      superblock %d is fully coded, fragment %d is coded\n",
1346
                        i, current_fragment);
1347
                }
1348
            }
1349
        }
1350
    }
1351

    
1352
    if (!first_c_fragment_seen)
1353
        /* only Y fragments coded in this frame */
1354
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
1355
    else 
1356
        /* end the list of coded C fragments */
1357
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1358

    
1359
    debug_block_coding("    %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1360
        s->coded_fragment_list_index,
1361
        s->first_coded_y_fragment,
1362
        s->last_coded_y_fragment,
1363
        s->first_coded_c_fragment,
1364
        s->last_coded_c_fragment);
1365

    
1366
    return 0;
1367
}
1368

    
1369
/*
1370
 * This function unpacks all the coding mode data for individual macroblocks
1371
 * from the bitstream.
1372
 */
1373
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1374
{
1375
    int i, j, k;
1376
    int scheme;
1377
    int current_macroblock;
1378
    int current_fragment;
1379
    int coding_mode;
1380

    
1381
    debug_vp3("  vp3: unpacking encoding modes\n");
1382

    
1383
    if (s->keyframe) {
1384
        debug_vp3("    keyframe-- all blocks are coded as INTRA\n");
1385

    
1386
        for (i = 0; i < s->fragment_count; i++)
1387
            s->all_fragments[i].coding_method = MODE_INTRA;
1388

    
1389
    } else {
1390

    
1391
        /* fetch the mode coding scheme for this frame */
1392
        scheme = get_bits(gb, 3);
1393
        debug_modes("    using mode alphabet %d\n", scheme);
1394

    
1395
        /* is it a custom coding scheme? */
1396
        if (scheme == 0) {
1397
            debug_modes("    custom mode alphabet ahead:\n");
1398
            for (i = 0; i < 8; i++)
1399
                ModeAlphabet[scheme][get_bits(gb, 3)] = i;
1400
        }
1401

    
1402
        for (i = 0; i < 8; i++)
1403
            debug_modes("      mode[%d][%d] = %d\n", scheme, i, 
1404
                ModeAlphabet[scheme][i]);
1405

    
1406
        /* iterate through all of the macroblocks that contain 1 or more
1407
         * coded fragments */
1408
        for (i = 0; i < s->u_superblock_start; i++) {
1409

    
1410
            for (j = 0; j < 4; j++) {
1411
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1412
                if ((current_macroblock == -1) ||
1413
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1414
                    continue;
1415
                if (current_macroblock >= s->macroblock_count) {
1416
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1417
                        current_macroblock, s->macroblock_count);
1418
                    return 1;
1419
                }
1420

    
1421
                /* mode 7 means get 3 bits for each coding mode */
1422
                if (scheme == 7)
1423
                    coding_mode = get_bits(gb, 3);
1424
                else
1425
{
1426
#if 1
1427
                    coding_mode = ModeAlphabet[scheme]
1428
                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1429
#else
1430
                    coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
1431
#endif
1432
}
1433

    
1434
                s->macroblock_coding[current_macroblock] = coding_mode;
1435
                for (k = 0; k < 6; k++) {
1436
                    current_fragment = 
1437
                        s->macroblock_fragments[current_macroblock * 6 + k];
1438
                    if (current_fragment == -1)
1439
                        continue;
1440
                    if (current_fragment >= s->fragment_count) {
1441
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1442
                            current_fragment, s->fragment_count);
1443
                        return 1;
1444
                    }
1445
                    if (s->all_fragments[current_fragment].coding_method != 
1446
                        MODE_COPY)
1447
                        s->all_fragments[current_fragment].coding_method =
1448
                            coding_mode;
1449
                }
1450

    
1451
                debug_modes("    coding method for macroblock starting @ fragment %d = %d\n",
1452
                    s->macroblock_fragments[current_macroblock * 6], coding_mode);
1453
            }
1454
        }
1455
    }
1456

    
1457
    return 0;
1458
}
1459

    
1460
/*
1461
 * This function unpacks all the motion vectors for the individual
1462
 * macroblocks from the bitstream.
1463
 */
1464
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1465
{
1466
    int i, j, k;
1467
    int coding_mode;
1468
    int motion_x[6];
1469
    int motion_y[6];
1470
    int last_motion_x = 0;
1471
    int last_motion_y = 0;
1472
    int prior_last_motion_x = 0;
1473
    int prior_last_motion_y = 0;
1474
    int current_macroblock;
1475
    int current_fragment;
1476

    
1477
    debug_vp3("  vp3: unpacking motion vectors\n");
1478
    if (s->keyframe) {
1479

    
1480
        debug_vp3("    keyframe-- there are no motion vectors\n");
1481

    
1482
    } else {
1483

    
1484
        memset(motion_x, 0, 6 * sizeof(int));
1485
        memset(motion_y, 0, 6 * sizeof(int));
1486

    
1487
        /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1488
        coding_mode = get_bits(gb, 1);
1489
        debug_vectors("    using %s scheme for unpacking motion vectors\n",
1490
            (coding_mode == 0) ? "VLC" : "fixed-length");
1491

    
1492
        /* iterate through all of the macroblocks that contain 1 or more
1493
         * coded fragments */
1494
        for (i = 0; i < s->u_superblock_start; i++) {
1495

    
1496
            for (j = 0; j < 4; j++) {
1497
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1498
                if ((current_macroblock == -1) ||
1499
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1500
                    continue;
1501
                if (current_macroblock >= s->macroblock_count) {
1502
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1503
                        current_macroblock, s->macroblock_count);
1504
                    return 1;
1505
                }
1506

    
1507
                current_fragment = s->macroblock_fragments[current_macroblock * 6];
1508
                if (current_fragment >= s->fragment_count) {
1509
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1510
                        current_fragment, s->fragment_count);
1511
                    return 1;
1512
                }
1513
                switch (s->macroblock_coding[current_macroblock]) {
1514

    
1515
                case MODE_INTER_PLUS_MV:
1516
                case MODE_GOLDEN_MV:
1517
                    /* all 6 fragments use the same motion vector */
1518
                    if (coding_mode == 0) {
1519
#if 0
1520
                        motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1521
                        motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1522
#else
1523
                        motion_x[0] = get_motion_vector_vlc(gb);
1524
                        motion_y[0] = get_motion_vector_vlc(gb);
1525
#endif
1526
                    } else {
1527
                        motion_x[0] = get_motion_vector_fixed(gb);
1528
                        motion_y[0] = get_motion_vector_fixed(gb);
1529
                    }
1530
                    for (k = 1; k < 6; k++) {
1531
                        motion_x[k] = motion_x[0];
1532
                        motion_y[k] = motion_y[0];
1533
                    }
1534

    
1535
                    /* vector maintenance, only on MODE_INTER_PLUS_MV */
1536
                    if (s->macroblock_coding[current_macroblock] ==
1537
                        MODE_INTER_PLUS_MV) {
1538
                        prior_last_motion_x = last_motion_x;
1539
                        prior_last_motion_y = last_motion_y;
1540
                        last_motion_x = motion_x[0];
1541
                        last_motion_y = motion_y[0];
1542
                    }
1543
                    break;
1544

    
1545
                case MODE_INTER_FOURMV:
1546
                    /* fetch 4 vectors from the bitstream, one for each
1547
                     * Y fragment, then average for the C fragment vectors */
1548
                    motion_x[4] = motion_y[4] = 0;
1549
                    for (k = 0; k < 4; k++) {
1550
                        if (coding_mode == 0) {
1551
#if 0
1552
                            motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1553
                            motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1554
#else
1555
                            motion_x[k] = get_motion_vector_vlc(gb);
1556
                            motion_y[k] = get_motion_vector_vlc(gb);
1557
#endif
1558
                        } else {
1559
                            motion_x[k] = get_motion_vector_fixed(gb);
1560
                            motion_y[k] = get_motion_vector_fixed(gb);
1561
                        }
1562
                        motion_x[4] += motion_x[k];
1563
                        motion_y[4] += motion_y[k];
1564
                    }
1565

    
1566
                    if (motion_x[4] >= 0) 
1567
                        motion_x[4] = (motion_x[4] + 2) / 4;
1568
                    else
1569
                        motion_x[4] = (motion_x[4] - 2) / 4;
1570
                    motion_x[5] = motion_x[4];
1571

    
1572
                    if (motion_y[4] >= 0) 
1573
                        motion_y[4] = (motion_y[4] + 2) / 4;
1574
                    else
1575
                        motion_y[4] = (motion_y[4] - 2) / 4;
1576
                    motion_y[5] = motion_y[4];
1577

    
1578
                    /* vector maintenance; vector[3] is treated as the
1579
                     * last vector in this case */
1580
                    prior_last_motion_x = last_motion_x;
1581
                    prior_last_motion_y = last_motion_y;
1582
                    last_motion_x = motion_x[3];
1583
                    last_motion_y = motion_y[3];
1584
                    break;
1585

    
1586
                case MODE_INTER_LAST_MV:
1587
                    /* all 6 fragments use the last motion vector */
1588
                    motion_x[0] = last_motion_x;
1589
                    motion_y[0] = last_motion_y;
1590
                    for (k = 1; k < 6; k++) {
1591
                        motion_x[k] = motion_x[0];
1592
                        motion_y[k] = motion_y[0];
1593
                    }
1594

    
1595
                    /* no vector maintenance (last vector remains the
1596
                     * last vector) */
1597
                    break;
1598

    
1599
                case MODE_INTER_PRIOR_LAST:
1600
                    /* all 6 fragments use the motion vector prior to the
1601
                     * last motion vector */
1602
                    motion_x[0] = prior_last_motion_x;
1603
                    motion_y[0] = prior_last_motion_y;
1604
                    for (k = 1; k < 6; k++) {
1605
                        motion_x[k] = motion_x[0];
1606
                        motion_y[k] = motion_y[0];
1607
                    }
1608

    
1609
                    /* vector maintenance */
1610
                    prior_last_motion_x = last_motion_x;
1611
                    prior_last_motion_y = last_motion_y;
1612
                    last_motion_x = motion_x[0];
1613
                    last_motion_y = motion_y[0];
1614
                    break;
1615

    
1616
                default:
1617
                    /* covers intra, inter without MV, golden without MV */
1618
                    memset(motion_x, 0, 6 * sizeof(int));
1619
                    memset(motion_y, 0, 6 * sizeof(int));
1620

    
1621
                    /* no vector maintenance */
1622
                    break;
1623
                }
1624

    
1625
                /* assign the motion vectors to the correct fragments */
1626
                debug_vectors("    vectors for macroblock starting @ fragment %d (coding method %d):\n",
1627
                    current_fragment,
1628
                    s->macroblock_coding[current_macroblock]);
1629
                for (k = 0; k < 6; k++) {
1630
                    current_fragment = 
1631
                        s->macroblock_fragments[current_macroblock * 6 + k];
1632
                    if (current_fragment == -1)
1633
                        continue;
1634
                    if (current_fragment >= s->fragment_count) {
1635
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1636
                            current_fragment, s->fragment_count);
1637
                        return 1;
1638
                    }
1639
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
1640
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
1641
                    debug_vectors("    vector %d: fragment %d = (%d, %d)\n",
1642
                        k, current_fragment, motion_x[k], motion_y[k]);
1643
                }
1644
            }
1645
        }
1646
    }
1647

    
1648
    return 0;
1649
}
1650

    
1651
/* 
1652
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1653
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1654
 * data. This function unpacks all the VLCs for either the Y plane or both
1655
 * C planes, and is called for DC coefficients or different AC coefficient
1656
 * levels (since different coefficient types require different VLC tables.
1657
 *
1658
 * This function returns a residual eob run. E.g, if a particular token gave
1659
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1660
 * left in the current fragment range, 3 would be returned so that it could
1661
 * be passed into the next call to this same function.
1662
 */
1663
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1664
                        VLC *table, int coeff_index,
1665
                        int first_fragment, int last_fragment,
1666
                        int eob_run)
1667
{
1668
    int i;
1669
    int token;
1670
    int zero_run;
1671
    DCTELEM coeff;
1672
    Vp3Fragment *fragment;
1673
    uint8_t *perm= s->scantable.permutated;
1674

    
1675
    if ((first_fragment >= s->fragment_count) ||
1676
        (last_fragment >= s->fragment_count)) {
1677

    
1678
        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1679
            first_fragment, last_fragment);
1680
        return 0;
1681
    }
1682

    
1683
    for (i = first_fragment; i <= last_fragment; i++) {
1684

    
1685
        fragment = &s->all_fragments[s->coded_fragment_list[i]];
1686
        if (fragment->coeff_count > coeff_index)
1687
            continue;
1688

    
1689
        if (!eob_run) {
1690
            /* decode a VLC into a token */
1691
            token = get_vlc2(gb, table->table, 5, 3);
1692
            debug_vlc(" token = %2d, ", token);
1693
            /* use the token to get a zero run, a coefficient, and an eob run */
1694
            unpack_token(gb, token, &zero_run, &coeff, &eob_run);
1695
        }
1696

    
1697
        if (!eob_run) {
1698
            fragment->coeff_count += zero_run;
1699
            if (fragment->coeff_count < 64)
1700
                fragment->coeffs[perm[fragment->coeff_count++]] = coeff;
1701
            debug_vlc(" fragment %d coeff = %d\n",
1702
                s->coded_fragment_list[i], fragment->coeffs[coeff_index]);
1703
        } else {
1704
            fragment->last_coeff = fragment->coeff_count;
1705
            fragment->coeff_count = 64;
1706
            debug_vlc(" fragment %d eob with %d coefficients\n", 
1707
                s->coded_fragment_list[i], fragment->last_coeff);
1708
            eob_run--;
1709
        }
1710
    }
1711

    
1712
    return eob_run;
1713
}
1714

    
1715
/*
1716
 * This function unpacks all of the DCT coefficient data from the
1717
 * bitstream.
1718
 */
1719
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1720
{
1721
    int i;
1722
    int dc_y_table;
1723
    int dc_c_table;
1724
    int ac_y_table;
1725
    int ac_c_table;
1726
    int residual_eob_run = 0;
1727

    
1728
    /* fetch the DC table indices */
1729
    dc_y_table = get_bits(gb, 4);
1730
    dc_c_table = get_bits(gb, 4);
1731

    
1732
    /* unpack the Y plane DC coefficients */
1733
    debug_vp3("  vp3: unpacking Y plane DC coefficients using table %d\n",
1734
        dc_y_table);
1735
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, 
1736
        s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1737

    
1738
    /* unpack the C plane DC coefficients */
1739
    debug_vp3("  vp3: unpacking C plane DC coefficients using table %d\n",
1740
        dc_c_table);
1741
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1742
        s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1743

    
1744
    /* fetch the AC table indices */
1745
    ac_y_table = get_bits(gb, 4);
1746
    ac_c_table = get_bits(gb, 4);
1747

    
1748
    /* unpack the group 1 AC coefficients (coeffs 1-5) */
1749
    for (i = 1; i <= 5; i++) {
1750

    
1751
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1752
            i, ac_y_table);
1753
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i, 
1754
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1755

    
1756
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1757
            i, ac_c_table);
1758
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i, 
1759
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1760
    }
1761

    
1762
    /* unpack the group 2 AC coefficients (coeffs 6-14) */
1763
    for (i = 6; i <= 14; i++) {
1764

    
1765
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1766
            i, ac_y_table);
1767
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i, 
1768
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1769

    
1770
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1771
            i, ac_c_table);
1772
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i, 
1773
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1774
    }
1775

    
1776
    /* unpack the group 3 AC coefficients (coeffs 15-27) */
1777
    for (i = 15; i <= 27; i++) {
1778

    
1779
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1780
            i, ac_y_table);
1781
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i, 
1782
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1783

    
1784
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1785
            i, ac_c_table);
1786
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i, 
1787
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1788
    }
1789

    
1790
    /* unpack the group 4 AC coefficients (coeffs 28-63) */
1791
    for (i = 28; i <= 63; i++) {
1792

    
1793
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1794
            i, ac_y_table);
1795
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i, 
1796
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1797

    
1798
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1799
            i, ac_c_table);
1800
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i, 
1801
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1802
    }
1803

    
1804
    return 0;
1805
}
1806

    
1807
/*
1808
 * This function reverses the DC prediction for each coded fragment in
1809
 * the frame. Much of this function is adapted directly from the original 
1810
 * VP3 source code.
1811
 */
1812
#define COMPATIBLE_FRAME(x) \
1813
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1814
#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
1815
static inline int iabs (int x) { return ((x < 0) ? -x : x); }
1816

    
1817
static void reverse_dc_prediction(Vp3DecodeContext *s,
1818
                                  int first_fragment,
1819
                                  int fragment_width,
1820
                                  int fragment_height) 
1821
{
1822

    
1823
#define PUL 8
1824
#define PU 4
1825
#define PUR 2
1826
#define PL 1
1827

    
1828
    int x, y;
1829
    int i = first_fragment;
1830

    
1831
    /*
1832
     * Fragment prediction groups:
1833
     *
1834
     * 32222222226
1835
     * 10000000004
1836
     * 10000000004
1837
     * 10000000004
1838
     * 10000000004
1839
     *
1840
     * Note: Groups 5 and 7 do not exist as it would mean that the 
1841
     * fragment's x coordinate is both 0 and (width - 1) at the same time.
1842
     */
1843
    int predictor_group;
1844
    short predicted_dc;
1845

    
1846
    /* validity flags for the left, up-left, up, and up-right fragments */
1847
    int fl, ful, fu, fur;
1848

    
1849
    /* DC values for the left, up-left, up, and up-right fragments */
1850
    int vl, vul, vu, vur;
1851

    
1852
    /* indices for the left, up-left, up, and up-right fragments */
1853
    int l, ul, u, ur;
1854

    
1855
    /* 
1856
     * The 6 fields mean:
1857
     *   0: up-left multiplier
1858
     *   1: up multiplier
1859
     *   2: up-right multiplier
1860
     *   3: left multiplier
1861
     *   4: mask
1862
     *   5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
1863
     */
1864
    int predictor_transform[16][6] = {
1865
        {  0,  0,  0,  0,   0,  0 },
1866
        {  0,  0,  0,  1,   0,  0 },        // PL
1867
        {  0,  0,  1,  0,   0,  0 },        // PUR
1868
        {  0,  0, 53, 75, 127,  7 },        // PUR|PL
1869
        {  0,  1,  0,  0,   0,  0 },        // PU
1870
        {  0,  1,  0,  1,   1,  1 },        // PU|PL
1871
        {  0,  1,  0,  0,   0,  0 },        // PU|PUR
1872
        {  0,  0, 53, 75, 127,  7 },        // PU|PUR|PL
1873
        {  1,  0,  0,  0,   0,  0 },        // PUL
1874
        {  0,  0,  0,  1,   0,  0 },        // PUL|PL
1875
        {  1,  0,  1,  0,   1,  1 },        // PUL|PUR
1876
        {  0,  0, 53, 75, 127,  7 },        // PUL|PUR|PL
1877
        {  0,  1,  0,  0,   0,  0 },        // PUL|PU
1878
        {-26, 29,  0, 29,  31,  5 },        // PUL|PU|PL
1879
        {  3, 10,  3,  0,  15,  4 },        // PUL|PU|PUR
1880
        {-26, 29,  0, 29,  31,  5 }         // PUL|PU|PUR|PL
1881
    };
1882

    
1883
    /* This table shows which types of blocks can use other blocks for
1884
     * prediction. For example, INTRA is the only mode in this table to
1885
     * have a frame number of 0. That means INTRA blocks can only predict
1886
     * from other INTRA blocks. There are 2 golden frame coding types; 
1887
     * blocks encoding in these modes can only predict from other blocks
1888
     * that were encoded with these 1 of these 2 modes. */
1889
    unsigned char compatible_frame[8] = {
1890
        1,    /* MODE_INTER_NO_MV */
1891
        0,    /* MODE_INTRA */
1892
        1,    /* MODE_INTER_PLUS_MV */
1893
        1,    /* MODE_INTER_LAST_MV */
1894
        1,    /* MODE_INTER_PRIOR_MV */
1895
        2,    /* MODE_USING_GOLDEN */
1896
        2,    /* MODE_GOLDEN_MV */
1897
        1     /* MODE_INTER_FOUR_MV */
1898
    };
1899
    int current_frame_type;
1900

    
1901
    /* there is a last DC predictor for each of the 3 frame types */
1902
    short last_dc[3];
1903

    
1904
    int transform = 0;
1905

    
1906
    debug_vp3("  vp3: reversing DC prediction\n");
1907

    
1908
    vul = vu = vur = vl = 0;
1909
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
1910

    
1911
    /* for each fragment row... */
1912
    for (y = 0; y < fragment_height; y++) {
1913

    
1914
        /* for each fragment in a row... */
1915
        for (x = 0; x < fragment_width; x++, i++) {
1916

    
1917
            /* reverse prediction if this block was coded */
1918
            if (s->all_fragments[i].coding_method != MODE_COPY) {
1919

    
1920
                current_frame_type = 
1921
                    compatible_frame[s->all_fragments[i].coding_method];
1922
                predictor_group = (x == 0) + ((y == 0) << 1) +
1923
                    ((x + 1 == fragment_width) << 2);
1924
                debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
1925
                    i, predictor_group, s->all_fragments[i].coeffs[0]);
1926

    
1927
                switch (predictor_group) {
1928

    
1929
                case 0:
1930
                    /* main body of fragments; consider all 4 possible
1931
                     * fragments for prediction */
1932

    
1933
                    /* calculate the indices of the predicting fragments */
1934
                    ul = i - fragment_width - 1;
1935
                    u = i - fragment_width;
1936
                    ur = i - fragment_width + 1;
1937
                    l = i - 1;
1938

    
1939
                    /* fetch the DC values for the predicting fragments */
1940
                    vul = s->all_fragments[ul].coeffs[0];
1941
                    vu = s->all_fragments[u].coeffs[0];
1942
                    vur = s->all_fragments[ur].coeffs[0];
1943
                    vl = s->all_fragments[l].coeffs[0];
1944

    
1945
                    /* figure out which fragments are valid */
1946
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
1947
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
1948
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
1949
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
1950

    
1951
                    /* decide which predictor transform to use */
1952
                    transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
1953

    
1954
                    break;
1955

    
1956
                case 1:
1957
                    /* left column of fragments, not including top corner;
1958
                     * only consider up and up-right fragments */
1959

    
1960
                    /* calculate the indices of the predicting fragments */
1961
                    u = i - fragment_width;
1962
                    ur = i - fragment_width + 1;
1963

    
1964
                    /* fetch the DC values for the predicting fragments */
1965
                    vu = s->all_fragments[u].coeffs[0];
1966
                    vur = s->all_fragments[ur].coeffs[0];
1967

    
1968
                    /* figure out which fragments are valid */
1969
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
1970
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
1971

    
1972
                    /* decide which predictor transform to use */
1973
                    transform = (fu*PU) | (fur*PUR);
1974

    
1975
                    break;
1976

    
1977
                case 2:
1978
                case 6:
1979
                    /* top row of fragments, not including top-left frag;
1980
                     * only consider the left fragment for prediction */
1981

    
1982
                    /* calculate the indices of the predicting fragments */
1983
                    l = i - 1;
1984

    
1985
                    /* fetch the DC values for the predicting fragments */
1986
                    vl = s->all_fragments[l].coeffs[0];
1987

    
1988
                    /* figure out which fragments are valid */
1989
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
1990

    
1991
                    /* decide which predictor transform to use */
1992
                    transform = (fl*PL);
1993

    
1994
                    break;
1995

    
1996
                case 3:
1997
                    /* top-left fragment */
1998

    
1999
                    /* nothing to predict from in this case */
2000
                    transform = 0;
2001

    
2002
                    break;
2003

    
2004
                case 4:
2005
                    /* right column of fragments, not including top corner;
2006
                     * consider up-left, up, and left fragments for
2007
                     * prediction */
2008

    
2009
                    /* calculate the indices of the predicting fragments */
2010
                    ul = i - fragment_width - 1;
2011
                    u = i - fragment_width;
2012
                    l = i - 1;
2013

    
2014
                    /* fetch the DC values for the predicting fragments */
2015
                    vul = s->all_fragments[ul].coeffs[0];
2016
                    vu = s->all_fragments[u].coeffs[0];
2017
                    vl = s->all_fragments[l].coeffs[0];
2018

    
2019
                    /* figure out which fragments are valid */
2020
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2021
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2022
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2023

    
2024
                    /* decide which predictor transform to use */
2025
                    transform = (fl*PL) | (fu*PU) | (ful*PUL);
2026

    
2027
                    break;
2028

    
2029
                }
2030

    
2031
                debug_dc_pred("transform = %d, ", transform);
2032

    
2033
                if (transform == 0) {
2034

    
2035
                    /* if there were no fragments to predict from, use last
2036
                     * DC saved */
2037
                    s->all_fragments[i].coeffs[0] += last_dc[current_frame_type];
2038
                    debug_dc_pred("from last DC (%d) = %d\n", 
2039
                        current_frame_type, s->all_fragments[i].coeffs[0]);
2040

    
2041
                } else {
2042

    
2043
                    /* apply the appropriate predictor transform */
2044
                    predicted_dc =
2045
                        (predictor_transform[transform][0] * vul) +
2046
                        (predictor_transform[transform][1] * vu) +
2047
                        (predictor_transform[transform][2] * vur) +
2048
                        (predictor_transform[transform][3] * vl);
2049

    
2050
                    /* if there is a shift value in the transform, add
2051
                     * the sign bit before the shift */
2052
                    if (predictor_transform[transform][5] != 0) {
2053
                        predicted_dc += ((predicted_dc >> 15) & 
2054
                            predictor_transform[transform][4]);
2055
                        predicted_dc >>= predictor_transform[transform][5];
2056
                    }
2057

    
2058
                    /* check for outranging on the [ul u l] and
2059
                     * [ul u ur l] predictors */
2060
                    if ((transform == 13) || (transform == 15)) {
2061
                        if (iabs(predicted_dc - vu) > 128)
2062
                            predicted_dc = vu;
2063
                        else if (iabs(predicted_dc - vl) > 128)
2064
                            predicted_dc = vl;
2065
                        else if (iabs(predicted_dc - vul) > 128)
2066
                            predicted_dc = vul;
2067
                    }
2068

    
2069
                    /* at long last, apply the predictor */
2070
                    s->all_fragments[i].coeffs[0] += predicted_dc;
2071
                    debug_dc_pred("from pred DC = %d\n", 
2072
                    s->all_fragments[i].coeffs[0]);
2073
                }
2074

    
2075
                /* save the DC */
2076
                last_dc[current_frame_type] = s->all_fragments[i].coeffs[0];
2077
                if(s->all_fragments[i].coeffs[0] && s->all_fragments[i].last_coeff<0)
2078
                    s->all_fragments[i].last_coeff= 0;
2079
            }
2080
        }
2081
    }
2082
}
2083

    
2084
/*
2085
 * This function performs the final rendering of each fragment's data
2086
 * onto the output frame.
2087
 */
2088
static void render_fragments(Vp3DecodeContext *s,
2089
                             int first_fragment,
2090
                             int width,
2091
                             int height,
2092
                             int plane /* 0 = Y, 1 = U, 2 = V */) 
2093
{
2094
    int x, y, j;
2095
    int m, n;
2096
    int i = first_fragment;
2097
    int16_t *dequantizer;
2098
    DCTELEM __align16 output_samples[64];
2099
    unsigned char *output_plane;
2100
    unsigned char *last_plane;
2101
    unsigned char *golden_plane;
2102
    int stride;
2103
    int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2104
    int upper_motion_limit, lower_motion_limit;
2105
    int motion_halfpel_index;
2106
    uint8_t *motion_source;
2107

    
2108
    debug_vp3("  vp3: rendering final fragments for %s\n",
2109
        (plane == 0) ? "Y plane" : (plane == 1) ? "U plane" : "V plane");
2110

    
2111
    /* set up plane-specific parameters */
2112
    if (plane == 0) {
2113
        output_plane = s->current_frame.data[0];
2114
        last_plane = s->last_frame.data[0];
2115
        golden_plane = s->golden_frame.data[0];
2116
        stride = s->current_frame.linesize[0];
2117
        if (!s->flipped_image) stride = -stride;
2118
        upper_motion_limit = 7 * s->current_frame.linesize[0];
2119
        lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
2120
    } else if (plane == 1) {
2121
        output_plane = s->current_frame.data[1];
2122
        last_plane = s->last_frame.data[1];
2123
        golden_plane = s->golden_frame.data[1];
2124
        stride = s->current_frame.linesize[1];
2125
        if (!s->flipped_image) stride = -stride;
2126
        upper_motion_limit = 7 * s->current_frame.linesize[1];
2127
        lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
2128
    } else {
2129
        output_plane = s->current_frame.data[2];
2130
        last_plane = s->last_frame.data[2];
2131
        golden_plane = s->golden_frame.data[2];
2132
        stride = s->current_frame.linesize[2];
2133
        if (!s->flipped_image) stride = -stride;
2134
        upper_motion_limit = 7 * s->current_frame.linesize[2];
2135
        lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
2136
    }
2137
    
2138
    if(ABS(stride) > 2048)
2139
        return; //various tables are fixed size
2140

    
2141
    /* for each fragment row... */
2142
    for (y = 0; y < height; y += 8) {
2143

    
2144
        /* for each fragment in a row... */
2145
        for (x = 0; x < width; x += 8, i++) {
2146

    
2147
            if ((i < 0) || (i >= s->fragment_count)) {
2148
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:render_fragments(): bad fragment number (%d)\n", i);
2149
                return;
2150
            }
2151

    
2152
            /* transform if this block was coded */
2153
            if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2154
                !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
2155

    
2156
                if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2157
                    (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2158
                    motion_source= golden_plane;
2159
                else 
2160
                    motion_source= last_plane;
2161

    
2162
                motion_source += s->all_fragments[i].first_pixel;
2163
                motion_halfpel_index = 0;
2164

    
2165
                /* sort out the motion vector if this fragment is coded
2166
                 * using a motion vector method */
2167
                if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2168
                    (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2169
                    int src_x, src_y;
2170
                    motion_x = s->all_fragments[i].motion_x;
2171
                    motion_y = s->all_fragments[i].motion_y;
2172
                    if(plane){
2173
                        motion_x= (motion_x>>1) | (motion_x&1);
2174
                        motion_y= (motion_y>>1) | (motion_y&1);
2175
                    }
2176

    
2177
                    src_x= (motion_x>>1) + x;
2178
                    src_y= (motion_y>>1) + y;
2179
if ((motion_x == 0xbeef) || (motion_y == 0xbeef))
2180
av_log(s->avctx, AV_LOG_ERROR, " help! got beefy vector! (%X, %X)\n", motion_x, motion_y);
2181

    
2182
                    motion_halfpel_index = motion_x & 0x01;
2183
                    motion_source += (motion_x >> 1);
2184

    
2185
//                    motion_y = -motion_y;
2186
                    motion_halfpel_index |= (motion_y & 0x01) << 1;
2187
                    motion_source += ((motion_y >> 1) * stride);
2188

    
2189
                    if(src_x<0 || src_y<0 || src_x + 9 >= width || src_y + 9 >= height){
2190
                        uint8_t *temp= s->edge_emu_buffer;
2191
                        if(stride<0) temp -= 9*stride;
2192
                        else temp += 9*stride;
2193

    
2194
                        ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, width, height);
2195
                        motion_source= temp;
2196
                    }
2197
                }
2198
                
2199

    
2200
                /* first, take care of copying a block from either the
2201
                 * previous or the golden frame */
2202
                if (s->all_fragments[i].coding_method != MODE_INTRA) {
2203
                    //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
2204
                    if(motion_halfpel_index != 3){
2205
                        s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2206
                            output_plane + s->all_fragments[i].first_pixel,
2207
                            motion_source, stride, 8);
2208
                    }else{
2209
                        int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2210
                        s->dsp.put_no_rnd_pixels_l2[1](
2211
                            output_plane + s->all_fragments[i].first_pixel,
2212
                            motion_source - d, 
2213
                            motion_source + stride + 1 + d, 
2214
                            stride, 8);
2215
                    }
2216
                    dequantizer = s->inter_dequant;
2217
                }else{
2218
                    if (plane == 0)
2219
                        dequantizer = s->intra_y_dequant;
2220
                    else
2221
                        dequantizer = s->intra_c_dequant;
2222
                }
2223

    
2224
                /* dequantize the DCT coefficients */
2225
                debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n", 
2226
                    i, s->all_fragments[i].coding_method, 
2227
                    s->all_fragments[i].coeffs[0], dequantizer[0]);
2228

    
2229
                if(s->avctx->idct_algo==FF_IDCT_VP3){
2230
                    for (j = 0; j < 64; j++) {
2231
                        s->all_fragments[i].coeffs[j] *= dequantizer[j];
2232
                    }
2233
                }else{
2234
                    for (j = 0; j < 64; j++) {
2235
                        s->all_fragments[i].coeffs[j]= (dequantizer[j] * s->all_fragments[i].coeffs[j] + 2) >> 2;
2236
                    }
2237
                }
2238

    
2239
                /* invert DCT and place (or add) in final output */
2240
                
2241
                if (s->all_fragments[i].coding_method == MODE_INTRA) {
2242
                    if(s->avctx->idct_algo!=FF_IDCT_VP3)
2243
                        s->all_fragments[i].coeffs[0] += 128<<3;
2244
                    s->dsp.idct_put(
2245
                        output_plane + s->all_fragments[i].first_pixel,
2246
                        stride,
2247
                        s->all_fragments[i].coeffs);
2248
                } else {
2249
                    s->dsp.idct_add(
2250
                        output_plane + s->all_fragments[i].first_pixel,
2251
                        stride,
2252
                        s->all_fragments[i].coeffs);
2253
                }
2254
                memset(s->all_fragments[i].coeffs, 0, 64*sizeof(DCTELEM));
2255

    
2256
                debug_idct("block after idct_%s():\n",
2257
                    (s->all_fragments[i].coding_method == MODE_INTRA)?
2258
                    "put" : "add");
2259
                for (m = 0; m < 8; m++) {
2260
                    for (n = 0; n < 8; n++) {
2261
                        debug_idct(" %3d", *(output_plane + 
2262
                            s->all_fragments[i].first_pixel + (m * stride + n)));
2263
                    }
2264
                    debug_idct("\n");
2265
                }
2266
                debug_idct("\n");
2267

    
2268
            } else {
2269

    
2270
                /* copy directly from the previous frame */
2271
                s->dsp.put_pixels_tab[1][0](
2272
                    output_plane + s->all_fragments[i].first_pixel,
2273
                    last_plane + s->all_fragments[i].first_pixel,
2274
                    stride, 8);
2275

    
2276
            }
2277
        }
2278
    }
2279

    
2280
    emms_c();
2281
}
2282

    
2283
static void horizontal_filter(unsigned char *first_pixel, int stride,
2284
    int *bounding_values)
2285
{
2286
    unsigned char *end;
2287
    int filter_value;
2288

    
2289
    for (end= first_pixel + 8*stride; first_pixel < end; first_pixel += stride) {
2290
        filter_value = 
2291
            (first_pixel[-2] - first_pixel[ 1])
2292
         +3*(first_pixel[ 0] - first_pixel[-1]);
2293
        filter_value = bounding_values[(filter_value + 4) >> 3];
2294
        first_pixel[-1] = clip_uint8(first_pixel[-1] + filter_value);
2295
        first_pixel[ 0] = clip_uint8(first_pixel[ 0] - filter_value);
2296
    }
2297
}
2298

    
2299
static void vertical_filter(unsigned char *first_pixel, int stride,
2300
    int *bounding_values)
2301
{
2302
    unsigned char *end;
2303
    int filter_value;
2304
    const int nstride= -stride;
2305

    
2306
    for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
2307
        filter_value = 
2308
            (first_pixel[2 * nstride] - first_pixel[ stride])
2309
         +3*(first_pixel[0          ] - first_pixel[nstride]);
2310
        filter_value = bounding_values[(filter_value + 4) >> 3];
2311
        first_pixel[nstride] = clip_uint8(first_pixel[nstride] + filter_value);
2312
        first_pixel[0] = clip_uint8(first_pixel[0] - filter_value);
2313
    }
2314
}
2315

    
2316
static void apply_loop_filter(Vp3DecodeContext *s)
2317
{
2318
    int x, y, plane;
2319
    int width, height;
2320
    int fragment;
2321
    int stride;
2322
    unsigned char *plane_data;
2323

    
2324
    int bounding_values_array[256];
2325
    int *bounding_values= bounding_values_array+127;
2326
    int filter_limit;
2327

    
2328
    /* find the right loop limit value */
2329
    for (x = 63; x >= 0; x--) {
2330
        if (vp31_ac_scale_factor[x] >= s->quality_index)
2331
            break;
2332
    }
2333
    filter_limit = vp31_filter_limit_values[s->quality_index];
2334

    
2335
    /* set up the bounding values */
2336
    memset(bounding_values_array, 0, 256 * sizeof(int));
2337
    for (x = 0; x < filter_limit; x++) {
2338
        bounding_values[-x - filter_limit] = -filter_limit + x;
2339
        bounding_values[-x] = -x;
2340
        bounding_values[x] = x;
2341
        bounding_values[x + filter_limit] = filter_limit - x;
2342
    }
2343

    
2344
    for (plane = 0; plane < 3; plane++) {
2345

    
2346
        if (plane == 0) {
2347
            /* Y plane parameters */
2348
            fragment = 0;
2349
            width = s->fragment_width;
2350
            height = s->fragment_height;
2351
            stride = s->current_frame.linesize[0];
2352
            plane_data = s->current_frame.data[0];
2353
        } else if (plane == 1) {
2354
            /* U plane parameters */
2355
            fragment = s->u_fragment_start;
2356
            width = s->fragment_width / 2;
2357
            height = s->fragment_height / 2;
2358
            stride = s->current_frame.linesize[1];
2359
            plane_data = s->current_frame.data[1];
2360
        } else {
2361
            /* V plane parameters */
2362
            fragment = s->v_fragment_start;
2363
            width = s->fragment_width / 2;
2364
            height = s->fragment_height / 2;
2365
            stride = s->current_frame.linesize[2];
2366
            plane_data = s->current_frame.data[2];
2367
        }
2368

    
2369
        for (y = 0; y < height; y++) {
2370

    
2371
            for (x = 0; x < width; x++) {
2372
START_TIMER
2373
                /* do not perform left edge filter for left columns frags */
2374
                if ((x > 0) &&
2375
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2376
                    horizontal_filter(
2377
                        plane_data + s->all_fragments[fragment].first_pixel - 7*stride, 
2378
                        stride, bounding_values);
2379
                }
2380

    
2381
                /* do not perform top edge filter for top row fragments */
2382
                if ((y > 0) &&
2383
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2384
                    vertical_filter(
2385
                        plane_data + s->all_fragments[fragment].first_pixel + stride, 
2386
                        stride, bounding_values);
2387
                }
2388

    
2389
                /* do not perform right edge filter for right column
2390
                 * fragments or if right fragment neighbor is also coded
2391
                 * in this frame (it will be filtered in next iteration) */
2392
                if ((x < width - 1) &&
2393
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2394
                    (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
2395
                    horizontal_filter(
2396
                        plane_data + s->all_fragments[fragment + 1].first_pixel - 7*stride, 
2397
                        stride, bounding_values);
2398
                }
2399

    
2400
                /* do not perform bottom edge filter for bottom row
2401
                 * fragments or if bottom fragment neighbor is also coded
2402
                 * in this frame (it will be filtered in the next row) */
2403
                if ((y < height - 1) &&
2404
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2405
                    (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
2406
                    vertical_filter(
2407
                        plane_data + s->all_fragments[fragment + width].first_pixel + stride, 
2408
                        stride, bounding_values);
2409
                }
2410

    
2411
                fragment++;
2412
STOP_TIMER("loop filter")
2413
            }
2414
        }
2415
    }
2416
}
2417

    
2418
/* 
2419
 * This function computes the first pixel addresses for each fragment.
2420
 * This function needs to be invoked after the first frame is allocated
2421
 * so that it has access to the plane strides.
2422
 */
2423
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s) 
2424
{
2425

    
2426
    int i, x, y;
2427

    
2428
    /* figure out the first pixel addresses for each of the fragments */
2429
    /* Y plane */
2430
    i = 0;
2431
    for (y = s->fragment_height; y > 0; y--) {
2432
        for (x = 0; x < s->fragment_width; x++) {
2433
            s->all_fragments[i++].first_pixel = 
2434
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2435
                    s->golden_frame.linesize[0] +
2436
                    x * FRAGMENT_PIXELS;
2437
            debug_init("  fragment %d, first pixel @ %d\n", 
2438
                i-1, s->all_fragments[i-1].first_pixel);
2439
        }
2440
    }
2441

    
2442
    /* U plane */
2443
    i = s->u_fragment_start;
2444
    for (y = s->fragment_height / 2; y > 0; y--) {
2445
        for (x = 0; x < s->fragment_width / 2; x++) {
2446
            s->all_fragments[i++].first_pixel = 
2447
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2448
                    s->golden_frame.linesize[1] +
2449
                    x * FRAGMENT_PIXELS;
2450
            debug_init("  fragment %d, first pixel @ %d\n", 
2451
                i-1, s->all_fragments[i-1].first_pixel);
2452
        }
2453
    }
2454

    
2455
    /* V plane */
2456
    i = s->v_fragment_start;
2457
    for (y = s->fragment_height / 2; y > 0; y--) {
2458
        for (x = 0; x < s->fragment_width / 2; x++) {
2459
            s->all_fragments[i++].first_pixel = 
2460
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2461
                    s->golden_frame.linesize[2] +
2462
                    x * FRAGMENT_PIXELS;
2463
            debug_init("  fragment %d, first pixel @ %d\n", 
2464
                i-1, s->all_fragments[i-1].first_pixel);
2465
        }
2466
    }
2467
}
2468

    
2469
/* FIXME: this should be merged with the above! */
2470
static void theora_calculate_pixel_addresses(Vp3DecodeContext *s) 
2471
{
2472

    
2473
    int i, x, y;
2474

    
2475
    /* figure out the first pixel addresses for each of the fragments */
2476
    /* Y plane */
2477
    i = 0;
2478
    for (y = 1; y <= s->fragment_height; y++) {
2479
        for (x = 0; x < s->fragment_width; x++) {
2480
            s->all_fragments[i++].first_pixel = 
2481
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2482
                    s->golden_frame.linesize[0] +
2483
                    x * FRAGMENT_PIXELS;
2484
            debug_init("  fragment %d, first pixel @ %d\n", 
2485
                i-1, s->all_fragments[i-1].first_pixel);
2486
        }
2487
    }
2488

    
2489
    /* U plane */
2490
    i = s->u_fragment_start;
2491
    for (y = 1; y <= s->fragment_height / 2; y++) {
2492
        for (x = 0; x < s->fragment_width / 2; x++) {
2493
            s->all_fragments[i++].first_pixel = 
2494
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2495
                    s->golden_frame.linesize[1] +
2496
                    x * FRAGMENT_PIXELS;
2497
            debug_init("  fragment %d, first pixel @ %d\n", 
2498
                i-1, s->all_fragments[i-1].first_pixel);
2499
        }
2500
    }
2501

    
2502
    /* V plane */
2503
    i = s->v_fragment_start;
2504
    for (y = 1; y <= s->fragment_height / 2; y++) {
2505
        for (x = 0; x < s->fragment_width / 2; x++) {
2506
            s->all_fragments[i++].first_pixel = 
2507
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2508
                    s->golden_frame.linesize[2] +
2509
                    x * FRAGMENT_PIXELS;
2510
            debug_init("  fragment %d, first pixel @ %d\n", 
2511
                i-1, s->all_fragments[i-1].first_pixel);
2512
        }
2513
    }
2514
}
2515

    
2516
/*
2517
 * This is the ffmpeg/libavcodec API init function.
2518
 */
2519
static int vp3_decode_init(AVCodecContext *avctx)
2520
{
2521
    Vp3DecodeContext *s = avctx->priv_data;
2522
    int i;
2523
    int c_width;
2524
    int c_height;
2525
    int y_superblock_count;
2526
    int c_superblock_count;
2527

    
2528
    if (avctx->codec_tag == MKTAG('V','P','3','0'))
2529
        s->version = 0;
2530
    else
2531
        s->version = 1;
2532

    
2533
    s->avctx = avctx;
2534
    s->width = (avctx->width + 15) & 0xFFFFFFF0;
2535
    s->height = (avctx->height + 15) & 0xFFFFFFF0;
2536
    avctx->pix_fmt = PIX_FMT_YUV420P;
2537
    avctx->has_b_frames = 0;
2538
    if(avctx->idct_algo==FF_IDCT_AUTO)
2539
        avctx->idct_algo=FF_IDCT_VP3;
2540
    dsputil_init(&s->dsp, avctx);
2541
    
2542
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
2543

    
2544
    /* initialize to an impossible value which will force a recalculation
2545
     * in the first frame decode */
2546
    s->quality_index = -1;
2547

    
2548
    s->y_superblock_width = (s->width + 31) / 32;
2549
    s->y_superblock_height = (s->height + 31) / 32;
2550
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2551

    
2552
    /* work out the dimensions for the C planes */
2553
    c_width = s->width / 2;
2554
    c_height = s->height / 2;
2555
    s->c_superblock_width = (c_width + 31) / 32;
2556
    s->c_superblock_height = (c_height + 31) / 32;
2557
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2558

    
2559
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2560
    s->u_superblock_start = y_superblock_count;
2561
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
2562
    s->superblock_coding = av_malloc(s->superblock_count);
2563

    
2564
    s->macroblock_width = (s->width + 15) / 16;
2565
    s->macroblock_height = (s->height + 15) / 16;
2566
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
2567

    
2568
    s->fragment_width = s->width / FRAGMENT_PIXELS;
2569
    s->fragment_height = s->height / FRAGMENT_PIXELS;
2570

    
2571
    /* fragment count covers all 8x8 blocks for all 3 planes */
2572
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2573
    s->u_fragment_start = s->fragment_width * s->fragment_height;
2574
    s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2575

    
2576
    debug_init("  Y plane: %d x %d\n", s->width, s->height);
2577
    debug_init("  C plane: %d x %d\n", c_width, c_height);
2578
    debug_init("  Y superblocks: %d x %d, %d total\n",
2579
        s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2580
    debug_init("  C superblocks: %d x %d, %d total\n",
2581
        s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2582
    debug_init("  total superblocks = %d, U starts @ %d, V starts @ %d\n", 
2583
        s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2584
    debug_init("  macroblocks: %d x %d, %d total\n",
2585
        s->macroblock_width, s->macroblock_height, s->macroblock_count);
2586
    debug_init("  %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2587
        s->fragment_count,
2588
        s->fragment_width,
2589
        s->fragment_height,
2590
        s->u_fragment_start,
2591
        s->v_fragment_start);
2592

    
2593
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2594
    s->coeffs = av_malloc(s->fragment_count * sizeof(DCTELEM) * 64);
2595
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2596
    s->pixel_addresses_inited = 0;
2597

    
2598
    if (!s->theora_tables)
2599
    {
2600
        for (i = 0; i < 64; i++)
2601
            s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2602
        for (i = 0; i < 64; i++)
2603
            s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
2604
        for (i = 0; i < 64; i++)
2605
            s->coded_intra_y_dequant[i] = vp31_intra_y_dequant[i];
2606
        for (i = 0; i < 64; i++)
2607
            s->coded_intra_c_dequant[i] = vp31_intra_c_dequant[i];
2608
        for (i = 0; i < 64; i++)
2609
            s->coded_inter_dequant[i] = vp31_inter_dequant[i];
2610
    }
2611

    
2612
    /* init VLC tables */
2613
    for (i = 0; i < 16; i++) {
2614

    
2615
        /* DC histograms */
2616
        init_vlc(&s->dc_vlc[i], 5, 32,
2617
            &dc_bias[i][0][1], 4, 2,
2618
            &dc_bias[i][0][0], 4, 2, 0);
2619

    
2620
        /* group 1 AC histograms */
2621
        init_vlc(&s->ac_vlc_1[i], 5, 32,
2622
            &ac_bias_0[i][0][1], 4, 2,
2623
            &ac_bias_0[i][0][0], 4, 2, 0);
2624

    
2625
        /* group 2 AC histograms */
2626
        init_vlc(&s->ac_vlc_2[i], 5, 32,
2627
            &ac_bias_1[i][0][1], 4, 2,
2628
            &ac_bias_1[i][0][0], 4, 2, 0);
2629

    
2630
        /* group 3 AC histograms */
2631
        init_vlc(&s->ac_vlc_3[i], 5, 32,
2632
            &ac_bias_2[i][0][1], 4, 2,
2633
            &ac_bias_2[i][0][0], 4, 2, 0);
2634

    
2635
        /* group 4 AC histograms */
2636
        init_vlc(&s->ac_vlc_4[i], 5, 32,
2637
            &ac_bias_3[i][0][1], 4, 2,
2638
            &ac_bias_3[i][0][0], 4, 2, 0);
2639
    }
2640

    
2641
    init_vlc(&s->superblock_run_length_vlc, 6, 34,
2642
        &superblock_run_length_vlc_table[0][1], 4, 2,
2643
        &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2644

    
2645
    init_vlc(&s->fragment_run_length_vlc, 5, 31,
2646
        &fragment_run_length_vlc_table[0][1], 4, 2,
2647
        &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2648

    
2649
    init_vlc(&s->mode_code_vlc, 3, 8,
2650
        &mode_code_vlc_table[0][1], 2, 1,
2651
        &mode_code_vlc_table[0][0], 2, 1, 0);
2652

    
2653
    init_vlc(&s->motion_vector_vlc, 6, 63,
2654
        &motion_vector_vlc_table[0][1], 2, 1,
2655
        &motion_vector_vlc_table[0][0], 2, 1, 0);
2656

    
2657
    /* work out the block mapping tables */
2658
    s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2659
    s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2660
    s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
2661
    s->macroblock_coding = av_malloc(s->macroblock_count + 1);
2662
    init_block_mapping(s);
2663

    
2664
    for (i = 0; i < 3; i++) {
2665
        s->current_frame.data[i] = NULL;
2666
        s->last_frame.data[i] = NULL;
2667
        s->golden_frame.data[i] = NULL;
2668
    }
2669

    
2670
    return 0;
2671
}
2672

    
2673
/*
2674
 * This is the ffmpeg/libavcodec API frame decode function.
2675
 */
2676
static int vp3_decode_frame(AVCodecContext *avctx, 
2677
                            void *data, int *data_size,
2678
                            uint8_t *buf, int buf_size)
2679
{
2680
    Vp3DecodeContext *s = avctx->priv_data;
2681
    GetBitContext gb;
2682
    static int counter = 0;
2683

    
2684
    init_get_bits(&gb, buf, buf_size * 8);
2685
    
2686
    if (s->theora && get_bits1(&gb))
2687
    {
2688
        int ptype = get_bits(&gb, 7);
2689

    
2690
        skip_bits(&gb, 6*8); /* "theora" */
2691
        
2692
        switch(ptype)
2693
        {
2694
            case 1:
2695
                theora_decode_comments(avctx, gb);
2696
                break;
2697
            case 2:
2698
                theora_decode_tables(avctx, gb);
2699
                    init_dequantizer(s);
2700
                break;
2701
            default:
2702
                av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype);
2703
        }
2704
        return buf_size;
2705
    }
2706

    
2707
    s->keyframe = !get_bits1(&gb);
2708
    if (!s->theora)
2709
        skip_bits(&gb, 1);
2710
    s->last_quality_index = s->quality_index;
2711
    s->quality_index = get_bits(&gb, 6);
2712
    if (s->theora >= 0x030200)
2713
        skip_bits1(&gb);
2714

    
2715
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2716
        av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2717
            s->keyframe?"key":"", counter, s->quality_index);
2718
    counter++;
2719

    
2720
    if (s->quality_index != s->last_quality_index)
2721
        init_dequantizer(s);
2722

    
2723
    if (s->keyframe) {
2724
        if (!s->theora)
2725
        {
2726
            skip_bits(&gb, 4); /* width code */
2727
            skip_bits(&gb, 4); /* height code */
2728
            if (s->version)
2729
            {
2730
                s->version = get_bits(&gb, 5);
2731
                if (counter == 1)
2732
                    av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
2733
            }
2734
        }
2735
        if (s->version || s->theora)
2736
        {
2737
                if (get_bits1(&gb))
2738
                    av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
2739
            skip_bits(&gb, 2); /* reserved? */
2740
        }
2741

    
2742
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2743
            if (s->golden_frame.data[0])
2744
                avctx->release_buffer(avctx, &s->golden_frame);
2745
            s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
2746
        } else {
2747
            if (s->golden_frame.data[0])
2748
                avctx->release_buffer(avctx, &s->golden_frame);
2749
            if (s->last_frame.data[0])
2750
                avctx->release_buffer(avctx, &s->last_frame);
2751
        }
2752

    
2753
        s->golden_frame.reference = 3;
2754
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2755
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2756
            return -1;
2757
        }
2758

    
2759
        /* golden frame is also the current frame */
2760
        memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
2761

    
2762
        /* time to figure out pixel addresses? */
2763
        if (!s->pixel_addresses_inited)
2764
        {
2765
            if (!s->flipped_image)
2766
                vp3_calculate_pixel_addresses(s);
2767
            else
2768
                theora_calculate_pixel_addresses(s);
2769
        }
2770
    } else {
2771
        /* allocate a new current frame */
2772
        s->current_frame.reference = 3;
2773
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2774
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2775
            return -1;
2776
        }
2777
    }
2778

    
2779
    s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2780
    s->current_frame.qstride= 0;
2781

    
2782
    {START_TIMER
2783
    init_frame(s, &gb);
2784
    STOP_TIMER("init_frame")}
2785

    
2786
#if KEYFRAMES_ONLY
2787
if (!s->keyframe) {
2788

    
2789
    memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2790
        s->current_frame.linesize[0] * s->height);
2791
    memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2792
        s->current_frame.linesize[1] * s->height / 2);
2793
    memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2794
        s->current_frame.linesize[2] * s->height / 2);
2795

    
2796
} else {
2797
#endif
2798

    
2799
    {START_TIMER
2800
    if (unpack_superblocks(s, &gb)){
2801
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2802
        return -1;
2803
    }
2804
    STOP_TIMER("unpack_superblocks")}
2805
    {START_TIMER
2806
    if (unpack_modes(s, &gb)){
2807
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2808
        return -1;
2809
    }
2810
    STOP_TIMER("unpack_modes")}
2811
    {START_TIMER
2812
    if (unpack_vectors(s, &gb)){
2813
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2814
        return -1;
2815
    }
2816
    STOP_TIMER("unpack_vectors")}
2817
    {START_TIMER
2818
    if (unpack_dct_coeffs(s, &gb)){
2819
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2820
        return -1;
2821
    }
2822
    STOP_TIMER("unpack_dct_coeffs")}
2823
    {START_TIMER
2824

    
2825
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2826
    STOP_TIMER("reverse_dc_prediction")}
2827
    {START_TIMER
2828
    render_fragments(s, 0, s->width, s->height, 0);
2829
    STOP_TIMER("render_fragments")}
2830

    
2831
    if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2832
        reverse_dc_prediction(s, s->u_fragment_start,
2833
            s->fragment_width / 2, s->fragment_height / 2);
2834
        reverse_dc_prediction(s, s->v_fragment_start,
2835
            s->fragment_width / 2, s->fragment_height / 2);
2836
        render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
2837
        render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
2838
    } else {
2839
        memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
2840
        memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
2841
    }
2842

    
2843
    {START_TIMER
2844
    apply_loop_filter(s);
2845
    STOP_TIMER("apply_loop_filter")}
2846
#if KEYFRAMES_ONLY
2847
}
2848
#endif
2849

    
2850
    *data_size=sizeof(AVFrame);
2851
    *(AVFrame*)data= s->current_frame;
2852

    
2853
    /* release the last frame, if it is allocated and if it is not the
2854
     * golden frame */
2855
    if ((s->last_frame.data[0]) &&
2856
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2857
        avctx->release_buffer(avctx, &s->last_frame);
2858

    
2859
    /* shuffle frames (last = current) */
2860
    memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));
2861
    s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
2862

    
2863
    return buf_size;
2864
}
2865

    
2866
/*
2867
 * This is the ffmpeg/libavcodec API module cleanup function.
2868
 */
2869
static int vp3_decode_end(AVCodecContext *avctx)
2870
{
2871
    Vp3DecodeContext *s = avctx->priv_data;
2872

    
2873
    av_free(s->all_fragments);
2874
    av_free(s->coeffs);
2875
    av_free(s->coded_fragment_list);
2876
    av_free(s->superblock_fragments);
2877
    av_free(s->superblock_macroblocks);
2878
    av_free(s->macroblock_fragments);
2879
    av_free(s->macroblock_coding);
2880
    
2881
    /* release all frames */
2882
    if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2883
        avctx->release_buffer(avctx, &s->golden_frame);
2884
    if (s->last_frame.data[0])
2885
        avctx->release_buffer(avctx, &s->last_frame);
2886
    /* no need to release the current_frame since it will always be pointing
2887
     * to the same frame as either the golden or last frame */
2888

    
2889
    return 0;
2890
}
2891

    
2892
static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
2893
{
2894
    Vp3DecodeContext *s = avctx->priv_data;
2895
    int major, minor, micro;
2896

    
2897
    major = get_bits(&gb, 8); /* version major */
2898
    minor = get_bits(&gb, 8); /* version minor */
2899
    micro = get_bits(&gb, 8); /* version micro */
2900
    av_log(avctx, AV_LOG_INFO, "Theora bitstream version %d.%d.%d\n",
2901
        major, minor, micro);
2902

    
2903
    /* FIXME: endianess? */
2904
    s->theora = (major << 16) | (minor << 8) | micro;
2905

    
2906
    /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
2907
    /* but previous versions have the image flipped relative to vp3 */
2908
    if (s->theora < 0x030200)
2909
    {
2910
        s->flipped_image = 1;
2911
        av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
2912
    }
2913

    
2914
    s->width = get_bits(&gb, 16) << 4;
2915
    s->height = get_bits(&gb, 16) << 4;
2916
    
2917
    if(avcodec_check_dimensions(avctx, s->width, s->height)){
2918
        s->width= s->height= 0;
2919
        return -1;
2920
    }
2921
    
2922
    skip_bits(&gb, 24); /* frame width */
2923
    skip_bits(&gb, 24); /* frame height */
2924

    
2925
    skip_bits(&gb, 8); /* offset x */
2926
    skip_bits(&gb, 8); /* offset y */
2927

    
2928
    skip_bits(&gb, 32); /* fps numerator */
2929
    skip_bits(&gb, 32); /* fps denumerator */
2930
    skip_bits(&gb, 24); /* aspect numerator */
2931
    skip_bits(&gb, 24); /* aspect denumerator */
2932
    
2933
    if (s->theora < 0x030200)
2934
        skip_bits(&gb, 5); /* keyframe frequency force */
2935
    skip_bits(&gb, 8); /* colorspace */
2936
    skip_bits(&gb, 24); /* bitrate */
2937

    
2938
    skip_bits(&gb, 6); /* last(?) quality index */
2939
    
2940
    if (s->theora >= 0x030200)
2941
    {
2942
        skip_bits(&gb, 5); /* keyframe frequency force */
2943
        skip_bits(&gb, 5); /* spare bits */
2944
    }
2945
    
2946
//    align_get_bits(&gb);
2947
    
2948
    avctx->width = s->width;
2949
    avctx->height = s->height;
2950

    
2951
    return 0;
2952
}
2953

    
2954
static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb)
2955
{
2956
    int nb_comments, i, tmp;
2957

    
2958
    tmp = get_bits_long(&gb, 32);
2959
    tmp = be2me_32(tmp);
2960
    while(tmp--)
2961
            skip_bits(&gb, 8);
2962

    
2963
    nb_comments = get_bits_long(&gb, 32);
2964
    nb_comments = be2me_32(nb_comments);
2965
    for (i = 0; i < nb_comments; i++)
2966
    {
2967
        tmp = get_bits_long(&gb, 32);
2968
        tmp = be2me_32(tmp);
2969
        while(tmp--)
2970
            skip_bits(&gb, 8);
2971
    }
2972
    
2973
    return 0;
2974
}
2975

    
2976
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb)
2977
{
2978
    Vp3DecodeContext *s = avctx->priv_data;
2979
    int i, n;
2980

    
2981
    if (s->theora >= 0x030200) {
2982
        n = get_bits(&gb, 3);
2983
        /* loop filter table */
2984
        for (i = 0; i < 64; i++)
2985
            skip_bits(&gb, n);
2986
    }
2987
    
2988
    if (s->theora >= 0x030200)
2989
        n = get_bits(&gb, 4) + 1;
2990
    else
2991
        n = 16;
2992
    /* quality threshold table */
2993
    for (i = 0; i < 64; i++)
2994
        s->coded_ac_scale_factor[i] = get_bits(&gb, n);
2995

    
2996
    if (s->theora >= 0x030200)
2997
        n = get_bits(&gb, 4) + 1;
2998
    else
2999
        n = 16;
3000
    /* dc scale factor table */
3001
    for (i = 0; i < 64; i++)
3002
        s->coded_dc_scale_factor[i] = get_bits(&gb, n);
3003

    
3004
    if (s->theora >= 0x030200)
3005
        n = get_bits(&gb, 9) + 1;
3006
    else
3007
        n = 3;
3008
    if (n != 3) {
3009
        av_log(NULL,AV_LOG_ERROR, "unsupported nbms : %d\n", n);
3010
        return -1;
3011
    }
3012
    /* y coeffs */
3013
    for (i = 0; i < 64; i++)
3014
        s->coded_intra_y_dequant[i] = get_bits(&gb, 8);
3015

    
3016
    /* uv coeffs */
3017
    for (i = 0; i < 64; i++)
3018
        s->coded_intra_c_dequant[i] = get_bits(&gb, 8);
3019

    
3020
    /* inter coeffs */
3021
    for (i = 0; i < 64; i++)
3022
        s->coded_inter_dequant[i] = get_bits(&gb, 8);
3023

    
3024
    /* FIXME: read huffmann tree.. */
3025
    
3026
    s->theora_tables = 1;
3027
    
3028
    return 0;
3029
}
3030

    
3031
static int theora_decode_init(AVCodecContext *avctx)
3032
{
3033
    Vp3DecodeContext *s = avctx->priv_data;
3034
    GetBitContext gb;
3035
    int ptype;
3036
    uint8_t *p= avctx->extradata;
3037
    int op_bytes, i;
3038
    
3039
    s->theora = 1;
3040

    
3041
    if (!avctx->extradata_size)
3042
        return -1;
3043

    
3044
  for(i=0;i<3;i++) {
3045
    op_bytes = *(p++)<<8;
3046
    op_bytes += *(p++);
3047

    
3048
    init_get_bits(&gb, p, op_bytes);
3049
    p += op_bytes;
3050

    
3051
    ptype = get_bits(&gb, 8);
3052
    debug_vp3("Theora headerpacket type: %x\n", ptype);
3053
            
3054
    if (!(ptype & 0x80))
3055
        return -1;
3056
        
3057
    skip_bits(&gb, 6*8); /* "theora" */
3058
        
3059
    switch(ptype)
3060
    {
3061
        case 0x80:
3062
            theora_decode_header(avctx, gb);
3063
                break;
3064
        case 0x81:
3065
            theora_decode_comments(avctx, gb);
3066
            break;
3067
        case 0x82:
3068
            theora_decode_tables(avctx, gb);
3069
            break;
3070
    }
3071
  }
3072

    
3073
    vp3_decode_init(avctx);
3074
    return 0;
3075
}
3076

    
3077
AVCodec vp3_decoder = {
3078
    "vp3",
3079
    CODEC_TYPE_VIDEO,
3080
    CODEC_ID_VP3,
3081
    sizeof(Vp3DecodeContext),
3082
    vp3_decode_init,
3083
    NULL,
3084
    vp3_decode_end,
3085
    vp3_decode_frame,
3086
    0,
3087
    NULL
3088
};
3089

    
3090
#ifndef CONFIG_LIBTHEORA
3091
AVCodec theora_decoder = {
3092
    "theora",
3093
    CODEC_TYPE_VIDEO,
3094
    CODEC_ID_THEORA,
3095
    sizeof(Vp3DecodeContext),
3096
    theora_decode_init,
3097
    NULL,
3098
    vp3_decode_end,
3099
    vp3_decode_frame,
3100
    0,
3101
    NULL
3102
};
3103
#endif