Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ a8de3901

History | View | Annotate | Download (83.8 KB)

1
/*
2
 * Copyright (C) 2003-2004 the ffmpeg project
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20

    
21
/**
22
 * @file libavcodec/vp3.c
23
 * On2 VP3 Video Decoder
24
 *
25
 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
26
 * For more information about the VP3 coding process, visit:
27
 *   http://wiki.multimedia.cx/index.php?title=On2_VP3
28
 *
29
 * Theora decoder by Alex Beregszaszi
30
 */
31

    
32
#include <stdio.h>
33
#include <stdlib.h>
34
#include <string.h>
35

    
36
#include "avcodec.h"
37
#include "dsputil.h"
38
#include "get_bits.h"
39

    
40
#include "vp3data.h"
41
#include "xiph.h"
42

    
43
#define FRAGMENT_PIXELS 8
44

    
45
static av_cold int vp3_decode_end(AVCodecContext *avctx);
46

    
47
typedef struct Coeff {
48
    struct Coeff *next;
49
    DCTELEM coeff;
50
    uint8_t index;
51
} Coeff;
52

    
53
//FIXME split things out into their own arrays
54
typedef struct Vp3Fragment {
55
    Coeff *next_coeff;
56
    /* address of first pixel taking into account which plane the fragment
57
     * lives on as well as the plane stride */
58
    int first_pixel;
59
    /* this is the macroblock that the fragment belongs to */
60
    uint16_t macroblock;
61
    uint8_t coding_method;
62
    int8_t motion_x;
63
    int8_t motion_y;
64
    uint8_t qpi;
65
} Vp3Fragment;
66

    
67
#define SB_NOT_CODED        0
68
#define SB_PARTIALLY_CODED  1
69
#define SB_FULLY_CODED      2
70

    
71
#define MODE_INTER_NO_MV      0
72
#define MODE_INTRA            1
73
#define MODE_INTER_PLUS_MV    2
74
#define MODE_INTER_LAST_MV    3
75
#define MODE_INTER_PRIOR_LAST 4
76
#define MODE_USING_GOLDEN     5
77
#define MODE_GOLDEN_MV        6
78
#define MODE_INTER_FOURMV     7
79
#define CODING_MODE_COUNT     8
80

    
81
/* special internal mode */
82
#define MODE_COPY             8
83

    
84
/* There are 6 preset schemes, plus a free-form scheme */
85
static const int ModeAlphabet[6][CODING_MODE_COUNT] =
86
{
87
    /* scheme 1: Last motion vector dominates */
88
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
89
         MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
90
         MODE_INTRA,            MODE_USING_GOLDEN,
91
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
92

    
93
    /* scheme 2 */
94
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
95
         MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,
96
         MODE_INTRA,            MODE_USING_GOLDEN,
97
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
98

    
99
    /* scheme 3 */
100
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
101
         MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
102
         MODE_INTRA,            MODE_USING_GOLDEN,
103
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
104

    
105
    /* scheme 4 */
106
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
107
         MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
108
         MODE_INTRA,            MODE_USING_GOLDEN,
109
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
110

    
111
    /* scheme 5: No motion vector dominates */
112
    {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,
113
         MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
114
         MODE_INTRA,            MODE_USING_GOLDEN,
115
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
116

    
117
    /* scheme 6 */
118
    {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,
119
         MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
120
         MODE_INTER_PLUS_MV,    MODE_INTRA,
121
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
122

    
123
};
124

    
125
#define MIN_DEQUANT_VAL 2
126

    
127
typedef struct Vp3DecodeContext {
128
    AVCodecContext *avctx;
129
    int theora, theora_tables;
130
    int version;
131
    int width, height;
132
    AVFrame golden_frame;
133
    AVFrame last_frame;
134
    AVFrame current_frame;
135
    int keyframe;
136
    DSPContext dsp;
137
    int flipped_image;
138
    int last_slice_end;
139

    
140
    int qps[3];
141
    int nqps;
142
    int last_qps[3];
143

    
144
    int superblock_count;
145
    int y_superblock_width;
146
    int y_superblock_height;
147
    int c_superblock_width;
148
    int c_superblock_height;
149
    int u_superblock_start;
150
    int v_superblock_start;
151
    unsigned char *superblock_coding;
152

    
153
    int macroblock_count;
154
    int macroblock_width;
155
    int macroblock_height;
156

    
157
    int fragment_count;
158
    int fragment_width;
159
    int fragment_height;
160

    
161
    Vp3Fragment *all_fragments;
162
    uint8_t *coeff_counts;
163
    Coeff *coeffs;
164
    Coeff *next_coeff;
165
    int fragment_start[3];
166

    
167
    ScanTable scantable;
168

    
169
    /* tables */
170
    uint16_t coded_dc_scale_factor[64];
171
    uint32_t coded_ac_scale_factor[64];
172
    uint8_t base_matrix[384][64];
173
    uint8_t qr_count[2][3];
174
    uint8_t qr_size [2][3][64];
175
    uint16_t qr_base[2][3][64];
176

    
177
    /* this is a list of indexes into the all_fragments array indicating
178
     * which of the fragments are coded */
179
    int *coded_fragment_list;
180
    int coded_fragment_list_index;
181
    int pixel_addresses_initialized;
182

    
183
    /* track which fragments have already been decoded; called 'fast'
184
     * because this data structure avoids having to iterate through every
185
     * fragment in coded_fragment_list; once a fragment has been fully
186
     * decoded, it is removed from this list */
187
    int *fast_fragment_list;
188
    int fragment_list_y_head;
189
    int fragment_list_c_head;
190

    
191
    VLC dc_vlc[16];
192
    VLC ac_vlc_1[16];
193
    VLC ac_vlc_2[16];
194
    VLC ac_vlc_3[16];
195
    VLC ac_vlc_4[16];
196

    
197
    VLC superblock_run_length_vlc;
198
    VLC fragment_run_length_vlc;
199
    VLC mode_code_vlc;
200
    VLC motion_vector_vlc;
201

    
202
    /* these arrays need to be on 16-byte boundaries since SSE2 operations
203
     * index into them */
204
    DECLARE_ALIGNED_16(int16_t, qmat)[3][2][3][64];     //<qmat[qpi][is_inter][plane]
205

    
206
    /* This table contains superblock_count * 16 entries. Each set of 16
207
     * numbers corresponds to the fragment indexes 0..15 of the superblock.
208
     * An entry will be -1 to indicate that no entry corresponds to that
209
     * index. */
210
    int *superblock_fragments;
211

    
212
    /* This table contains superblock_count * 4 entries. Each set of 4
213
     * numbers corresponds to the macroblock indexes 0..3 of the superblock.
214
     * An entry will be -1 to indicate that no entry corresponds to that
215
     * index. */
216
    int *superblock_macroblocks;
217

    
218
    /* This table contains macroblock_count * 6 entries. Each set of 6
219
     * numbers corresponds to the fragment indexes 0..5 which comprise
220
     * the macroblock (4 Y fragments and 2 C fragments). */
221
    int *macroblock_fragments;
222
    /* This is an array that indicates how a particular macroblock
223
     * is coded. */
224
    unsigned char *macroblock_coding;
225

    
226
    int first_coded_y_fragment;
227
    int first_coded_c_fragment;
228
    int last_coded_y_fragment;
229
    int last_coded_c_fragment;
230

    
231
    uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
232
    int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
233

    
234
    /* Huffman decode */
235
    int hti;
236
    unsigned int hbits;
237
    int entries;
238
    int huff_code_size;
239
    uint16_t huffman_table[80][32][2];
240

    
241
    uint8_t filter_limit_values[64];
242
    DECLARE_ALIGNED_8(int, bounding_values_array)[256+2];
243
} Vp3DecodeContext;
244

    
245
/************************************************************************
246
 * VP3 specific functions
247
 ************************************************************************/
248

    
249
/*
250
 * This function sets up all of the various blocks mappings:
251
 * superblocks <-> fragments, macroblocks <-> fragments,
252
 * superblocks <-> macroblocks
253
 *
254
 * Returns 0 is successful; returns 1 if *anything* went wrong.
255
 */
256
static int init_block_mapping(Vp3DecodeContext *s)
257
{
258
    int i, j;
259
    signed int hilbert_walk_mb[4];
260

    
261
    int current_fragment = 0;
262
    int current_width = 0;
263
    int current_height = 0;
264
    int right_edge = 0;
265
    int bottom_edge = 0;
266
    int superblock_row_inc = 0;
267
    int mapping_index = 0;
268

    
269
    int current_macroblock;
270
    int c_fragment;
271

    
272
    static const signed char travel_width[16] = {
273
         1,  1,  0, -1,
274
         0,  0,  1,  0,
275
         1,  0,  1,  0,
276
         0, -1,  0,  1
277
    };
278

    
279
    static const signed char travel_height[16] = {
280
         0,  0,  1,  0,
281
         1,  1,  0, -1,
282
         0,  1,  0, -1,
283
        -1,  0, -1,  0
284
    };
285

    
286
    static const signed char travel_width_mb[4] = {
287
         1,  0,  1,  0
288
    };
289

    
290
    static const signed char travel_height_mb[4] = {
291
         0,  1,  0, -1
292
    };
293

    
294
    hilbert_walk_mb[0] = 1;
295
    hilbert_walk_mb[1] = s->macroblock_width;
296
    hilbert_walk_mb[2] = 1;
297
    hilbert_walk_mb[3] = -s->macroblock_width;
298

    
299
    /* iterate through each superblock (all planes) and map the fragments */
300
    for (i = 0; i < s->superblock_count; i++) {
301
        /* time to re-assign the limits? */
302
        if (i == 0) {
303

    
304
            /* start of Y superblocks */
305
            right_edge = s->fragment_width;
306
            bottom_edge = s->fragment_height;
307
            current_width = -1;
308
            current_height = 0;
309
            superblock_row_inc = 3 * s->fragment_width -
310
                (s->y_superblock_width * 4 - s->fragment_width);
311

    
312
            /* the first operation for this variable is to advance by 1 */
313
            current_fragment = -1;
314

    
315
        } else if (i == s->u_superblock_start) {
316

    
317
            /* start of U superblocks */
318
            right_edge = s->fragment_width / 2;
319
            bottom_edge = s->fragment_height / 2;
320
            current_width = -1;
321
            current_height = 0;
322
            superblock_row_inc = 3 * (s->fragment_width / 2) -
323
                (s->c_superblock_width * 4 - s->fragment_width / 2);
324

    
325
            /* the first operation for this variable is to advance by 1 */
326
            current_fragment = s->fragment_start[1] - 1;
327

    
328
        } else if (i == s->v_superblock_start) {
329

    
330
            /* start of V superblocks */
331
            right_edge = s->fragment_width / 2;
332
            bottom_edge = s->fragment_height / 2;
333
            current_width = -1;
334
            current_height = 0;
335
            superblock_row_inc = 3 * (s->fragment_width / 2) -
336
                (s->c_superblock_width * 4 - s->fragment_width / 2);
337

    
338
            /* the first operation for this variable is to advance by 1 */
339
            current_fragment = s->fragment_start[2] - 1;
340

    
341
        }
342

    
343
        if (current_width >= right_edge - 1) {
344
            /* reset width and move to next superblock row */
345
            current_width = -1;
346
            current_height += 4;
347

    
348
            /* fragment is now at the start of a new superblock row */
349
            current_fragment += superblock_row_inc;
350
        }
351

    
352
        /* iterate through all 16 fragments in a superblock */
353
        for (j = 0; j < 16; j++) {
354
            current_fragment += travel_width[j] + right_edge * travel_height[j];
355
            current_width += travel_width[j];
356
            current_height += travel_height[j];
357

    
358
            /* check if the fragment is in bounds */
359
            if ((current_width < right_edge) &&
360
                (current_height < bottom_edge)) {
361
                s->superblock_fragments[mapping_index] = current_fragment;
362
            } else {
363
                s->superblock_fragments[mapping_index] = -1;
364
            }
365

    
366
            mapping_index++;
367
        }
368
    }
369

    
370
    /* initialize the superblock <-> macroblock mapping; iterate through
371
     * all of the Y plane superblocks to build this mapping */
372
    right_edge = s->macroblock_width;
373
    bottom_edge = s->macroblock_height;
374
    current_width = -1;
375
    current_height = 0;
376
    superblock_row_inc = s->macroblock_width -
377
        (s->y_superblock_width * 2 - s->macroblock_width);
378
    mapping_index = 0;
379
    current_macroblock = -1;
380
    for (i = 0; i < s->u_superblock_start; i++) {
381

    
382
        if (current_width >= right_edge - 1) {
383
            /* reset width and move to next superblock row */
384
            current_width = -1;
385
            current_height += 2;
386

    
387
            /* macroblock is now at the start of a new superblock row */
388
            current_macroblock += superblock_row_inc;
389
        }
390

    
391
        /* iterate through each potential macroblock in the superblock */
392
        for (j = 0; j < 4; j++) {
393
            current_macroblock += hilbert_walk_mb[j];
394
            current_width += travel_width_mb[j];
395
            current_height += travel_height_mb[j];
396

    
397
            /* check if the macroblock is in bounds */
398
            if ((current_width < right_edge) &&
399
                (current_height < bottom_edge)) {
400
                s->superblock_macroblocks[mapping_index] = current_macroblock;
401
            } else {
402
                s->superblock_macroblocks[mapping_index] = -1;
403
            }
404

    
405
            mapping_index++;
406
        }
407
    }
408

    
409
    /* initialize the macroblock <-> fragment mapping */
410
    current_fragment = 0;
411
    current_macroblock = 0;
412
    mapping_index = 0;
413
    for (i = 0; i < s->fragment_height; i += 2) {
414

    
415
        for (j = 0; j < s->fragment_width; j += 2) {
416

    
417
            s->all_fragments[current_fragment].macroblock = current_macroblock;
418
            s->macroblock_fragments[mapping_index++] = current_fragment;
419

    
420
            if (j + 1 < s->fragment_width) {
421
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
422
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
423
            } else
424
                s->macroblock_fragments[mapping_index++] = -1;
425

    
426
            if (i + 1 < s->fragment_height) {
427
                s->all_fragments[current_fragment + s->fragment_width].macroblock =
428
                    current_macroblock;
429
                s->macroblock_fragments[mapping_index++] =
430
                    current_fragment + s->fragment_width;
431
            } else
432
                s->macroblock_fragments[mapping_index++] = -1;
433

    
434
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
435
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
436
                    current_macroblock;
437
                s->macroblock_fragments[mapping_index++] =
438
                    current_fragment + s->fragment_width + 1;
439
            } else
440
                s->macroblock_fragments[mapping_index++] = -1;
441

    
442
            /* C planes */
443
            c_fragment = s->fragment_start[1] +
444
                (i * s->fragment_width / 4) + (j / 2);
445
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
446
            s->macroblock_fragments[mapping_index++] = c_fragment;
447

    
448
            c_fragment = s->fragment_start[2] +
449
                (i * s->fragment_width / 4) + (j / 2);
450
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
451
            s->macroblock_fragments[mapping_index++] = c_fragment;
452

    
453
            if (j + 2 <= s->fragment_width)
454
                current_fragment += 2;
455
            else
456
                current_fragment++;
457
            current_macroblock++;
458
        }
459

    
460
        current_fragment += s->fragment_width;
461
    }
462

    
463
    return 0;  /* successful path out */
464
}
465

    
466
/*
467
 * This function wipes out all of the fragment data.
468
 */
469
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
470
{
471
    int i;
472

    
473
    /* zero out all of the fragment information */
474
    s->coded_fragment_list_index = 0;
475
    for (i = 0; i < s->fragment_count; i++) {
476
        s->coeff_counts[i] = 0;
477
        s->all_fragments[i].motion_x = 127;
478
        s->all_fragments[i].motion_y = 127;
479
        s->all_fragments[i].next_coeff= NULL;
480
        s->all_fragments[i].qpi = 0;
481
        s->coeffs[i].index=
482
        s->coeffs[i].coeff=0;
483
        s->coeffs[i].next= NULL;
484
    }
485
}
486

    
487
/*
488
 * This function sets up the dequantization tables used for a particular
489
 * frame.
490
 */
491
static void init_dequantizer(Vp3DecodeContext *s, int qpi)
492
{
493
    int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];
494
    int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]];
495
    int i, plane, inter, qri, bmi, bmj, qistart;
496

    
497
    for(inter=0; inter<2; inter++){
498
        for(plane=0; plane<3; plane++){
499
            int sum=0;
500
            for(qri=0; qri<s->qr_count[inter][plane]; qri++){
501
                sum+= s->qr_size[inter][plane][qri];
502
                if(s->qps[qpi] <= sum)
503
                    break;
504
            }
505
            qistart= sum - s->qr_size[inter][plane][qri];
506
            bmi= s->qr_base[inter][plane][qri  ];
507
            bmj= s->qr_base[inter][plane][qri+1];
508
            for(i=0; i<64; i++){
509
                int coeff= (  2*(sum    -s->qps[qpi])*s->base_matrix[bmi][i]
510
                            - 2*(qistart-s->qps[qpi])*s->base_matrix[bmj][i]
511
                            + s->qr_size[inter][plane][qri])
512
                           / (2*s->qr_size[inter][plane][qri]);
513

    
514
                int qmin= 8<<(inter + !i);
515
                int qscale= i ? ac_scale_factor : dc_scale_factor;
516

    
517
                s->qmat[qpi][inter][plane][s->dsp.idct_permutation[i]]= av_clip((qscale * coeff)/100 * 4, qmin, 4096);
518
            }
519
            // all DC coefficients use the same quant so as not to interfere with DC prediction
520
            s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];
521
        }
522
    }
523

    
524
    memset(s->qscale_table, (FFMAX(s->qmat[0][0][0][1], s->qmat[0][0][1][1])+8)/16, 512); //FIXME finetune
525
}
526

    
527
/*
528
 * This function initializes the loop filter boundary limits if the frame's
529
 * quality index is different from the previous frame's.
530
 *
531
 * The filter_limit_values may not be larger than 127.
532
 */
533
static void init_loop_filter(Vp3DecodeContext *s)
534
{
535
    int *bounding_values= s->bounding_values_array+127;
536
    int filter_limit;
537
    int x;
538
    int value;
539

    
540
    filter_limit = s->filter_limit_values[s->qps[0]];
541

    
542
    /* set up the bounding values */
543
    memset(s->bounding_values_array, 0, 256 * sizeof(int));
544
    for (x = 0; x < filter_limit; x++) {
545
        bounding_values[-x] = -x;
546
        bounding_values[x] = x;
547
    }
548
    for (x = value = filter_limit; x < 128 && value; x++, value--) {
549
        bounding_values[ x] =  value;
550
        bounding_values[-x] = -value;
551
    }
552
    if (value)
553
        bounding_values[128] = value;
554
    bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
555
}
556

    
557
/*
558
 * This function unpacks all of the superblock/macroblock/fragment coding
559
 * information from the bitstream.
560
 */
561
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
562
{
563
    int bit = 0;
564
    int current_superblock = 0;
565
    int current_run = 0;
566
    int decode_fully_flags = 0;
567
    int decode_partial_blocks = 0;
568
    int first_c_fragment_seen;
569

    
570
    int i, j;
571
    int current_fragment;
572

    
573
    if (s->keyframe) {
574
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
575

    
576
    } else {
577

    
578
        /* unpack the list of partially-coded superblocks */
579
        bit = get_bits1(gb);
580
        /* toggle the bit because as soon as the first run length is
581
         * fetched the bit will be toggled again */
582
        bit ^= 1;
583
        while (current_superblock < s->superblock_count) {
584
            if (current_run-- == 0) {
585
                bit ^= 1;
586
                current_run = get_vlc2(gb,
587
                    s->superblock_run_length_vlc.table, 6, 2);
588
                if (current_run == 33)
589
                    current_run += get_bits(gb, 12);
590

    
591
                /* if any of the superblocks are not partially coded, flag
592
                 * a boolean to decode the list of fully-coded superblocks */
593
                if (bit == 0) {
594
                    decode_fully_flags = 1;
595
                } else {
596

    
597
                    /* make a note of the fact that there are partially coded
598
                     * superblocks */
599
                    decode_partial_blocks = 1;
600
                }
601
            }
602
            s->superblock_coding[current_superblock++] = bit;
603
        }
604

    
605
        /* unpack the list of fully coded superblocks if any of the blocks were
606
         * not marked as partially coded in the previous step */
607
        if (decode_fully_flags) {
608

    
609
            current_superblock = 0;
610
            current_run = 0;
611
            bit = get_bits1(gb);
612
            /* toggle the bit because as soon as the first run length is
613
             * fetched the bit will be toggled again */
614
            bit ^= 1;
615
            while (current_superblock < s->superblock_count) {
616

    
617
                /* skip any superblocks already marked as partially coded */
618
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
619

    
620
                    if (current_run-- == 0) {
621
                        bit ^= 1;
622
                        current_run = get_vlc2(gb,
623
                            s->superblock_run_length_vlc.table, 6, 2);
624
                        if (current_run == 33)
625
                            current_run += get_bits(gb, 12);
626
                    }
627
                    s->superblock_coding[current_superblock] = 2*bit;
628
                }
629
                current_superblock++;
630
            }
631
        }
632

    
633
        /* if there were partial blocks, initialize bitstream for
634
         * unpacking fragment codings */
635
        if (decode_partial_blocks) {
636

    
637
            current_run = 0;
638
            bit = get_bits1(gb);
639
            /* toggle the bit because as soon as the first run length is
640
             * fetched the bit will be toggled again */
641
            bit ^= 1;
642
        }
643
    }
644

    
645
    /* figure out which fragments are coded; iterate through each
646
     * superblock (all planes) */
647
    s->coded_fragment_list_index = 0;
648
    s->next_coeff= s->coeffs + s->fragment_count;
649
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
650
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
651
    first_c_fragment_seen = 0;
652
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
653
    for (i = 0; i < s->superblock_count; i++) {
654

    
655
        /* iterate through all 16 fragments in a superblock */
656
        for (j = 0; j < 16; j++) {
657

    
658
            /* if the fragment is in bounds, check its coding status */
659
            current_fragment = s->superblock_fragments[i * 16 + j];
660
            if (current_fragment >= s->fragment_count) {
661
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
662
                    current_fragment, s->fragment_count);
663
                return 1;
664
            }
665
            if (current_fragment != -1) {
666
                if (s->superblock_coding[i] == SB_NOT_CODED) {
667

    
668
                    /* copy all the fragments from the prior frame */
669
                    s->all_fragments[current_fragment].coding_method =
670
                        MODE_COPY;
671

    
672
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
673

    
674
                    /* fragment may or may not be coded; this is the case
675
                     * that cares about the fragment coding runs */
676
                    if (current_run-- == 0) {
677
                        bit ^= 1;
678
                        current_run = get_vlc2(gb,
679
                            s->fragment_run_length_vlc.table, 5, 2);
680
                    }
681

    
682
                    if (bit) {
683
                        /* default mode; actual mode will be decoded in
684
                         * the next phase */
685
                        s->all_fragments[current_fragment].coding_method =
686
                            MODE_INTER_NO_MV;
687
                        s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
688
                        s->coded_fragment_list[s->coded_fragment_list_index] =
689
                            current_fragment;
690
                        if ((current_fragment >= s->fragment_start[1]) &&
691
                            (s->last_coded_y_fragment == -1) &&
692
                            (!first_c_fragment_seen)) {
693
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
694
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
695
                            first_c_fragment_seen = 1;
696
                        }
697
                        s->coded_fragment_list_index++;
698
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
699
                    } else {
700
                        /* not coded; copy this fragment from the prior frame */
701
                        s->all_fragments[current_fragment].coding_method =
702
                            MODE_COPY;
703
                    }
704

    
705
                } else {
706

    
707
                    /* fragments are fully coded in this superblock; actual
708
                     * coding will be determined in next step */
709
                    s->all_fragments[current_fragment].coding_method =
710
                        MODE_INTER_NO_MV;
711
                    s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
712
                    s->coded_fragment_list[s->coded_fragment_list_index] =
713
                        current_fragment;
714
                    if ((current_fragment >= s->fragment_start[1]) &&
715
                        (s->last_coded_y_fragment == -1) &&
716
                        (!first_c_fragment_seen)) {
717
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
718
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
719
                        first_c_fragment_seen = 1;
720
                    }
721
                    s->coded_fragment_list_index++;
722
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
723
                }
724
            }
725
        }
726
    }
727

    
728
    if (!first_c_fragment_seen)
729
        /* only Y fragments coded in this frame */
730
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
731
    else
732
        /* end the list of coded C fragments */
733
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
734

    
735
    for (i = 0; i < s->fragment_count - 1; i++) {
736
        s->fast_fragment_list[i] = i + 1;
737
    }
738
    s->fast_fragment_list[s->fragment_count - 1] = -1;
739

    
740
    if (s->last_coded_y_fragment == -1)
741
        s->fragment_list_y_head = -1;
742
    else {
743
        s->fragment_list_y_head = s->first_coded_y_fragment;
744
        s->fast_fragment_list[s->last_coded_y_fragment] = -1;
745
    }
746

    
747
    if (s->last_coded_c_fragment == -1)
748
        s->fragment_list_c_head = -1;
749
    else {
750
        s->fragment_list_c_head = s->first_coded_c_fragment;
751
        s->fast_fragment_list[s->last_coded_c_fragment] = -1;
752
    }
753

    
754
    return 0;
755
}
756

    
757
/*
758
 * This function unpacks all the coding mode data for individual macroblocks
759
 * from the bitstream.
760
 */
761
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
762
{
763
    int i, j, k;
764
    int scheme;
765
    int current_macroblock;
766
    int current_fragment;
767
    int coding_mode;
768
    int custom_mode_alphabet[CODING_MODE_COUNT];
769

    
770
    if (s->keyframe) {
771
        for (i = 0; i < s->fragment_count; i++)
772
            s->all_fragments[i].coding_method = MODE_INTRA;
773

    
774
    } else {
775

    
776
        /* fetch the mode coding scheme for this frame */
777
        scheme = get_bits(gb, 3);
778

    
779
        /* is it a custom coding scheme? */
780
        if (scheme == 0) {
781
            for (i = 0; i < 8; i++)
782
                custom_mode_alphabet[i] = MODE_INTER_NO_MV;
783
            for (i = 0; i < 8; i++)
784
                custom_mode_alphabet[get_bits(gb, 3)] = i;
785
        }
786

    
787
        /* iterate through all of the macroblocks that contain 1 or more
788
         * coded fragments */
789
        for (i = 0; i < s->u_superblock_start; i++) {
790

    
791
            for (j = 0; j < 4; j++) {
792
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
793
                if ((current_macroblock == -1) ||
794
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
795
                    continue;
796
                if (current_macroblock >= s->macroblock_count) {
797
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
798
                        current_macroblock, s->macroblock_count);
799
                    return 1;
800
                }
801

    
802
                /* mode 7 means get 3 bits for each coding mode */
803
                if (scheme == 7)
804
                    coding_mode = get_bits(gb, 3);
805
                else if(scheme == 0)
806
                    coding_mode = custom_mode_alphabet
807
                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
808
                else
809
                    coding_mode = ModeAlphabet[scheme-1]
810
                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
811

    
812
                s->macroblock_coding[current_macroblock] = coding_mode;
813
                for (k = 0; k < 6; k++) {
814
                    current_fragment =
815
                        s->macroblock_fragments[current_macroblock * 6 + k];
816
                    if (current_fragment == -1)
817
                        continue;
818
                    if (current_fragment >= s->fragment_count) {
819
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
820
                            current_fragment, s->fragment_count);
821
                        return 1;
822
                    }
823
                    if (s->all_fragments[current_fragment].coding_method !=
824
                        MODE_COPY)
825
                        s->all_fragments[current_fragment].coding_method =
826
                            coding_mode;
827
                }
828
            }
829
        }
830
    }
831

    
832
    return 0;
833
}
834

    
835
/*
836
 * This function unpacks all the motion vectors for the individual
837
 * macroblocks from the bitstream.
838
 */
839
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
840
{
841
    int i, j, k, l;
842
    int coding_mode;
843
    int motion_x[6];
844
    int motion_y[6];
845
    int last_motion_x = 0;
846
    int last_motion_y = 0;
847
    int prior_last_motion_x = 0;
848
    int prior_last_motion_y = 0;
849
    int current_macroblock;
850
    int current_fragment;
851

    
852
    if (s->keyframe)
853
        return 0;
854

    
855
    memset(motion_x, 0, 6 * sizeof(int));
856
    memset(motion_y, 0, 6 * sizeof(int));
857

    
858
    /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
859
    coding_mode = get_bits1(gb);
860

    
861
    /* iterate through all of the macroblocks that contain 1 or more
862
     * coded fragments */
863
    for (i = 0; i < s->u_superblock_start; i++) {
864

    
865
        for (j = 0; j < 4; j++) {
866
            current_macroblock = s->superblock_macroblocks[i * 4 + j];
867
            if ((current_macroblock == -1) ||
868
                (s->macroblock_coding[current_macroblock] == MODE_COPY))
869
                continue;
870
            if (current_macroblock >= s->macroblock_count) {
871
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
872
                    current_macroblock, s->macroblock_count);
873
                return 1;
874
            }
875

    
876
            current_fragment = s->macroblock_fragments[current_macroblock * 6];
877
            if (current_fragment >= s->fragment_count) {
878
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
879
                    current_fragment, s->fragment_count);
880
                return 1;
881
            }
882
            switch (s->macroblock_coding[current_macroblock]) {
883

    
884
            case MODE_INTER_PLUS_MV:
885
            case MODE_GOLDEN_MV:
886
                /* all 6 fragments use the same motion vector */
887
                if (coding_mode == 0) {
888
                    motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
889
                    motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
890
                } else {
891
                    motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
892
                    motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
893
                }
894

    
895
                /* vector maintenance, only on MODE_INTER_PLUS_MV */
896
                if (s->macroblock_coding[current_macroblock] ==
897
                    MODE_INTER_PLUS_MV) {
898
                    prior_last_motion_x = last_motion_x;
899
                    prior_last_motion_y = last_motion_y;
900
                    last_motion_x = motion_x[0];
901
                    last_motion_y = motion_y[0];
902
                }
903
                break;
904

    
905
            case MODE_INTER_FOURMV:
906
                /* vector maintenance */
907
                prior_last_motion_x = last_motion_x;
908
                prior_last_motion_y = last_motion_y;
909

    
910
                /* fetch 4 vectors from the bitstream, one for each
911
                 * Y fragment, then average for the C fragment vectors */
912
                motion_x[4] = motion_y[4] = 0;
913
                for (k = 0; k < 4; k++) {
914
                    for (l = 0; l < s->coded_fragment_list_index; l++)
915
                        if (s->coded_fragment_list[l] == s->macroblock_fragments[6*current_macroblock + k])
916
                            break;
917
                    if (l < s->coded_fragment_list_index) {
918
                        if (coding_mode == 0) {
919
                            motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
920
                            motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
921
                        } else {
922
                            motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
923
                            motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
924
                        }
925
                        last_motion_x = motion_x[k];
926
                        last_motion_y = motion_y[k];
927
                    } else {
928
                        motion_x[k] = 0;
929
                        motion_y[k] = 0;
930
                    }
931
                    motion_x[4] += motion_x[k];
932
                    motion_y[4] += motion_y[k];
933
                }
934

    
935
                motion_x[5]=
936
                motion_x[4]= RSHIFT(motion_x[4], 2);
937
                motion_y[5]=
938
                motion_y[4]= RSHIFT(motion_y[4], 2);
939
                break;
940

    
941
            case MODE_INTER_LAST_MV:
942
                /* all 6 fragments use the last motion vector */
943
                motion_x[0] = last_motion_x;
944
                motion_y[0] = last_motion_y;
945

    
946
                /* no vector maintenance (last vector remains the
947
                 * last vector) */
948
                break;
949

    
950
            case MODE_INTER_PRIOR_LAST:
951
                /* all 6 fragments use the motion vector prior to the
952
                 * last motion vector */
953
                motion_x[0] = prior_last_motion_x;
954
                motion_y[0] = prior_last_motion_y;
955

    
956
                /* vector maintenance */
957
                prior_last_motion_x = last_motion_x;
958
                prior_last_motion_y = last_motion_y;
959
                last_motion_x = motion_x[0];
960
                last_motion_y = motion_y[0];
961
                break;
962

    
963
            default:
964
                /* covers intra, inter without MV, golden without MV */
965
                motion_x[0] = 0;
966
                motion_y[0] = 0;
967

    
968
                /* no vector maintenance */
969
                break;
970
            }
971

    
972
            /* assign the motion vectors to the correct fragments */
973
            for (k = 0; k < 6; k++) {
974
                current_fragment =
975
                    s->macroblock_fragments[current_macroblock * 6 + k];
976
                if (current_fragment == -1)
977
                    continue;
978
                if (current_fragment >= s->fragment_count) {
979
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
980
                        current_fragment, s->fragment_count);
981
                    return 1;
982
                }
983
                if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
984
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
985
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
986
                } else {
987
                    s->all_fragments[current_fragment].motion_x = motion_x[0];
988
                    s->all_fragments[current_fragment].motion_y = motion_y[0];
989
                }
990
            }
991
        }
992
    }
993

    
994
    return 0;
995
}
996

    
997
static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
998
{
999
    int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
1000
    int num_blocks = s->coded_fragment_list_index;
1001

    
1002
    for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) {
1003
        i = blocks_decoded = num_blocks_at_qpi = 0;
1004

    
1005
        bit = get_bits1(gb);
1006

    
1007
        do {
1008
            run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;
1009
            if (run_length == 34)
1010
                run_length += get_bits(gb, 12);
1011
            blocks_decoded += run_length;
1012

    
1013
            if (!bit)
1014
                num_blocks_at_qpi += run_length;
1015

    
1016
            for (j = 0; j < run_length; i++) {
1017
                if (i >= s->coded_fragment_list_index)
1018
                    return -1;
1019

    
1020
                if (s->all_fragments[s->coded_fragment_list[i]].qpi == qpi) {
1021
                    s->all_fragments[s->coded_fragment_list[i]].qpi += bit;
1022
                    j++;
1023
                }
1024
            }
1025

    
1026
            if (run_length == 4129)
1027
                bit = get_bits1(gb);
1028
            else
1029
                bit ^= 1;
1030
        } while (blocks_decoded < num_blocks);
1031

    
1032
        num_blocks -= num_blocks_at_qpi;
1033
    }
1034

    
1035
    return 0;
1036
}
1037

    
1038
/*
1039
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1040
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1041
 * data. This function unpacks all the VLCs for either the Y plane or both
1042
 * C planes, and is called for DC coefficients or different AC coefficient
1043
 * levels (since different coefficient types require different VLC tables.
1044
 *
1045
 * This function returns a residual eob run. E.g, if a particular token gave
1046
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1047
 * left in the current fragment range, 3 would be returned so that it could
1048
 * be passed into the next call to this same function.
1049
 */
1050
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1051
                        VLC *table, int coeff_index,
1052
                        int y_plane,
1053
                        int eob_run)
1054
{
1055
    int i;
1056
    int token;
1057
    int zero_run = 0;
1058
    DCTELEM coeff = 0;
1059
    Vp3Fragment *fragment;
1060
    int bits_to_get;
1061
    int next_fragment;
1062
    int previous_fragment;
1063
    int fragment_num;
1064
    int *list_head;
1065

    
1066
    /* local references to structure members to avoid repeated deferences */
1067
    uint8_t *perm= s->scantable.permutated;
1068
    int *coded_fragment_list = s->coded_fragment_list;
1069
    Vp3Fragment *all_fragments = s->all_fragments;
1070
    uint8_t *coeff_counts = s->coeff_counts;
1071
    VLC_TYPE (*vlc_table)[2] = table->table;
1072
    int *fast_fragment_list = s->fast_fragment_list;
1073

    
1074
    if (y_plane) {
1075
        next_fragment = s->fragment_list_y_head;
1076
        list_head = &s->fragment_list_y_head;
1077
    } else {
1078
        next_fragment = s->fragment_list_c_head;
1079
        list_head = &s->fragment_list_c_head;
1080
    }
1081

    
1082
    i = next_fragment;
1083
    previous_fragment = -1;  /* this indicates that the previous fragment is actually the list head */
1084
    while (i != -1) {
1085
        fragment_num = coded_fragment_list[i];
1086

    
1087
        if (coeff_counts[fragment_num] > coeff_index) {
1088
            previous_fragment = i;
1089
            i = fast_fragment_list[i];
1090
            continue;
1091
        }
1092
        fragment = &all_fragments[fragment_num];
1093

    
1094
        if (!eob_run) {
1095
            /* decode a VLC into a token */
1096
            token = get_vlc2(gb, vlc_table, 5, 3);
1097
            /* use the token to get a zero run, a coefficient, and an eob run */
1098
            if (token <= 6) {
1099
                eob_run = eob_run_base[token];
1100
                if (eob_run_get_bits[token])
1101
                    eob_run += get_bits(gb, eob_run_get_bits[token]);
1102
                coeff = zero_run = 0;
1103
            } else {
1104
                bits_to_get = coeff_get_bits[token];
1105
                if (bits_to_get)
1106
                    bits_to_get = get_bits(gb, bits_to_get);
1107
                coeff = coeff_tables[token][bits_to_get];
1108

    
1109
                zero_run = zero_run_base[token];
1110
                if (zero_run_get_bits[token])
1111
                    zero_run += get_bits(gb, zero_run_get_bits[token]);
1112
            }
1113
        }
1114

    
1115
        if (!eob_run) {
1116
            coeff_counts[fragment_num] += zero_run;
1117
            if (coeff_counts[fragment_num] < 64){
1118
                fragment->next_coeff->coeff= coeff;
1119
                fragment->next_coeff->index= perm[coeff_counts[fragment_num]++]; //FIXME perm here already?
1120
                fragment->next_coeff->next= s->next_coeff;
1121
                s->next_coeff->next=NULL;
1122
                fragment->next_coeff= s->next_coeff++;
1123
            }
1124
            /* previous fragment is now this fragment */
1125
            previous_fragment = i;
1126
        } else {
1127
            coeff_counts[fragment_num] |= 128;
1128
            eob_run--;
1129
            /* remove this fragment from the list */
1130
            if (previous_fragment != -1)
1131
                fast_fragment_list[previous_fragment] = fast_fragment_list[i];
1132
            else
1133
                *list_head = fast_fragment_list[i];
1134
            /* previous fragment remains unchanged */
1135
        }
1136

    
1137
        i = fast_fragment_list[i];
1138
    }
1139

    
1140
    return eob_run;
1141
}
1142

    
1143
static void reverse_dc_prediction(Vp3DecodeContext *s,
1144
                                  int first_fragment,
1145
                                  int fragment_width,
1146
                                  int fragment_height);
1147
/*
1148
 * This function unpacks all of the DCT coefficient data from the
1149
 * bitstream.
1150
 */
1151
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1152
{
1153
    int i;
1154
    int dc_y_table;
1155
    int dc_c_table;
1156
    int ac_y_table;
1157
    int ac_c_table;
1158
    int residual_eob_run = 0;
1159
    VLC *y_tables[64];
1160
    VLC *c_tables[64];
1161

    
1162
    /* fetch the DC table indexes */
1163
    dc_y_table = get_bits(gb, 4);
1164
    dc_c_table = get_bits(gb, 4);
1165

    
1166
    /* unpack the Y plane DC coefficients */
1167
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1168
        1, residual_eob_run);
1169

    
1170
    /* reverse prediction of the Y-plane DC coefficients */
1171
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
1172

    
1173
    /* unpack the C plane DC coefficients */
1174
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1175
        0, residual_eob_run);
1176

    
1177
    /* reverse prediction of the C-plane DC coefficients */
1178
    if (!(s->avctx->flags & CODEC_FLAG_GRAY))
1179
    {
1180
        reverse_dc_prediction(s, s->fragment_start[1],
1181
            s->fragment_width / 2, s->fragment_height / 2);
1182
        reverse_dc_prediction(s, s->fragment_start[2],
1183
            s->fragment_width / 2, s->fragment_height / 2);
1184
    }
1185

    
1186
    /* fetch the AC table indexes */
1187
    ac_y_table = get_bits(gb, 4);
1188
    ac_c_table = get_bits(gb, 4);
1189

    
1190
    /* build tables of AC VLC tables */
1191
    for (i = 1; i <= 5; i++) {
1192
        y_tables[i] = &s->ac_vlc_1[ac_y_table];
1193
        c_tables[i] = &s->ac_vlc_1[ac_c_table];
1194
    }
1195
    for (i = 6; i <= 14; i++) {
1196
        y_tables[i] = &s->ac_vlc_2[ac_y_table];
1197
        c_tables[i] = &s->ac_vlc_2[ac_c_table];
1198
    }
1199
    for (i = 15; i <= 27; i++) {
1200
        y_tables[i] = &s->ac_vlc_3[ac_y_table];
1201
        c_tables[i] = &s->ac_vlc_3[ac_c_table];
1202
    }
1203
    for (i = 28; i <= 63; i++) {
1204
        y_tables[i] = &s->ac_vlc_4[ac_y_table];
1205
        c_tables[i] = &s->ac_vlc_4[ac_c_table];
1206
    }
1207

    
1208
    /* decode all AC coefficents */
1209
    for (i = 1; i <= 63; i++) {
1210
        if (s->fragment_list_y_head != -1)
1211
            residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,
1212
                1, residual_eob_run);
1213

    
1214
        if (s->fragment_list_c_head != -1)
1215
            residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
1216
                0, residual_eob_run);
1217
    }
1218

    
1219
    return 0;
1220
}
1221

    
1222
/*
1223
 * This function reverses the DC prediction for each coded fragment in
1224
 * the frame. Much of this function is adapted directly from the original
1225
 * VP3 source code.
1226
 */
1227
#define COMPATIBLE_FRAME(x) \
1228
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1229
#define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1230

    
1231
static void reverse_dc_prediction(Vp3DecodeContext *s,
1232
                                  int first_fragment,
1233
                                  int fragment_width,
1234
                                  int fragment_height)
1235
{
1236

    
1237
#define PUL 8
1238
#define PU 4
1239
#define PUR 2
1240
#define PL 1
1241

    
1242
    int x, y;
1243
    int i = first_fragment;
1244

    
1245
    int predicted_dc;
1246

    
1247
    /* DC values for the left, up-left, up, and up-right fragments */
1248
    int vl, vul, vu, vur;
1249

    
1250
    /* indexes for the left, up-left, up, and up-right fragments */
1251
    int l, ul, u, ur;
1252

    
1253
    /*
1254
     * The 6 fields mean:
1255
     *   0: up-left multiplier
1256
     *   1: up multiplier
1257
     *   2: up-right multiplier
1258
     *   3: left multiplier
1259
     */
1260
    static const int predictor_transform[16][4] = {
1261
        {  0,  0,  0,  0},
1262
        {  0,  0,  0,128},        // PL
1263
        {  0,  0,128,  0},        // PUR
1264
        {  0,  0, 53, 75},        // PUR|PL
1265
        {  0,128,  0,  0},        // PU
1266
        {  0, 64,  0, 64},        // PU|PL
1267
        {  0,128,  0,  0},        // PU|PUR
1268
        {  0,  0, 53, 75},        // PU|PUR|PL
1269
        {128,  0,  0,  0},        // PUL
1270
        {  0,  0,  0,128},        // PUL|PL
1271
        { 64,  0, 64,  0},        // PUL|PUR
1272
        {  0,  0, 53, 75},        // PUL|PUR|PL
1273
        {  0,128,  0,  0},        // PUL|PU
1274
       {-104,116,  0,116},        // PUL|PU|PL
1275
        { 24, 80, 24,  0},        // PUL|PU|PUR
1276
       {-104,116,  0,116}         // PUL|PU|PUR|PL
1277
    };
1278

    
1279
    /* This table shows which types of blocks can use other blocks for
1280
     * prediction. For example, INTRA is the only mode in this table to
1281
     * have a frame number of 0. That means INTRA blocks can only predict
1282
     * from other INTRA blocks. There are 2 golden frame coding types;
1283
     * blocks encoding in these modes can only predict from other blocks
1284
     * that were encoded with these 1 of these 2 modes. */
1285
    static const unsigned char compatible_frame[9] = {
1286
        1,    /* MODE_INTER_NO_MV */
1287
        0,    /* MODE_INTRA */
1288
        1,    /* MODE_INTER_PLUS_MV */
1289
        1,    /* MODE_INTER_LAST_MV */
1290
        1,    /* MODE_INTER_PRIOR_MV */
1291
        2,    /* MODE_USING_GOLDEN */
1292
        2,    /* MODE_GOLDEN_MV */
1293
        1,    /* MODE_INTER_FOUR_MV */
1294
        3     /* MODE_COPY */
1295
    };
1296
    int current_frame_type;
1297

    
1298
    /* there is a last DC predictor for each of the 3 frame types */
1299
    short last_dc[3];
1300

    
1301
    int transform = 0;
1302

    
1303
    vul = vu = vur = vl = 0;
1304
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
1305

    
1306
    /* for each fragment row... */
1307
    for (y = 0; y < fragment_height; y++) {
1308

    
1309
        /* for each fragment in a row... */
1310
        for (x = 0; x < fragment_width; x++, i++) {
1311

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

    
1315
                current_frame_type =
1316
                    compatible_frame[s->all_fragments[i].coding_method];
1317

    
1318
                transform= 0;
1319
                if(x){
1320
                    l= i-1;
1321
                    vl = DC_COEFF(l);
1322
                    if(COMPATIBLE_FRAME(l))
1323
                        transform |= PL;
1324
                }
1325
                if(y){
1326
                    u= i-fragment_width;
1327
                    vu = DC_COEFF(u);
1328
                    if(COMPATIBLE_FRAME(u))
1329
                        transform |= PU;
1330
                    if(x){
1331
                        ul= i-fragment_width-1;
1332
                        vul = DC_COEFF(ul);
1333
                        if(COMPATIBLE_FRAME(ul))
1334
                            transform |= PUL;
1335
                    }
1336
                    if(x + 1 < fragment_width){
1337
                        ur= i-fragment_width+1;
1338
                        vur = DC_COEFF(ur);
1339
                        if(COMPATIBLE_FRAME(ur))
1340
                            transform |= PUR;
1341
                    }
1342
                }
1343

    
1344
                if (transform == 0) {
1345

    
1346
                    /* if there were no fragments to predict from, use last
1347
                     * DC saved */
1348
                    predicted_dc = last_dc[current_frame_type];
1349
                } else {
1350

    
1351
                    /* apply the appropriate predictor transform */
1352
                    predicted_dc =
1353
                        (predictor_transform[transform][0] * vul) +
1354
                        (predictor_transform[transform][1] * vu) +
1355
                        (predictor_transform[transform][2] * vur) +
1356
                        (predictor_transform[transform][3] * vl);
1357

    
1358
                    predicted_dc /= 128;
1359

    
1360
                    /* check for outranging on the [ul u l] and
1361
                     * [ul u ur l] predictors */
1362
                    if ((transform == 15) || (transform == 13)) {
1363
                        if (FFABS(predicted_dc - vu) > 128)
1364
                            predicted_dc = vu;
1365
                        else if (FFABS(predicted_dc - vl) > 128)
1366
                            predicted_dc = vl;
1367
                        else if (FFABS(predicted_dc - vul) > 128)
1368
                            predicted_dc = vul;
1369
                    }
1370
                }
1371

    
1372
                /* at long last, apply the predictor */
1373
                if(s->coeffs[i].index){
1374
                    *s->next_coeff= s->coeffs[i];
1375
                    s->coeffs[i].index=0;
1376
                    s->coeffs[i].coeff=0;
1377
                    s->coeffs[i].next= s->next_coeff++;
1378
                }
1379
                s->coeffs[i].coeff += predicted_dc;
1380
                /* save the DC */
1381
                last_dc[current_frame_type] = DC_COEFF(i);
1382
                if(DC_COEFF(i) && !(s->coeff_counts[i]&127)){
1383
                    s->coeff_counts[i]= 129;
1384
//                    s->all_fragments[i].next_coeff= s->next_coeff;
1385
                    s->coeffs[i].next= s->next_coeff;
1386
                    (s->next_coeff++)->next=NULL;
1387
                }
1388
            }
1389
        }
1390
    }
1391
}
1392

    
1393
static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)
1394
{
1395
    int x, y;
1396
    int *bounding_values= s->bounding_values_array+127;
1397

    
1398
    int width           = s->fragment_width  >> !!plane;
1399
    int height          = s->fragment_height >> !!plane;
1400
    int fragment        = s->fragment_start        [plane] + ystart * width;
1401
    int stride          = s->current_frame.linesize[plane];
1402
    uint8_t *plane_data = s->current_frame.data    [plane];
1403
    if (!s->flipped_image) stride = -stride;
1404

    
1405
    for (y = ystart; y < yend; y++) {
1406

    
1407
        for (x = 0; x < width; x++) {
1408
            /* This code basically just deblocks on the edges of coded blocks.
1409
             * However, it has to be much more complicated because of the
1410
             * braindamaged deblock ordering used in VP3/Theora. Order matters
1411
             * because some pixels get filtered twice. */
1412
            if( s->all_fragments[fragment].coding_method != MODE_COPY )
1413
            {
1414
                /* do not perform left edge filter for left columns frags */
1415
                if (x > 0) {
1416
                    s->dsp.vp3_h_loop_filter(
1417
                        plane_data + s->all_fragments[fragment].first_pixel,
1418
                        stride, bounding_values);
1419
                }
1420

    
1421
                /* do not perform top edge filter for top row fragments */
1422
                if (y > 0) {
1423
                    s->dsp.vp3_v_loop_filter(
1424
                        plane_data + s->all_fragments[fragment].first_pixel,
1425
                        stride, bounding_values);
1426
                }
1427

    
1428
                /* do not perform right edge filter for right column
1429
                 * fragments or if right fragment neighbor is also coded
1430
                 * in this frame (it will be filtered in next iteration) */
1431
                if ((x < width - 1) &&
1432
                    (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
1433
                    s->dsp.vp3_h_loop_filter(
1434
                        plane_data + s->all_fragments[fragment + 1].first_pixel,
1435
                        stride, bounding_values);
1436
                }
1437

    
1438
                /* do not perform bottom edge filter for bottom row
1439
                 * fragments or if bottom fragment neighbor is also coded
1440
                 * in this frame (it will be filtered in the next row) */
1441
                if ((y < height - 1) &&
1442
                    (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
1443
                    s->dsp.vp3_v_loop_filter(
1444
                        plane_data + s->all_fragments[fragment + width].first_pixel,
1445
                        stride, bounding_values);
1446
                }
1447
            }
1448

    
1449
            fragment++;
1450
        }
1451
    }
1452
}
1453

    
1454
/**
1455
 * called when all pixels up to row y are complete
1456
 */
1457
static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
1458
{
1459
    int h, cy;
1460
    int offset[4];
1461

    
1462
    if(s->avctx->draw_horiz_band==NULL)
1463
        return;
1464

    
1465
    h= y - s->last_slice_end;
1466
    y -= h;
1467

    
1468
    if (!s->flipped_image) {
1469
        if (y == 0)
1470
            h -= s->height - s->avctx->height;  // account for non-mod16
1471
        y = s->height - y - h;
1472
    }
1473

    
1474
    cy = y >> 1;
1475
    offset[0] = s->current_frame.linesize[0]*y;
1476
    offset[1] = s->current_frame.linesize[1]*cy;
1477
    offset[2] = s->current_frame.linesize[2]*cy;
1478
    offset[3] = 0;
1479

    
1480
    emms_c();
1481
    s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h);
1482
    s->last_slice_end= y + h;
1483
}
1484

    
1485
/*
1486
 * Perform the final rendering for a particular slice of data.
1487
 * The slice number ranges from 0..(macroblock_height - 1).
1488
 */
1489
static void render_slice(Vp3DecodeContext *s, int slice)
1490
{
1491
    int x;
1492
    int16_t *dequantizer;
1493
    DECLARE_ALIGNED_16(DCTELEM, block)[64];
1494
    int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1495
    int motion_halfpel_index;
1496
    uint8_t *motion_source;
1497
    int plane;
1498
    int current_macroblock_entry = slice * s->macroblock_width * 6;
1499

    
1500
    if (slice >= s->macroblock_height)
1501
        return;
1502

    
1503
    for (plane = 0; plane < 3; plane++) {
1504
        uint8_t *output_plane = s->current_frame.data    [plane];
1505
        uint8_t *  last_plane = s->   last_frame.data    [plane];
1506
        uint8_t *golden_plane = s-> golden_frame.data    [plane];
1507
        int stride            = s->current_frame.linesize[plane];
1508
        int plane_width       = s->width  >> !!plane;
1509
        int plane_height      = s->height >> !!plane;
1510
        int y =        slice *  FRAGMENT_PIXELS << !plane ;
1511
        int slice_height = y + (FRAGMENT_PIXELS << !plane);
1512
        int i = s->macroblock_fragments[current_macroblock_entry + plane + 3*!!plane];
1513

    
1514
        if (!s->flipped_image) stride = -stride;
1515

    
1516

    
1517
        if(FFABS(stride) > 2048)
1518
            return; //various tables are fixed size
1519

    
1520
        /* for each fragment row in the slice (both of them)... */
1521
        for (; y < slice_height; y += 8) {
1522

    
1523
            /* for each fragment in a row... */
1524
            for (x = 0; x < plane_width; x += 8, i++) {
1525

    
1526
                if ((i < 0) || (i >= s->fragment_count)) {
1527
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:render_slice(): bad fragment number (%d)\n", i);
1528
                    return;
1529
                }
1530

    
1531
                /* transform if this block was coded */
1532
                if ((s->all_fragments[i].coding_method != MODE_COPY) &&
1533
                    !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
1534

    
1535
                    if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
1536
                        (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
1537
                        motion_source= golden_plane;
1538
                    else
1539
                        motion_source= last_plane;
1540

    
1541
                    motion_source += s->all_fragments[i].first_pixel;
1542
                    motion_halfpel_index = 0;
1543

    
1544
                    /* sort out the motion vector if this fragment is coded
1545
                     * using a motion vector method */
1546
                    if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
1547
                        (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
1548
                        int src_x, src_y;
1549
                        motion_x = s->all_fragments[i].motion_x;
1550
                        motion_y = s->all_fragments[i].motion_y;
1551
                        if(plane){
1552
                            motion_x= (motion_x>>1) | (motion_x&1);
1553
                            motion_y= (motion_y>>1) | (motion_y&1);
1554
                        }
1555

    
1556
                        src_x= (motion_x>>1) + x;
1557
                        src_y= (motion_y>>1) + y;
1558
                        if ((motion_x == 127) || (motion_y == 127))
1559
                            av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
1560

    
1561
                        motion_halfpel_index = motion_x & 0x01;
1562
                        motion_source += (motion_x >> 1);
1563

    
1564
                        motion_halfpel_index |= (motion_y & 0x01) << 1;
1565
                        motion_source += ((motion_y >> 1) * stride);
1566

    
1567
                        if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
1568
                            uint8_t *temp= s->edge_emu_buffer;
1569
                            if(stride<0) temp -= 9*stride;
1570
                            else temp += 9*stride;
1571

    
1572
                            ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
1573
                            motion_source= temp;
1574
                        }
1575
                    }
1576

    
1577

    
1578
                    /* first, take care of copying a block from either the
1579
                     * previous or the golden frame */
1580
                    if (s->all_fragments[i].coding_method != MODE_INTRA) {
1581
                        /* Note, it is possible to implement all MC cases with
1582
                           put_no_rnd_pixels_l2 which would look more like the
1583
                           VP3 source but this would be slower as
1584
                           put_no_rnd_pixels_tab is better optimzed */
1585
                        if(motion_halfpel_index != 3){
1586
                            s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
1587
                                output_plane + s->all_fragments[i].first_pixel,
1588
                                motion_source, stride, 8);
1589
                        }else{
1590
                            int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
1591
                            s->dsp.put_no_rnd_pixels_l2[1](
1592
                                output_plane + s->all_fragments[i].first_pixel,
1593
                                motion_source - d,
1594
                                motion_source + stride + 1 + d,
1595
                                stride, 8);
1596
                        }
1597
                        dequantizer = s->qmat[s->all_fragments[i].qpi][1][plane];
1598
                    }else{
1599
                        dequantizer = s->qmat[s->all_fragments[i].qpi][0][plane];
1600
                    }
1601

    
1602
                    /* dequantize the DCT coefficients */
1603
                    if(s->avctx->idct_algo==FF_IDCT_VP3){
1604
                        Coeff *coeff= s->coeffs + i;
1605
                        s->dsp.clear_block(block);
1606
                        while(coeff->next){
1607
                            block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
1608
                            coeff= coeff->next;
1609
                        }
1610
                    }else{
1611
                        Coeff *coeff= s->coeffs + i;
1612
                        s->dsp.clear_block(block);
1613
                        while(coeff->next){
1614
                            block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
1615
                            coeff= coeff->next;
1616
                        }
1617
                    }
1618

    
1619
                    /* invert DCT and place (or add) in final output */
1620

    
1621
                    if (s->all_fragments[i].coding_method == MODE_INTRA) {
1622
                        if(s->avctx->idct_algo!=FF_IDCT_VP3)
1623
                            block[0] += 128<<3;
1624
                        s->dsp.idct_put(
1625
                            output_plane + s->all_fragments[i].first_pixel,
1626
                            stride,
1627
                            block);
1628
                    } else {
1629
                        s->dsp.idct_add(
1630
                            output_plane + s->all_fragments[i].first_pixel,
1631
                            stride,
1632
                            block);
1633
                    }
1634
                } else {
1635

    
1636
                    /* copy directly from the previous frame */
1637
                    s->dsp.put_pixels_tab[1][0](
1638
                        output_plane + s->all_fragments[i].first_pixel,
1639
                        last_plane + s->all_fragments[i].first_pixel,
1640
                        stride, 8);
1641

    
1642
                }
1643
            }
1644
            // Filter the previous block row. We can't filter the current row yet
1645
            // since it needs pixels from the next row
1646
            if (y > 0)
1647
                apply_loop_filter(s, plane, (y>>3)-1, (y>>3));
1648
        }
1649
    }
1650

    
1651
     /* this looks like a good place for slice dispatch... */
1652
     /* algorithm:
1653
      *   if (slice == s->macroblock_height - 1)
1654
      *     dispatch (both last slice & 2nd-to-last slice);
1655
      *   else if (slice > 0)
1656
      *     dispatch (slice - 1);
1657
      */
1658

    
1659
    // now that we've filtered the last rows, they're safe to display
1660
    if (slice)
1661
        vp3_draw_horiz_band(s, 16*slice);
1662
}
1663

    
1664
/*
1665
 * This function computes the first pixel addresses for each fragment.
1666
 * This function needs to be invoked after the first frame is allocated
1667
 * so that it has access to the plane strides.
1668
 */
1669
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
1670
{
1671
#define Y_INITIAL(chroma_shift)  s->flipped_image ? 1  : s->fragment_height >> chroma_shift
1672
#define Y_FINISHED(chroma_shift) s->flipped_image ? y <= s->fragment_height >> chroma_shift : y > 0
1673

    
1674
    int i, x, y;
1675
    const int y_inc = s->flipped_image ? 1 : -1;
1676

    
1677
    /* figure out the first pixel addresses for each of the fragments */
1678
    /* Y plane */
1679
    i = 0;
1680
    for (y = Y_INITIAL(0); Y_FINISHED(0); y += y_inc) {
1681
        for (x = 0; x < s->fragment_width; x++) {
1682
            s->all_fragments[i++].first_pixel =
1683
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
1684
                    s->golden_frame.linesize[0] +
1685
                    x * FRAGMENT_PIXELS;
1686
        }
1687
    }
1688

    
1689
    /* U plane */
1690
    i = s->fragment_start[1];
1691
    for (y = Y_INITIAL(1); Y_FINISHED(1); y += y_inc) {
1692
        for (x = 0; x < s->fragment_width / 2; x++) {
1693
            s->all_fragments[i++].first_pixel =
1694
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
1695
                    s->golden_frame.linesize[1] +
1696
                    x * FRAGMENT_PIXELS;
1697
        }
1698
    }
1699

    
1700
    /* V plane */
1701
    i = s->fragment_start[2];
1702
    for (y = Y_INITIAL(1); Y_FINISHED(1); y += y_inc) {
1703
        for (x = 0; x < s->fragment_width / 2; x++) {
1704
            s->all_fragments[i++].first_pixel =
1705
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
1706
                    s->golden_frame.linesize[2] +
1707
                    x * FRAGMENT_PIXELS;
1708
        }
1709
    }
1710
}
1711

    
1712
/*
1713
 * This is the ffmpeg/libavcodec API init function.
1714
 */
1715
static av_cold int vp3_decode_init(AVCodecContext *avctx)
1716
{
1717
    Vp3DecodeContext *s = avctx->priv_data;
1718
    int i, inter, plane;
1719
    int c_width;
1720
    int c_height;
1721
    int y_superblock_count;
1722
    int c_superblock_count;
1723

    
1724
    if (avctx->codec_tag == MKTAG('V','P','3','0'))
1725
        s->version = 0;
1726
    else
1727
        s->version = 1;
1728

    
1729
    s->avctx = avctx;
1730
    s->width = FFALIGN(avctx->width, 16);
1731
    s->height = FFALIGN(avctx->height, 16);
1732
    avctx->pix_fmt = PIX_FMT_YUV420P;
1733
    avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
1734
    if(avctx->idct_algo==FF_IDCT_AUTO)
1735
        avctx->idct_algo=FF_IDCT_VP3;
1736
    dsputil_init(&s->dsp, avctx);
1737

    
1738
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1739

    
1740
    /* initialize to an impossible value which will force a recalculation
1741
     * in the first frame decode */
1742
    for (i = 0; i < 3; i++)
1743
        s->qps[i] = -1;
1744

    
1745
    s->y_superblock_width = (s->width + 31) / 32;
1746
    s->y_superblock_height = (s->height + 31) / 32;
1747
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
1748

    
1749
    /* work out the dimensions for the C planes */
1750
    c_width = s->width / 2;
1751
    c_height = s->height / 2;
1752
    s->c_superblock_width = (c_width + 31) / 32;
1753
    s->c_superblock_height = (c_height + 31) / 32;
1754
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
1755

    
1756
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
1757
    s->u_superblock_start = y_superblock_count;
1758
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
1759
    s->superblock_coding = av_malloc(s->superblock_count);
1760

    
1761
    s->macroblock_width = (s->width + 15) / 16;
1762
    s->macroblock_height = (s->height + 15) / 16;
1763
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
1764

    
1765
    s->fragment_width = s->width / FRAGMENT_PIXELS;
1766
    s->fragment_height = s->height / FRAGMENT_PIXELS;
1767

    
1768
    /* fragment count covers all 8x8 blocks for all 3 planes */
1769
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
1770
    s->fragment_start[1] = s->fragment_width * s->fragment_height;
1771
    s->fragment_start[2] = s->fragment_width * s->fragment_height * 5 / 4;
1772

    
1773
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
1774
    s->coeff_counts = av_malloc(s->fragment_count * sizeof(*s->coeff_counts));
1775
    s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
1776
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
1777
    s->fast_fragment_list = av_malloc(s->fragment_count * sizeof(int));
1778
    s->pixel_addresses_initialized = 0;
1779
    if (!s->superblock_coding || !s->all_fragments || !s->coeff_counts ||
1780
        !s->coeffs || !s->coded_fragment_list || !s->fast_fragment_list) {
1781
        vp3_decode_end(avctx);
1782
        return -1;
1783
    }
1784

    
1785
    if (!s->theora_tables)
1786
    {
1787
        for (i = 0; i < 64; i++) {
1788
            s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
1789
            s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
1790
            s->base_matrix[0][i] = vp31_intra_y_dequant[i];
1791
            s->base_matrix[1][i] = vp31_intra_c_dequant[i];
1792
            s->base_matrix[2][i] = vp31_inter_dequant[i];
1793
            s->filter_limit_values[i] = vp31_filter_limit_values[i];
1794
        }
1795

    
1796
        for(inter=0; inter<2; inter++){
1797
            for(plane=0; plane<3; plane++){
1798
                s->qr_count[inter][plane]= 1;
1799
                s->qr_size [inter][plane][0]= 63;
1800
                s->qr_base [inter][plane][0]=
1801
                s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
1802
            }
1803
        }
1804

    
1805
        /* init VLC tables */
1806
        for (i = 0; i < 16; i++) {
1807

    
1808
            /* DC histograms */
1809
            init_vlc(&s->dc_vlc[i], 5, 32,
1810
                &dc_bias[i][0][1], 4, 2,
1811
                &dc_bias[i][0][0], 4, 2, 0);
1812

    
1813
            /* group 1 AC histograms */
1814
            init_vlc(&s->ac_vlc_1[i], 5, 32,
1815
                &ac_bias_0[i][0][1], 4, 2,
1816
                &ac_bias_0[i][0][0], 4, 2, 0);
1817

    
1818
            /* group 2 AC histograms */
1819
            init_vlc(&s->ac_vlc_2[i], 5, 32,
1820
                &ac_bias_1[i][0][1], 4, 2,
1821
                &ac_bias_1[i][0][0], 4, 2, 0);
1822

    
1823
            /* group 3 AC histograms */
1824
            init_vlc(&s->ac_vlc_3[i], 5, 32,
1825
                &ac_bias_2[i][0][1], 4, 2,
1826
                &ac_bias_2[i][0][0], 4, 2, 0);
1827

    
1828
            /* group 4 AC histograms */
1829
            init_vlc(&s->ac_vlc_4[i], 5, 32,
1830
                &ac_bias_3[i][0][1], 4, 2,
1831
                &ac_bias_3[i][0][0], 4, 2, 0);
1832
        }
1833
    } else {
1834
        for (i = 0; i < 16; i++) {
1835

    
1836
            /* DC histograms */
1837
            if (init_vlc(&s->dc_vlc[i], 5, 32,
1838
                &s->huffman_table[i][0][1], 4, 2,
1839
                &s->huffman_table[i][0][0], 4, 2, 0) < 0)
1840
                goto vlc_fail;
1841

    
1842
            /* group 1 AC histograms */
1843
            if (init_vlc(&s->ac_vlc_1[i], 5, 32,
1844
                &s->huffman_table[i+16][0][1], 4, 2,
1845
                &s->huffman_table[i+16][0][0], 4, 2, 0) < 0)
1846
                goto vlc_fail;
1847

    
1848
            /* group 2 AC histograms */
1849
            if (init_vlc(&s->ac_vlc_2[i], 5, 32,
1850
                &s->huffman_table[i+16*2][0][1], 4, 2,
1851
                &s->huffman_table[i+16*2][0][0], 4, 2, 0) < 0)
1852
                goto vlc_fail;
1853

    
1854
            /* group 3 AC histograms */
1855
            if (init_vlc(&s->ac_vlc_3[i], 5, 32,
1856
                &s->huffman_table[i+16*3][0][1], 4, 2,
1857
                &s->huffman_table[i+16*3][0][0], 4, 2, 0) < 0)
1858
                goto vlc_fail;
1859

    
1860
            /* group 4 AC histograms */
1861
            if (init_vlc(&s->ac_vlc_4[i], 5, 32,
1862
                &s->huffman_table[i+16*4][0][1], 4, 2,
1863
                &s->huffman_table[i+16*4][0][0], 4, 2, 0) < 0)
1864
                goto vlc_fail;
1865
        }
1866
    }
1867

    
1868
    init_vlc(&s->superblock_run_length_vlc, 6, 34,
1869
        &superblock_run_length_vlc_table[0][1], 4, 2,
1870
        &superblock_run_length_vlc_table[0][0], 4, 2, 0);
1871

    
1872
    init_vlc(&s->fragment_run_length_vlc, 5, 30,
1873
        &fragment_run_length_vlc_table[0][1], 4, 2,
1874
        &fragment_run_length_vlc_table[0][0], 4, 2, 0);
1875

    
1876
    init_vlc(&s->mode_code_vlc, 3, 8,
1877
        &mode_code_vlc_table[0][1], 2, 1,
1878
        &mode_code_vlc_table[0][0], 2, 1, 0);
1879

    
1880
    init_vlc(&s->motion_vector_vlc, 6, 63,
1881
        &motion_vector_vlc_table[0][1], 2, 1,
1882
        &motion_vector_vlc_table[0][0], 2, 1, 0);
1883

    
1884
    /* work out the block mapping tables */
1885
    s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
1886
    s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
1887
    s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
1888
    s->macroblock_coding = av_malloc(s->macroblock_count + 1);
1889
    if (!s->superblock_fragments || !s->superblock_macroblocks ||
1890
        !s->macroblock_fragments || !s->macroblock_coding) {
1891
        vp3_decode_end(avctx);
1892
        return -1;
1893
    }
1894
    init_block_mapping(s);
1895

    
1896
    for (i = 0; i < 3; i++) {
1897
        s->current_frame.data[i] = NULL;
1898
        s->last_frame.data[i] = NULL;
1899
        s->golden_frame.data[i] = NULL;
1900
    }
1901

    
1902
    return 0;
1903

    
1904
vlc_fail:
1905
    av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");
1906
    return -1;
1907
}
1908

    
1909
/*
1910
 * This is the ffmpeg/libavcodec API frame decode function.
1911
 */
1912
static int vp3_decode_frame(AVCodecContext *avctx,
1913
                            void *data, int *data_size,
1914
                            AVPacket *avpkt)
1915
{
1916
    const uint8_t *buf = avpkt->data;
1917
    int buf_size = avpkt->size;
1918
    Vp3DecodeContext *s = avctx->priv_data;
1919
    GetBitContext gb;
1920
    static int counter = 0;
1921
    int i;
1922

    
1923
    init_get_bits(&gb, buf, buf_size * 8);
1924

    
1925
    if (s->theora && get_bits1(&gb))
1926
    {
1927
        av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n");
1928
        return -1;
1929
    }
1930

    
1931
    s->keyframe = !get_bits1(&gb);
1932
    if (!s->theora)
1933
        skip_bits(&gb, 1);
1934
    for (i = 0; i < 3; i++)
1935
        s->last_qps[i] = s->qps[i];
1936

    
1937
    s->nqps=0;
1938
    do{
1939
        s->qps[s->nqps++]= get_bits(&gb, 6);
1940
    } while(s->theora >= 0x030200 && s->nqps<3 && get_bits1(&gb));
1941
    for (i = s->nqps; i < 3; i++)
1942
        s->qps[i] = -1;
1943

    
1944
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
1945
        av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
1946
            s->keyframe?"key":"", counter, s->qps[0]);
1947
    counter++;
1948

    
1949
    if (s->qps[0] != s->last_qps[0])
1950
        init_loop_filter(s);
1951

    
1952
    for (i = 0; i < s->nqps; i++)
1953
        // reinit all dequantizers if the first one changed, because
1954
        // the DC of the first quantizer must be used for all matrices
1955
        if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])
1956
            init_dequantizer(s, i);
1957

    
1958
    if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)
1959
        return buf_size;
1960

    
1961
    if (s->keyframe) {
1962
        if (!s->theora)
1963
        {
1964
            skip_bits(&gb, 4); /* width code */
1965
            skip_bits(&gb, 4); /* height code */
1966
            if (s->version)
1967
            {
1968
                s->version = get_bits(&gb, 5);
1969
                if (counter == 1)
1970
                    av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
1971
            }
1972
        }
1973
        if (s->version || s->theora)
1974
        {
1975
                if (get_bits1(&gb))
1976
                    av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
1977
            skip_bits(&gb, 2); /* reserved? */
1978
        }
1979

    
1980
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
1981
            if (s->golden_frame.data[0])
1982
                avctx->release_buffer(avctx, &s->golden_frame);
1983
            s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
1984
        } else {
1985
            if (s->golden_frame.data[0])
1986
                avctx->release_buffer(avctx, &s->golden_frame);
1987
            if (s->last_frame.data[0])
1988
                avctx->release_buffer(avctx, &s->last_frame);
1989
        }
1990

    
1991
        s->golden_frame.reference = 3;
1992
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
1993
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
1994
            return -1;
1995
        }
1996

    
1997
        /* golden frame is also the current frame */
1998
        s->current_frame= s->golden_frame;
1999

    
2000
        /* time to figure out pixel addresses? */
2001
        if (!s->pixel_addresses_initialized)
2002
        {
2003
            vp3_calculate_pixel_addresses(s);
2004
            s->pixel_addresses_initialized = 1;
2005
        }
2006
    } else {
2007
        /* allocate a new current frame */
2008
        s->current_frame.reference = 3;
2009
        if (!s->pixel_addresses_initialized) {
2010
            av_log(s->avctx, AV_LOG_ERROR, "vp3: first frame not a keyframe\n");
2011
            return -1;
2012
        }
2013
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2014
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2015
            return -1;
2016
        }
2017
    }
2018

    
2019
    s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2020
    s->current_frame.qstride= 0;
2021

    
2022
    init_frame(s, &gb);
2023

    
2024
    if (unpack_superblocks(s, &gb)){
2025
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2026
        return -1;
2027
    }
2028
    if (unpack_modes(s, &gb)){
2029
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2030
        return -1;
2031
    }
2032
    if (unpack_vectors(s, &gb)){
2033
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2034
        return -1;
2035
    }
2036
    if (unpack_block_qpis(s, &gb)){
2037
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");
2038
        return -1;
2039
    }
2040
    if (unpack_dct_coeffs(s, &gb)){
2041
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2042
        return -1;
2043
    }
2044

    
2045
    s->last_slice_end = 0;
2046
    for (i = 0; i < s->macroblock_height; i++)
2047
        render_slice(s, i);
2048

    
2049
    // filter the last row
2050
    for (i = 0; i < 3; i++) {
2051
        int row = (s->height >> (3+!!i)) - 1;
2052
        apply_loop_filter(s, i, row, row+1);
2053
    }
2054
    vp3_draw_horiz_band(s, s->height);
2055

    
2056
    *data_size=sizeof(AVFrame);
2057
    *(AVFrame*)data= s->current_frame;
2058

    
2059
    /* release the last frame, if it is allocated and if it is not the
2060
     * golden frame */
2061
    if ((s->last_frame.data[0]) &&
2062
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2063
        avctx->release_buffer(avctx, &s->last_frame);
2064

    
2065
    /* shuffle frames (last = current) */
2066
    s->last_frame= s->current_frame;
2067
    s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
2068

    
2069
    return buf_size;
2070
}
2071

    
2072
/*
2073
 * This is the ffmpeg/libavcodec API module cleanup function.
2074
 */
2075
static av_cold int vp3_decode_end(AVCodecContext *avctx)
2076
{
2077
    Vp3DecodeContext *s = avctx->priv_data;
2078
    int i;
2079

    
2080
    av_free(s->superblock_coding);
2081
    av_free(s->all_fragments);
2082
    av_free(s->coeff_counts);
2083
    av_free(s->coeffs);
2084
    av_free(s->coded_fragment_list);
2085
    av_free(s->fast_fragment_list);
2086
    av_free(s->superblock_fragments);
2087
    av_free(s->superblock_macroblocks);
2088
    av_free(s->macroblock_fragments);
2089
    av_free(s->macroblock_coding);
2090

    
2091
    for (i = 0; i < 16; i++) {
2092
        free_vlc(&s->dc_vlc[i]);
2093
        free_vlc(&s->ac_vlc_1[i]);
2094
        free_vlc(&s->ac_vlc_2[i]);
2095
        free_vlc(&s->ac_vlc_3[i]);
2096
        free_vlc(&s->ac_vlc_4[i]);
2097
    }
2098

    
2099
    free_vlc(&s->superblock_run_length_vlc);
2100
    free_vlc(&s->fragment_run_length_vlc);
2101
    free_vlc(&s->mode_code_vlc);
2102
    free_vlc(&s->motion_vector_vlc);
2103

    
2104
    /* release all frames */
2105
    if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2106
        avctx->release_buffer(avctx, &s->golden_frame);
2107
    if (s->last_frame.data[0])
2108
        avctx->release_buffer(avctx, &s->last_frame);
2109
    /* no need to release the current_frame since it will always be pointing
2110
     * to the same frame as either the golden or last frame */
2111

    
2112
    return 0;
2113
}
2114

    
2115
static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
2116
{
2117
    Vp3DecodeContext *s = avctx->priv_data;
2118

    
2119
    if (get_bits1(gb)) {
2120
        int token;
2121
        if (s->entries >= 32) { /* overflow */
2122
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2123
            return -1;
2124
        }
2125
        token = get_bits(gb, 5);
2126
        //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);
2127
        s->huffman_table[s->hti][token][0] = s->hbits;
2128
        s->huffman_table[s->hti][token][1] = s->huff_code_size;
2129
        s->entries++;
2130
    }
2131
    else {
2132
        if (s->huff_code_size >= 32) {/* overflow */
2133
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2134
            return -1;
2135
        }
2136
        s->huff_code_size++;
2137
        s->hbits <<= 1;
2138
        if (read_huffman_tree(avctx, gb))
2139
            return -1;
2140
        s->hbits |= 1;
2141
        if (read_huffman_tree(avctx, gb))
2142
            return -1;
2143
        s->hbits >>= 1;
2144
        s->huff_code_size--;
2145
    }
2146
    return 0;
2147
}
2148

    
2149
#if CONFIG_THEORA_DECODER
2150
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
2151
{
2152
    Vp3DecodeContext *s = avctx->priv_data;
2153
    int visible_width, visible_height, colorspace;
2154

    
2155
    s->theora = get_bits_long(gb, 24);
2156
    av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
2157

    
2158
    /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
2159
    /* but previous versions have the image flipped relative to vp3 */
2160
    if (s->theora < 0x030200)
2161
    {
2162
        s->flipped_image = 1;
2163
        av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
2164
    }
2165

    
2166
    visible_width  = s->width  = get_bits(gb, 16) << 4;
2167
    visible_height = s->height = get_bits(gb, 16) << 4;
2168

    
2169
    if(avcodec_check_dimensions(avctx, s->width, s->height)){
2170
        av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);
2171
        s->width= s->height= 0;
2172
        return -1;
2173
    }
2174

    
2175
    if (s->theora >= 0x030200) {
2176
        visible_width  = get_bits_long(gb, 24);
2177
        visible_height = get_bits_long(gb, 24);
2178

    
2179
        skip_bits(gb, 8); /* offset x */
2180
        skip_bits(gb, 8); /* offset y */
2181
    }
2182

    
2183
    skip_bits(gb, 32); /* fps numerator */
2184
    skip_bits(gb, 32); /* fps denumerator */
2185
    skip_bits(gb, 24); /* aspect numerator */
2186
    skip_bits(gb, 24); /* aspect denumerator */
2187

    
2188
    if (s->theora < 0x030200)
2189
        skip_bits(gb, 5); /* keyframe frequency force */
2190
    colorspace = get_bits(gb, 8);
2191
    skip_bits(gb, 24); /* bitrate */
2192

    
2193
    skip_bits(gb, 6); /* quality hint */
2194

    
2195
    if (s->theora >= 0x030200)
2196
    {
2197
        skip_bits(gb, 5); /* keyframe frequency force */
2198
        skip_bits(gb, 2); /* pixel format: 420,res,422,444 */
2199
        skip_bits(gb, 3); /* reserved */
2200
    }
2201

    
2202
//    align_get_bits(gb);
2203

    
2204
    if (   visible_width  <= s->width  && visible_width  > s->width-16
2205
        && visible_height <= s->height && visible_height > s->height-16)
2206
        avcodec_set_dimensions(avctx, visible_width, visible_height);
2207
    else
2208
        avcodec_set_dimensions(avctx, s->width, s->height);
2209

    
2210
    if (colorspace == 1) {
2211
        avctx->color_primaries = AVCOL_PRI_BT470M;
2212
    } else if (colorspace == 2) {
2213
        avctx->color_primaries = AVCOL_PRI_BT470BG;
2214
    }
2215
    if (colorspace == 1 || colorspace == 2) {
2216
        avctx->colorspace = AVCOL_SPC_BT470BG;
2217
        avctx->color_trc  = AVCOL_TRC_BT709;
2218
    }
2219

    
2220
    return 0;
2221
}
2222

    
2223
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
2224
{
2225
    Vp3DecodeContext *s = avctx->priv_data;
2226
    int i, n, matrices, inter, plane;
2227

    
2228
    if (s->theora >= 0x030200) {
2229
        n = get_bits(gb, 3);
2230
        /* loop filter limit values table */
2231
        for (i = 0; i < 64; i++) {
2232
            s->filter_limit_values[i] = get_bits(gb, n);
2233
            if (s->filter_limit_values[i] > 127) {
2234
                av_log(avctx, AV_LOG_ERROR, "filter limit value too large (%i > 127), clamping\n", s->filter_limit_values[i]);
2235
                s->filter_limit_values[i] = 127;
2236
            }
2237
        }
2238
    }
2239

    
2240
    if (s->theora >= 0x030200)
2241
        n = get_bits(gb, 4) + 1;
2242
    else
2243
        n = 16;
2244
    /* quality threshold table */
2245
    for (i = 0; i < 64; i++)
2246
        s->coded_ac_scale_factor[i] = get_bits(gb, n);
2247

    
2248
    if (s->theora >= 0x030200)
2249
        n = get_bits(gb, 4) + 1;
2250
    else
2251
        n = 16;
2252
    /* dc scale factor table */
2253
    for (i = 0; i < 64; i++)
2254
        s->coded_dc_scale_factor[i] = get_bits(gb, n);
2255

    
2256
    if (s->theora >= 0x030200)
2257
        matrices = get_bits(gb, 9) + 1;
2258
    else
2259
        matrices = 3;
2260

    
2261
    if(matrices > 384){
2262
        av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
2263
        return -1;
2264
    }
2265

    
2266
    for(n=0; n<matrices; n++){
2267
        for (i = 0; i < 64; i++)
2268
            s->base_matrix[n][i]= get_bits(gb, 8);
2269
    }
2270

    
2271
    for (inter = 0; inter <= 1; inter++) {
2272
        for (plane = 0; plane <= 2; plane++) {
2273
            int newqr= 1;
2274
            if (inter || plane > 0)
2275
                newqr = get_bits1(gb);
2276
            if (!newqr) {
2277
                int qtj, plj;
2278
                if(inter && get_bits1(gb)){
2279
                    qtj = 0;
2280
                    plj = plane;
2281
                }else{
2282
                    qtj= (3*inter + plane - 1) / 3;
2283
                    plj= (plane + 2) % 3;
2284
                }
2285
                s->qr_count[inter][plane]= s->qr_count[qtj][plj];
2286
                memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0]));
2287
                memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0]));
2288
            } else {
2289
                int qri= 0;
2290
                int qi = 0;
2291

    
2292
                for(;;){
2293
                    i= get_bits(gb, av_log2(matrices-1)+1);
2294
                    if(i>= matrices){
2295
                        av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n");
2296
                        return -1;
2297
                    }
2298
                    s->qr_base[inter][plane][qri]= i;
2299
                    if(qi >= 63)
2300
                        break;
2301
                    i = get_bits(gb, av_log2(63-qi)+1) + 1;
2302
                    s->qr_size[inter][plane][qri++]= i;
2303
                    qi += i;
2304
                }
2305

    
2306
                if (qi > 63) {
2307
                    av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
2308
                    return -1;
2309
                }
2310
                s->qr_count[inter][plane]= qri;
2311
            }
2312
        }
2313
    }
2314

    
2315
    /* Huffman tables */
2316
    for (s->hti = 0; s->hti < 80; s->hti++) {
2317
        s->entries = 0;
2318
        s->huff_code_size = 1;
2319
        if (!get_bits1(gb)) {
2320
            s->hbits = 0;
2321
            if(read_huffman_tree(avctx, gb))
2322
                return -1;
2323
            s->hbits = 1;
2324
            if(read_huffman_tree(avctx, gb))
2325
                return -1;
2326
        }
2327
    }
2328

    
2329
    s->theora_tables = 1;
2330

    
2331
    return 0;
2332
}
2333

    
2334
static av_cold int theora_decode_init(AVCodecContext *avctx)
2335
{
2336
    Vp3DecodeContext *s = avctx->priv_data;
2337
    GetBitContext gb;
2338
    int ptype;
2339
    uint8_t *header_start[3];
2340
    int header_len[3];
2341
    int i;
2342

    
2343
    s->theora = 1;
2344

    
2345
    if (!avctx->extradata_size)
2346
    {
2347
        av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
2348
        return -1;
2349
    }
2350

    
2351
    if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size,
2352
                              42, header_start, header_len) < 0) {
2353
        av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
2354
        return -1;
2355
    }
2356

    
2357
  for(i=0;i<3;i++) {
2358
    init_get_bits(&gb, header_start[i], header_len[i] * 8);
2359

    
2360
    ptype = get_bits(&gb, 8);
2361

    
2362
     if (!(ptype & 0x80))
2363
     {
2364
        av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
2365
//        return -1;
2366
     }
2367

    
2368
    // FIXME: Check for this as well.
2369
    skip_bits_long(&gb, 6*8); /* "theora" */
2370

    
2371
    switch(ptype)
2372
    {
2373
        case 0x80:
2374
            theora_decode_header(avctx, &gb);
2375
                break;
2376
        case 0x81:
2377
// FIXME: is this needed? it breaks sometimes
2378
//            theora_decode_comments(avctx, gb);
2379
            break;
2380
        case 0x82:
2381
            if (theora_decode_tables(avctx, &gb))
2382
                return -1;
2383
            break;
2384
        default:
2385
            av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80);
2386
            break;
2387
    }
2388
    if(ptype != 0x81 && 8*header_len[i] != get_bits_count(&gb))
2389
        av_log(avctx, AV_LOG_WARNING, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype);
2390
    if (s->theora < 0x030200)
2391
        break;
2392
  }
2393

    
2394
    return vp3_decode_init(avctx);
2395
}
2396

    
2397
AVCodec theora_decoder = {
2398
    "theora",
2399
    CODEC_TYPE_VIDEO,
2400
    CODEC_ID_THEORA,
2401
    sizeof(Vp3DecodeContext),
2402
    theora_decode_init,
2403
    NULL,
2404
    vp3_decode_end,
2405
    vp3_decode_frame,
2406
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
2407
    NULL,
2408
    .long_name = NULL_IF_CONFIG_SMALL("Theora"),
2409
};
2410
#endif
2411

    
2412
AVCodec vp3_decoder = {
2413
    "vp3",
2414
    CODEC_TYPE_VIDEO,
2415
    CODEC_ID_VP3,
2416
    sizeof(Vp3DecodeContext),
2417
    vp3_decode_init,
2418
    NULL,
2419
    vp3_decode_end,
2420
    vp3_decode_frame,
2421
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
2422
    NULL,
2423
    .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),
2424
};