Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ 39922395

History | View | Annotate | Download (108 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 Coeff {
138
    struct Coeff *next;
139
    DCTELEM coeff;
140
    uint8_t index;
141
} Coeff;
142

    
143
//FIXME split things out into their own arrays
144
typedef struct Vp3Fragment {
145
    Coeff *next_coeff;
146
    /* address of first pixel taking into account which plane the fragment
147
     * lives on as well as the plane stride */
148
    int first_pixel;
149
    /* this is the macroblock that the fragment belongs to */
150
    uint16_t macroblock;
151
    uint8_t coding_method;
152
    uint8_t coeff_count;
153
    int8_t motion_x;
154
    int8_t motion_y;
155
} Vp3Fragment;
156

    
157
#define SB_NOT_CODED        0
158
#define SB_PARTIALLY_CODED  1
159
#define SB_FULLY_CODED      2
160

    
161
#define MODE_INTER_NO_MV      0
162
#define MODE_INTRA            1
163
#define MODE_INTER_PLUS_MV    2
164
#define MODE_INTER_LAST_MV    3
165
#define MODE_INTER_PRIOR_LAST 4
166
#define MODE_USING_GOLDEN     5
167
#define MODE_GOLDEN_MV        6
168
#define MODE_INTER_FOURMV     7
169
#define CODING_MODE_COUNT     8
170

    
171
/* special internal mode */
172
#define MODE_COPY             8
173

    
174
/* There are 6 preset schemes, plus a free-form scheme */
175
static int ModeAlphabet[7][CODING_MODE_COUNT] =
176
{
177
    /* this is the custom scheme */
178
    { 0, 0, 0, 0, 0, 0, 0, 0 },
179

    
180
    /* scheme 1: Last motion vector dominates */
181
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,  
182
         MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
183
         MODE_INTRA,            MODE_USING_GOLDEN,      
184
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
185

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

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

    
198
    /* scheme 4 */
199
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,     
200
         MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
201
         MODE_INTRA,            MODE_USING_GOLDEN,      
202
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
203

    
204
    /* scheme 5: No motion vector dominates */
205
    {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,     
206
         MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
207
         MODE_INTRA,            MODE_USING_GOLDEN,      
208
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
209

    
210
    /* scheme 6 */
211
    {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,      
212
         MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
213
         MODE_INTER_PLUS_MV,    MODE_INTRA,             
214
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
215

    
216
};
217

    
218
#define MIN_DEQUANT_VAL 2
219

    
220
typedef struct Vp3DecodeContext {
221
    AVCodecContext *avctx;
222
    int theora, theora_tables;
223
    int version;
224
    int width, height;
225
    AVFrame golden_frame;
226
    AVFrame last_frame;
227
    AVFrame current_frame;
228
    int keyframe;
229
    DSPContext dsp;
230
    int flipped_image;
231

    
232
    int quality_index;
233
    int last_quality_index;
234

    
235
    int superblock_count;
236
    int superblock_width;
237
    int superblock_height;
238
    int y_superblock_width;
239
    int y_superblock_height;
240
    int c_superblock_width;
241
    int c_superblock_height;
242
    int u_superblock_start;
243
    int v_superblock_start;
244
    unsigned char *superblock_coding;
245

    
246
    int macroblock_count;
247
    int macroblock_width;
248
    int macroblock_height;
249

    
250
    int fragment_count;
251
    int fragment_width;
252
    int fragment_height;
253

    
254
    Vp3Fragment *all_fragments;
255
    Coeff *coeffs;
256
    Coeff *next_coeff;
257
    int u_fragment_start;
258
    int v_fragment_start;
259
    
260
    ScanTable scantable;
261
    
262
    /* tables */
263
    uint16_t coded_dc_scale_factor[64];
264
    uint32_t coded_ac_scale_factor[64];
265
    uint16_t coded_intra_y_dequant[64];
266
    uint16_t coded_intra_c_dequant[64];
267
    uint16_t coded_inter_dequant[64];
268

    
269
    /* this is a list of indices into the all_fragments array indicating
270
     * which of the fragments are coded */
271
    int *coded_fragment_list;
272
    int coded_fragment_list_index;
273
    int pixel_addresses_inited;
274

    
275
    VLC dc_vlc[16];
276
    VLC ac_vlc_1[16];
277
    VLC ac_vlc_2[16];
278
    VLC ac_vlc_3[16];
279
    VLC ac_vlc_4[16];
280

    
281
    VLC superblock_run_length_vlc;
282
    VLC fragment_run_length_vlc;
283
    VLC mode_code_vlc;
284
    VLC motion_vector_vlc;
285

    
286
    /* these arrays need to be on 16-byte boundaries since SSE2 operations
287
     * index into them */
288
    int16_t __align16 intra_y_dequant[64];
289
    int16_t __align16 intra_c_dequant[64];
290
    int16_t __align16 inter_dequant[64];
291

    
292
    /* This table contains superblock_count * 16 entries. Each set of 16
293
     * numbers corresponds to the fragment indices 0..15 of the superblock.
294
     * An entry will be -1 to indicate that no entry corresponds to that
295
     * index. */
296
    int *superblock_fragments;
297

    
298
    /* This table contains superblock_count * 4 entries. Each set of 4
299
     * numbers corresponds to the macroblock indices 0..3 of the superblock.
300
     * An entry will be -1 to indicate that no entry corresponds to that
301
     * index. */
302
    int *superblock_macroblocks;
303

    
304
    /* This table contains macroblock_count * 6 entries. Each set of 6
305
     * numbers corresponds to the fragment indices 0..5 which comprise
306
     * the macroblock (4 Y fragments and 2 C fragments). */
307
    int *macroblock_fragments;
308
    /* This is an array that indicates how a particular macroblock 
309
     * is coded. */
310
    unsigned char *macroblock_coding;
311

    
312
    int first_coded_y_fragment;
313
    int first_coded_c_fragment;
314
    int last_coded_y_fragment;
315
    int last_coded_c_fragment;
316

    
317
    uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
318
    uint8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
319

    
320
     /* Huffman decode */
321
     int hti;
322
     unsigned int hbits;
323
     int entries;
324
     int huff_code_size;
325
     uint16_t huffman_table[80][32][2];
326
} Vp3DecodeContext;
327

    
328
static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb);
329
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb);
330

    
331
/************************************************************************
332
 * VP3 specific functions
333
 ************************************************************************/
334

    
335
/*
336
 * This function sets up all of the various blocks mappings:
337
 * superblocks <-> fragments, macroblocks <-> fragments,
338
 * superblocks <-> macroblocks
339
 *
340
 * Returns 0 is successful; returns 1 if *anything* went wrong.
341
 */
342
static int init_block_mapping(Vp3DecodeContext *s) 
343
{
344
    int i, j;
345
    signed int hilbert_walk_y[16];
346
    signed int hilbert_walk_c[16];
347
    signed int hilbert_walk_mb[4];
348

    
349
    int current_fragment = 0;
350
    int current_width = 0;
351
    int current_height = 0;
352
    int right_edge = 0;
353
    int bottom_edge = 0;
354
    int superblock_row_inc = 0;
355
    int *hilbert = NULL;
356
    int mapping_index = 0;
357

    
358
    int current_macroblock;
359
    int c_fragment;
360

    
361
    signed char travel_width[16] = {
362
         1,  1,  0, -1, 
363
         0,  0,  1,  0,
364
         1,  0,  1,  0,
365
         0, -1,  0,  1
366
    };
367

    
368
    signed char travel_height[16] = {
369
         0,  0,  1,  0,
370
         1,  1,  0, -1,
371
         0,  1,  0, -1,
372
        -1,  0, -1,  0
373
    };
374

    
375
    signed char travel_width_mb[4] = {
376
         1,  0,  1,  0
377
    };
378

    
379
    signed char travel_height_mb[4] = {
380
         0,  1,  0, -1
381
    };
382

    
383
    debug_vp3("  vp3: initialize block mapping tables\n");
384

    
385
    /* figure out hilbert pattern per these frame dimensions */
386
    hilbert_walk_y[0]  = 1;
387
    hilbert_walk_y[1]  = 1;
388
    hilbert_walk_y[2]  = s->fragment_width;
389
    hilbert_walk_y[3]  = -1;
390
    hilbert_walk_y[4]  = s->fragment_width;
391
    hilbert_walk_y[5]  = s->fragment_width;
392
    hilbert_walk_y[6]  = 1;
393
    hilbert_walk_y[7]  = -s->fragment_width;
394
    hilbert_walk_y[8]  = 1;
395
    hilbert_walk_y[9]  = s->fragment_width;
396
    hilbert_walk_y[10]  = 1;
397
    hilbert_walk_y[11] = -s->fragment_width;
398
    hilbert_walk_y[12] = -s->fragment_width;
399
    hilbert_walk_y[13] = -1;
400
    hilbert_walk_y[14] = -s->fragment_width;
401
    hilbert_walk_y[15] = 1;
402

    
403
    hilbert_walk_c[0]  = 1;
404
    hilbert_walk_c[1]  = 1;
405
    hilbert_walk_c[2]  = s->fragment_width / 2;
406
    hilbert_walk_c[3]  = -1;
407
    hilbert_walk_c[4]  = s->fragment_width / 2;
408
    hilbert_walk_c[5]  = s->fragment_width / 2;
409
    hilbert_walk_c[6]  = 1;
410
    hilbert_walk_c[7]  = -s->fragment_width / 2;
411
    hilbert_walk_c[8]  = 1;
412
    hilbert_walk_c[9]  = s->fragment_width / 2;
413
    hilbert_walk_c[10]  = 1;
414
    hilbert_walk_c[11] = -s->fragment_width / 2;
415
    hilbert_walk_c[12] = -s->fragment_width / 2;
416
    hilbert_walk_c[13] = -1;
417
    hilbert_walk_c[14] = -s->fragment_width / 2;
418
    hilbert_walk_c[15] = 1;
419

    
420
    hilbert_walk_mb[0] = 1;
421
    hilbert_walk_mb[1] = s->macroblock_width;
422
    hilbert_walk_mb[2] = 1;
423
    hilbert_walk_mb[3] = -s->macroblock_width;
424

    
425
    /* iterate through each superblock (all planes) and map the fragments */
426
    for (i = 0; i < s->superblock_count; i++) {
427
        debug_init("    superblock %d (u starts @ %d, v starts @ %d)\n",
428
            i, s->u_superblock_start, s->v_superblock_start);
429

    
430
        /* time to re-assign the limits? */
431
        if (i == 0) {
432

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

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

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

    
447
            /* start of U superblocks */
448
            right_edge = s->fragment_width / 2;
449
            bottom_edge = s->fragment_height / 2;
450
            current_width = -1;
451
            current_height = 0;
452
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
453
                (s->c_superblock_width * 4 - s->fragment_width / 2);
454
            hilbert = hilbert_walk_c;
455

    
456
            /* the first operation for this variable is to advance by 1 */
457
            current_fragment = s->u_fragment_start - 1;
458

    
459
        } else if (i == s->v_superblock_start) {
460

    
461
            /* start of V superblocks */
462
            right_edge = s->fragment_width / 2;
463
            bottom_edge = s->fragment_height / 2;
464
            current_width = -1;
465
            current_height = 0;
466
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
467
                (s->c_superblock_width * 4 - s->fragment_width / 2);
468
            hilbert = hilbert_walk_c;
469

    
470
            /* the first operation for this variable is to advance by 1 */
471
            current_fragment = s->v_fragment_start - 1;
472

    
473
        }
474

    
475
        if (current_width >= right_edge - 1) {
476
            /* reset width and move to next superblock row */
477
            current_width = -1;
478
            current_height += 4;
479

    
480
            /* fragment is now at the start of a new superblock row */
481
            current_fragment += superblock_row_inc;
482
        }
483

    
484
        /* iterate through all 16 fragments in a superblock */
485
        for (j = 0; j < 16; j++) {
486
            current_fragment += hilbert[j];
487
            current_width += travel_width[j];
488
            current_height += travel_height[j];
489

    
490
            /* check if the fragment is in bounds */
491
            if ((current_width < right_edge) &&
492
                (current_height < bottom_edge)) {
493
                s->superblock_fragments[mapping_index] = current_fragment;
494
                debug_init("    mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n", 
495
                    s->superblock_fragments[mapping_index], i, j,
496
                    current_width, right_edge, current_height, bottom_edge);
497
            } else {
498
                s->superblock_fragments[mapping_index] = -1;
499
                debug_init("    superblock %d, position %d has no fragment (%d/%d x %d/%d)\n", 
500
                    i, j,
501
                    current_width, right_edge, current_height, bottom_edge);
502
            }
503

    
504
            mapping_index++;
505
        }
506
    }
507

    
508
    /* initialize the superblock <-> macroblock mapping; iterate through
509
     * all of the Y plane superblocks to build this mapping */
510
    right_edge = s->macroblock_width;
511
    bottom_edge = s->macroblock_height;
512
    current_width = -1;
513
    current_height = 0;
514
    superblock_row_inc = s->macroblock_width -
515
        (s->y_superblock_width * 2 - s->macroblock_width);;
516
    hilbert = hilbert_walk_mb;
517
    mapping_index = 0;
518
    current_macroblock = -1;
519
    for (i = 0; i < s->u_superblock_start; i++) {
520

    
521
        if (current_width >= right_edge - 1) {
522
            /* reset width and move to next superblock row */
523
            current_width = -1;
524
            current_height += 2;
525

    
526
            /* macroblock is now at the start of a new superblock row */
527
            current_macroblock += superblock_row_inc;
528
        }
529

    
530
        /* iterate through each potential macroblock in the superblock */
531
        for (j = 0; j < 4; j++) {
532
            current_macroblock += hilbert_walk_mb[j];
533
            current_width += travel_width_mb[j];
534
            current_height += travel_height_mb[j];
535

    
536
            /* check if the macroblock is in bounds */
537
            if ((current_width < right_edge) &&
538
                (current_height < bottom_edge)) {
539
                s->superblock_macroblocks[mapping_index] = current_macroblock;
540
                debug_init("    mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
541
                    s->superblock_macroblocks[mapping_index], i, j,
542
                    current_width, right_edge, current_height, bottom_edge);
543
            } else {
544
                s->superblock_macroblocks[mapping_index] = -1;
545
                debug_init("    superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
546
                    i, j,
547
                    current_width, right_edge, current_height, bottom_edge);
548
            }
549

    
550
            mapping_index++;
551
        }
552
    }
553

    
554
    /* initialize the macroblock <-> fragment mapping */
555
    current_fragment = 0;
556
    current_macroblock = 0;
557
    mapping_index = 0;
558
    for (i = 0; i < s->fragment_height; i += 2) {
559

    
560
        for (j = 0; j < s->fragment_width; j += 2) {
561

    
562
            debug_init("    macroblock %d contains fragments: ", current_macroblock);
563
            s->all_fragments[current_fragment].macroblock = current_macroblock;
564
            s->macroblock_fragments[mapping_index++] = current_fragment;
565
            debug_init("%d ", current_fragment);
566

    
567
            if (j + 1 < s->fragment_width) {
568
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
569
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
570
                debug_init("%d ", current_fragment + 1);
571
            } else
572
                s->macroblock_fragments[mapping_index++] = -1;
573

    
574
            if (i + 1 < s->fragment_height) {
575
                s->all_fragments[current_fragment + s->fragment_width].macroblock = 
576
                    current_macroblock;
577
                s->macroblock_fragments[mapping_index++] = 
578
                    current_fragment + s->fragment_width;
579
                debug_init("%d ", current_fragment + s->fragment_width);
580
            } else
581
                s->macroblock_fragments[mapping_index++] = -1;
582

    
583
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
584
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock = 
585
                    current_macroblock;
586
                s->macroblock_fragments[mapping_index++] = 
587
                    current_fragment + s->fragment_width + 1;
588
                debug_init("%d ", current_fragment + s->fragment_width + 1);
589
            } else
590
                s->macroblock_fragments[mapping_index++] = -1;
591

    
592
            /* C planes */
593
            c_fragment = s->u_fragment_start + 
594
                (i * s->fragment_width / 4) + (j / 2);
595
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
596
            s->macroblock_fragments[mapping_index++] = c_fragment;
597
            debug_init("%d ", c_fragment);
598

    
599
            c_fragment = s->v_fragment_start + 
600
                (i * s->fragment_width / 4) + (j / 2);
601
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
602
            s->macroblock_fragments[mapping_index++] = c_fragment;
603
            debug_init("%d ", c_fragment);
604

    
605
            debug_init("\n");
606

    
607
            if (j + 2 <= s->fragment_width)
608
                current_fragment += 2;
609
            else 
610
                current_fragment++;
611
            current_macroblock++;
612
        }
613

    
614
        current_fragment += s->fragment_width;
615
    }
616

    
617
    return 0;  /* successful path out */
618
}
619

    
620
/*
621
 * This function unpacks a single token (which should be in the range 0..31)
622
 * and returns a zero run (number of zero coefficients in current DCT matrix
623
 * before next non-zero coefficient), the next DCT coefficient, and the
624
 * number of consecutive, non-EOB'd DCT blocks to EOB.
625
 */
626
static void unpack_token(GetBitContext *gb, int token, int *zero_run,
627
                         DCTELEM *coeff, int *eob_run) 
628
{
629
    int sign;
630

    
631
    *zero_run = 0;
632
    *eob_run = 0;
633
    *coeff = 0;
634

    
635
    debug_token("    vp3 token %d: ", token);
636
    switch (token) {
637

    
638
    case 0:
639
        debug_token("DCT_EOB_TOKEN, EOB next block\n");
640
        *eob_run = 1;
641
        break;
642

    
643
    case 1:
644
        debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
645
        *eob_run = 2;
646
        break;
647

    
648
    case 2:
649
        debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
650
        *eob_run = 3;
651
        break;
652

    
653
    case 3:
654
        debug_token("DCT_REPEAT_RUN_TOKEN, ");
655
        *eob_run = get_bits(gb, 2) + 4;
656
        debug_token("EOB the next %d blocks\n", *eob_run);
657
        break;
658

    
659
    case 4:
660
        debug_token("DCT_REPEAT_RUN2_TOKEN, ");
661
        *eob_run = get_bits(gb, 3) + 8;
662
        debug_token("EOB the next %d blocks\n", *eob_run);
663
        break;
664

    
665
    case 5:
666
        debug_token("DCT_REPEAT_RUN3_TOKEN, ");
667
        *eob_run = get_bits(gb, 4) + 16;
668
        debug_token("EOB the next %d blocks\n", *eob_run);
669
        break;
670

    
671
    case 6:
672
        debug_token("DCT_REPEAT_RUN4_TOKEN, ");
673
        *eob_run = get_bits(gb, 12);
674
        debug_token("EOB the next %d blocks\n", *eob_run);
675
        break;
676

    
677
    case 7:
678
        debug_token("DCT_SHORT_ZRL_TOKEN, ");
679
        /* note that this token actually indicates that (3 extra bits) + 1 0s
680
         * should be output; this case specifies a run of (3 EBs) 0s and a
681
         * coefficient of 0. */
682
        *zero_run = get_bits(gb, 3);
683
        *coeff = 0;
684
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
685
        break;
686

    
687
    case 8:
688
        debug_token("DCT_ZRL_TOKEN, ");
689
        /* note that this token actually indicates that (6 extra bits) + 1 0s
690
         * should be output; this case specifies a run of (6 EBs) 0s and a
691
         * coefficient of 0. */
692
        *zero_run = get_bits(gb, 6);
693
        *coeff = 0;
694
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
695
        break;
696

    
697
    case 9:
698
        debug_token("ONE_TOKEN, output 1\n");
699
        *coeff = 1;
700
        break;
701

    
702
    case 10:
703
        debug_token("MINUS_ONE_TOKEN, output -1\n");
704
        *coeff = -1;
705
        break;
706

    
707
    case 11:
708
        debug_token("TWO_TOKEN, output 2\n");
709
        *coeff = 2;
710
        break;
711

    
712
    case 12:
713
        debug_token("MINUS_TWO_TOKEN, output -2\n");
714
        *coeff = -2;
715
        break;
716

    
717
    case 13:
718
    case 14:
719
    case 15:
720
    case 16:
721
        debug_token("LOW_VAL_TOKENS, ");
722
        if (get_bits(gb, 1))
723
            *coeff = -(3 + (token - 13));
724
        else
725
            *coeff = 3 + (token - 13);
726
        debug_token("output %d\n", *coeff);
727
        break;
728

    
729
    case 17:
730
        debug_token("DCT_VAL_CATEGORY3, ");
731
        sign = get_bits(gb, 1);
732
        *coeff = 7 + get_bits(gb, 1);
733
        if (sign)
734
            *coeff = -(*coeff);
735
        debug_token("output %d\n", *coeff);
736
        break;
737

    
738
    case 18:
739
        debug_token("DCT_VAL_CATEGORY4, ");
740
        sign = get_bits(gb, 1);
741
        *coeff = 9 + get_bits(gb, 2);
742
        if (sign)
743
            *coeff = -(*coeff);
744
        debug_token("output %d\n", *coeff);
745
        break;
746

    
747
    case 19:
748
        debug_token("DCT_VAL_CATEGORY5, ");
749
        sign = get_bits(gb, 1);
750
        *coeff = 13 + get_bits(gb, 3);
751
        if (sign)
752
            *coeff = -(*coeff);
753
        debug_token("output %d\n", *coeff);
754
        break;
755

    
756
    case 20:
757
        debug_token("DCT_VAL_CATEGORY6, ");
758
        sign = get_bits(gb, 1);
759
        *coeff = 21 + get_bits(gb, 4);
760
        if (sign)
761
            *coeff = -(*coeff);
762
        debug_token("output %d\n", *coeff);
763
        break;
764

    
765
    case 21:
766
        debug_token("DCT_VAL_CATEGORY7, ");
767
        sign = get_bits(gb, 1);
768
        *coeff = 37 + get_bits(gb, 5);
769
        if (sign)
770
            *coeff = -(*coeff);
771
        debug_token("output %d\n", *coeff);
772
        break;
773

    
774
    case 22:
775
        debug_token("DCT_VAL_CATEGORY8, ");
776
        sign = get_bits(gb, 1);
777
        *coeff = 69 + get_bits(gb, 9);
778
        if (sign)
779
            *coeff = -(*coeff);
780
        debug_token("output %d\n", *coeff);
781
        break;
782

    
783
    case 23:
784
    case 24:
785
    case 25:
786
    case 26:
787
    case 27:
788
        debug_token("DCT_RUN_CATEGORY1, ");
789
        *zero_run = token - 22;
790
        if (get_bits(gb, 1))
791
            *coeff = -1;
792
        else
793
            *coeff = 1;
794
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
795
        break;
796

    
797
    case 28:
798
        debug_token("DCT_RUN_CATEGORY1B, ");
799
        if (get_bits(gb, 1))
800
            *coeff = -1;
801
        else
802
            *coeff = 1;
803
        *zero_run = 6 + get_bits(gb, 2);
804
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
805
        break;
806

    
807
    case 29:
808
        debug_token("DCT_RUN_CATEGORY1C, ");
809
        if (get_bits(gb, 1))
810
            *coeff = -1;
811
        else
812
            *coeff = 1;
813
        *zero_run = 10 + get_bits(gb, 3);
814
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
815
        break;
816

    
817
    case 30:
818
        debug_token("DCT_RUN_CATEGORY2, ");
819
        sign = get_bits(gb, 1);
820
        *coeff = 2 + get_bits(gb, 1);
821
        if (sign)
822
            *coeff = -(*coeff);
823
        *zero_run = 1;
824
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
825
        break;
826

    
827
    case 31:
828
        debug_token("DCT_RUN_CATEGORY2, ");
829
        sign = get_bits(gb, 1);
830
        *coeff = 2 + get_bits(gb, 1);
831
        if (sign)
832
            *coeff = -(*coeff);
833
        *zero_run = 2 + get_bits(gb, 1);
834
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
835
        break;
836

    
837
    default:
838
        av_log(NULL, AV_LOG_ERROR, "  vp3: help! Got a bad token: %d > 31\n", token);
839
        break;
840

    
841
  }
842
}
843

    
844
/*
845
 * This function wipes out all of the fragment data.
846
 */
847
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
848
{
849
    int i;
850

    
851
    /* zero out all of the fragment information */
852
    s->coded_fragment_list_index = 0;
853
    for (i = 0; i < s->fragment_count; i++) {
854
        s->all_fragments[i].coeff_count = 0;
855
s->all_fragments[i].motion_x = 0xbeef;
856
s->all_fragments[i].motion_y = 0xbeef;
857
s->all_fragments[i].next_coeff= NULL;
858
        s->coeffs[i].index=
859
        s->coeffs[i].coeff=0;
860
        s->coeffs[i].next= NULL;
861
    }
862
}
863

    
864
/*
865
 * This function sets of the dequantization tables used for a particular
866
 * frame.
867
 */
868
static void init_dequantizer(Vp3DecodeContext *s)
869
{
870

    
871
    int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
872
    int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
873
    int i, j;
874

    
875
    debug_vp3("  vp3: initializing dequantization tables\n");
876

    
877
    /* 
878
     * Scale dequantizers:
879
     *
880
     *   quantizer * sf
881
     *   --------------
882
     *        100
883
     *
884
     * where sf = dc_scale_factor for DC quantizer
885
     *         or ac_scale_factor for AC quantizer
886
     *
887
     * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
888
     */
889
#define SCALER 4
890

    
891
    /* scale DC quantizers */
892
    s->intra_y_dequant[0] = s->coded_intra_y_dequant[0] * dc_scale_factor / 100;
893
    if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
894
        s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
895
    s->intra_y_dequant[0] *= SCALER;
896

    
897
    s->intra_c_dequant[0] = s->coded_intra_c_dequant[0] * dc_scale_factor / 100;
898
    if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
899
        s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
900
    s->intra_c_dequant[0] *= SCALER;
901

    
902
    s->inter_dequant[0] = s->coded_inter_dequant[0] * dc_scale_factor / 100;
903
    if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
904
        s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
905
    s->inter_dequant[0] *= SCALER;
906

    
907
    /* scale AC quantizers, zigzag at the same time in preparation for
908
     * the dequantization phase */
909
    for (i = 1; i < 64; i++) {
910
        int k= s->scantable.scantable[i];
911
        j = s->scantable.permutated[i];
912

    
913
        s->intra_y_dequant[j] = s->coded_intra_y_dequant[k] * ac_scale_factor / 100;
914
        if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
915
            s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
916
        s->intra_y_dequant[j] *= SCALER;
917

    
918
        s->intra_c_dequant[j] = s->coded_intra_c_dequant[k] * ac_scale_factor / 100;
919
        if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
920
            s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
921
        s->intra_c_dequant[j] *= SCALER;
922

    
923
        s->inter_dequant[j] = s->coded_inter_dequant[k] * ac_scale_factor / 100;
924
        if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
925
            s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
926
        s->inter_dequant[j] *= SCALER;
927
    }
928
    
929
    memset(s->qscale_table, (FFMAX(s->intra_y_dequant[1], s->intra_c_dequant[1])+8)/16, 512); //FIXME finetune
930

    
931
    /* print debug information as requested */
932
    debug_dequantizers("intra Y dequantizers:\n");
933
    for (i = 0; i < 8; i++) {
934
      for (j = i * 8; j < i * 8 + 8; j++) {
935
        debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
936
      }
937
      debug_dequantizers("\n");
938
    }
939
    debug_dequantizers("\n");
940

    
941
    debug_dequantizers("intra C dequantizers:\n");
942
    for (i = 0; i < 8; i++) {
943
      for (j = i * 8; j < i * 8 + 8; j++) {
944
        debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
945
      }
946
      debug_dequantizers("\n");
947
    }
948
    debug_dequantizers("\n");
949

    
950
    debug_dequantizers("interframe dequantizers:\n");
951
    for (i = 0; i < 8; i++) {
952
      for (j = i * 8; j < i * 8 + 8; j++) {
953
        debug_dequantizers(" %4d,", s->inter_dequant[j]);
954
      }
955
      debug_dequantizers("\n");
956
    }
957
    debug_dequantizers("\n");
958
}
959

    
960
/*
961
 * This function is used to fetch runs of 1s or 0s from the bitstream for
962
 * use in determining which superblocks are fully and partially coded.
963
 *
964
 *  Codeword                RunLength
965
 *  0                       1
966
 *  10x                     2-3
967
 *  110x                    4-5
968
 *  1110xx                  6-9
969
 *  11110xxx                10-17
970
 *  111110xxxx              18-33
971
 *  111111xxxxxxxxxxxx      34-4129
972
 */
973
static int get_superblock_run_length(GetBitContext *gb)
974
{
975

    
976
    if (get_bits(gb, 1) == 0)
977
        return 1;
978

    
979
    else if (get_bits(gb, 1) == 0)
980
        return (2 + get_bits(gb, 1));
981

    
982
    else if (get_bits(gb, 1) == 0)
983
        return (4 + get_bits(gb, 1));
984

    
985
    else if (get_bits(gb, 1) == 0)
986
        return (6 + get_bits(gb, 2));
987

    
988
    else if (get_bits(gb, 1) == 0)
989
        return (10 + get_bits(gb, 3));
990

    
991
    else if (get_bits(gb, 1) == 0)
992
        return (18 + get_bits(gb, 4));
993

    
994
    else
995
        return (34 + get_bits(gb, 12));
996

    
997
}
998

    
999
/*
1000
 * This function is used to fetch runs of 1s or 0s from the bitstream for
1001
 * use in determining which particular fragments are coded.
1002
 *
1003
 * Codeword                RunLength
1004
 * 0x                      1-2
1005
 * 10x                     3-4
1006
 * 110x                    5-6
1007
 * 1110xx                  7-10
1008
 * 11110xx                 11-14
1009
 * 11111xxxx               15-30
1010
 */
1011
static int get_fragment_run_length(GetBitContext *gb)
1012
{
1013

    
1014
    if (get_bits(gb, 1) == 0)
1015
        return (1 + get_bits(gb, 1));
1016

    
1017
    else if (get_bits(gb, 1) == 0)
1018
        return (3 + get_bits(gb, 1));
1019

    
1020
    else if (get_bits(gb, 1) == 0)
1021
        return (5 + get_bits(gb, 1));
1022

    
1023
    else if (get_bits(gb, 1) == 0)
1024
        return (7 + get_bits(gb, 2));
1025

    
1026
    else if (get_bits(gb, 1) == 0)
1027
        return (11 + get_bits(gb, 2));
1028

    
1029
    else
1030
        return (15 + get_bits(gb, 4));
1031

    
1032
}
1033

    
1034
/*
1035
 * This function decodes a VLC from the bitstream and returns a number
1036
 * that ranges from 0..7. The number indicates which of the 8 coding
1037
 * modes to use.
1038
 *
1039
 *  VLC       Number
1040
 *  0            0
1041
 *  10           1
1042
 *  110          2
1043
 *  1110         3
1044
 *  11110        4
1045
 *  111110       5
1046
 *  1111110      6
1047
 *  1111111      7
1048
 *
1049
 */
1050
static int get_mode_code(GetBitContext *gb)
1051
{
1052

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

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

    
1059
    else if (get_bits(gb, 1) == 0)
1060
        return 2;
1061

    
1062
    else if (get_bits(gb, 1) == 0)
1063
        return 3;
1064

    
1065
    else if (get_bits(gb, 1) == 0)
1066
        return 4;
1067

    
1068
    else if (get_bits(gb, 1) == 0)
1069
        return 5;
1070

    
1071
    else if (get_bits(gb, 1) == 0)
1072
        return 6;
1073

    
1074
    else
1075
        return 7;
1076

    
1077
}
1078

    
1079
/*
1080
 * This function extracts a motion vector from the bitstream using a VLC
1081
 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1082
 * taken depending on the value on those 3 bits:
1083
 *
1084
 *  0: return 0
1085
 *  1: return 1
1086
 *  2: return -1
1087
 *  3: if (next bit is 1) return -2, else return 2
1088
 *  4: if (next bit is 1) return -3, else return 3
1089
 *  5: return 4 + (next 2 bits), next bit is sign
1090
 *  6: return 8 + (next 3 bits), next bit is sign
1091
 *  7: return 16 + (next 4 bits), next bit is sign
1092
 */
1093
static int get_motion_vector_vlc(GetBitContext *gb)
1094
{
1095
    int bits;
1096

    
1097
    bits = get_bits(gb, 3);
1098

    
1099
    switch(bits) {
1100

    
1101
    case 0:
1102
        bits = 0;
1103
        break;
1104

    
1105
    case 1:
1106
        bits = 1;
1107
        break;
1108

    
1109
    case 2:
1110
        bits = -1;
1111
        break;
1112

    
1113
    case 3:
1114
        if (get_bits(gb, 1) == 0)
1115
            bits = 2;
1116
        else
1117
            bits = -2;
1118
        break;
1119

    
1120
    case 4:
1121
        if (get_bits(gb, 1) == 0)
1122
            bits = 3;
1123
        else
1124
            bits = -3;
1125
        break;
1126

    
1127
    case 5:
1128
        bits = 4 + get_bits(gb, 2);
1129
        if (get_bits(gb, 1) == 1)
1130
            bits = -bits;
1131
        break;
1132

    
1133
    case 6:
1134
        bits = 8 + get_bits(gb, 3);
1135
        if (get_bits(gb, 1) == 1)
1136
            bits = -bits;
1137
        break;
1138

    
1139
    case 7:
1140
        bits = 16 + get_bits(gb, 4);
1141
        if (get_bits(gb, 1) == 1)
1142
            bits = -bits;
1143
        break;
1144

    
1145
    }
1146

    
1147
    return bits;
1148
}
1149

    
1150
/*
1151
 * This function fetches a 5-bit number from the stream followed by
1152
 * a sign and calls it a motion vector.
1153
 */
1154
static int get_motion_vector_fixed(GetBitContext *gb)
1155
{
1156

    
1157
    int bits;
1158

    
1159
    bits = get_bits(gb, 5);
1160

    
1161
    if (get_bits(gb, 1) == 1)
1162
        bits = -bits;
1163

    
1164
    return bits;
1165
}
1166

    
1167
/*
1168
 * This function unpacks all of the superblock/macroblock/fragment coding 
1169
 * information from the bitstream.
1170
 */
1171
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1172
{
1173
    int bit = 0;
1174
    int current_superblock = 0;
1175
    int current_run = 0;
1176
    int decode_fully_flags = 0;
1177
    int decode_partial_blocks = 0;
1178
    int first_c_fragment_seen;
1179

    
1180
    int i, j;
1181
    int current_fragment;
1182

    
1183
    debug_vp3("  vp3: unpacking superblock coding\n");
1184

    
1185
    if (s->keyframe) {
1186

    
1187
        debug_vp3("    keyframe-- all superblocks are fully coded\n");
1188
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1189

    
1190
    } else {
1191

    
1192
        /* unpack the list of partially-coded superblocks */
1193
        bit = get_bits(gb, 1);
1194
        /* toggle the bit because as soon as the first run length is 
1195
         * fetched the bit will be toggled again */
1196
        bit ^= 1;
1197
        while (current_superblock < s->superblock_count) {
1198
            if (current_run-- == 0) {
1199
                bit ^= 1;
1200
#if 1
1201
                current_run = get_vlc2(gb, 
1202
                    s->superblock_run_length_vlc.table, 6, 2);
1203
                if (current_run == 33)
1204
                    current_run += get_bits(gb, 12);
1205
#else
1206
                current_run = get_superblock_run_length(gb);
1207
#endif
1208
                debug_block_coding("      setting superblocks %d..%d to %s\n",
1209
                    current_superblock,
1210
                    current_superblock + current_run - 1,
1211
                    (bit) ? "partially coded" : "not coded");
1212

    
1213
                /* if any of the superblocks are not partially coded, flag
1214
                 * a boolean to decode the list of fully-coded superblocks */
1215
                if (bit == 0) {
1216
                    decode_fully_flags = 1;
1217
                } else {
1218

    
1219
                    /* make a note of the fact that there are partially coded
1220
                     * superblocks */
1221
                    decode_partial_blocks = 1;
1222
                }
1223
            }
1224
            s->superblock_coding[current_superblock++] = bit;
1225
        }
1226

    
1227
        /* unpack the list of fully coded superblocks if any of the blocks were
1228
         * not marked as partially coded in the previous step */
1229
        if (decode_fully_flags) {
1230

    
1231
            current_superblock = 0;
1232
            current_run = 0;
1233
            bit = get_bits(gb, 1);
1234
            /* toggle the bit because as soon as the first run length is 
1235
             * fetched the bit will be toggled again */
1236
            bit ^= 1;
1237
            while (current_superblock < s->superblock_count) {
1238

    
1239
                /* skip any superblocks already marked as partially coded */
1240
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1241

    
1242
                    if (current_run-- == 0) {
1243
                        bit ^= 1;
1244
#if 1
1245
                        current_run = get_vlc2(gb, 
1246
                            s->superblock_run_length_vlc.table, 6, 2);
1247
                        if (current_run == 33)
1248
                            current_run += get_bits(gb, 12);
1249
#else
1250
                        current_run = get_superblock_run_length(gb);
1251
#endif
1252
                    }
1253

    
1254
                    debug_block_coding("      setting superblock %d to %s\n",
1255
                        current_superblock,
1256
                        (bit) ? "fully coded" : "not coded");
1257
                    s->superblock_coding[current_superblock] = 2*bit;
1258
                }
1259
                current_superblock++;
1260
            }
1261
        }
1262

    
1263
        /* if there were partial blocks, initialize bitstream for
1264
         * unpacking fragment codings */
1265
        if (decode_partial_blocks) {
1266

    
1267
            current_run = 0;
1268
            bit = get_bits(gb, 1);
1269
            /* toggle the bit because as soon as the first run length is 
1270
             * fetched the bit will be toggled again */
1271
            bit ^= 1;
1272
        }
1273
    }
1274

    
1275
    /* figure out which fragments are coded; iterate through each
1276
     * superblock (all planes) */
1277
    s->coded_fragment_list_index = 0;
1278
    s->next_coeff= s->coeffs + s->fragment_count;
1279
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1280
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1281
    first_c_fragment_seen = 0;
1282
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1283
    for (i = 0; i < s->superblock_count; i++) {
1284

    
1285
        /* iterate through all 16 fragments in a superblock */
1286
        for (j = 0; j < 16; j++) {
1287

    
1288
            /* if the fragment is in bounds, check its coding status */
1289
            current_fragment = s->superblock_fragments[i * 16 + j];
1290
            if (current_fragment >= s->fragment_count) {
1291
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1292
                    current_fragment, s->fragment_count);
1293
                return 1;
1294
            }
1295
            if (current_fragment != -1) {
1296
                if (s->superblock_coding[i] == SB_NOT_CODED) {
1297

    
1298
                    /* copy all the fragments from the prior frame */
1299
                    s->all_fragments[current_fragment].coding_method = 
1300
                        MODE_COPY;
1301

    
1302
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1303

    
1304
                    /* fragment may or may not be coded; this is the case
1305
                     * that cares about the fragment coding runs */
1306
                    if (current_run-- == 0) {
1307
                        bit ^= 1;
1308
#if 1
1309
                        current_run = get_vlc2(gb, 
1310
                            s->fragment_run_length_vlc.table, 5, 2);
1311
#else
1312
                        current_run = get_fragment_run_length(gb);
1313
#endif
1314
                    }
1315

    
1316
                    if (bit) {
1317
                        /* default mode; actual mode will be decoded in 
1318
                         * the next phase */
1319
                        s->all_fragments[current_fragment].coding_method = 
1320
                            MODE_INTER_NO_MV;
1321
                        s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
1322
                        s->coded_fragment_list[s->coded_fragment_list_index] = 
1323
                            current_fragment;
1324
                        if ((current_fragment >= s->u_fragment_start) &&
1325
                            (s->last_coded_y_fragment == -1) &&
1326
                            (!first_c_fragment_seen)) {
1327
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
1328
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1329
                            first_c_fragment_seen = 1;
1330
                        }
1331
                        s->coded_fragment_list_index++;
1332
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1333
                        debug_block_coding("      superblock %d is partially coded, fragment %d is coded\n",
1334
                            i, current_fragment);
1335
                    } else {
1336
                        /* not coded; copy this fragment from the prior frame */
1337
                        s->all_fragments[current_fragment].coding_method =
1338
                            MODE_COPY;
1339
                        debug_block_coding("      superblock %d is partially coded, fragment %d is not coded\n",
1340
                            i, current_fragment);
1341
                    }
1342

    
1343
                } else {
1344

    
1345
                    /* fragments are fully coded in this superblock; actual
1346
                     * coding will be determined in next step */
1347
                    s->all_fragments[current_fragment].coding_method = 
1348
                        MODE_INTER_NO_MV;
1349
                    s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
1350
                    s->coded_fragment_list[s->coded_fragment_list_index] = 
1351
                        current_fragment;
1352
                    if ((current_fragment >= s->u_fragment_start) &&
1353
                        (s->last_coded_y_fragment == -1) &&
1354
                        (!first_c_fragment_seen)) {
1355
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
1356
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1357
                        first_c_fragment_seen = 1;
1358
                    }
1359
                    s->coded_fragment_list_index++;
1360
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1361
                    debug_block_coding("      superblock %d is fully coded, fragment %d is coded\n",
1362
                        i, current_fragment);
1363
                }
1364
            }
1365
        }
1366
    }
1367

    
1368
    if (!first_c_fragment_seen)
1369
        /* only Y fragments coded in this frame */
1370
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
1371
    else 
1372
        /* end the list of coded C fragments */
1373
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1374

    
1375
    debug_block_coding("    %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1376
        s->coded_fragment_list_index,
1377
        s->first_coded_y_fragment,
1378
        s->last_coded_y_fragment,
1379
        s->first_coded_c_fragment,
1380
        s->last_coded_c_fragment);
1381

    
1382
    return 0;
1383
}
1384

    
1385
/*
1386
 * This function unpacks all the coding mode data for individual macroblocks
1387
 * from the bitstream.
1388
 */
1389
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1390
{
1391
    int i, j, k;
1392
    int scheme;
1393
    int current_macroblock;
1394
    int current_fragment;
1395
    int coding_mode;
1396

    
1397
    debug_vp3("  vp3: unpacking encoding modes\n");
1398

    
1399
    if (s->keyframe) {
1400
        debug_vp3("    keyframe-- all blocks are coded as INTRA\n");
1401

    
1402
        for (i = 0; i < s->fragment_count; i++)
1403
            s->all_fragments[i].coding_method = MODE_INTRA;
1404

    
1405
    } else {
1406

    
1407
        /* fetch the mode coding scheme for this frame */
1408
        scheme = get_bits(gb, 3);
1409
        debug_modes("    using mode alphabet %d\n", scheme);
1410

    
1411
        /* is it a custom coding scheme? */
1412
        if (scheme == 0) {
1413
            debug_modes("    custom mode alphabet ahead:\n");
1414
            for (i = 0; i < 8; i++)
1415
                ModeAlphabet[scheme][get_bits(gb, 3)] = i;
1416
        }
1417

    
1418
        for (i = 0; i < 8; i++)
1419
            debug_modes("      mode[%d][%d] = %d\n", scheme, i, 
1420
                ModeAlphabet[scheme][i]);
1421

    
1422
        /* iterate through all of the macroblocks that contain 1 or more
1423
         * coded fragments */
1424
        for (i = 0; i < s->u_superblock_start; i++) {
1425

    
1426
            for (j = 0; j < 4; j++) {
1427
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1428
                if ((current_macroblock == -1) ||
1429
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1430
                    continue;
1431
                if (current_macroblock >= s->macroblock_count) {
1432
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1433
                        current_macroblock, s->macroblock_count);
1434
                    return 1;
1435
                }
1436

    
1437
                /* mode 7 means get 3 bits for each coding mode */
1438
                if (scheme == 7)
1439
                    coding_mode = get_bits(gb, 3);
1440
                else
1441
{
1442
#if 1
1443
                    coding_mode = ModeAlphabet[scheme]
1444
                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1445
#else
1446
                    coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
1447
#endif
1448
}
1449

    
1450
                s->macroblock_coding[current_macroblock] = coding_mode;
1451
                for (k = 0; k < 6; k++) {
1452
                    current_fragment = 
1453
                        s->macroblock_fragments[current_macroblock * 6 + k];
1454
                    if (current_fragment == -1)
1455
                        continue;
1456
                    if (current_fragment >= s->fragment_count) {
1457
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1458
                            current_fragment, s->fragment_count);
1459
                        return 1;
1460
                    }
1461
                    if (s->all_fragments[current_fragment].coding_method != 
1462
                        MODE_COPY)
1463
                        s->all_fragments[current_fragment].coding_method =
1464
                            coding_mode;
1465
                }
1466

    
1467
                debug_modes("    coding method for macroblock starting @ fragment %d = %d\n",
1468
                    s->macroblock_fragments[current_macroblock * 6], coding_mode);
1469
            }
1470
        }
1471
    }
1472

    
1473
    return 0;
1474
}
1475

    
1476
/*
1477
 * This function unpacks all the motion vectors for the individual
1478
 * macroblocks from the bitstream.
1479
 */
1480
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1481
{
1482
    int i, j, k;
1483
    int coding_mode;
1484
    int motion_x[6];
1485
    int motion_y[6];
1486
    int last_motion_x = 0;
1487
    int last_motion_y = 0;
1488
    int prior_last_motion_x = 0;
1489
    int prior_last_motion_y = 0;
1490
    int current_macroblock;
1491
    int current_fragment;
1492

    
1493
    debug_vp3("  vp3: unpacking motion vectors\n");
1494
    if (s->keyframe) {
1495

    
1496
        debug_vp3("    keyframe-- there are no motion vectors\n");
1497

    
1498
    } else {
1499

    
1500
        memset(motion_x, 0, 6 * sizeof(int));
1501
        memset(motion_y, 0, 6 * sizeof(int));
1502

    
1503
        /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1504
        coding_mode = get_bits(gb, 1);
1505
        debug_vectors("    using %s scheme for unpacking motion vectors\n",
1506
            (coding_mode == 0) ? "VLC" : "fixed-length");
1507

    
1508
        /* iterate through all of the macroblocks that contain 1 or more
1509
         * coded fragments */
1510
        for (i = 0; i < s->u_superblock_start; i++) {
1511

    
1512
            for (j = 0; j < 4; j++) {
1513
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1514
                if ((current_macroblock == -1) ||
1515
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1516
                    continue;
1517
                if (current_macroblock >= s->macroblock_count) {
1518
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1519
                        current_macroblock, s->macroblock_count);
1520
                    return 1;
1521
                }
1522

    
1523
                current_fragment = s->macroblock_fragments[current_macroblock * 6];
1524
                if (current_fragment >= s->fragment_count) {
1525
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1526
                        current_fragment, s->fragment_count);
1527
                    return 1;
1528
                }
1529
                switch (s->macroblock_coding[current_macroblock]) {
1530

    
1531
                case MODE_INTER_PLUS_MV:
1532
                case MODE_GOLDEN_MV:
1533
                    /* all 6 fragments use the same motion vector */
1534
                    if (coding_mode == 0) {
1535
#if 1
1536
                        motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1537
                        motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1538
#else
1539
                        motion_x[0] = get_motion_vector_vlc(gb);
1540
                        motion_y[0] = get_motion_vector_vlc(gb);
1541
#endif
1542
                    } else {
1543
                        motion_x[0] = get_motion_vector_fixed(gb);
1544
                        motion_y[0] = get_motion_vector_fixed(gb);
1545
                    }
1546
                    for (k = 1; k < 6; k++) {
1547
                        motion_x[k] = motion_x[0];
1548
                        motion_y[k] = motion_y[0];
1549
                    }
1550

    
1551
                    /* vector maintenance, only on MODE_INTER_PLUS_MV */
1552
                    if (s->macroblock_coding[current_macroblock] ==
1553
                        MODE_INTER_PLUS_MV) {
1554
                        prior_last_motion_x = last_motion_x;
1555
                        prior_last_motion_y = last_motion_y;
1556
                        last_motion_x = motion_x[0];
1557
                        last_motion_y = motion_y[0];
1558
                    }
1559
                    break;
1560

    
1561
                case MODE_INTER_FOURMV:
1562
                    /* fetch 4 vectors from the bitstream, one for each
1563
                     * Y fragment, then average for the C fragment vectors */
1564
                    motion_x[4] = motion_y[4] = 0;
1565
                    for (k = 0; k < 4; k++) {
1566
                        if (coding_mode == 0) {
1567
#if 1
1568
                            motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1569
                            motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1570
#else
1571
                            motion_x[k] = get_motion_vector_vlc(gb);
1572
                            motion_y[k] = get_motion_vector_vlc(gb);
1573
#endif
1574
                        } else {
1575
                            motion_x[k] = get_motion_vector_fixed(gb);
1576
                            motion_y[k] = get_motion_vector_fixed(gb);
1577
                        }
1578
                        motion_x[4] += motion_x[k];
1579
                        motion_y[4] += motion_y[k];
1580
                    }
1581

    
1582
                    if (motion_x[4] >= 0) 
1583
                        motion_x[4] = (motion_x[4] + 2) / 4;
1584
                    else
1585
                        motion_x[4] = (motion_x[4] - 2) / 4;
1586
                    motion_x[5] = motion_x[4];
1587

    
1588
                    if (motion_y[4] >= 0) 
1589
                        motion_y[4] = (motion_y[4] + 2) / 4;
1590
                    else
1591
                        motion_y[4] = (motion_y[4] - 2) / 4;
1592
                    motion_y[5] = motion_y[4];
1593

    
1594
                    /* vector maintenance; vector[3] is treated as the
1595
                     * last vector in this case */
1596
                    prior_last_motion_x = last_motion_x;
1597
                    prior_last_motion_y = last_motion_y;
1598
                    last_motion_x = motion_x[3];
1599
                    last_motion_y = motion_y[3];
1600
                    break;
1601

    
1602
                case MODE_INTER_LAST_MV:
1603
                    /* all 6 fragments use the last motion vector */
1604
                    motion_x[0] = last_motion_x;
1605
                    motion_y[0] = last_motion_y;
1606
                    for (k = 1; k < 6; k++) {
1607
                        motion_x[k] = motion_x[0];
1608
                        motion_y[k] = motion_y[0];
1609
                    }
1610

    
1611
                    /* no vector maintenance (last vector remains the
1612
                     * last vector) */
1613
                    break;
1614

    
1615
                case MODE_INTER_PRIOR_LAST:
1616
                    /* all 6 fragments use the motion vector prior to the
1617
                     * last motion vector */
1618
                    motion_x[0] = prior_last_motion_x;
1619
                    motion_y[0] = prior_last_motion_y;
1620
                    for (k = 1; k < 6; k++) {
1621
                        motion_x[k] = motion_x[0];
1622
                        motion_y[k] = motion_y[0];
1623
                    }
1624

    
1625
                    /* vector maintenance */
1626
                    prior_last_motion_x = last_motion_x;
1627
                    prior_last_motion_y = last_motion_y;
1628
                    last_motion_x = motion_x[0];
1629
                    last_motion_y = motion_y[0];
1630
                    break;
1631

    
1632
                default:
1633
                    /* covers intra, inter without MV, golden without MV */
1634
                    memset(motion_x, 0, 6 * sizeof(int));
1635
                    memset(motion_y, 0, 6 * sizeof(int));
1636

    
1637
                    /* no vector maintenance */
1638
                    break;
1639
                }
1640

    
1641
                /* assign the motion vectors to the correct fragments */
1642
                debug_vectors("    vectors for macroblock starting @ fragment %d (coding method %d):\n",
1643
                    current_fragment,
1644
                    s->macroblock_coding[current_macroblock]);
1645
                for (k = 0; k < 6; k++) {
1646
                    current_fragment = 
1647
                        s->macroblock_fragments[current_macroblock * 6 + k];
1648
                    if (current_fragment == -1)
1649
                        continue;
1650
                    if (current_fragment >= s->fragment_count) {
1651
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1652
                            current_fragment, s->fragment_count);
1653
                        return 1;
1654
                    }
1655
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
1656
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
1657
                    debug_vectors("    vector %d: fragment %d = (%d, %d)\n",
1658
                        k, current_fragment, motion_x[k], motion_y[k]);
1659
                }
1660
            }
1661
        }
1662
    }
1663

    
1664
    return 0;
1665
}
1666

    
1667
/* 
1668
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1669
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1670
 * data. This function unpacks all the VLCs for either the Y plane or both
1671
 * C planes, and is called for DC coefficients or different AC coefficient
1672
 * levels (since different coefficient types require different VLC tables.
1673
 *
1674
 * This function returns a residual eob run. E.g, if a particular token gave
1675
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1676
 * left in the current fragment range, 3 would be returned so that it could
1677
 * be passed into the next call to this same function.
1678
 */
1679
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1680
                        VLC *table, int coeff_index,
1681
                        int first_fragment, int last_fragment,
1682
                        int eob_run)
1683
{
1684
    int i;
1685
    int token;
1686
    int zero_run = 0;
1687
    DCTELEM coeff = 0;
1688
    Vp3Fragment *fragment;
1689
    uint8_t *perm= s->scantable.permutated;
1690
    int bits_to_get;
1691

    
1692
    if ((first_fragment >= s->fragment_count) ||
1693
        (last_fragment >= s->fragment_count)) {
1694

    
1695
        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1696
            first_fragment, last_fragment);
1697
        return 0;
1698
    }
1699

    
1700
    for (i = first_fragment; i <= last_fragment; i++) {
1701

    
1702
        fragment = &s->all_fragments[s->coded_fragment_list[i]];
1703
        if (fragment->coeff_count > coeff_index)
1704
            continue;
1705

    
1706
        if (!eob_run) {
1707
            /* decode a VLC into a token */
1708
            token = get_vlc2(gb, table->table, 5, 3);
1709
            debug_vlc(" token = %2d, ", token);
1710
            /* use the token to get a zero run, a coefficient, and an eob run */
1711
#if 1
1712
            if (token <= 6) {
1713
                eob_run = eob_run_base[token];
1714
                if (eob_run_get_bits[token])
1715
                    eob_run += get_bits(gb, eob_run_get_bits[token]);
1716
                coeff = zero_run = 0;
1717
            } else {
1718
                bits_to_get = coeff_get_bits[token];
1719
                if (!bits_to_get)
1720
                    coeff = coeff_tables[token][0];
1721
                else
1722
                    coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
1723

    
1724
                zero_run = zero_run_base[token];
1725
                if (zero_run_get_bits[token])
1726
                    zero_run += get_bits(gb, zero_run_get_bits[token]);
1727
            }
1728
#else
1729
            unpack_token(gb, token, &zero_run, &coeff, &eob_run);
1730
#endif
1731
        }
1732

    
1733
        if (!eob_run) {
1734
            fragment->coeff_count += zero_run;
1735
            if (fragment->coeff_count < 64){
1736
                fragment->next_coeff->coeff= coeff;
1737
                fragment->next_coeff->index= perm[fragment->coeff_count++]; //FIXME perm here already?
1738
                fragment->next_coeff->next= s->next_coeff;
1739
                s->next_coeff->next=NULL;
1740
                fragment->next_coeff= s->next_coeff++;
1741
            }
1742
            debug_vlc(" fragment %d coeff = %d\n",
1743
                s->coded_fragment_list[i], fragment->next_coeff[coeff_index]);
1744
        } else {
1745
            fragment->coeff_count |= 128;
1746
            debug_vlc(" fragment %d eob with %d coefficients\n", 
1747
                s->coded_fragment_list[i], fragment->coeff_count&127);
1748
            eob_run--;
1749
        }
1750
    }
1751

    
1752
    return eob_run;
1753
}
1754

    
1755
/*
1756
 * This function unpacks all of the DCT coefficient data from the
1757
 * bitstream.
1758
 */
1759
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1760
{
1761
    int i;
1762
    int dc_y_table;
1763
    int dc_c_table;
1764
    int ac_y_table;
1765
    int ac_c_table;
1766
    int residual_eob_run = 0;
1767

    
1768
    /* fetch the DC table indices */
1769
    dc_y_table = get_bits(gb, 4);
1770
    dc_c_table = get_bits(gb, 4);
1771

    
1772
    /* unpack the Y plane DC coefficients */
1773
    debug_vp3("  vp3: unpacking Y plane DC coefficients using table %d\n",
1774
        dc_y_table);
1775
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, 
1776
        s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1777

    
1778
    /* unpack the C plane DC coefficients */
1779
    debug_vp3("  vp3: unpacking C plane DC coefficients using table %d\n",
1780
        dc_c_table);
1781
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1782
        s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1783

    
1784
    /* fetch the AC table indices */
1785
    ac_y_table = get_bits(gb, 4);
1786
    ac_c_table = get_bits(gb, 4);
1787

    
1788
    /* unpack the group 1 AC coefficients (coeffs 1-5) */
1789
    for (i = 1; i <= 5; i++) {
1790

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

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

    
1802
    /* unpack the group 2 AC coefficients (coeffs 6-14) */
1803
    for (i = 6; i <= 14; i++) {
1804

    
1805
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1806
            i, ac_y_table);
1807
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i, 
1808
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1809

    
1810
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1811
            i, ac_c_table);
1812
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i, 
1813
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1814
    }
1815

    
1816
    /* unpack the group 3 AC coefficients (coeffs 15-27) */
1817
    for (i = 15; i <= 27; i++) {
1818

    
1819
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1820
            i, ac_y_table);
1821
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i, 
1822
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1823

    
1824
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1825
            i, ac_c_table);
1826
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i, 
1827
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1828
    }
1829

    
1830
    /* unpack the group 4 AC coefficients (coeffs 28-63) */
1831
    for (i = 28; i <= 63; i++) {
1832

    
1833
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1834
            i, ac_y_table);
1835
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i, 
1836
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1837

    
1838
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1839
            i, ac_c_table);
1840
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i, 
1841
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1842
    }
1843

    
1844
    return 0;
1845
}
1846

    
1847
/*
1848
 * This function reverses the DC prediction for each coded fragment in
1849
 * the frame. Much of this function is adapted directly from the original 
1850
 * VP3 source code.
1851
 */
1852
#define COMPATIBLE_FRAME(x) \
1853
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1854
#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
1855
#define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1856
static inline int iabs (int x) { return ((x < 0) ? -x : x); }
1857

    
1858
static void reverse_dc_prediction(Vp3DecodeContext *s,
1859
                                  int first_fragment,
1860
                                  int fragment_width,
1861
                                  int fragment_height) 
1862
{
1863

    
1864
#define PUL 8
1865
#define PU 4
1866
#define PUR 2
1867
#define PL 1
1868

    
1869
    int x, y;
1870
    int i = first_fragment;
1871

    
1872
    /*
1873
     * Fragment prediction groups:
1874
     *
1875
     * 32222222226
1876
     * 10000000004
1877
     * 10000000004
1878
     * 10000000004
1879
     * 10000000004
1880
     *
1881
     * Note: Groups 5 and 7 do not exist as it would mean that the 
1882
     * fragment's x coordinate is both 0 and (width - 1) at the same time.
1883
     */
1884
    int predictor_group;
1885
    short predicted_dc;
1886

    
1887
    /* validity flags for the left, up-left, up, and up-right fragments */
1888
    int fl, ful, fu, fur;
1889

    
1890
    /* DC values for the left, up-left, up, and up-right fragments */
1891
    int vl, vul, vu, vur;
1892

    
1893
    /* indices for the left, up-left, up, and up-right fragments */
1894
    int l, ul, u, ur;
1895

    
1896
    /* 
1897
     * The 6 fields mean:
1898
     *   0: up-left multiplier
1899
     *   1: up multiplier
1900
     *   2: up-right multiplier
1901
     *   3: left multiplier
1902
     *   4: mask
1903
     *   5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
1904
     */
1905
    int predictor_transform[16][6] = {
1906
        {  0,  0,  0,  0,   0,  0 },
1907
        {  0,  0,  0,  1,   0,  0 },        // PL
1908
        {  0,  0,  1,  0,   0,  0 },        // PUR
1909
        {  0,  0, 53, 75, 127,  7 },        // PUR|PL
1910
        {  0,  1,  0,  0,   0,  0 },        // PU
1911
        {  0,  1,  0,  1,   1,  1 },        // PU|PL
1912
        {  0,  1,  0,  0,   0,  0 },        // PU|PUR
1913
        {  0,  0, 53, 75, 127,  7 },        // PU|PUR|PL
1914
        {  1,  0,  0,  0,   0,  0 },        // PUL
1915
        {  0,  0,  0,  1,   0,  0 },        // PUL|PL
1916
        {  1,  0,  1,  0,   1,  1 },        // PUL|PUR
1917
        {  0,  0, 53, 75, 127,  7 },        // PUL|PUR|PL
1918
        {  0,  1,  0,  0,   0,  0 },        // PUL|PU
1919
        {-26, 29,  0, 29,  31,  5 },        // PUL|PU|PL
1920
        {  3, 10,  3,  0,  15,  4 },        // PUL|PU|PUR
1921
        {-26, 29,  0, 29,  31,  5 }         // PUL|PU|PUR|PL
1922
    };
1923

    
1924
    /* This table shows which types of blocks can use other blocks for
1925
     * prediction. For example, INTRA is the only mode in this table to
1926
     * have a frame number of 0. That means INTRA blocks can only predict
1927
     * from other INTRA blocks. There are 2 golden frame coding types; 
1928
     * blocks encoding in these modes can only predict from other blocks
1929
     * that were encoded with these 1 of these 2 modes. */
1930
    unsigned char compatible_frame[8] = {
1931
        1,    /* MODE_INTER_NO_MV */
1932
        0,    /* MODE_INTRA */
1933
        1,    /* MODE_INTER_PLUS_MV */
1934
        1,    /* MODE_INTER_LAST_MV */
1935
        1,    /* MODE_INTER_PRIOR_MV */
1936
        2,    /* MODE_USING_GOLDEN */
1937
        2,    /* MODE_GOLDEN_MV */
1938
        1     /* MODE_INTER_FOUR_MV */
1939
    };
1940
    int current_frame_type;
1941

    
1942
    /* there is a last DC predictor for each of the 3 frame types */
1943
    short last_dc[3];
1944

    
1945
    int transform = 0;
1946

    
1947
    debug_vp3("  vp3: reversing DC prediction\n");
1948

    
1949
    vul = vu = vur = vl = 0;
1950
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
1951

    
1952
    /* for each fragment row... */
1953
    for (y = 0; y < fragment_height; y++) {
1954

    
1955
        /* for each fragment in a row... */
1956
        for (x = 0; x < fragment_width; x++, i++) {
1957

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

    
1961
                current_frame_type = 
1962
                    compatible_frame[s->all_fragments[i].coding_method];
1963
                predictor_group = (x == 0) + ((y == 0) << 1) +
1964
                    ((x + 1 == fragment_width) << 2);
1965
                debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
1966
                    i, predictor_group, DC_COEFF(i));
1967

    
1968
                switch (predictor_group) {
1969

    
1970
                case 0:
1971
                    /* main body of fragments; consider all 4 possible
1972
                     * fragments for prediction */
1973

    
1974
                    /* calculate the indices of the predicting fragments */
1975
                    ul = i - fragment_width - 1;
1976
                    u = i - fragment_width;
1977
                    ur = i - fragment_width + 1;
1978
                    l = i - 1;
1979

    
1980
                    /* fetch the DC values for the predicting fragments */
1981
                    vul = DC_COEFF(ul);
1982
                    vu = DC_COEFF(u);
1983
                    vur = DC_COEFF(ur);
1984
                    vl = DC_COEFF(l);
1985

    
1986
                    /* figure out which fragments are valid */
1987
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
1988
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
1989
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
1990
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
1991

    
1992
                    /* decide which predictor transform to use */
1993
                    transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
1994

    
1995
                    break;
1996

    
1997
                case 1:
1998
                    /* left column of fragments, not including top corner;
1999
                     * only consider up and up-right fragments */
2000

    
2001
                    /* calculate the indices of the predicting fragments */
2002
                    u = i - fragment_width;
2003
                    ur = i - fragment_width + 1;
2004

    
2005
                    /* fetch the DC values for the predicting fragments */
2006
                    vu = DC_COEFF(u);
2007
                    vur = DC_COEFF(ur);
2008

    
2009
                    /* figure out which fragments are valid */
2010
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2011
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2012

    
2013
                    /* decide which predictor transform to use */
2014
                    transform = (fu*PU) | (fur*PUR);
2015

    
2016
                    break;
2017

    
2018
                case 2:
2019
                case 6:
2020
                    /* top row of fragments, not including top-left frag;
2021
                     * only consider the left fragment for prediction */
2022

    
2023
                    /* calculate the indices of the predicting fragments */
2024
                    l = i - 1;
2025

    
2026
                    /* fetch the DC values for the predicting fragments */
2027
                    vl = DC_COEFF(l);
2028

    
2029
                    /* figure out which fragments are valid */
2030
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2031

    
2032
                    /* decide which predictor transform to use */
2033
                    transform = (fl*PL);
2034

    
2035
                    break;
2036

    
2037
                case 3:
2038
                    /* top-left fragment */
2039

    
2040
                    /* nothing to predict from in this case */
2041
                    transform = 0;
2042

    
2043
                    break;
2044

    
2045
                case 4:
2046
                    /* right column of fragments, not including top corner;
2047
                     * consider up-left, up, and left fragments for
2048
                     * prediction */
2049

    
2050
                    /* calculate the indices of the predicting fragments */
2051
                    ul = i - fragment_width - 1;
2052
                    u = i - fragment_width;
2053
                    l = i - 1;
2054

    
2055
                    /* fetch the DC values for the predicting fragments */
2056
                    vul = DC_COEFF(ul);
2057
                    vu = DC_COEFF(u);
2058
                    vl = DC_COEFF(l);
2059

    
2060
                    /* figure out which fragments are valid */
2061
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2062
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2063
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2064

    
2065
                    /* decide which predictor transform to use */
2066
                    transform = (fl*PL) | (fu*PU) | (ful*PUL);
2067

    
2068
                    break;
2069

    
2070
                }
2071

    
2072
                debug_dc_pred("transform = %d, ", transform);
2073

    
2074
                if (transform == 0) {
2075

    
2076
                    /* if there were no fragments to predict from, use last
2077
                     * DC saved */
2078
                    predicted_dc = last_dc[current_frame_type];
2079
                    debug_dc_pred("from last DC (%d) = %d\n", 
2080
                        current_frame_type, DC_COEFF(i));
2081

    
2082
                } else {
2083

    
2084
                    /* apply the appropriate predictor transform */
2085
                    predicted_dc =
2086
                        (predictor_transform[transform][0] * vul) +
2087
                        (predictor_transform[transform][1] * vu) +
2088
                        (predictor_transform[transform][2] * vur) +
2089
                        (predictor_transform[transform][3] * vl);
2090

    
2091
                    /* if there is a shift value in the transform, add
2092
                     * the sign bit before the shift */
2093
                    if (predictor_transform[transform][5] != 0) {
2094
                        predicted_dc += ((predicted_dc >> 15) & 
2095
                            predictor_transform[transform][4]);
2096
                        predicted_dc >>= predictor_transform[transform][5];
2097
                    }
2098

    
2099
                    /* check for outranging on the [ul u l] and
2100
                     * [ul u ur l] predictors */
2101
                    if ((transform == 13) || (transform == 15)) {
2102
                        if (iabs(predicted_dc - vu) > 128)
2103
                            predicted_dc = vu;
2104
                        else if (iabs(predicted_dc - vl) > 128)
2105
                            predicted_dc = vl;
2106
                        else if (iabs(predicted_dc - vul) > 128)
2107
                            predicted_dc = vul;
2108
                    }
2109

    
2110
                    debug_dc_pred("from pred DC = %d\n", 
2111
                    DC_COEFF(i));
2112
                }
2113

    
2114
                /* at long last, apply the predictor */
2115
                if(s->coeffs[i].index){
2116
                    *s->next_coeff= s->coeffs[i];
2117
                    s->coeffs[i].index=0;
2118
                    s->coeffs[i].coeff=0;
2119
                    s->coeffs[i].next= s->next_coeff++;
2120
                }
2121
                s->coeffs[i].coeff += predicted_dc;
2122
                /* save the DC */
2123
                last_dc[current_frame_type] = DC_COEFF(i);
2124
                if(DC_COEFF(i) && !(s->all_fragments[i].coeff_count&127)){
2125
                    s->all_fragments[i].coeff_count= 129;
2126
//                    s->all_fragments[i].next_coeff= s->next_coeff;
2127
                    s->coeffs[i].next= s->next_coeff;
2128
                    (s->next_coeff++)->next=NULL;
2129
                }
2130
            }
2131
        }
2132
    }
2133
}
2134

    
2135
/*
2136
 * This function performs the final rendering of each fragment's data
2137
 * onto the output frame.
2138
 */
2139
static void render_fragments(Vp3DecodeContext *s,
2140
                             int first_fragment,
2141
                             int width,
2142
                             int height,
2143
                             int plane /* 0 = Y, 1 = U, 2 = V */) 
2144
{
2145
    int x, y, j;
2146
    int m, n;
2147
    int i = first_fragment;
2148
    int16_t *dequantizer;
2149
    DCTELEM __align16 block[64];
2150
    unsigned char *output_plane;
2151
    unsigned char *last_plane;
2152
    unsigned char *golden_plane;
2153
    int stride;
2154
    int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2155
    int upper_motion_limit, lower_motion_limit;
2156
    int motion_halfpel_index;
2157
    uint8_t *motion_source;
2158

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

    
2162
    /* set up plane-specific parameters */
2163
    if (plane == 0) {
2164
        output_plane = s->current_frame.data[0];
2165
        last_plane = s->last_frame.data[0];
2166
        golden_plane = s->golden_frame.data[0];
2167
        stride = s->current_frame.linesize[0];
2168
        if (!s->flipped_image) stride = -stride;
2169
        upper_motion_limit = 7 * s->current_frame.linesize[0];
2170
        lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
2171
    } else if (plane == 1) {
2172
        output_plane = s->current_frame.data[1];
2173
        last_plane = s->last_frame.data[1];
2174
        golden_plane = s->golden_frame.data[1];
2175
        stride = s->current_frame.linesize[1];
2176
        if (!s->flipped_image) stride = -stride;
2177
        upper_motion_limit = 7 * s->current_frame.linesize[1];
2178
        lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
2179
    } else {
2180
        output_plane = s->current_frame.data[2];
2181
        last_plane = s->last_frame.data[2];
2182
        golden_plane = s->golden_frame.data[2];
2183
        stride = s->current_frame.linesize[2];
2184
        if (!s->flipped_image) stride = -stride;
2185
        upper_motion_limit = 7 * s->current_frame.linesize[2];
2186
        lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
2187
    }
2188
    
2189
    if(ABS(stride) > 2048)
2190
        return; //various tables are fixed size
2191

    
2192
    /* for each fragment row... */
2193
    for (y = 0; y < height; y += 8) {
2194

    
2195
        /* for each fragment in a row... */
2196
        for (x = 0; x < width; x += 8, i++) {
2197

    
2198
            if ((i < 0) || (i >= s->fragment_count)) {
2199
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:render_fragments(): bad fragment number (%d)\n", i);
2200
                return;
2201
            }
2202

    
2203
            /* transform if this block was coded */
2204
            if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2205
                !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
2206

    
2207
                if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2208
                    (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2209
                    motion_source= golden_plane;
2210
                else 
2211
                    motion_source= last_plane;
2212

    
2213
                motion_source += s->all_fragments[i].first_pixel;
2214
                motion_halfpel_index = 0;
2215

    
2216
                /* sort out the motion vector if this fragment is coded
2217
                 * using a motion vector method */
2218
                if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2219
                    (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2220
                    int src_x, src_y;
2221
                    motion_x = s->all_fragments[i].motion_x;
2222
                    motion_y = s->all_fragments[i].motion_y;
2223
                    if(plane){
2224
                        motion_x= (motion_x>>1) | (motion_x&1);
2225
                        motion_y= (motion_y>>1) | (motion_y&1);
2226
                    }
2227

    
2228
                    src_x= (motion_x>>1) + x;
2229
                    src_y= (motion_y>>1) + y;
2230
if ((motion_x == 0xbeef) || (motion_y == 0xbeef))
2231
av_log(s->avctx, AV_LOG_ERROR, " help! got beefy vector! (%X, %X)\n", motion_x, motion_y);
2232

    
2233
                    motion_halfpel_index = motion_x & 0x01;
2234
                    motion_source += (motion_x >> 1);
2235

    
2236
//                    motion_y = -motion_y;
2237
                    motion_halfpel_index |= (motion_y & 0x01) << 1;
2238
                    motion_source += ((motion_y >> 1) * stride);
2239

    
2240
                    if(src_x<0 || src_y<0 || src_x + 9 >= width || src_y + 9 >= height){
2241
                        uint8_t *temp= s->edge_emu_buffer;
2242
                        if(stride<0) temp -= 9*stride;
2243
                        else temp += 9*stride;
2244

    
2245
                        ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, width, height);
2246
                        motion_source= temp;
2247
                    }
2248
                }
2249
                
2250

    
2251
                /* first, take care of copying a block from either the
2252
                 * previous or the golden frame */
2253
                if (s->all_fragments[i].coding_method != MODE_INTRA) {
2254
                    //Note, it is possible to implement all MC cases with put_no_rnd_pixels_l2 which would look more like the VP3 source but this would be slower as put_no_rnd_pixels_tab is better optimzed
2255
                    if(motion_halfpel_index != 3){
2256
                        s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2257
                            output_plane + s->all_fragments[i].first_pixel,
2258
                            motion_source, stride, 8);
2259
                    }else{
2260
                        int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2261
                        s->dsp.put_no_rnd_pixels_l2[1](
2262
                            output_plane + s->all_fragments[i].first_pixel,
2263
                            motion_source - d, 
2264
                            motion_source + stride + 1 + d, 
2265
                            stride, 8);
2266
                    }
2267
                    dequantizer = s->inter_dequant;
2268
                }else{
2269
                    if (plane == 0)
2270
                        dequantizer = s->intra_y_dequant;
2271
                    else
2272
                        dequantizer = s->intra_c_dequant;
2273
                }
2274

    
2275
                /* dequantize the DCT coefficients */
2276
                debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n", 
2277
                    i, s->all_fragments[i].coding_method, 
2278
                    DC_COEFF(i), dequantizer[0]);
2279

    
2280
                if(s->avctx->idct_algo==FF_IDCT_VP3){
2281
                    Coeff *coeff= s->coeffs + i;
2282
                    memset(block, 0, sizeof(block));
2283
                    while(coeff->next){
2284
                        block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
2285
                        coeff= coeff->next;
2286
                    }
2287
                }else{
2288
                    Coeff *coeff= s->coeffs + i;
2289
                    memset(block, 0, sizeof(block));
2290
                    while(coeff->next){
2291
                        block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
2292
                        coeff= coeff->next;
2293
                    }
2294
                }
2295

    
2296
                /* invert DCT and place (or add) in final output */
2297
                
2298
                if (s->all_fragments[i].coding_method == MODE_INTRA) {
2299
                    if(s->avctx->idct_algo!=FF_IDCT_VP3)
2300
                        block[0] += 128<<3;
2301
                    s->dsp.idct_put(
2302
                        output_plane + s->all_fragments[i].first_pixel,
2303
                        stride,
2304
                        block);
2305
                } else {
2306
                    s->dsp.idct_add(
2307
                        output_plane + s->all_fragments[i].first_pixel,
2308
                        stride,
2309
                        block);
2310
                }
2311

    
2312
                debug_idct("block after idct_%s():\n",
2313
                    (s->all_fragments[i].coding_method == MODE_INTRA)?
2314
                    "put" : "add");
2315
                for (m = 0; m < 8; m++) {
2316
                    for (n = 0; n < 8; n++) {
2317
                        debug_idct(" %3d", *(output_plane + 
2318
                            s->all_fragments[i].first_pixel + (m * stride + n)));
2319
                    }
2320
                    debug_idct("\n");
2321
                }
2322
                debug_idct("\n");
2323

    
2324
            } else {
2325

    
2326
                /* copy directly from the previous frame */
2327
                s->dsp.put_pixels_tab[1][0](
2328
                    output_plane + s->all_fragments[i].first_pixel,
2329
                    last_plane + s->all_fragments[i].first_pixel,
2330
                    stride, 8);
2331

    
2332
            }
2333
        }
2334
    }
2335

    
2336
    emms_c();
2337
}
2338

    
2339
static void horizontal_filter(unsigned char *first_pixel, int stride,
2340
    int *bounding_values)
2341
{
2342
    unsigned char *end;
2343
    int filter_value;
2344

    
2345
    for (end= first_pixel + 8*stride; first_pixel < end; first_pixel += stride) {
2346
        filter_value = 
2347
            (first_pixel[-2] - first_pixel[ 1])
2348
         +3*(first_pixel[ 0] - first_pixel[-1]);
2349
        filter_value = bounding_values[(filter_value + 4) >> 3];
2350
        first_pixel[-1] = clip_uint8(first_pixel[-1] + filter_value);
2351
        first_pixel[ 0] = clip_uint8(first_pixel[ 0] - filter_value);
2352
    }
2353
}
2354

    
2355
static void vertical_filter(unsigned char *first_pixel, int stride,
2356
    int *bounding_values)
2357
{
2358
    unsigned char *end;
2359
    int filter_value;
2360
    const int nstride= -stride;
2361

    
2362
    for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
2363
        filter_value = 
2364
            (first_pixel[2 * nstride] - first_pixel[ stride])
2365
         +3*(first_pixel[0          ] - first_pixel[nstride]);
2366
        filter_value = bounding_values[(filter_value + 4) >> 3];
2367
        first_pixel[nstride] = clip_uint8(first_pixel[nstride] + filter_value);
2368
        first_pixel[0] = clip_uint8(first_pixel[0] - filter_value);
2369
    }
2370
}
2371

    
2372
static void apply_loop_filter(Vp3DecodeContext *s)
2373
{
2374
    int x, y, plane;
2375
    int width, height;
2376
    int fragment;
2377
    int stride;
2378
    unsigned char *plane_data;
2379

    
2380
    int bounding_values_array[256];
2381
    int *bounding_values= bounding_values_array+127;
2382
    int filter_limit;
2383

    
2384
    /* find the right loop limit value */
2385
    for (x = 63; x >= 0; x--) {
2386
        if (vp31_ac_scale_factor[x] >= s->quality_index)
2387
            break;
2388
    }
2389
    filter_limit = vp31_filter_limit_values[s->quality_index];
2390

    
2391
    /* set up the bounding values */
2392
    memset(bounding_values_array, 0, 256 * sizeof(int));
2393
    for (x = 0; x < filter_limit; x++) {
2394
        bounding_values[-x - filter_limit] = -filter_limit + x;
2395
        bounding_values[-x] = -x;
2396
        bounding_values[x] = x;
2397
        bounding_values[x + filter_limit] = filter_limit - x;
2398
    }
2399

    
2400
    for (plane = 0; plane < 3; plane++) {
2401

    
2402
        if (plane == 0) {
2403
            /* Y plane parameters */
2404
            fragment = 0;
2405
            width = s->fragment_width;
2406
            height = s->fragment_height;
2407
            stride = s->current_frame.linesize[0];
2408
            plane_data = s->current_frame.data[0];
2409
        } else if (plane == 1) {
2410
            /* U plane parameters */
2411
            fragment = s->u_fragment_start;
2412
            width = s->fragment_width / 2;
2413
            height = s->fragment_height / 2;
2414
            stride = s->current_frame.linesize[1];
2415
            plane_data = s->current_frame.data[1];
2416
        } else {
2417
            /* V plane parameters */
2418
            fragment = s->v_fragment_start;
2419
            width = s->fragment_width / 2;
2420
            height = s->fragment_height / 2;
2421
            stride = s->current_frame.linesize[2];
2422
            plane_data = s->current_frame.data[2];
2423
        }
2424

    
2425
        for (y = 0; y < height; y++) {
2426

    
2427
            for (x = 0; x < width; x++) {
2428
START_TIMER
2429
                /* do not perform left edge filter for left columns frags */
2430
                if ((x > 0) &&
2431
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2432
                    horizontal_filter(
2433
                        plane_data + s->all_fragments[fragment].first_pixel - 7*stride, 
2434
                        stride, bounding_values);
2435
                }
2436

    
2437
                /* do not perform top edge filter for top row fragments */
2438
                if ((y > 0) &&
2439
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2440
                    vertical_filter(
2441
                        plane_data + s->all_fragments[fragment].first_pixel + stride, 
2442
                        stride, bounding_values);
2443
                }
2444

    
2445
                /* do not perform right edge filter for right column
2446
                 * fragments or if right fragment neighbor is also coded
2447
                 * in this frame (it will be filtered in next iteration) */
2448
                if ((x < width - 1) &&
2449
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2450
                    (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
2451
                    horizontal_filter(
2452
                        plane_data + s->all_fragments[fragment + 1].first_pixel - 7*stride, 
2453
                        stride, bounding_values);
2454
                }
2455

    
2456
                /* do not perform bottom edge filter for bottom row
2457
                 * fragments or if bottom fragment neighbor is also coded
2458
                 * in this frame (it will be filtered in the next row) */
2459
                if ((y < height - 1) &&
2460
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2461
                    (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
2462
                    vertical_filter(
2463
                        plane_data + s->all_fragments[fragment + width].first_pixel + stride, 
2464
                        stride, bounding_values);
2465
                }
2466

    
2467
                fragment++;
2468
STOP_TIMER("loop filter")
2469
            }
2470
        }
2471
    }
2472
}
2473

    
2474
/* 
2475
 * This function computes the first pixel addresses for each fragment.
2476
 * This function needs to be invoked after the first frame is allocated
2477
 * so that it has access to the plane strides.
2478
 */
2479
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s) 
2480
{
2481

    
2482
    int i, x, y;
2483

    
2484
    /* figure out the first pixel addresses for each of the fragments */
2485
    /* Y plane */
2486
    i = 0;
2487
    for (y = s->fragment_height; y > 0; y--) {
2488
        for (x = 0; x < s->fragment_width; x++) {
2489
            s->all_fragments[i++].first_pixel = 
2490
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2491
                    s->golden_frame.linesize[0] +
2492
                    x * FRAGMENT_PIXELS;
2493
            debug_init("  fragment %d, first pixel @ %d\n", 
2494
                i-1, s->all_fragments[i-1].first_pixel);
2495
        }
2496
    }
2497

    
2498
    /* U plane */
2499
    i = s->u_fragment_start;
2500
    for (y = s->fragment_height / 2; y > 0; y--) {
2501
        for (x = 0; x < s->fragment_width / 2; x++) {
2502
            s->all_fragments[i++].first_pixel = 
2503
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2504
                    s->golden_frame.linesize[1] +
2505
                    x * FRAGMENT_PIXELS;
2506
            debug_init("  fragment %d, first pixel @ %d\n", 
2507
                i-1, s->all_fragments[i-1].first_pixel);
2508
        }
2509
    }
2510

    
2511
    /* V plane */
2512
    i = s->v_fragment_start;
2513
    for (y = s->fragment_height / 2; y > 0; y--) {
2514
        for (x = 0; x < s->fragment_width / 2; x++) {
2515
            s->all_fragments[i++].first_pixel = 
2516
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2517
                    s->golden_frame.linesize[2] +
2518
                    x * FRAGMENT_PIXELS;
2519
            debug_init("  fragment %d, first pixel @ %d\n", 
2520
                i-1, s->all_fragments[i-1].first_pixel);
2521
        }
2522
    }
2523
}
2524

    
2525
/* FIXME: this should be merged with the above! */
2526
static void theora_calculate_pixel_addresses(Vp3DecodeContext *s) 
2527
{
2528

    
2529
    int i, x, y;
2530

    
2531
    /* figure out the first pixel addresses for each of the fragments */
2532
    /* Y plane */
2533
    i = 0;
2534
    for (y = 1; y <= s->fragment_height; y++) {
2535
        for (x = 0; x < s->fragment_width; x++) {
2536
            s->all_fragments[i++].first_pixel = 
2537
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2538
                    s->golden_frame.linesize[0] +
2539
                    x * FRAGMENT_PIXELS;
2540
            debug_init("  fragment %d, first pixel @ %d\n", 
2541
                i-1, s->all_fragments[i-1].first_pixel);
2542
        }
2543
    }
2544

    
2545
    /* U plane */
2546
    i = s->u_fragment_start;
2547
    for (y = 1; y <= s->fragment_height / 2; y++) {
2548
        for (x = 0; x < s->fragment_width / 2; x++) {
2549
            s->all_fragments[i++].first_pixel = 
2550
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2551
                    s->golden_frame.linesize[1] +
2552
                    x * FRAGMENT_PIXELS;
2553
            debug_init("  fragment %d, first pixel @ %d\n", 
2554
                i-1, s->all_fragments[i-1].first_pixel);
2555
        }
2556
    }
2557

    
2558
    /* V plane */
2559
    i = s->v_fragment_start;
2560
    for (y = 1; y <= s->fragment_height / 2; y++) {
2561
        for (x = 0; x < s->fragment_width / 2; x++) {
2562
            s->all_fragments[i++].first_pixel = 
2563
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2564
                    s->golden_frame.linesize[2] +
2565
                    x * FRAGMENT_PIXELS;
2566
            debug_init("  fragment %d, first pixel @ %d\n", 
2567
                i-1, s->all_fragments[i-1].first_pixel);
2568
        }
2569
    }
2570
}
2571

    
2572
/*
2573
 * This is the ffmpeg/libavcodec API init function.
2574
 */
2575
static int vp3_decode_init(AVCodecContext *avctx)
2576
{
2577
    Vp3DecodeContext *s = avctx->priv_data;
2578
    int i;
2579
    int c_width;
2580
    int c_height;
2581
    int y_superblock_count;
2582
    int c_superblock_count;
2583

    
2584
    if (avctx->codec_tag == MKTAG('V','P','3','0'))
2585
        s->version = 0;
2586
    else
2587
        s->version = 1;
2588

    
2589
    s->avctx = avctx;
2590
    s->width = (avctx->width + 15) & 0xFFFFFFF0;
2591
    s->height = (avctx->height + 15) & 0xFFFFFFF0;
2592
    avctx->pix_fmt = PIX_FMT_YUV420P;
2593
    avctx->has_b_frames = 0;
2594
    if(avctx->idct_algo==FF_IDCT_AUTO)
2595
        avctx->idct_algo=FF_IDCT_VP3;
2596
    dsputil_init(&s->dsp, avctx);
2597
    
2598
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
2599

    
2600
    /* initialize to an impossible value which will force a recalculation
2601
     * in the first frame decode */
2602
    s->quality_index = -1;
2603

    
2604
    s->y_superblock_width = (s->width + 31) / 32;
2605
    s->y_superblock_height = (s->height + 31) / 32;
2606
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2607

    
2608
    /* work out the dimensions for the C planes */
2609
    c_width = s->width / 2;
2610
    c_height = s->height / 2;
2611
    s->c_superblock_width = (c_width + 31) / 32;
2612
    s->c_superblock_height = (c_height + 31) / 32;
2613
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2614

    
2615
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2616
    s->u_superblock_start = y_superblock_count;
2617
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
2618
    s->superblock_coding = av_malloc(s->superblock_count);
2619

    
2620
    s->macroblock_width = (s->width + 15) / 16;
2621
    s->macroblock_height = (s->height + 15) / 16;
2622
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
2623

    
2624
    s->fragment_width = s->width / FRAGMENT_PIXELS;
2625
    s->fragment_height = s->height / FRAGMENT_PIXELS;
2626

    
2627
    /* fragment count covers all 8x8 blocks for all 3 planes */
2628
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2629
    s->u_fragment_start = s->fragment_width * s->fragment_height;
2630
    s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2631

    
2632
    debug_init("  Y plane: %d x %d\n", s->width, s->height);
2633
    debug_init("  C plane: %d x %d\n", c_width, c_height);
2634
    debug_init("  Y superblocks: %d x %d, %d total\n",
2635
        s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2636
    debug_init("  C superblocks: %d x %d, %d total\n",
2637
        s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2638
    debug_init("  total superblocks = %d, U starts @ %d, V starts @ %d\n", 
2639
        s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2640
    debug_init("  macroblocks: %d x %d, %d total\n",
2641
        s->macroblock_width, s->macroblock_height, s->macroblock_count);
2642
    debug_init("  %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2643
        s->fragment_count,
2644
        s->fragment_width,
2645
        s->fragment_height,
2646
        s->u_fragment_start,
2647
        s->v_fragment_start);
2648

    
2649
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2650
    s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
2651
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2652
    s->pixel_addresses_inited = 0;
2653

    
2654
    if (!s->theora_tables)
2655
    {
2656
        for (i = 0; i < 64; i++)
2657
            s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2658
        for (i = 0; i < 64; i++)
2659
            s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
2660
        for (i = 0; i < 64; i++)
2661
            s->coded_intra_y_dequant[i] = vp31_intra_y_dequant[i];
2662
        for (i = 0; i < 64; i++)
2663
            s->coded_intra_c_dequant[i] = vp31_intra_c_dequant[i];
2664
        for (i = 0; i < 64; i++)
2665
            s->coded_inter_dequant[i] = vp31_inter_dequant[i];
2666

    
2667
        /* init VLC tables */
2668
        for (i = 0; i < 16; i++) {
2669

    
2670
            /* DC histograms */
2671
            init_vlc(&s->dc_vlc[i], 5, 32,
2672
                &dc_bias[i][0][1], 4, 2,
2673
                &dc_bias[i][0][0], 4, 2, 0);
2674

    
2675
            /* group 1 AC histograms */
2676
            init_vlc(&s->ac_vlc_1[i], 5, 32,
2677
                &ac_bias_0[i][0][1], 4, 2,
2678
                &ac_bias_0[i][0][0], 4, 2, 0);
2679

    
2680
            /* group 2 AC histograms */
2681
            init_vlc(&s->ac_vlc_2[i], 5, 32,
2682
                &ac_bias_1[i][0][1], 4, 2,
2683
                &ac_bias_1[i][0][0], 4, 2, 0);
2684

    
2685
            /* group 3 AC histograms */
2686
            init_vlc(&s->ac_vlc_3[i], 5, 32,
2687
                &ac_bias_2[i][0][1], 4, 2,
2688
                &ac_bias_2[i][0][0], 4, 2, 0);
2689

    
2690
            /* group 4 AC histograms */
2691
            init_vlc(&s->ac_vlc_4[i], 5, 32,
2692
                &ac_bias_3[i][0][1], 4, 2,
2693
                &ac_bias_3[i][0][0], 4, 2, 0);
2694
        }
2695
    } else {
2696
        for (i = 0; i < 16; i++) {
2697

    
2698
            /* DC histograms */
2699
            init_vlc(&s->dc_vlc[i], 5, 32,
2700
                &s->huffman_table[i][0][1], 4, 2,
2701
                &s->huffman_table[i][0][0], 4, 2, 0);
2702

    
2703
            /* group 1 AC histograms */
2704
            init_vlc(&s->ac_vlc_1[i], 5, 32,
2705
                &s->huffman_table[i+16][0][1], 4, 2,
2706
                &s->huffman_table[i+16][0][0], 4, 2, 0);
2707

    
2708
            /* group 2 AC histograms */
2709
            init_vlc(&s->ac_vlc_2[i], 5, 32,
2710
                &s->huffman_table[i+16*2][0][1], 4, 2,
2711
                &s->huffman_table[i+16*2][0][0], 4, 2, 0);
2712

    
2713
            /* group 3 AC histograms */
2714
            init_vlc(&s->ac_vlc_3[i], 5, 32,
2715
                &s->huffman_table[i+16*3][0][1], 4, 2,
2716
                &s->huffman_table[i+16*3][0][0], 4, 2, 0);
2717

    
2718
            /* group 4 AC histograms */
2719
            init_vlc(&s->ac_vlc_4[i], 5, 32,
2720
                &s->huffman_table[i+16*4][0][1], 4, 2,
2721
                &s->huffman_table[i+16*4][0][0], 4, 2, 0);
2722
        }
2723
    }
2724

    
2725
    init_vlc(&s->superblock_run_length_vlc, 6, 34,
2726
        &superblock_run_length_vlc_table[0][1], 4, 2,
2727
        &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2728

    
2729
    init_vlc(&s->fragment_run_length_vlc, 5, 31,
2730
        &fragment_run_length_vlc_table[0][1], 4, 2,
2731
        &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2732

    
2733
    init_vlc(&s->mode_code_vlc, 3, 8,
2734
        &mode_code_vlc_table[0][1], 2, 1,
2735
        &mode_code_vlc_table[0][0], 2, 1, 0);
2736

    
2737
    init_vlc(&s->motion_vector_vlc, 6, 63,
2738
        &motion_vector_vlc_table[0][1], 2, 1,
2739
        &motion_vector_vlc_table[0][0], 2, 1, 0);
2740

    
2741
    /* work out the block mapping tables */
2742
    s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2743
    s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2744
    s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
2745
    s->macroblock_coding = av_malloc(s->macroblock_count + 1);
2746
    init_block_mapping(s);
2747

    
2748
    for (i = 0; i < 3; i++) {
2749
        s->current_frame.data[i] = NULL;
2750
        s->last_frame.data[i] = NULL;
2751
        s->golden_frame.data[i] = NULL;
2752
    }
2753

    
2754
    return 0;
2755
}
2756

    
2757
/*
2758
 * This is the ffmpeg/libavcodec API frame decode function.
2759
 */
2760
static int vp3_decode_frame(AVCodecContext *avctx, 
2761
                            void *data, int *data_size,
2762
                            uint8_t *buf, int buf_size)
2763
{
2764
    Vp3DecodeContext *s = avctx->priv_data;
2765
    GetBitContext gb;
2766
    static int counter = 0;
2767

    
2768
    init_get_bits(&gb, buf, buf_size * 8);
2769
    
2770
    if (s->theora && get_bits1(&gb))
2771
    {
2772
        int ptype = get_bits(&gb, 7);
2773

    
2774
        skip_bits(&gb, 6*8); /* "theora" */
2775
        
2776
        switch(ptype)
2777
        {
2778
            case 1:
2779
                theora_decode_comments(avctx, gb);
2780
                break;
2781
            case 2:
2782
                theora_decode_tables(avctx, gb);
2783
                    init_dequantizer(s);
2784
                break;
2785
            default:
2786
                av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype);
2787
        }
2788
        return buf_size;
2789
    }
2790

    
2791
    s->keyframe = !get_bits1(&gb);
2792
    if (!s->theora)
2793
        skip_bits(&gb, 1);
2794
    s->last_quality_index = s->quality_index;
2795
    s->quality_index = get_bits(&gb, 6);
2796
    if (s->theora >= 0x030200)
2797
        skip_bits1(&gb);
2798

    
2799
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2800
        av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2801
            s->keyframe?"key":"", counter, s->quality_index);
2802
    counter++;
2803

    
2804
    if (s->quality_index != s->last_quality_index)
2805
        init_dequantizer(s);
2806

    
2807
    if (s->keyframe) {
2808
        if (!s->theora)
2809
        {
2810
            skip_bits(&gb, 4); /* width code */
2811
            skip_bits(&gb, 4); /* height code */
2812
            if (s->version)
2813
            {
2814
                s->version = get_bits(&gb, 5);
2815
                if (counter == 1)
2816
                    av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
2817
            }
2818
        }
2819
        if (s->version || s->theora)
2820
        {
2821
                if (get_bits1(&gb))
2822
                    av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
2823
            skip_bits(&gb, 2); /* reserved? */
2824
        }
2825

    
2826
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2827
            if (s->golden_frame.data[0])
2828
                avctx->release_buffer(avctx, &s->golden_frame);
2829
            s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
2830
        } else {
2831
            if (s->golden_frame.data[0])
2832
                avctx->release_buffer(avctx, &s->golden_frame);
2833
            if (s->last_frame.data[0])
2834
                avctx->release_buffer(avctx, &s->last_frame);
2835
        }
2836

    
2837
        s->golden_frame.reference = 3;
2838
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2839
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2840
            return -1;
2841
        }
2842

    
2843
        /* golden frame is also the current frame */
2844
        memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
2845

    
2846
        /* time to figure out pixel addresses? */
2847
        if (!s->pixel_addresses_inited)
2848
        {
2849
            if (!s->flipped_image)
2850
                vp3_calculate_pixel_addresses(s);
2851
            else
2852
                theora_calculate_pixel_addresses(s);
2853
        }
2854
    } else {
2855
        /* allocate a new current frame */
2856
        s->current_frame.reference = 3;
2857
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2858
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2859
            return -1;
2860
        }
2861
    }
2862

    
2863
    s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2864
    s->current_frame.qstride= 0;
2865

    
2866
    {START_TIMER
2867
    init_frame(s, &gb);
2868
    STOP_TIMER("init_frame")}
2869

    
2870
#if KEYFRAMES_ONLY
2871
if (!s->keyframe) {
2872

    
2873
    memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2874
        s->current_frame.linesize[0] * s->height);
2875
    memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2876
        s->current_frame.linesize[1] * s->height / 2);
2877
    memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2878
        s->current_frame.linesize[2] * s->height / 2);
2879

    
2880
} else {
2881
#endif
2882

    
2883
    {START_TIMER
2884
    if (unpack_superblocks(s, &gb)){
2885
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2886
        return -1;
2887
    }
2888
    STOP_TIMER("unpack_superblocks")}
2889
    {START_TIMER
2890
    if (unpack_modes(s, &gb)){
2891
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2892
        return -1;
2893
    }
2894
    STOP_TIMER("unpack_modes")}
2895
    {START_TIMER
2896
    if (unpack_vectors(s, &gb)){
2897
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2898
        return -1;
2899
    }
2900
    STOP_TIMER("unpack_vectors")}
2901
    {START_TIMER
2902
    if (unpack_dct_coeffs(s, &gb)){
2903
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2904
        return -1;
2905
    }
2906
    STOP_TIMER("unpack_dct_coeffs")}
2907
    {START_TIMER
2908

    
2909
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2910
    STOP_TIMER("reverse_dc_prediction")}
2911
    {START_TIMER
2912
    render_fragments(s, 0, s->width, s->height, 0);
2913
    STOP_TIMER("render_fragments")}
2914

    
2915
    if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2916
        reverse_dc_prediction(s, s->u_fragment_start,
2917
            s->fragment_width / 2, s->fragment_height / 2);
2918
        reverse_dc_prediction(s, s->v_fragment_start,
2919
            s->fragment_width / 2, s->fragment_height / 2);
2920
        render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
2921
        render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
2922
    } else {
2923
        memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
2924
        memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
2925
    }
2926

    
2927
    {START_TIMER
2928
    apply_loop_filter(s);
2929
    STOP_TIMER("apply_loop_filter")}
2930
#if KEYFRAMES_ONLY
2931
}
2932
#endif
2933

    
2934
    *data_size=sizeof(AVFrame);
2935
    *(AVFrame*)data= s->current_frame;
2936

    
2937
    /* release the last frame, if it is allocated and if it is not the
2938
     * golden frame */
2939
    if ((s->last_frame.data[0]) &&
2940
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2941
        avctx->release_buffer(avctx, &s->last_frame);
2942

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

    
2947
    return buf_size;
2948
}
2949

    
2950
/*
2951
 * This is the ffmpeg/libavcodec API module cleanup function.
2952
 */
2953
static int vp3_decode_end(AVCodecContext *avctx)
2954
{
2955
    Vp3DecodeContext *s = avctx->priv_data;
2956

    
2957
    av_free(s->all_fragments);
2958
    av_free(s->coeffs);
2959
    av_free(s->coded_fragment_list);
2960
    av_free(s->superblock_fragments);
2961
    av_free(s->superblock_macroblocks);
2962
    av_free(s->macroblock_fragments);
2963
    av_free(s->macroblock_coding);
2964
    
2965
    /* release all frames */
2966
    if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2967
        avctx->release_buffer(avctx, &s->golden_frame);
2968
    if (s->last_frame.data[0])
2969
        avctx->release_buffer(avctx, &s->last_frame);
2970
    /* no need to release the current_frame since it will always be pointing
2971
     * to the same frame as either the golden or last frame */
2972

    
2973
    return 0;
2974
}
2975

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

    
2980
    if (get_bits(gb, 1)) {
2981
        int token;
2982
        if (s->entries >= 32) { /* overflow */
2983
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2984
            return -1;
2985
        }
2986
        token = get_bits(gb, 5);
2987
        //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size);
2988
        s->huffman_table[s->hti][token][0] = s->hbits;
2989
        s->huffman_table[s->hti][token][1] = s->huff_code_size;
2990
        s->entries++;
2991
    }
2992
    else {
2993
        if (s->huff_code_size >= 32) {/* overflow */
2994
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2995
            return -1;
2996
        }
2997
        s->huff_code_size++;
2998
        s->hbits <<= 1;
2999
        read_huffman_tree(avctx, gb);
3000
        s->hbits |= 1;
3001
        read_huffman_tree(avctx, gb);
3002
        s->hbits >>= 1;
3003
        s->huff_code_size--;
3004
    }
3005
    return 0;
3006
}
3007

    
3008
static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
3009
{
3010
    Vp3DecodeContext *s = avctx->priv_data;
3011
    int major, minor, micro;
3012

    
3013
    major = get_bits(&gb, 8); /* version major */
3014
    minor = get_bits(&gb, 8); /* version minor */
3015
    micro = get_bits(&gb, 8); /* version micro */
3016
    av_log(avctx, AV_LOG_INFO, "Theora bitstream version %d.%d.%d\n",
3017
        major, minor, micro);
3018

    
3019
    /* FIXME: endianess? */
3020
    s->theora = (major << 16) | (minor << 8) | micro;
3021

    
3022
    /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
3023
    /* but previous versions have the image flipped relative to vp3 */
3024
    if (s->theora < 0x030200)
3025
    {
3026
        s->flipped_image = 1;
3027
        av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
3028
    }
3029

    
3030
    s->width = get_bits(&gb, 16) << 4;
3031
    s->height = get_bits(&gb, 16) << 4;
3032
    
3033
    if(avcodec_check_dimensions(avctx, s->width, s->height)){
3034
        s->width= s->height= 0;
3035
        return -1;
3036
    }
3037
    
3038
    skip_bits(&gb, 24); /* frame width */
3039
    skip_bits(&gb, 24); /* frame height */
3040

    
3041
    skip_bits(&gb, 8); /* offset x */
3042
    skip_bits(&gb, 8); /* offset y */
3043

    
3044
    skip_bits(&gb, 32); /* fps numerator */
3045
    skip_bits(&gb, 32); /* fps denumerator */
3046
    skip_bits(&gb, 24); /* aspect numerator */
3047
    skip_bits(&gb, 24); /* aspect denumerator */
3048
    
3049
    if (s->theora < 0x030200)
3050
        skip_bits(&gb, 5); /* keyframe frequency force */
3051
    skip_bits(&gb, 8); /* colorspace */
3052
    skip_bits(&gb, 24); /* bitrate */
3053

    
3054
    skip_bits(&gb, 6); /* last(?) quality index */
3055
    
3056
    if (s->theora >= 0x030200)
3057
    {
3058
        skip_bits(&gb, 5); /* keyframe frequency force */
3059
        skip_bits(&gb, 5); /* spare bits */
3060
    }
3061
    
3062
//    align_get_bits(&gb);
3063
    
3064
    avctx->width = s->width;
3065
    avctx->height = s->height;
3066

    
3067
    return 0;
3068
}
3069

    
3070
static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb)
3071
{
3072
    int nb_comments, i, tmp;
3073

    
3074
    tmp = get_bits_long(&gb, 32);
3075
    tmp = be2me_32(tmp);
3076
    while(tmp--)
3077
            skip_bits(&gb, 8);
3078

    
3079
    nb_comments = get_bits_long(&gb, 32);
3080
    nb_comments = be2me_32(nb_comments);
3081
    for (i = 0; i < nb_comments; i++)
3082
    {
3083
        tmp = get_bits_long(&gb, 32);
3084
        tmp = be2me_32(tmp);
3085
        while(tmp--)
3086
            skip_bits(&gb, 8);
3087
    }
3088
    
3089
    return 0;
3090
}
3091

    
3092
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb)
3093
{
3094
    Vp3DecodeContext *s = avctx->priv_data;
3095
    int i, n;
3096

    
3097
    if (s->theora >= 0x030200) {
3098
        n = get_bits(&gb, 3);
3099
        /* loop filter table */
3100
        for (i = 0; i < 64; i++)
3101
            skip_bits(&gb, n);
3102
    }
3103
    
3104
    if (s->theora >= 0x030200)
3105
        n = get_bits(&gb, 4) + 1;
3106
    else
3107
        n = 16;
3108
    /* quality threshold table */
3109
    for (i = 0; i < 64; i++)
3110
        s->coded_ac_scale_factor[i] = get_bits(&gb, n);
3111

    
3112
    if (s->theora >= 0x030200)
3113
        n = get_bits(&gb, 4) + 1;
3114
    else
3115
        n = 16;
3116
    /* dc scale factor table */
3117
    for (i = 0; i < 64; i++)
3118
        s->coded_dc_scale_factor[i] = get_bits(&gb, n);
3119

    
3120
    if (s->theora >= 0x030200)
3121
        n = get_bits(&gb, 9) + 1;
3122
    else
3123
        n = 3;
3124
    if (n != 3) {
3125
        av_log(NULL,AV_LOG_ERROR, "unsupported nbms : %d\n", n);
3126
        return -1;
3127
    }
3128
    /* y coeffs */
3129
    for (i = 0; i < 64; i++)
3130
        s->coded_intra_y_dequant[i] = get_bits(&gb, 8);
3131

    
3132
    /* uv coeffs */
3133
    for (i = 0; i < 64; i++)
3134
        s->coded_intra_c_dequant[i] = get_bits(&gb, 8);
3135

    
3136
    /* inter coeffs */
3137
    for (i = 0; i < 64; i++)
3138
        s->coded_inter_dequant[i] = get_bits(&gb, 8);
3139

    
3140
    /* Huffman tables */
3141
    for (i = 0; i <= 1; i++) {
3142
        for (n = 0; n <= 2; n++) {
3143
            int newqr;
3144
            if (i > 0 || n > 0)
3145
                newqr = get_bits(&gb, 1);
3146
            else
3147
                newqr = 1;
3148
            if (!newqr) {
3149
                if (i > 0)
3150
                    get_bits(&gb, 1);
3151
            }
3152
            else {
3153
                int qi = 0;
3154
                skip_bits(&gb, av_log2(2)+1);
3155
                while (qi < 63) {
3156
                    qi += get_bits(&gb, av_log2(63-qi)+1) + 1;
3157
                    skip_bits(&gb, av_log2(2)+1);
3158
                }
3159
                if (qi > 63)
3160
                    av_log(NULL, AV_LOG_ERROR, "error...\n");
3161
            }
3162
        }
3163
    }
3164

    
3165
    for (s->hti = 0; s->hti < 80; s->hti++) {
3166
        s->entries = 0;
3167
        s->huff_code_size = 1;
3168
        if (!get_bits(&gb, 1)) {
3169
            s->hbits = 0;
3170
            read_huffman_tree(avctx, &gb);
3171
            s->hbits = 1;
3172
            read_huffman_tree(avctx, &gb);
3173
        }
3174
    }
3175
    
3176
    s->theora_tables = 1;
3177
    
3178
    return 0;
3179
}
3180

    
3181
static int theora_decode_init(AVCodecContext *avctx)
3182
{
3183
    Vp3DecodeContext *s = avctx->priv_data;
3184
    GetBitContext gb;
3185
    int ptype;
3186
    uint8_t *p= avctx->extradata;
3187
    int op_bytes, i;
3188
    
3189
    s->theora = 1;
3190

    
3191
    if (!avctx->extradata_size)
3192
        return -1;
3193

    
3194
  for(i=0;i<3;i++) {
3195
    op_bytes = *(p++)<<8;
3196
    op_bytes += *(p++);
3197

    
3198
    init_get_bits(&gb, p, op_bytes);
3199
    p += op_bytes;
3200

    
3201
    ptype = get_bits(&gb, 8);
3202
    debug_vp3("Theora headerpacket type: %x\n", ptype);
3203
            
3204
    if (!(ptype & 0x80))
3205
        return -1;
3206
        
3207
    skip_bits(&gb, 6*8); /* "theora" */
3208
        
3209
    switch(ptype)
3210
    {
3211
        case 0x80:
3212
            theora_decode_header(avctx, gb);
3213
                break;
3214
        case 0x81:
3215
            theora_decode_comments(avctx, gb);
3216
            break;
3217
        case 0x82:
3218
            theora_decode_tables(avctx, gb);
3219
            break;
3220
    }
3221
  }
3222

    
3223
    vp3_decode_init(avctx);
3224
    return 0;
3225
}
3226

    
3227
AVCodec vp3_decoder = {
3228
    "vp3",
3229
    CODEC_TYPE_VIDEO,
3230
    CODEC_ID_VP3,
3231
    sizeof(Vp3DecodeContext),
3232
    vp3_decode_init,
3233
    NULL,
3234
    vp3_decode_end,
3235
    vp3_decode_frame,
3236
    0,
3237
    NULL
3238
};
3239

    
3240
#ifndef CONFIG_LIBTHEORA
3241
AVCodec theora_decoder = {
3242
    "theora",
3243
    CODEC_TYPE_VIDEO,
3244
    CODEC_ID_THEORA,
3245
    sizeof(Vp3DecodeContext),
3246
    theora_decode_init,
3247
    NULL,
3248
    vp3_decode_end,
3249
    vp3_decode_frame,
3250
    0,
3251
    NULL
3252
};
3253
#endif