Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ ba4816a0

History | View | Annotate | Download (93.7 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
/**
23
 * @file vp3.c
24
 * On2 VP3 Video Decoder
25
 *
26
 * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
27
 * For more information about the VP3 coding process, visit:
28
 *   http://multimedia.cx/
29
 *
30
 * Theora decoder by Alex Beregszaszi
31
 */
32

    
33
#include <stdio.h>
34
#include <stdlib.h>
35
#include <string.h>
36
#include <unistd.h>
37

    
38
#include "common.h"
39
#include "avcodec.h"
40
#include "dsputil.h"
41
#include "mpegvideo.h"
42

    
43
#include "vp3data.h"
44
#include "xiph.h"
45

    
46
#define FRAGMENT_PIXELS 8
47

    
48
/*
49
 * Debugging Variables
50
 *
51
 * Define one or more of the following compile-time variables to 1 to obtain
52
 * elaborate information about certain aspects of the decoding process.
53
 *
54
 * KEYFRAMES_ONLY: set this to 1 to only see keyframes (VP3 slideshow mode)
55
 * DEBUG_VP3: high-level decoding flow
56
 * DEBUG_INIT: initialization parameters
57
 * DEBUG_DEQUANTIZERS: display how the dequanization tables are built
58
 * DEBUG_BLOCK_CODING: unpacking the superblock/macroblock/fragment coding
59
 * DEBUG_MODES: unpacking the coding modes for individual fragments
60
 * DEBUG_VECTORS: display the motion vectors
61
 * DEBUG_TOKEN: display exhaustive information about each DCT token
62
 * DEBUG_VLC: display the VLCs as they are extracted from the stream
63
 * DEBUG_DC_PRED: display the process of reversing DC prediction
64
 * DEBUG_IDCT: show every detail of the IDCT process
65
 */
66

    
67
#define KEYFRAMES_ONLY 0
68

    
69
#define DEBUG_VP3 0
70
#define DEBUG_INIT 0
71
#define DEBUG_DEQUANTIZERS 0
72
#define DEBUG_BLOCK_CODING 0
73
#define DEBUG_MODES 0
74
#define DEBUG_VECTORS 0
75
#define DEBUG_TOKEN 0
76
#define DEBUG_VLC 0
77
#define DEBUG_DC_PRED 0
78
#define DEBUG_IDCT 0
79

    
80
#if DEBUG_VP3
81
#define debug_vp3(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
82
#else
83
static inline void debug_vp3(const char *format, ...) { }
84
#endif
85

    
86
#if DEBUG_INIT
87
#define debug_init(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
88
#else
89
static inline void debug_init(const char *format, ...) { }
90
#endif
91

    
92
#if DEBUG_DEQUANTIZERS
93
#define debug_dequantizers(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
94
#else
95
static inline void debug_dequantizers(const char *format, ...) { }
96
#endif
97

    
98
#if DEBUG_BLOCK_CODING
99
#define debug_block_coding(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
100
#else
101
static inline void debug_block_coding(const char *format, ...) { }
102
#endif
103

    
104
#if DEBUG_MODES
105
#define debug_modes(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
106
#else
107
static inline void debug_modes(const char *format, ...) { }
108
#endif
109

    
110
#if DEBUG_VECTORS
111
#define debug_vectors(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
112
#else
113
static inline void debug_vectors(const char *format, ...) { }
114
#endif
115

    
116
#if DEBUG_TOKEN
117
#define debug_token(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
118
#else
119
static inline void debug_token(const char *format, ...) { }
120
#endif
121

    
122
#if DEBUG_VLC
123
#define debug_vlc(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
124
#else
125
static inline void debug_vlc(const char *format, ...) { }
126
#endif
127

    
128
#if DEBUG_DC_PRED
129
#define debug_dc_pred(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
130
#else
131
static inline void debug_dc_pred(const char *format, ...) { }
132
#endif
133

    
134
#if DEBUG_IDCT
135
#define debug_idct(args...) av_log(NULL, AV_LOG_DEBUG, ## args)
136
#else
137
static inline void debug_idct(const char *format, ...) { }
138
#endif
139

    
140
typedef struct Coeff {
141
    struct Coeff *next;
142
    DCTELEM coeff;
143
    uint8_t index;
144
} Coeff;
145

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

    
160
#define SB_NOT_CODED        0
161
#define SB_PARTIALLY_CODED  1
162
#define SB_FULLY_CODED      2
163

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

    
174
/* special internal mode */
175
#define MODE_COPY             8
176

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

    
183
    /* scheme 1: Last motion vector dominates */
184
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
185
         MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
186
         MODE_INTRA,            MODE_USING_GOLDEN,
187
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
188

    
189
    /* scheme 2 */
190
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
191
         MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,
192
         MODE_INTRA,            MODE_USING_GOLDEN,
193
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
194

    
195
    /* scheme 3 */
196
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
197
         MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
198
         MODE_INTRA,            MODE_USING_GOLDEN,
199
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
200

    
201
    /* scheme 4 */
202
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
203
         MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
204
         MODE_INTRA,            MODE_USING_GOLDEN,
205
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
206

    
207
    /* scheme 5: No motion vector dominates */
208
    {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,
209
         MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
210
         MODE_INTRA,            MODE_USING_GOLDEN,
211
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
212

    
213
    /* scheme 6 */
214
    {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,
215
         MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
216
         MODE_INTER_PLUS_MV,    MODE_INTRA,
217
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
218

    
219
};
220

    
221
#define MIN_DEQUANT_VAL 2
222

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

    
235
    int qis[3];
236
    int nqis;
237
    int quality_index;
238
    int last_quality_index;
239

    
240
    int superblock_count;
241
    int superblock_width;
242
    int superblock_height;
243
    int y_superblock_width;
244
    int y_superblock_height;
245
    int c_superblock_width;
246
    int c_superblock_height;
247
    int u_superblock_start;
248
    int v_superblock_start;
249
    unsigned char *superblock_coding;
250

    
251
    int macroblock_count;
252
    int macroblock_width;
253
    int macroblock_height;
254

    
255
    int fragment_count;
256
    int fragment_width;
257
    int fragment_height;
258

    
259
    Vp3Fragment *all_fragments;
260
    Coeff *coeffs;
261
    Coeff *next_coeff;
262
    int fragment_start[3];
263

    
264
    ScanTable scantable;
265

    
266
    /* tables */
267
    uint16_t coded_dc_scale_factor[64];
268
    uint32_t coded_ac_scale_factor[64];
269
    uint8_t base_matrix[384][64];
270
    uint8_t qr_count[2][3];
271
    uint8_t qr_size [2][3][64];
272
    uint16_t qr_base[2][3][64];
273

    
274
    /* this is a list of indices into the all_fragments array indicating
275
     * which of the fragments are coded */
276
    int *coded_fragment_list;
277
    int coded_fragment_list_index;
278
    int pixel_addresses_inited;
279

    
280
    VLC dc_vlc[16];
281
    VLC ac_vlc_1[16];
282
    VLC ac_vlc_2[16];
283
    VLC ac_vlc_3[16];
284
    VLC ac_vlc_4[16];
285

    
286
    VLC superblock_run_length_vlc;
287
    VLC fragment_run_length_vlc;
288
    VLC mode_code_vlc;
289
    VLC motion_vector_vlc;
290

    
291
    /* these arrays need to be on 16-byte boundaries since SSE2 operations
292
     * index into them */
293
    DECLARE_ALIGNED_16(int16_t, qmat[2][4][64]);        //<qmat[is_inter][plane]
294

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

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

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

    
315
    int first_coded_y_fragment;
316
    int first_coded_c_fragment;
317
    int last_coded_y_fragment;
318
    int last_coded_c_fragment;
319

    
320
    uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
321
    int8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
322

    
323
    /* Huffman decode */
324
    int hti;
325
    unsigned int hbits;
326
    int entries;
327
    int huff_code_size;
328
    uint16_t huffman_table[80][32][2];
329

    
330
    uint32_t filter_limit_values[64];
331
    int bounding_values_array[256];
332
} Vp3DecodeContext;
333

    
334
/************************************************************************
335
 * VP3 specific functions
336
 ************************************************************************/
337

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

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

    
359
    int current_macroblock;
360
    int c_fragment;
361

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

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

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

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

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

    
386
    hilbert_walk_mb[0] = 1;
387
    hilbert_walk_mb[1] = s->macroblock_width;
388
    hilbert_walk_mb[2] = 1;
389
    hilbert_walk_mb[3] = -s->macroblock_width;
390

    
391
    /* iterate through each superblock (all planes) and map the fragments */
392
    for (i = 0; i < s->superblock_count; i++) {
393
        debug_init("    superblock %d (u starts @ %d, v starts @ %d)\n",
394
            i, s->u_superblock_start, s->v_superblock_start);
395

    
396
        /* time to re-assign the limits? */
397
        if (i == 0) {
398

    
399
            /* start of Y superblocks */
400
            right_edge = s->fragment_width;
401
            bottom_edge = s->fragment_height;
402
            current_width = -1;
403
            current_height = 0;
404
            superblock_row_inc = 3 * s->fragment_width -
405
                (s->y_superblock_width * 4 - s->fragment_width);
406

    
407
            /* the first operation for this variable is to advance by 1 */
408
            current_fragment = -1;
409

    
410
        } else if (i == s->u_superblock_start) {
411

    
412
            /* start of U superblocks */
413
            right_edge = s->fragment_width / 2;
414
            bottom_edge = s->fragment_height / 2;
415
            current_width = -1;
416
            current_height = 0;
417
            superblock_row_inc = 3 * (s->fragment_width / 2) -
418
                (s->c_superblock_width * 4 - s->fragment_width / 2);
419

    
420
            /* the first operation for this variable is to advance by 1 */
421
            current_fragment = s->fragment_start[1] - 1;
422

    
423
        } else if (i == s->v_superblock_start) {
424

    
425
            /* start of V superblocks */
426
            right_edge = s->fragment_width / 2;
427
            bottom_edge = s->fragment_height / 2;
428
            current_width = -1;
429
            current_height = 0;
430
            superblock_row_inc = 3 * (s->fragment_width / 2) -
431
                (s->c_superblock_width * 4 - s->fragment_width / 2);
432

    
433
            /* the first operation for this variable is to advance by 1 */
434
            current_fragment = s->fragment_start[2] - 1;
435

    
436
        }
437

    
438
        if (current_width >= right_edge - 1) {
439
            /* reset width and move to next superblock row */
440
            current_width = -1;
441
            current_height += 4;
442

    
443
            /* fragment is now at the start of a new superblock row */
444
            current_fragment += superblock_row_inc;
445
        }
446

    
447
        /* iterate through all 16 fragments in a superblock */
448
        for (j = 0; j < 16; j++) {
449
            current_fragment += travel_width[j] + right_edge * travel_height[j];
450
            current_width += travel_width[j];
451
            current_height += travel_height[j];
452

    
453
            /* check if the fragment is in bounds */
454
            if ((current_width < right_edge) &&
455
                (current_height < bottom_edge)) {
456
                s->superblock_fragments[mapping_index] = current_fragment;
457
                debug_init("    mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n",
458
                    s->superblock_fragments[mapping_index], i, j,
459
                    current_width, right_edge, current_height, bottom_edge);
460
            } else {
461
                s->superblock_fragments[mapping_index] = -1;
462
                debug_init("    superblock %d, position %d has no fragment (%d/%d x %d/%d)\n",
463
                    i, j,
464
                    current_width, right_edge, current_height, bottom_edge);
465
            }
466

    
467
            mapping_index++;
468
        }
469
    }
470

    
471
    /* initialize the superblock <-> macroblock mapping; iterate through
472
     * all of the Y plane superblocks to build this mapping */
473
    right_edge = s->macroblock_width;
474
    bottom_edge = s->macroblock_height;
475
    current_width = -1;
476
    current_height = 0;
477
    superblock_row_inc = s->macroblock_width -
478
        (s->y_superblock_width * 2 - s->macroblock_width);;
479
    hilbert = hilbert_walk_mb;
480
    mapping_index = 0;
481
    current_macroblock = -1;
482
    for (i = 0; i < s->u_superblock_start; i++) {
483

    
484
        if (current_width >= right_edge - 1) {
485
            /* reset width and move to next superblock row */
486
            current_width = -1;
487
            current_height += 2;
488

    
489
            /* macroblock is now at the start of a new superblock row */
490
            current_macroblock += superblock_row_inc;
491
        }
492

    
493
        /* iterate through each potential macroblock in the superblock */
494
        for (j = 0; j < 4; j++) {
495
            current_macroblock += hilbert_walk_mb[j];
496
            current_width += travel_width_mb[j];
497
            current_height += travel_height_mb[j];
498

    
499
            /* check if the macroblock is in bounds */
500
            if ((current_width < right_edge) &&
501
                (current_height < bottom_edge)) {
502
                s->superblock_macroblocks[mapping_index] = current_macroblock;
503
                debug_init("    mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
504
                    s->superblock_macroblocks[mapping_index], i, j,
505
                    current_width, right_edge, current_height, bottom_edge);
506
            } else {
507
                s->superblock_macroblocks[mapping_index] = -1;
508
                debug_init("    superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
509
                    i, j,
510
                    current_width, right_edge, current_height, bottom_edge);
511
            }
512

    
513
            mapping_index++;
514
        }
515
    }
516

    
517
    /* initialize the macroblock <-> fragment mapping */
518
    current_fragment = 0;
519
    current_macroblock = 0;
520
    mapping_index = 0;
521
    for (i = 0; i < s->fragment_height; i += 2) {
522

    
523
        for (j = 0; j < s->fragment_width; j += 2) {
524

    
525
            debug_init("    macroblock %d contains fragments: ", current_macroblock);
526
            s->all_fragments[current_fragment].macroblock = current_macroblock;
527
            s->macroblock_fragments[mapping_index++] = current_fragment;
528
            debug_init("%d ", current_fragment);
529

    
530
            if (j + 1 < s->fragment_width) {
531
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
532
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
533
                debug_init("%d ", current_fragment + 1);
534
            } else
535
                s->macroblock_fragments[mapping_index++] = -1;
536

    
537
            if (i + 1 < s->fragment_height) {
538
                s->all_fragments[current_fragment + s->fragment_width].macroblock =
539
                    current_macroblock;
540
                s->macroblock_fragments[mapping_index++] =
541
                    current_fragment + s->fragment_width;
542
                debug_init("%d ", current_fragment + s->fragment_width);
543
            } else
544
                s->macroblock_fragments[mapping_index++] = -1;
545

    
546
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
547
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
548
                    current_macroblock;
549
                s->macroblock_fragments[mapping_index++] =
550
                    current_fragment + s->fragment_width + 1;
551
                debug_init("%d ", current_fragment + s->fragment_width + 1);
552
            } else
553
                s->macroblock_fragments[mapping_index++] = -1;
554

    
555
            /* C planes */
556
            c_fragment = s->fragment_start[1] +
557
                (i * s->fragment_width / 4) + (j / 2);
558
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
559
            s->macroblock_fragments[mapping_index++] = c_fragment;
560
            debug_init("%d ", c_fragment);
561

    
562
            c_fragment = s->fragment_start[2] +
563
                (i * s->fragment_width / 4) + (j / 2);
564
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
565
            s->macroblock_fragments[mapping_index++] = c_fragment;
566
            debug_init("%d ", c_fragment);
567

    
568
            debug_init("\n");
569

    
570
            if (j + 2 <= s->fragment_width)
571
                current_fragment += 2;
572
            else
573
                current_fragment++;
574
            current_macroblock++;
575
        }
576

    
577
        current_fragment += s->fragment_width;
578
    }
579

    
580
    return 0;  /* successful path out */
581
}
582

    
583
/*
584
 * This function wipes out all of the fragment data.
585
 */
586
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
587
{
588
    int i;
589

    
590
    /* zero out all of the fragment information */
591
    s->coded_fragment_list_index = 0;
592
    for (i = 0; i < s->fragment_count; i++) {
593
        s->all_fragments[i].coeff_count = 0;
594
        s->all_fragments[i].motion_x = 127;
595
        s->all_fragments[i].motion_y = 127;
596
        s->all_fragments[i].next_coeff= NULL;
597
        s->coeffs[i].index=
598
        s->coeffs[i].coeff=0;
599
        s->coeffs[i].next= NULL;
600
    }
601
}
602

    
603
/*
604
 * This function sets up the dequantization tables used for a particular
605
 * frame.
606
 */
607
static void init_dequantizer(Vp3DecodeContext *s)
608
{
609
    int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
610
    int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
611
    int i, plane, inter, qri, bmi, bmj, qistart;
612

    
613
    debug_vp3("  vp3: initializing dequantization tables\n");
614

    
615
    for(inter=0; inter<2; inter++){
616
        for(plane=0; plane<3; plane++){
617
            int sum=0;
618
            for(qri=0; qri<s->qr_count[inter][plane]; qri++){
619
                sum+= s->qr_size[inter][plane][qri];
620
                if(s->quality_index <= sum)
621
                    break;
622
            }
623
            qistart= sum - s->qr_size[inter][plane][qri];
624
            bmi= s->qr_base[inter][plane][qri  ];
625
            bmj= s->qr_base[inter][plane][qri+1];
626
            for(i=0; i<64; i++){
627
                int coeff= (  2*(sum    -s->quality_index)*s->base_matrix[bmi][i]
628
                            - 2*(qistart-s->quality_index)*s->base_matrix[bmj][i]
629
                            + s->qr_size[inter][plane][qri])
630
                           / (2*s->qr_size[inter][plane][qri]);
631

    
632
                int qmin= 8<<(inter + !i);
633
                int qscale= i ? ac_scale_factor : dc_scale_factor;
634

    
635
                s->qmat[inter][plane][i]= av_clip((qscale * coeff)/100 * 4, qmin, 4096);
636
            }
637
        }
638
    }
639

    
640
    memset(s->qscale_table, (FFMAX(s->qmat[0][0][1], s->qmat[0][1][1])+8)/16, 512); //FIXME finetune
641
}
642

    
643
/*
644
 * This function initializes the loop filter boundary limits if the frame's
645
 * quality index is different from the previous frame's.
646
 */
647
static void init_loop_filter(Vp3DecodeContext *s)
648
{
649
    int *bounding_values= s->bounding_values_array+127;
650
    int filter_limit;
651
    int x;
652

    
653
    filter_limit = s->filter_limit_values[s->quality_index];
654

    
655
    /* set up the bounding values */
656
    memset(s->bounding_values_array, 0, 256 * sizeof(int));
657
    for (x = 0; x < filter_limit; x++) {
658
        bounding_values[-x - filter_limit] = -filter_limit + x;
659
        bounding_values[-x] = -x;
660
        bounding_values[x] = x;
661
        bounding_values[x + filter_limit] = filter_limit - x;
662
    }
663
}
664

    
665
/*
666
 * This function unpacks all of the superblock/macroblock/fragment coding
667
 * information from the bitstream.
668
 */
669
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
670
{
671
    int bit = 0;
672
    int current_superblock = 0;
673
    int current_run = 0;
674
    int decode_fully_flags = 0;
675
    int decode_partial_blocks = 0;
676
    int first_c_fragment_seen;
677

    
678
    int i, j;
679
    int current_fragment;
680

    
681
    debug_vp3("  vp3: unpacking superblock coding\n");
682

    
683
    if (s->keyframe) {
684

    
685
        debug_vp3("    keyframe-- all superblocks are fully coded\n");
686
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
687

    
688
    } else {
689

    
690
        /* unpack the list of partially-coded superblocks */
691
        bit = get_bits(gb, 1);
692
        /* toggle the bit because as soon as the first run length is
693
         * fetched the bit will be toggled again */
694
        bit ^= 1;
695
        while (current_superblock < s->superblock_count) {
696
            if (current_run-- == 0) {
697
                bit ^= 1;
698
                current_run = get_vlc2(gb,
699
                    s->superblock_run_length_vlc.table, 6, 2);
700
                if (current_run == 33)
701
                    current_run += get_bits(gb, 12);
702
                debug_block_coding("      setting superblocks %d..%d to %s\n",
703
                    current_superblock,
704
                    current_superblock + current_run - 1,
705
                    (bit) ? "partially coded" : "not coded");
706

    
707
                /* if any of the superblocks are not partially coded, flag
708
                 * a boolean to decode the list of fully-coded superblocks */
709
                if (bit == 0) {
710
                    decode_fully_flags = 1;
711
                } else {
712

    
713
                    /* make a note of the fact that there are partially coded
714
                     * superblocks */
715
                    decode_partial_blocks = 1;
716
                }
717
            }
718
            s->superblock_coding[current_superblock++] = bit;
719
        }
720

    
721
        /* unpack the list of fully coded superblocks if any of the blocks were
722
         * not marked as partially coded in the previous step */
723
        if (decode_fully_flags) {
724

    
725
            current_superblock = 0;
726
            current_run = 0;
727
            bit = get_bits(gb, 1);
728
            /* toggle the bit because as soon as the first run length is
729
             * fetched the bit will be toggled again */
730
            bit ^= 1;
731
            while (current_superblock < s->superblock_count) {
732

    
733
                /* skip any superblocks already marked as partially coded */
734
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
735

    
736
                    if (current_run-- == 0) {
737
                        bit ^= 1;
738
                        current_run = get_vlc2(gb,
739
                            s->superblock_run_length_vlc.table, 6, 2);
740
                        if (current_run == 33)
741
                            current_run += get_bits(gb, 12);
742
                    }
743

    
744
                    debug_block_coding("      setting superblock %d to %s\n",
745
                        current_superblock,
746
                        (bit) ? "fully coded" : "not coded");
747
                    s->superblock_coding[current_superblock] = 2*bit;
748
                }
749
                current_superblock++;
750
            }
751
        }
752

    
753
        /* if there were partial blocks, initialize bitstream for
754
         * unpacking fragment codings */
755
        if (decode_partial_blocks) {
756

    
757
            current_run = 0;
758
            bit = get_bits(gb, 1);
759
            /* toggle the bit because as soon as the first run length is
760
             * fetched the bit will be toggled again */
761
            bit ^= 1;
762
        }
763
    }
764

    
765
    /* figure out which fragments are coded; iterate through each
766
     * superblock (all planes) */
767
    s->coded_fragment_list_index = 0;
768
    s->next_coeff= s->coeffs + s->fragment_count;
769
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
770
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
771
    first_c_fragment_seen = 0;
772
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
773
    for (i = 0; i < s->superblock_count; i++) {
774

    
775
        /* iterate through all 16 fragments in a superblock */
776
        for (j = 0; j < 16; j++) {
777

    
778
            /* if the fragment is in bounds, check its coding status */
779
            current_fragment = s->superblock_fragments[i * 16 + j];
780
            if (current_fragment >= s->fragment_count) {
781
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
782
                    current_fragment, s->fragment_count);
783
                return 1;
784
            }
785
            if (current_fragment != -1) {
786
                if (s->superblock_coding[i] == SB_NOT_CODED) {
787

    
788
                    /* copy all the fragments from the prior frame */
789
                    s->all_fragments[current_fragment].coding_method =
790
                        MODE_COPY;
791

    
792
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
793

    
794
                    /* fragment may or may not be coded; this is the case
795
                     * that cares about the fragment coding runs */
796
                    if (current_run-- == 0) {
797
                        bit ^= 1;
798
                        current_run = get_vlc2(gb,
799
                            s->fragment_run_length_vlc.table, 5, 2);
800
                    }
801

    
802
                    if (bit) {
803
                        /* default mode; actual mode will be decoded in
804
                         * the next phase */
805
                        s->all_fragments[current_fragment].coding_method =
806
                            MODE_INTER_NO_MV;
807
                        s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
808
                        s->coded_fragment_list[s->coded_fragment_list_index] =
809
                            current_fragment;
810
                        if ((current_fragment >= s->fragment_start[1]) &&
811
                            (s->last_coded_y_fragment == -1) &&
812
                            (!first_c_fragment_seen)) {
813
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
814
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
815
                            first_c_fragment_seen = 1;
816
                        }
817
                        s->coded_fragment_list_index++;
818
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
819
                        debug_block_coding("      superblock %d is partially coded, fragment %d is coded\n",
820
                            i, current_fragment);
821
                    } else {
822
                        /* not coded; copy this fragment from the prior frame */
823
                        s->all_fragments[current_fragment].coding_method =
824
                            MODE_COPY;
825
                        debug_block_coding("      superblock %d is partially coded, fragment %d is not coded\n",
826
                            i, current_fragment);
827
                    }
828

    
829
                } else {
830

    
831
                    /* fragments are fully coded in this superblock; actual
832
                     * coding will be determined in next step */
833
                    s->all_fragments[current_fragment].coding_method =
834
                        MODE_INTER_NO_MV;
835
                    s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
836
                    s->coded_fragment_list[s->coded_fragment_list_index] =
837
                        current_fragment;
838
                    if ((current_fragment >= s->fragment_start[1]) &&
839
                        (s->last_coded_y_fragment == -1) &&
840
                        (!first_c_fragment_seen)) {
841
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
842
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
843
                        first_c_fragment_seen = 1;
844
                    }
845
                    s->coded_fragment_list_index++;
846
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
847
                    debug_block_coding("      superblock %d is fully coded, fragment %d is coded\n",
848
                        i, current_fragment);
849
                }
850
            }
851
        }
852
    }
853

    
854
    if (!first_c_fragment_seen)
855
        /* only Y fragments coded in this frame */
856
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
857
    else
858
        /* end the list of coded C fragments */
859
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
860

    
861
    debug_block_coding("    %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
862
        s->coded_fragment_list_index,
863
        s->first_coded_y_fragment,
864
        s->last_coded_y_fragment,
865
        s->first_coded_c_fragment,
866
        s->last_coded_c_fragment);
867

    
868
    return 0;
869
}
870

    
871
/*
872
 * This function unpacks all the coding mode data for individual macroblocks
873
 * from the bitstream.
874
 */
875
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
876
{
877
    int i, j, k;
878
    int scheme;
879
    int current_macroblock;
880
    int current_fragment;
881
    int coding_mode;
882

    
883
    debug_vp3("  vp3: unpacking encoding modes\n");
884

    
885
    if (s->keyframe) {
886
        debug_vp3("    keyframe-- all blocks are coded as INTRA\n");
887

    
888
        for (i = 0; i < s->fragment_count; i++)
889
            s->all_fragments[i].coding_method = MODE_INTRA;
890

    
891
    } else {
892

    
893
        /* fetch the mode coding scheme for this frame */
894
        scheme = get_bits(gb, 3);
895
        debug_modes("    using mode alphabet %d\n", scheme);
896

    
897
        /* is it a custom coding scheme? */
898
        if (scheme == 0) {
899
            debug_modes("    custom mode alphabet ahead:\n");
900
            for (i = 0; i < 8; i++)
901
                ModeAlphabet[scheme][get_bits(gb, 3)] = i;
902
        }
903

    
904
        for (i = 0; i < 8; i++)
905
            debug_modes("      mode[%d][%d] = %d\n", scheme, i,
906
                ModeAlphabet[scheme][i]);
907

    
908
        /* iterate through all of the macroblocks that contain 1 or more
909
         * coded fragments */
910
        for (i = 0; i < s->u_superblock_start; i++) {
911

    
912
            for (j = 0; j < 4; j++) {
913
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
914
                if ((current_macroblock == -1) ||
915
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
916
                    continue;
917
                if (current_macroblock >= s->macroblock_count) {
918
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
919
                        current_macroblock, s->macroblock_count);
920
                    return 1;
921
                }
922

    
923
                /* mode 7 means get 3 bits for each coding mode */
924
                if (scheme == 7)
925
                    coding_mode = get_bits(gb, 3);
926
                else
927
                    coding_mode = ModeAlphabet[scheme]
928
                        [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
929

    
930
                s->macroblock_coding[current_macroblock] = coding_mode;
931
                for (k = 0; k < 6; k++) {
932
                    current_fragment =
933
                        s->macroblock_fragments[current_macroblock * 6 + k];
934
                    if (current_fragment == -1)
935
                        continue;
936
                    if (current_fragment >= s->fragment_count) {
937
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
938
                            current_fragment, s->fragment_count);
939
                        return 1;
940
                    }
941
                    if (s->all_fragments[current_fragment].coding_method !=
942
                        MODE_COPY)
943
                        s->all_fragments[current_fragment].coding_method =
944
                            coding_mode;
945
                }
946

    
947
                debug_modes("    coding method for macroblock starting @ fragment %d = %d\n",
948
                    s->macroblock_fragments[current_macroblock * 6], coding_mode);
949
            }
950
        }
951
    }
952

    
953
    return 0;
954
}
955

    
956
/*
957
 * This function unpacks all the motion vectors for the individual
958
 * macroblocks from the bitstream.
959
 */
960
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
961
{
962
    int i, j, k;
963
    int coding_mode;
964
    int motion_x[6];
965
    int motion_y[6];
966
    int last_motion_x = 0;
967
    int last_motion_y = 0;
968
    int prior_last_motion_x = 0;
969
    int prior_last_motion_y = 0;
970
    int current_macroblock;
971
    int current_fragment;
972

    
973
    debug_vp3("  vp3: unpacking motion vectors\n");
974
    if (s->keyframe) {
975

    
976
        debug_vp3("    keyframe-- there are no motion vectors\n");
977

    
978
    } else {
979

    
980
        memset(motion_x, 0, 6 * sizeof(int));
981
        memset(motion_y, 0, 6 * sizeof(int));
982

    
983
        /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
984
        coding_mode = get_bits(gb, 1);
985
        debug_vectors("    using %s scheme for unpacking motion vectors\n",
986
            (coding_mode == 0) ? "VLC" : "fixed-length");
987

    
988
        /* iterate through all of the macroblocks that contain 1 or more
989
         * coded fragments */
990
        for (i = 0; i < s->u_superblock_start; i++) {
991

    
992
            for (j = 0; j < 4; j++) {
993
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
994
                if ((current_macroblock == -1) ||
995
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
996
                    continue;
997
                if (current_macroblock >= s->macroblock_count) {
998
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
999
                        current_macroblock, s->macroblock_count);
1000
                    return 1;
1001
                }
1002

    
1003
                current_fragment = s->macroblock_fragments[current_macroblock * 6];
1004
                if (current_fragment >= s->fragment_count) {
1005
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1006
                        current_fragment, s->fragment_count);
1007
                    return 1;
1008
                }
1009
                switch (s->macroblock_coding[current_macroblock]) {
1010

    
1011
                case MODE_INTER_PLUS_MV:
1012
                case MODE_GOLDEN_MV:
1013
                    /* all 6 fragments use the same motion vector */
1014
                    if (coding_mode == 0) {
1015
                        motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1016
                        motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1017
                    } else {
1018
                        motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1019
                        motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1020
                    }
1021

    
1022
                    for (k = 1; k < 6; k++) {
1023
                        motion_x[k] = motion_x[0];
1024
                        motion_y[k] = motion_y[0];
1025
                    }
1026

    
1027
                    /* vector maintenance, only on MODE_INTER_PLUS_MV */
1028
                    if (s->macroblock_coding[current_macroblock] ==
1029
                        MODE_INTER_PLUS_MV) {
1030
                        prior_last_motion_x = last_motion_x;
1031
                        prior_last_motion_y = last_motion_y;
1032
                        last_motion_x = motion_x[0];
1033
                        last_motion_y = motion_y[0];
1034
                    }
1035
                    break;
1036

    
1037
                case MODE_INTER_FOURMV:
1038
                    /* fetch 4 vectors from the bitstream, one for each
1039
                     * Y fragment, then average for the C fragment vectors */
1040
                    motion_x[4] = motion_y[4] = 0;
1041
                    for (k = 0; k < 4; k++) {
1042
                        if (coding_mode == 0) {
1043
                            motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1044
                            motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1045
                        } else {
1046
                            motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1047
                            motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1048
                        }
1049
                        motion_x[4] += motion_x[k];
1050
                        motion_y[4] += motion_y[k];
1051
                    }
1052

    
1053
                    motion_x[5]=
1054
                    motion_x[4]= RSHIFT(motion_x[4], 2);
1055
                    motion_y[5]=
1056
                    motion_y[4]= RSHIFT(motion_y[4], 2);
1057

    
1058
                    /* vector maintenance; vector[3] is treated as the
1059
                     * last vector in this case */
1060
                    prior_last_motion_x = last_motion_x;
1061
                    prior_last_motion_y = last_motion_y;
1062
                    last_motion_x = motion_x[3];
1063
                    last_motion_y = motion_y[3];
1064
                    break;
1065

    
1066
                case MODE_INTER_LAST_MV:
1067
                    /* all 6 fragments use the last motion vector */
1068
                    motion_x[0] = last_motion_x;
1069
                    motion_y[0] = last_motion_y;
1070
                    for (k = 1; k < 6; k++) {
1071
                        motion_x[k] = motion_x[0];
1072
                        motion_y[k] = motion_y[0];
1073
                    }
1074

    
1075
                    /* no vector maintenance (last vector remains the
1076
                     * last vector) */
1077
                    break;
1078

    
1079
                case MODE_INTER_PRIOR_LAST:
1080
                    /* all 6 fragments use the motion vector prior to the
1081
                     * last motion vector */
1082
                    motion_x[0] = prior_last_motion_x;
1083
                    motion_y[0] = prior_last_motion_y;
1084
                    for (k = 1; k < 6; k++) {
1085
                        motion_x[k] = motion_x[0];
1086
                        motion_y[k] = motion_y[0];
1087
                    }
1088

    
1089
                    /* vector maintenance */
1090
                    prior_last_motion_x = last_motion_x;
1091
                    prior_last_motion_y = last_motion_y;
1092
                    last_motion_x = motion_x[0];
1093
                    last_motion_y = motion_y[0];
1094
                    break;
1095

    
1096
                default:
1097
                    /* covers intra, inter without MV, golden without MV */
1098
                    memset(motion_x, 0, 6 * sizeof(int));
1099
                    memset(motion_y, 0, 6 * sizeof(int));
1100

    
1101
                    /* no vector maintenance */
1102
                    break;
1103
                }
1104

    
1105
                /* assign the motion vectors to the correct fragments */
1106
                debug_vectors("    vectors for macroblock starting @ fragment %d (coding method %d):\n",
1107
                    current_fragment,
1108
                    s->macroblock_coding[current_macroblock]);
1109
                for (k = 0; k < 6; k++) {
1110
                    current_fragment =
1111
                        s->macroblock_fragments[current_macroblock * 6 + k];
1112
                    if (current_fragment == -1)
1113
                        continue;
1114
                    if (current_fragment >= s->fragment_count) {
1115
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1116
                            current_fragment, s->fragment_count);
1117
                        return 1;
1118
                    }
1119
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
1120
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
1121
                    debug_vectors("    vector %d: fragment %d = (%d, %d)\n",
1122
                        k, current_fragment, motion_x[k], motion_y[k]);
1123
                }
1124
            }
1125
        }
1126
    }
1127

    
1128
    return 0;
1129
}
1130

    
1131
/*
1132
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1133
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1134
 * data. This function unpacks all the VLCs for either the Y plane or both
1135
 * C planes, and is called for DC coefficients or different AC coefficient
1136
 * levels (since different coefficient types require different VLC tables.
1137
 *
1138
 * This function returns a residual eob run. E.g, if a particular token gave
1139
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1140
 * left in the current fragment range, 3 would be returned so that it could
1141
 * be passed into the next call to this same function.
1142
 */
1143
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1144
                        VLC *table, int coeff_index,
1145
                        int first_fragment, int last_fragment,
1146
                        int eob_run)
1147
{
1148
    int i;
1149
    int token;
1150
    int zero_run = 0;
1151
    DCTELEM coeff = 0;
1152
    Vp3Fragment *fragment;
1153
    uint8_t *perm= s->scantable.permutated;
1154
    int bits_to_get;
1155

    
1156
    if ((first_fragment >= s->fragment_count) ||
1157
        (last_fragment >= s->fragment_count)) {
1158

    
1159
        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1160
            first_fragment, last_fragment);
1161
        return 0;
1162
    }
1163

    
1164
    for (i = first_fragment; i <= last_fragment; i++) {
1165

    
1166
        fragment = &s->all_fragments[s->coded_fragment_list[i]];
1167
        if (fragment->coeff_count > coeff_index)
1168
            continue;
1169

    
1170
        if (!eob_run) {
1171
            /* decode a VLC into a token */
1172
            token = get_vlc2(gb, table->table, 5, 3);
1173
            debug_vlc(" token = %2d, ", token);
1174
            /* use the token to get a zero run, a coefficient, and an eob run */
1175
            if (token <= 6) {
1176
                eob_run = eob_run_base[token];
1177
                if (eob_run_get_bits[token])
1178
                    eob_run += get_bits(gb, eob_run_get_bits[token]);
1179
                coeff = zero_run = 0;
1180
            } else {
1181
                bits_to_get = coeff_get_bits[token];
1182
                if (!bits_to_get)
1183
                    coeff = coeff_tables[token][0];
1184
                else
1185
                    coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
1186

    
1187
                zero_run = zero_run_base[token];
1188
                if (zero_run_get_bits[token])
1189
                    zero_run += get_bits(gb, zero_run_get_bits[token]);
1190
            }
1191
        }
1192

    
1193
        if (!eob_run) {
1194
            fragment->coeff_count += zero_run;
1195
            if (fragment->coeff_count < 64){
1196
                fragment->next_coeff->coeff= coeff;
1197
                fragment->next_coeff->index= perm[fragment->coeff_count++]; //FIXME perm here already?
1198
                fragment->next_coeff->next= s->next_coeff;
1199
                s->next_coeff->next=NULL;
1200
                fragment->next_coeff= s->next_coeff++;
1201
            }
1202
            debug_vlc(" fragment %d coeff = %d\n",
1203
                s->coded_fragment_list[i], fragment->next_coeff[coeff_index]);
1204
        } else {
1205
            fragment->coeff_count |= 128;
1206
            debug_vlc(" fragment %d eob with %d coefficients\n",
1207
                s->coded_fragment_list[i], fragment->coeff_count&127);
1208
            eob_run--;
1209
        }
1210
    }
1211

    
1212
    return eob_run;
1213
}
1214

    
1215
/*
1216
 * This function unpacks all of the DCT coefficient data from the
1217
 * bitstream.
1218
 */
1219
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1220
{
1221
    int i;
1222
    int dc_y_table;
1223
    int dc_c_table;
1224
    int ac_y_table;
1225
    int ac_c_table;
1226
    int residual_eob_run = 0;
1227

    
1228
    /* fetch the DC table indices */
1229
    dc_y_table = get_bits(gb, 4);
1230
    dc_c_table = get_bits(gb, 4);
1231

    
1232
    /* unpack the Y plane DC coefficients */
1233
    debug_vp3("  vp3: unpacking Y plane DC coefficients using table %d\n",
1234
        dc_y_table);
1235
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
1236
        s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1237

    
1238
    /* unpack the C plane DC coefficients */
1239
    debug_vp3("  vp3: unpacking C plane DC coefficients using table %d\n",
1240
        dc_c_table);
1241
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1242
        s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1243

    
1244
    /* fetch the AC table indices */
1245
    ac_y_table = get_bits(gb, 4);
1246
    ac_c_table = get_bits(gb, 4);
1247

    
1248
    /* unpack the group 1 AC coefficients (coeffs 1-5) */
1249
    for (i = 1; i <= 5; i++) {
1250

    
1251
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1252
            i, ac_y_table);
1253
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i,
1254
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1255

    
1256
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1257
            i, ac_c_table);
1258
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i,
1259
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1260
    }
1261

    
1262
    /* unpack the group 2 AC coefficients (coeffs 6-14) */
1263
    for (i = 6; i <= 14; i++) {
1264

    
1265
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1266
            i, ac_y_table);
1267
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i,
1268
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1269

    
1270
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1271
            i, ac_c_table);
1272
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i,
1273
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1274
    }
1275

    
1276
    /* unpack the group 3 AC coefficients (coeffs 15-27) */
1277
    for (i = 15; i <= 27; i++) {
1278

    
1279
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1280
            i, ac_y_table);
1281
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i,
1282
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1283

    
1284
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1285
            i, ac_c_table);
1286
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i,
1287
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1288
    }
1289

    
1290
    /* unpack the group 4 AC coefficients (coeffs 28-63) */
1291
    for (i = 28; i <= 63; i++) {
1292

    
1293
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1294
            i, ac_y_table);
1295
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i,
1296
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1297

    
1298
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1299
            i, ac_c_table);
1300
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i,
1301
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1302
    }
1303

    
1304
    return 0;
1305
}
1306

    
1307
/*
1308
 * This function reverses the DC prediction for each coded fragment in
1309
 * the frame. Much of this function is adapted directly from the original
1310
 * VP3 source code.
1311
 */
1312
#define COMPATIBLE_FRAME(x) \
1313
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1314
#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
1315
#define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
1316

    
1317
static void reverse_dc_prediction(Vp3DecodeContext *s,
1318
                                  int first_fragment,
1319
                                  int fragment_width,
1320
                                  int fragment_height)
1321
{
1322

    
1323
#define PUL 8
1324
#define PU 4
1325
#define PUR 2
1326
#define PL 1
1327

    
1328
    int x, y;
1329
    int i = first_fragment;
1330

    
1331
    int predicted_dc;
1332

    
1333
    /* DC values for the left, up-left, up, and up-right fragments */
1334
    int vl, vul, vu, vur;
1335

    
1336
    /* indices for the left, up-left, up, and up-right fragments */
1337
    int l, ul, u, ur;
1338

    
1339
    /*
1340
     * The 6 fields mean:
1341
     *   0: up-left multiplier
1342
     *   1: up multiplier
1343
     *   2: up-right multiplier
1344
     *   3: left multiplier
1345
     */
1346
    int predictor_transform[16][4] = {
1347
        {  0,  0,  0,  0},
1348
        {  0,  0,  0,128},        // PL
1349
        {  0,  0,128,  0},        // PUR
1350
        {  0,  0, 53, 75},        // PUR|PL
1351
        {  0,128,  0,  0},        // PU
1352
        {  0, 64,  0, 64},        // PU|PL
1353
        {  0,128,  0,  0},        // PU|PUR
1354
        {  0,  0, 53, 75},        // PU|PUR|PL
1355
        {128,  0,  0,  0},        // PUL
1356
        {  0,  0,  0,128},        // PUL|PL
1357
        { 64,  0, 64,  0},        // PUL|PUR
1358
        {  0,  0, 53, 75},        // PUL|PUR|PL
1359
        {  0,128,  0,  0},        // PUL|PU
1360
       {-104,116,  0,116},        // PUL|PU|PL
1361
        { 24, 80, 24,  0},        // PUL|PU|PUR
1362
       {-104,116,  0,116}         // PUL|PU|PUR|PL
1363
    };
1364

    
1365
    /* This table shows which types of blocks can use other blocks for
1366
     * prediction. For example, INTRA is the only mode in this table to
1367
     * have a frame number of 0. That means INTRA blocks can only predict
1368
     * from other INTRA blocks. There are 2 golden frame coding types;
1369
     * blocks encoding in these modes can only predict from other blocks
1370
     * that were encoded with these 1 of these 2 modes. */
1371
    unsigned char compatible_frame[8] = {
1372
        1,    /* MODE_INTER_NO_MV */
1373
        0,    /* MODE_INTRA */
1374
        1,    /* MODE_INTER_PLUS_MV */
1375
        1,    /* MODE_INTER_LAST_MV */
1376
        1,    /* MODE_INTER_PRIOR_MV */
1377
        2,    /* MODE_USING_GOLDEN */
1378
        2,    /* MODE_GOLDEN_MV */
1379
        1     /* MODE_INTER_FOUR_MV */
1380
    };
1381
    int current_frame_type;
1382

    
1383
    /* there is a last DC predictor for each of the 3 frame types */
1384
    short last_dc[3];
1385

    
1386
    int transform = 0;
1387

    
1388
    debug_vp3("  vp3: reversing DC prediction\n");
1389

    
1390
    vul = vu = vur = vl = 0;
1391
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
1392

    
1393
    /* for each fragment row... */
1394
    for (y = 0; y < fragment_height; y++) {
1395

    
1396
        /* for each fragment in a row... */
1397
        for (x = 0; x < fragment_width; x++, i++) {
1398

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

    
1402
                current_frame_type =
1403
                    compatible_frame[s->all_fragments[i].coding_method];
1404
                debug_dc_pred(" frag %d: orig DC = %d, ",
1405
                    i, DC_COEFF(i));
1406

    
1407
                transform= 0;
1408
                if(x){
1409
                    l= i-1;
1410
                    vl = DC_COEFF(l);
1411
                    if(FRAME_CODED(l) && COMPATIBLE_FRAME(l))
1412
                        transform |= PL;
1413
                }
1414
                if(y){
1415
                    u= i-fragment_width;
1416
                    vu = DC_COEFF(u);
1417
                    if(FRAME_CODED(u) && COMPATIBLE_FRAME(u))
1418
                        transform |= PU;
1419
                    if(x){
1420
                        ul= i-fragment_width-1;
1421
                        vul = DC_COEFF(ul);
1422
                        if(FRAME_CODED(ul) && COMPATIBLE_FRAME(ul))
1423
                            transform |= PUL;
1424
                    }
1425
                    if(x + 1 < fragment_width){
1426
                        ur= i-fragment_width+1;
1427
                        vur = DC_COEFF(ur);
1428
                        if(FRAME_CODED(ur) && COMPATIBLE_FRAME(ur))
1429
                            transform |= PUR;
1430
                    }
1431
                }
1432

    
1433
                debug_dc_pred("transform = %d, ", transform);
1434

    
1435
                if (transform == 0) {
1436

    
1437
                    /* if there were no fragments to predict from, use last
1438
                     * DC saved */
1439
                    predicted_dc = last_dc[current_frame_type];
1440
                    debug_dc_pred("from last DC (%d) = %d\n",
1441
                        current_frame_type, DC_COEFF(i));
1442

    
1443
                } else {
1444

    
1445
                    /* apply the appropriate predictor transform */
1446
                    predicted_dc =
1447
                        (predictor_transform[transform][0] * vul) +
1448
                        (predictor_transform[transform][1] * vu) +
1449
                        (predictor_transform[transform][2] * vur) +
1450
                        (predictor_transform[transform][3] * vl);
1451

    
1452
                    predicted_dc /= 128;
1453

    
1454
                    /* check for outranging on the [ul u l] and
1455
                     * [ul u ur l] predictors */
1456
                    if ((transform == 13) || (transform == 15)) {
1457
                        if (FFABS(predicted_dc - vu) > 128)
1458
                            predicted_dc = vu;
1459
                        else if (FFABS(predicted_dc - vl) > 128)
1460
                            predicted_dc = vl;
1461
                        else if (FFABS(predicted_dc - vul) > 128)
1462
                            predicted_dc = vul;
1463
                    }
1464

    
1465
                    debug_dc_pred("from pred DC = %d\n",
1466
                    DC_COEFF(i));
1467
                }
1468

    
1469
                /* at long last, apply the predictor */
1470
                if(s->coeffs[i].index){
1471
                    *s->next_coeff= s->coeffs[i];
1472
                    s->coeffs[i].index=0;
1473
                    s->coeffs[i].coeff=0;
1474
                    s->coeffs[i].next= s->next_coeff++;
1475
                }
1476
                s->coeffs[i].coeff += predicted_dc;
1477
                /* save the DC */
1478
                last_dc[current_frame_type] = DC_COEFF(i);
1479
                if(DC_COEFF(i) && !(s->all_fragments[i].coeff_count&127)){
1480
                    s->all_fragments[i].coeff_count= 129;
1481
//                    s->all_fragments[i].next_coeff= s->next_coeff;
1482
                    s->coeffs[i].next= s->next_coeff;
1483
                    (s->next_coeff++)->next=NULL;
1484
                }
1485
            }
1486
        }
1487
    }
1488
}
1489

    
1490

    
1491
static void horizontal_filter(unsigned char *first_pixel, int stride,
1492
    int *bounding_values);
1493
static void vertical_filter(unsigned char *first_pixel, int stride,
1494
    int *bounding_values);
1495

    
1496
/*
1497
 * Perform the final rendering for a particular slice of data.
1498
 * The slice number ranges from 0..(macroblock_height - 1).
1499
 */
1500
static void render_slice(Vp3DecodeContext *s, int slice)
1501
{
1502
    int x;
1503
    int m, n;
1504
    int16_t *dequantizer;
1505
    DECLARE_ALIGNED_16(DCTELEM, block[64]);
1506
    int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
1507
    int motion_halfpel_index;
1508
    uint8_t *motion_source;
1509
    int plane;
1510
    int current_macroblock_entry = slice * s->macroblock_width * 6;
1511

    
1512
    if (slice >= s->macroblock_height)
1513
        return;
1514

    
1515
    for (plane = 0; plane < 3; plane++) {
1516
        uint8_t *output_plane = s->current_frame.data    [plane];
1517
        uint8_t *  last_plane = s->   last_frame.data    [plane];
1518
        uint8_t *golden_plane = s-> golden_frame.data    [plane];
1519
        int stride            = s->current_frame.linesize[plane];
1520
        int plane_width       = s->width  >> !!plane;
1521
        int plane_height      = s->height >> !!plane;
1522
        int y =        slice *  FRAGMENT_PIXELS << !plane ;
1523
        int slice_height = y + (FRAGMENT_PIXELS << !plane);
1524
        int i = s->macroblock_fragments[current_macroblock_entry + plane + 3*!!plane];
1525

    
1526
        if (!s->flipped_image) stride = -stride;
1527

    
1528

    
1529
        if(FFABS(stride) > 2048)
1530
            return; //various tables are fixed size
1531

    
1532
        /* for each fragment row in the slice (both of them)... */
1533
        for (; y < slice_height; y += 8) {
1534

    
1535
            /* for each fragment in a row... */
1536
            for (x = 0; x < plane_width; x += 8, i++) {
1537

    
1538
                if ((i < 0) || (i >= s->fragment_count)) {
1539
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:render_slice(): bad fragment number (%d)\n", i);
1540
                    return;
1541
                }
1542

    
1543
                /* transform if this block was coded */
1544
                if ((s->all_fragments[i].coding_method != MODE_COPY) &&
1545
                    !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
1546

    
1547
                    if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
1548
                        (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
1549
                        motion_source= golden_plane;
1550
                    else
1551
                        motion_source= last_plane;
1552

    
1553
                    motion_source += s->all_fragments[i].first_pixel;
1554
                    motion_halfpel_index = 0;
1555

    
1556
                    /* sort out the motion vector if this fragment is coded
1557
                     * using a motion vector method */
1558
                    if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
1559
                        (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
1560
                        int src_x, src_y;
1561
                        motion_x = s->all_fragments[i].motion_x;
1562
                        motion_y = s->all_fragments[i].motion_y;
1563
                        if(plane){
1564
                            motion_x= (motion_x>>1) | (motion_x&1);
1565
                            motion_y= (motion_y>>1) | (motion_y&1);
1566
                        }
1567

    
1568
                        src_x= (motion_x>>1) + x;
1569
                        src_y= (motion_y>>1) + y;
1570
                        if ((motion_x == 127) || (motion_y == 127))
1571
                            av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
1572

    
1573
                        motion_halfpel_index = motion_x & 0x01;
1574
                        motion_source += (motion_x >> 1);
1575

    
1576
                        motion_halfpel_index |= (motion_y & 0x01) << 1;
1577
                        motion_source += ((motion_y >> 1) * stride);
1578

    
1579
                        if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
1580
                            uint8_t *temp= s->edge_emu_buffer;
1581
                            if(stride<0) temp -= 9*stride;
1582
                            else temp += 9*stride;
1583

    
1584
                            ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
1585
                            motion_source= temp;
1586
                        }
1587
                    }
1588

    
1589

    
1590
                    /* first, take care of copying a block from either the
1591
                     * previous or the golden frame */
1592
                    if (s->all_fragments[i].coding_method != MODE_INTRA) {
1593
                        /* Note, it is possible to implement all MC cases with
1594
                           put_no_rnd_pixels_l2 which would look more like the
1595
                           VP3 source but this would be slower as
1596
                           put_no_rnd_pixels_tab is better optimzed */
1597
                        if(motion_halfpel_index != 3){
1598
                            s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
1599
                                output_plane + s->all_fragments[i].first_pixel,
1600
                                motion_source, stride, 8);
1601
                        }else{
1602
                            int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
1603
                            s->dsp.put_no_rnd_pixels_l2[1](
1604
                                output_plane + s->all_fragments[i].first_pixel,
1605
                                motion_source - d,
1606
                                motion_source + stride + 1 + d,
1607
                                stride, 8);
1608
                        }
1609
                        dequantizer = s->qmat[1][plane];
1610
                    }else{
1611
                        dequantizer = s->qmat[0][plane];
1612
                    }
1613

    
1614
                    /* dequantize the DCT coefficients */
1615
                    debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
1616
                        i, s->all_fragments[i].coding_method,
1617
                        DC_COEFF(i), dequantizer[0]);
1618

    
1619
                    if(s->avctx->idct_algo==FF_IDCT_VP3){
1620
                        Coeff *coeff= s->coeffs + i;
1621
                        memset(block, 0, sizeof(block));
1622
                        while(coeff->next){
1623
                            block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
1624
                            coeff= coeff->next;
1625
                        }
1626
                    }else{
1627
                        Coeff *coeff= s->coeffs + i;
1628
                        memset(block, 0, sizeof(block));
1629
                        while(coeff->next){
1630
                            block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
1631
                            coeff= coeff->next;
1632
                        }
1633
                    }
1634

    
1635
                    /* invert DCT and place (or add) in final output */
1636

    
1637
                    if (s->all_fragments[i].coding_method == MODE_INTRA) {
1638
                        if(s->avctx->idct_algo!=FF_IDCT_VP3)
1639
                            block[0] += 128<<3;
1640
                        s->dsp.idct_put(
1641
                            output_plane + s->all_fragments[i].first_pixel,
1642
                            stride,
1643
                            block);
1644
                    } else {
1645
                        s->dsp.idct_add(
1646
                            output_plane + s->all_fragments[i].first_pixel,
1647
                            stride,
1648
                            block);
1649
                    }
1650

    
1651
                    debug_idct("block after idct_%s():\n",
1652
                        (s->all_fragments[i].coding_method == MODE_INTRA)?
1653
                        "put" : "add");
1654
                    for (m = 0; m < 8; m++) {
1655
                        for (n = 0; n < 8; n++) {
1656
                            debug_idct(" %3d", *(output_plane +
1657
                                s->all_fragments[i].first_pixel + (m * stride + n)));
1658
                        }
1659
                        debug_idct("\n");
1660
                    }
1661
                    debug_idct("\n");
1662

    
1663
                } else {
1664

    
1665
                    /* copy directly from the previous frame */
1666
                    s->dsp.put_pixels_tab[1][0](
1667
                        output_plane + s->all_fragments[i].first_pixel,
1668
                        last_plane + s->all_fragments[i].first_pixel,
1669
                        stride, 8);
1670

    
1671
                }
1672
#if 0
1673
                /* perform the left edge filter if:
1674
                 *   - the fragment is not on the left column
1675
                 *   - the fragment is coded in this frame
1676
                 *   - the fragment is not coded in this frame but the left
1677
                 *     fragment is coded in this frame (this is done instead
1678
                 *     of a right edge filter when rendering the left fragment
1679
                 *     since this fragment is not available yet) */
1680
                if ((x > 0) &&
1681
                    ((s->all_fragments[i].coding_method != MODE_COPY) ||
1682
                     ((s->all_fragments[i].coding_method == MODE_COPY) &&
1683
                      (s->all_fragments[i - 1].coding_method != MODE_COPY)) )) {
1684
                    horizontal_filter(
1685
                        output_plane + s->all_fragments[i].first_pixel + 7*stride,
1686
                        -stride, s->bounding_values_array + 127);
1687
                }
1688

1689
                /* perform the top edge filter if:
1690
                 *   - the fragment is not on the top row
1691
                 *   - the fragment is coded in this frame
1692
                 *   - the fragment is not coded in this frame but the above
1693
                 *     fragment is coded in this frame (this is done instead
1694
                 *     of a bottom edge filter when rendering the above
1695
                 *     fragment since this fragment is not available yet) */
1696
                if ((y > 0) &&
1697
                    ((s->all_fragments[i].coding_method != MODE_COPY) ||
1698
                     ((s->all_fragments[i].coding_method == MODE_COPY) &&
1699
                      (s->all_fragments[i - fragment_width].coding_method != MODE_COPY)) )) {
1700
                    vertical_filter(
1701
                        output_plane + s->all_fragments[i].first_pixel - stride,
1702
                        -stride, s->bounding_values_array + 127);
1703
                }
1704
#endif
1705
            }
1706
        }
1707
    }
1708

    
1709
     /* this looks like a good place for slice dispatch... */
1710
     /* algorithm:
1711
      *   if (slice == s->macroblock_height - 1)
1712
      *     dispatch (both last slice & 2nd-to-last slice);
1713
      *   else if (slice > 0)
1714
      *     dispatch (slice - 1);
1715
      */
1716

    
1717
    emms_c();
1718
}
1719

    
1720
static void horizontal_filter(unsigned char *first_pixel, int stride,
1721
    int *bounding_values)
1722
{
1723
    unsigned char *end;
1724
    int filter_value;
1725

    
1726
    for (end= first_pixel + 8*stride; first_pixel != end; first_pixel += stride) {
1727
        filter_value =
1728
            (first_pixel[-2] - first_pixel[ 1])
1729
         +3*(first_pixel[ 0] - first_pixel[-1]);
1730
        filter_value = bounding_values[(filter_value + 4) >> 3];
1731
        first_pixel[-1] = av_clip_uint8(first_pixel[-1] + filter_value);
1732
        first_pixel[ 0] = av_clip_uint8(first_pixel[ 0] - filter_value);
1733
    }
1734
}
1735

    
1736
static void vertical_filter(unsigned char *first_pixel, int stride,
1737
    int *bounding_values)
1738
{
1739
    unsigned char *end;
1740
    int filter_value;
1741
    const int nstride= -stride;
1742

    
1743
    for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
1744
        filter_value =
1745
            (first_pixel[2 * nstride] - first_pixel[ stride])
1746
         +3*(first_pixel[0          ] - first_pixel[nstride]);
1747
        filter_value = bounding_values[(filter_value + 4) >> 3];
1748
        first_pixel[nstride] = av_clip_uint8(first_pixel[nstride] + filter_value);
1749
        first_pixel[0] = av_clip_uint8(first_pixel[0] - filter_value);
1750
    }
1751
}
1752

    
1753
static void apply_loop_filter(Vp3DecodeContext *s)
1754
{
1755
    int plane;
1756
    int x, y;
1757
    int *bounding_values= s->bounding_values_array+127;
1758

    
1759
#if 0
1760
    int bounding_values_array[256];
1761
    int filter_limit;
1762

1763
    /* find the right loop limit value */
1764
    for (x = 63; x >= 0; x--) {
1765
        if (vp31_ac_scale_factor[x] >= s->quality_index)
1766
            break;
1767
    }
1768
    filter_limit = vp31_filter_limit_values[s->quality_index];
1769

1770
    /* set up the bounding values */
1771
    memset(bounding_values_array, 0, 256 * sizeof(int));
1772
    for (x = 0; x < filter_limit; x++) {
1773
        bounding_values[-x - filter_limit] = -filter_limit + x;
1774
        bounding_values[-x] = -x;
1775
        bounding_values[x] = x;
1776
        bounding_values[x + filter_limit] = filter_limit - x;
1777
    }
1778
#endif
1779

    
1780
    for (plane = 0; plane < 3; plane++) {
1781
        int width           = s->fragment_width  >> !!plane;
1782
        int height          = s->fragment_height >> !!plane;
1783
        int fragment        = s->fragment_start        [plane];
1784
        int stride          = s->current_frame.linesize[plane];
1785
        uint8_t *plane_data = s->current_frame.data    [plane];
1786
        if (!s->flipped_image) stride = -stride;
1787

    
1788
        for (y = 0; y < height; y++) {
1789

    
1790
            for (x = 0; x < width; x++) {
1791
START_TIMER
1792
                /* do not perform left edge filter for left columns frags */
1793
                if ((x > 0) &&
1794
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
1795
                    horizontal_filter(
1796
                        plane_data + s->all_fragments[fragment].first_pixel,
1797
                        stride, bounding_values);
1798
                }
1799

    
1800
                /* do not perform top edge filter for top row fragments */
1801
                if ((y > 0) &&
1802
                    (s->all_fragments[fragment].coding_method != MODE_COPY)) {
1803
                    vertical_filter(
1804
                        plane_data + s->all_fragments[fragment].first_pixel,
1805
                        stride, bounding_values);
1806
                }
1807

    
1808
                /* do not perform right edge filter for right column
1809
                 * fragments or if right fragment neighbor is also coded
1810
                 * in this frame (it will be filtered in next iteration) */
1811
                if ((x < width - 1) &&
1812
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
1813
                    (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
1814
                    horizontal_filter(
1815
                        plane_data + s->all_fragments[fragment + 1].first_pixel,
1816
                        stride, bounding_values);
1817
                }
1818

    
1819
                /* do not perform bottom edge filter for bottom row
1820
                 * fragments or if bottom fragment neighbor is also coded
1821
                 * in this frame (it will be filtered in the next row) */
1822
                if ((y < height - 1) &&
1823
                    (s->all_fragments[fragment].coding_method != MODE_COPY) &&
1824
                    (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
1825
                    vertical_filter(
1826
                        plane_data + s->all_fragments[fragment + width].first_pixel,
1827
                        stride, bounding_values);
1828
                }
1829

    
1830
                fragment++;
1831
STOP_TIMER("loop filter")
1832
            }
1833
        }
1834
    }
1835
}
1836

    
1837
/*
1838
 * This function computes the first pixel addresses for each fragment.
1839
 * This function needs to be invoked after the first frame is allocated
1840
 * so that it has access to the plane strides.
1841
 */
1842
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
1843
{
1844

    
1845
    int i, x, y;
1846

    
1847
    /* figure out the first pixel addresses for each of the fragments */
1848
    /* Y plane */
1849
    i = 0;
1850
    for (y = s->fragment_height; y > 0; y--) {
1851
        for (x = 0; x < s->fragment_width; x++) {
1852
            s->all_fragments[i++].first_pixel =
1853
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
1854
                    s->golden_frame.linesize[0] +
1855
                    x * FRAGMENT_PIXELS;
1856
            debug_init("  fragment %d, first pixel @ %d\n",
1857
                i-1, s->all_fragments[i-1].first_pixel);
1858
        }
1859
    }
1860

    
1861
    /* U plane */
1862
    i = s->fragment_start[1];
1863
    for (y = s->fragment_height / 2; y > 0; y--) {
1864
        for (x = 0; x < s->fragment_width / 2; x++) {
1865
            s->all_fragments[i++].first_pixel =
1866
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
1867
                    s->golden_frame.linesize[1] +
1868
                    x * FRAGMENT_PIXELS;
1869
            debug_init("  fragment %d, first pixel @ %d\n",
1870
                i-1, s->all_fragments[i-1].first_pixel);
1871
        }
1872
    }
1873

    
1874
    /* V plane */
1875
    i = s->fragment_start[2];
1876
    for (y = s->fragment_height / 2; y > 0; y--) {
1877
        for (x = 0; x < s->fragment_width / 2; x++) {
1878
            s->all_fragments[i++].first_pixel =
1879
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
1880
                    s->golden_frame.linesize[2] +
1881
                    x * FRAGMENT_PIXELS;
1882
            debug_init("  fragment %d, first pixel @ %d\n",
1883
                i-1, s->all_fragments[i-1].first_pixel);
1884
        }
1885
    }
1886
}
1887

    
1888
/* FIXME: this should be merged with the above! */
1889
static void theora_calculate_pixel_addresses(Vp3DecodeContext *s)
1890
{
1891

    
1892
    int i, x, y;
1893

    
1894
    /* figure out the first pixel addresses for each of the fragments */
1895
    /* Y plane */
1896
    i = 0;
1897
    for (y = 1; y <= s->fragment_height; y++) {
1898
        for (x = 0; x < s->fragment_width; x++) {
1899
            s->all_fragments[i++].first_pixel =
1900
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
1901
                    s->golden_frame.linesize[0] +
1902
                    x * FRAGMENT_PIXELS;
1903
            debug_init("  fragment %d, first pixel @ %d\n",
1904
                i-1, s->all_fragments[i-1].first_pixel);
1905
        }
1906
    }
1907

    
1908
    /* U plane */
1909
    i = s->fragment_start[1];
1910
    for (y = 1; y <= s->fragment_height / 2; y++) {
1911
        for (x = 0; x < s->fragment_width / 2; x++) {
1912
            s->all_fragments[i++].first_pixel =
1913
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
1914
                    s->golden_frame.linesize[1] +
1915
                    x * FRAGMENT_PIXELS;
1916
            debug_init("  fragment %d, first pixel @ %d\n",
1917
                i-1, s->all_fragments[i-1].first_pixel);
1918
        }
1919
    }
1920

    
1921
    /* V plane */
1922
    i = s->fragment_start[2];
1923
    for (y = 1; y <= s->fragment_height / 2; y++) {
1924
        for (x = 0; x < s->fragment_width / 2; x++) {
1925
            s->all_fragments[i++].first_pixel =
1926
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
1927
                    s->golden_frame.linesize[2] +
1928
                    x * FRAGMENT_PIXELS;
1929
            debug_init("  fragment %d, first pixel @ %d\n",
1930
                i-1, s->all_fragments[i-1].first_pixel);
1931
        }
1932
    }
1933
}
1934

    
1935
/*
1936
 * This is the ffmpeg/libavcodec API init function.
1937
 */
1938
static int vp3_decode_init(AVCodecContext *avctx)
1939
{
1940
    Vp3DecodeContext *s = avctx->priv_data;
1941
    int i, inter, plane;
1942
    int c_width;
1943
    int c_height;
1944
    int y_superblock_count;
1945
    int c_superblock_count;
1946

    
1947
    if (avctx->codec_tag == MKTAG('V','P','3','0'))
1948
        s->version = 0;
1949
    else
1950
        s->version = 1;
1951

    
1952
    s->avctx = avctx;
1953
    s->width = (avctx->width + 15) & 0xFFFFFFF0;
1954
    s->height = (avctx->height + 15) & 0xFFFFFFF0;
1955
    avctx->pix_fmt = PIX_FMT_YUV420P;
1956
    if(avctx->idct_algo==FF_IDCT_AUTO)
1957
        avctx->idct_algo=FF_IDCT_VP3;
1958
    dsputil_init(&s->dsp, avctx);
1959

    
1960
    ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
1961

    
1962
    /* initialize to an impossible value which will force a recalculation
1963
     * in the first frame decode */
1964
    s->quality_index = -1;
1965

    
1966
    s->y_superblock_width = (s->width + 31) / 32;
1967
    s->y_superblock_height = (s->height + 31) / 32;
1968
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
1969

    
1970
    /* work out the dimensions for the C planes */
1971
    c_width = s->width / 2;
1972
    c_height = s->height / 2;
1973
    s->c_superblock_width = (c_width + 31) / 32;
1974
    s->c_superblock_height = (c_height + 31) / 32;
1975
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
1976

    
1977
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
1978
    s->u_superblock_start = y_superblock_count;
1979
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
1980
    s->superblock_coding = av_malloc(s->superblock_count);
1981

    
1982
    s->macroblock_width = (s->width + 15) / 16;
1983
    s->macroblock_height = (s->height + 15) / 16;
1984
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
1985

    
1986
    s->fragment_width = s->width / FRAGMENT_PIXELS;
1987
    s->fragment_height = s->height / FRAGMENT_PIXELS;
1988

    
1989
    /* fragment count covers all 8x8 blocks for all 3 planes */
1990
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
1991
    s->fragment_start[1] = s->fragment_width * s->fragment_height;
1992
    s->fragment_start[2] = s->fragment_width * s->fragment_height * 5 / 4;
1993

    
1994
    debug_init("  Y plane: %d x %d\n", s->width, s->height);
1995
    debug_init("  C plane: %d x %d\n", c_width, c_height);
1996
    debug_init("  Y superblocks: %d x %d, %d total\n",
1997
        s->y_superblock_width, s->y_superblock_height, y_superblock_count);
1998
    debug_init("  C superblocks: %d x %d, %d total\n",
1999
        s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2000
    debug_init("  total superblocks = %d, U starts @ %d, V starts @ %d\n",
2001
        s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2002
    debug_init("  macroblocks: %d x %d, %d total\n",
2003
        s->macroblock_width, s->macroblock_height, s->macroblock_count);
2004
    debug_init("  %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2005
        s->fragment_count,
2006
        s->fragment_width,
2007
        s->fragment_height,
2008
        s->fragment_start[1],
2009
        s->fragment_start[2]);
2010

    
2011
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2012
    s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
2013
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2014
    s->pixel_addresses_inited = 0;
2015

    
2016
    if (!s->theora_tables)
2017
    {
2018
        for (i = 0; i < 64; i++) {
2019
            s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2020
            s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
2021
            s->base_matrix[0][i] = vp31_intra_y_dequant[i];
2022
            s->base_matrix[1][i] = vp31_intra_c_dequant[i];
2023
            s->base_matrix[2][i] = vp31_inter_dequant[i];
2024
            s->filter_limit_values[i] = vp31_filter_limit_values[i];
2025
        }
2026

    
2027
        for(inter=0; inter<2; inter++){
2028
            for(plane=0; plane<3; plane++){
2029
                s->qr_count[inter][plane]= 1;
2030
                s->qr_size [inter][plane][0]= 63;
2031
                s->qr_base [inter][plane][0]=
2032
                s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;
2033
            }
2034
        }
2035

    
2036
        /* init VLC tables */
2037
        for (i = 0; i < 16; i++) {
2038

    
2039
            /* DC histograms */
2040
            init_vlc(&s->dc_vlc[i], 5, 32,
2041
                &dc_bias[i][0][1], 4, 2,
2042
                &dc_bias[i][0][0], 4, 2, 0);
2043

    
2044
            /* group 1 AC histograms */
2045
            init_vlc(&s->ac_vlc_1[i], 5, 32,
2046
                &ac_bias_0[i][0][1], 4, 2,
2047
                &ac_bias_0[i][0][0], 4, 2, 0);
2048

    
2049
            /* group 2 AC histograms */
2050
            init_vlc(&s->ac_vlc_2[i], 5, 32,
2051
                &ac_bias_1[i][0][1], 4, 2,
2052
                &ac_bias_1[i][0][0], 4, 2, 0);
2053

    
2054
            /* group 3 AC histograms */
2055
            init_vlc(&s->ac_vlc_3[i], 5, 32,
2056
                &ac_bias_2[i][0][1], 4, 2,
2057
                &ac_bias_2[i][0][0], 4, 2, 0);
2058

    
2059
            /* group 4 AC histograms */
2060
            init_vlc(&s->ac_vlc_4[i], 5, 32,
2061
                &ac_bias_3[i][0][1], 4, 2,
2062
                &ac_bias_3[i][0][0], 4, 2, 0);
2063
        }
2064
    } else {
2065
        for (i = 0; i < 16; i++) {
2066

    
2067
            /* DC histograms */
2068
            init_vlc(&s->dc_vlc[i], 5, 32,
2069
                &s->huffman_table[i][0][1], 4, 2,
2070
                &s->huffman_table[i][0][0], 4, 2, 0);
2071

    
2072
            /* group 1 AC histograms */
2073
            init_vlc(&s->ac_vlc_1[i], 5, 32,
2074
                &s->huffman_table[i+16][0][1], 4, 2,
2075
                &s->huffman_table[i+16][0][0], 4, 2, 0);
2076

    
2077
            /* group 2 AC histograms */
2078
            init_vlc(&s->ac_vlc_2[i], 5, 32,
2079
                &s->huffman_table[i+16*2][0][1], 4, 2,
2080
                &s->huffman_table[i+16*2][0][0], 4, 2, 0);
2081

    
2082
            /* group 3 AC histograms */
2083
            init_vlc(&s->ac_vlc_3[i], 5, 32,
2084
                &s->huffman_table[i+16*3][0][1], 4, 2,
2085
                &s->huffman_table[i+16*3][0][0], 4, 2, 0);
2086

    
2087
            /* group 4 AC histograms */
2088
            init_vlc(&s->ac_vlc_4[i], 5, 32,
2089
                &s->huffman_table[i+16*4][0][1], 4, 2,
2090
                &s->huffman_table[i+16*4][0][0], 4, 2, 0);
2091
        }
2092
    }
2093

    
2094
    init_vlc(&s->superblock_run_length_vlc, 6, 34,
2095
        &superblock_run_length_vlc_table[0][1], 4, 2,
2096
        &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2097

    
2098
    init_vlc(&s->fragment_run_length_vlc, 5, 30,
2099
        &fragment_run_length_vlc_table[0][1], 4, 2,
2100
        &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2101

    
2102
    init_vlc(&s->mode_code_vlc, 3, 8,
2103
        &mode_code_vlc_table[0][1], 2, 1,
2104
        &mode_code_vlc_table[0][0], 2, 1, 0);
2105

    
2106
    init_vlc(&s->motion_vector_vlc, 6, 63,
2107
        &motion_vector_vlc_table[0][1], 2, 1,
2108
        &motion_vector_vlc_table[0][0], 2, 1, 0);
2109

    
2110
    /* work out the block mapping tables */
2111
    s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2112
    s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2113
    s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
2114
    s->macroblock_coding = av_malloc(s->macroblock_count + 1);
2115
    init_block_mapping(s);
2116

    
2117
    for (i = 0; i < 3; i++) {
2118
        s->current_frame.data[i] = NULL;
2119
        s->last_frame.data[i] = NULL;
2120
        s->golden_frame.data[i] = NULL;
2121
    }
2122

    
2123
    return 0;
2124
}
2125

    
2126
/*
2127
 * This is the ffmpeg/libavcodec API frame decode function.
2128
 */
2129
static int vp3_decode_frame(AVCodecContext *avctx,
2130
                            void *data, int *data_size,
2131
                            uint8_t *buf, int buf_size)
2132
{
2133
    Vp3DecodeContext *s = avctx->priv_data;
2134
    GetBitContext gb;
2135
    static int counter = 0;
2136
    int i;
2137

    
2138
    init_get_bits(&gb, buf, buf_size * 8);
2139

    
2140
    if (s->theora && get_bits1(&gb))
2141
    {
2142
        av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n");
2143
        return -1;
2144
    }
2145

    
2146
    s->keyframe = !get_bits1(&gb);
2147
    if (!s->theora)
2148
        skip_bits(&gb, 1);
2149
    s->last_quality_index = s->quality_index;
2150

    
2151
    s->nqis=0;
2152
    do{
2153
        s->qis[s->nqis++]= get_bits(&gb, 6);
2154
    } while(s->theora >= 0x030200 && s->nqis<3 && get_bits1(&gb));
2155

    
2156
    s->quality_index= s->qis[0];
2157

    
2158
    if (s->avctx->debug & FF_DEBUG_PICT_INFO)
2159
        av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
2160
            s->keyframe?"key":"", counter, s->quality_index);
2161
    counter++;
2162

    
2163
    if (s->quality_index != s->last_quality_index) {
2164
        init_dequantizer(s);
2165
        init_loop_filter(s);
2166
    }
2167

    
2168
    if (s->keyframe) {
2169
        if (!s->theora)
2170
        {
2171
            skip_bits(&gb, 4); /* width code */
2172
            skip_bits(&gb, 4); /* height code */
2173
            if (s->version)
2174
            {
2175
                s->version = get_bits(&gb, 5);
2176
                if (counter == 1)
2177
                    av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
2178
            }
2179
        }
2180
        if (s->version || s->theora)
2181
        {
2182
                if (get_bits1(&gb))
2183
                    av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
2184
            skip_bits(&gb, 2); /* reserved? */
2185
        }
2186

    
2187
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2188
            if (s->golden_frame.data[0])
2189
                avctx->release_buffer(avctx, &s->golden_frame);
2190
            s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
2191
        } else {
2192
            if (s->golden_frame.data[0])
2193
                avctx->release_buffer(avctx, &s->golden_frame);
2194
            if (s->last_frame.data[0])
2195
                avctx->release_buffer(avctx, &s->last_frame);
2196
        }
2197

    
2198
        s->golden_frame.reference = 3;
2199
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2200
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2201
            return -1;
2202
        }
2203

    
2204
        /* golden frame is also the current frame */
2205
        s->current_frame= s->golden_frame;
2206

    
2207
        /* time to figure out pixel addresses? */
2208
        if (!s->pixel_addresses_inited)
2209
        {
2210
            if (!s->flipped_image)
2211
                vp3_calculate_pixel_addresses(s);
2212
            else
2213
                theora_calculate_pixel_addresses(s);
2214
            s->pixel_addresses_inited = 1;
2215
        }
2216
    } else {
2217
        /* allocate a new current frame */
2218
        s->current_frame.reference = 3;
2219
        if (!s->pixel_addresses_inited) {
2220
            av_log(s->avctx, AV_LOG_ERROR, "vp3: first frame not a keyframe\n");
2221
            return -1;
2222
        }
2223
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2224
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2225
            return -1;
2226
        }
2227
    }
2228

    
2229
    s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2230
    s->current_frame.qstride= 0;
2231

    
2232
    {START_TIMER
2233
    init_frame(s, &gb);
2234
    STOP_TIMER("init_frame")}
2235

    
2236
#if KEYFRAMES_ONLY
2237
if (!s->keyframe) {
2238

    
2239
    memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2240
        s->current_frame.linesize[0] * s->height);
2241
    memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2242
        s->current_frame.linesize[1] * s->height / 2);
2243
    memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2244
        s->current_frame.linesize[2] * s->height / 2);
2245

    
2246
} else {
2247
#endif
2248

    
2249
    {START_TIMER
2250
    if (unpack_superblocks(s, &gb)){
2251
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
2252
        return -1;
2253
    }
2254
    STOP_TIMER("unpack_superblocks")}
2255
    {START_TIMER
2256
    if (unpack_modes(s, &gb)){
2257
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
2258
        return -1;
2259
    }
2260
    STOP_TIMER("unpack_modes")}
2261
    {START_TIMER
2262
    if (unpack_vectors(s, &gb)){
2263
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
2264
        return -1;
2265
    }
2266
    STOP_TIMER("unpack_vectors")}
2267
    {START_TIMER
2268
    if (unpack_dct_coeffs(s, &gb)){
2269
        av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
2270
        return -1;
2271
    }
2272
    STOP_TIMER("unpack_dct_coeffs")}
2273
    {START_TIMER
2274

    
2275
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2276
    if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2277
        reverse_dc_prediction(s, s->fragment_start[1],
2278
            s->fragment_width / 2, s->fragment_height / 2);
2279
        reverse_dc_prediction(s, s->fragment_start[2],
2280
            s->fragment_width / 2, s->fragment_height / 2);
2281
    }
2282
    STOP_TIMER("reverse_dc_prediction")}
2283
    {START_TIMER
2284

    
2285
    for (i = 0; i < s->macroblock_height; i++)
2286
        render_slice(s, i);
2287
    STOP_TIMER("render_fragments")}
2288

    
2289
    {START_TIMER
2290
    apply_loop_filter(s);
2291
    STOP_TIMER("apply_loop_filter")}
2292
#if KEYFRAMES_ONLY
2293
}
2294
#endif
2295

    
2296
    *data_size=sizeof(AVFrame);
2297
    *(AVFrame*)data= s->current_frame;
2298

    
2299
    /* release the last frame, if it is allocated and if it is not the
2300
     * golden frame */
2301
    if ((s->last_frame.data[0]) &&
2302
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2303
        avctx->release_buffer(avctx, &s->last_frame);
2304

    
2305
    /* shuffle frames (last = current) */
2306
    s->last_frame= s->current_frame;
2307
    s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
2308

    
2309
    return buf_size;
2310
}
2311

    
2312
/*
2313
 * This is the ffmpeg/libavcodec API module cleanup function.
2314
 */
2315
static int vp3_decode_end(AVCodecContext *avctx)
2316
{
2317
    Vp3DecodeContext *s = avctx->priv_data;
2318

    
2319
    av_free(s->all_fragments);
2320
    av_free(s->coeffs);
2321
    av_free(s->coded_fragment_list);
2322
    av_free(s->superblock_fragments);
2323
    av_free(s->superblock_macroblocks);
2324
    av_free(s->macroblock_fragments);
2325
    av_free(s->macroblock_coding);
2326

    
2327
    /* release all frames */
2328
    if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2329
        avctx->release_buffer(avctx, &s->golden_frame);
2330
    if (s->last_frame.data[0])
2331
        avctx->release_buffer(avctx, &s->last_frame);
2332
    /* no need to release the current_frame since it will always be pointing
2333
     * to the same frame as either the golden or last frame */
2334

    
2335
    return 0;
2336
}
2337

    
2338
static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
2339
{
2340
    Vp3DecodeContext *s = avctx->priv_data;
2341

    
2342
    if (get_bits(gb, 1)) {
2343
        int token;
2344
        if (s->entries >= 32) { /* overflow */
2345
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2346
            return -1;
2347
        }
2348
        token = get_bits(gb, 5);
2349
        //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size);
2350
        s->huffman_table[s->hti][token][0] = s->hbits;
2351
        s->huffman_table[s->hti][token][1] = s->huff_code_size;
2352
        s->entries++;
2353
    }
2354
    else {
2355
        if (s->huff_code_size >= 32) {/* overflow */
2356
            av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
2357
            return -1;
2358
        }
2359
        s->huff_code_size++;
2360
        s->hbits <<= 1;
2361
        read_huffman_tree(avctx, gb);
2362
        s->hbits |= 1;
2363
        read_huffman_tree(avctx, gb);
2364
        s->hbits >>= 1;
2365
        s->huff_code_size--;
2366
    }
2367
    return 0;
2368
}
2369

    
2370
#ifdef CONFIG_THEORA_DECODER
2371
static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
2372
{
2373
    Vp3DecodeContext *s = avctx->priv_data;
2374
    int visible_width, visible_height;
2375

    
2376
    s->theora = get_bits_long(gb, 24);
2377
    av_log(avctx, AV_LOG_INFO, "Theora bitstream version %X\n", s->theora);
2378

    
2379
    /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
2380
    /* but previous versions have the image flipped relative to vp3 */
2381
    if (s->theora < 0x030200)
2382
    {
2383
        s->flipped_image = 1;
2384
        av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
2385
    }
2386

    
2387
    s->width = get_bits(gb, 16) << 4;
2388
    s->height = get_bits(gb, 16) << 4;
2389

    
2390
    if(avcodec_check_dimensions(avctx, s->width, s->height)){
2391
        av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);
2392
        s->width= s->height= 0;
2393
        return -1;
2394
    }
2395

    
2396
    if (s->theora >= 0x030400)
2397
    {
2398
        skip_bits(gb, 32); /* total number of superblocks in a frame */
2399
        // fixme, the next field is 36bits long
2400
        skip_bits(gb, 32); /* total number of blocks in a frame */
2401
        skip_bits(gb, 4); /* total number of blocks in a frame */
2402
        skip_bits(gb, 32); /* total number of macroblocks in a frame */
2403
    }
2404

    
2405
    visible_width  = get_bits_long(gb, 24);
2406
    visible_height = get_bits_long(gb, 24);
2407

    
2408
    if (s->theora >= 0x030200) {
2409
        skip_bits(gb, 8); /* offset x */
2410
        skip_bits(gb, 8); /* offset y */
2411
    }
2412

    
2413
    skip_bits(gb, 32); /* fps numerator */
2414
    skip_bits(gb, 32); /* fps denumerator */
2415
    skip_bits(gb, 24); /* aspect numerator */
2416
    skip_bits(gb, 24); /* aspect denumerator */
2417

    
2418
    if (s->theora < 0x030200)
2419
        skip_bits(gb, 5); /* keyframe frequency force */
2420
    skip_bits(gb, 8); /* colorspace */
2421
    if (s->theora >= 0x030400)
2422
        skip_bits(gb, 2); /* pixel format: 420,res,422,444 */
2423
    skip_bits(gb, 24); /* bitrate */
2424

    
2425
    skip_bits(gb, 6); /* quality hint */
2426

    
2427
    if (s->theora >= 0x030200)
2428
    {
2429
        skip_bits(gb, 5); /* keyframe frequency force */
2430

    
2431
        if (s->theora < 0x030400)
2432
            skip_bits(gb, 5); /* spare bits */
2433
    }
2434

    
2435
//    align_get_bits(gb);
2436

    
2437
    if (   visible_width  <= s->width  && visible_width  > s->width-16
2438
        && visible_height <= s->height && visible_height > s->height-16)
2439
        avcodec_set_dimensions(avctx, visible_width, visible_height);
2440
    else
2441
        avcodec_set_dimensions(avctx, s->width, s->height);
2442

    
2443
    return 0;
2444
}
2445

    
2446
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
2447
{
2448
    Vp3DecodeContext *s = avctx->priv_data;
2449
    int i, n, matrices, inter, plane;
2450

    
2451
    if (s->theora >= 0x030200) {
2452
        n = get_bits(gb, 3);
2453
        /* loop filter limit values table */
2454
        for (i = 0; i < 64; i++)
2455
            s->filter_limit_values[i] = get_bits(gb, n);
2456
    }
2457

    
2458
    if (s->theora >= 0x030200)
2459
        n = get_bits(gb, 4) + 1;
2460
    else
2461
        n = 16;
2462
    /* quality threshold table */
2463
    for (i = 0; i < 64; i++)
2464
        s->coded_ac_scale_factor[i] = get_bits(gb, n);
2465

    
2466
    if (s->theora >= 0x030200)
2467
        n = get_bits(gb, 4) + 1;
2468
    else
2469
        n = 16;
2470
    /* dc scale factor table */
2471
    for (i = 0; i < 64; i++)
2472
        s->coded_dc_scale_factor[i] = get_bits(gb, n);
2473

    
2474
    if (s->theora >= 0x030200)
2475
        matrices = get_bits(gb, 9) + 1;
2476
    else
2477
        matrices = 3;
2478

    
2479
    if(matrices > 384){
2480
        av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
2481
        return -1;
2482
    }
2483

    
2484
    for(n=0; n<matrices; n++){
2485
        for (i = 0; i < 64; i++)
2486
            s->base_matrix[n][i]= get_bits(gb, 8);
2487
    }
2488

    
2489
    for (inter = 0; inter <= 1; inter++) {
2490
        for (plane = 0; plane <= 2; plane++) {
2491
            int newqr= 1;
2492
            if (inter || plane > 0)
2493
                newqr = get_bits(gb, 1);
2494
            if (!newqr) {
2495
                int qtj, plj;
2496
                if(inter && get_bits(gb, 1)){
2497
                    qtj = 0;
2498
                    plj = plane;
2499
                }else{
2500
                    qtj= (3*inter + plane - 1) / 3;
2501
                    plj= (plane + 2) % 3;
2502
                }
2503
                s->qr_count[inter][plane]= s->qr_count[qtj][plj];
2504
                memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0]));
2505
                memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0]));
2506
            } else {
2507
                int qri= 0;
2508
                int qi = 0;
2509

    
2510
                for(;;){
2511
                    i= get_bits(gb, av_log2(matrices-1)+1);
2512
                    if(i>= matrices){
2513
                        av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n");
2514
                        return -1;
2515
                    }
2516
                    s->qr_base[inter][plane][qri]= i;
2517
                    if(qi >= 63)
2518
                        break;
2519
                    i = get_bits(gb, av_log2(63-qi)+1) + 1;
2520
                    s->qr_size[inter][plane][qri++]= i;
2521
                    qi += i;
2522
                }
2523

    
2524
                if (qi > 63) {
2525
                    av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
2526
                    return -1;
2527
                }
2528
                s->qr_count[inter][plane]= qri;
2529
            }
2530
        }
2531
    }
2532

    
2533
    /* Huffman tables */
2534
    for (s->hti = 0; s->hti < 80; s->hti++) {
2535
        s->entries = 0;
2536
        s->huff_code_size = 1;
2537
        if (!get_bits(gb, 1)) {
2538
            s->hbits = 0;
2539
            read_huffman_tree(avctx, gb);
2540
            s->hbits = 1;
2541
            read_huffman_tree(avctx, gb);
2542
        }
2543
    }
2544

    
2545
    s->theora_tables = 1;
2546

    
2547
    return 0;
2548
}
2549

    
2550
static int theora_decode_init(AVCodecContext *avctx)
2551
{
2552
    Vp3DecodeContext *s = avctx->priv_data;
2553
    GetBitContext gb;
2554
    int ptype;
2555
    uint8_t *header_start[3];
2556
    int header_len[3];
2557
    int i;
2558

    
2559
    s->theora = 1;
2560

    
2561
    if (!avctx->extradata_size)
2562
    {
2563
        av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
2564
        return -1;
2565
    }
2566

    
2567
    if (ff_split_xiph_headers(avctx->extradata, avctx->extradata_size,
2568
                              42, header_start, header_len) < 0) {
2569
        av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
2570
        return -1;
2571
    }
2572

    
2573
  for(i=0;i<3;i++) {
2574
    init_get_bits(&gb, header_start[i], header_len[i]);
2575

    
2576
    ptype = get_bits(&gb, 8);
2577
    debug_vp3("Theora headerpacket type: %x\n", ptype);
2578

    
2579
     if (!(ptype & 0x80))
2580
     {
2581
        av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
2582
//        return -1;
2583
     }
2584

    
2585
    // FIXME: Check for this as well.
2586
    skip_bits(&gb, 6*8); /* "theora" */
2587

    
2588
    switch(ptype)
2589
    {
2590
        case 0x80:
2591
            theora_decode_header(avctx, &gb);
2592
                break;
2593
        case 0x81:
2594
// FIXME: is this needed? it breaks sometimes
2595
//            theora_decode_comments(avctx, gb);
2596
            break;
2597
        case 0x82:
2598
            theora_decode_tables(avctx, &gb);
2599
            break;
2600
        default:
2601
            av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80);
2602
            break;
2603
    }
2604
    if(8*header_len[i] != get_bits_count(&gb))
2605
        av_log(avctx, AV_LOG_ERROR, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype);
2606
    if (s->theora < 0x030200)
2607
        break;
2608
  }
2609

    
2610
    vp3_decode_init(avctx);
2611
    return 0;
2612
}
2613

    
2614
AVCodec theora_decoder = {
2615
    "theora",
2616
    CODEC_TYPE_VIDEO,
2617
    CODEC_ID_THEORA,
2618
    sizeof(Vp3DecodeContext),
2619
    theora_decode_init,
2620
    NULL,
2621
    vp3_decode_end,
2622
    vp3_decode_frame,
2623
    0,
2624
    NULL
2625
};
2626
#endif
2627

    
2628
AVCodec vp3_decoder = {
2629
    "vp3",
2630
    CODEC_TYPE_VIDEO,
2631
    CODEC_ID_VP3,
2632
    sizeof(Vp3DecodeContext),
2633
    vp3_decode_init,
2634
    NULL,
2635
    vp3_decode_end,
2636
    vp3_decode_frame,
2637
    0,
2638
    NULL
2639
};