Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ 3d32b429

History | View | Annotate | Download (92.2 KB)

1
/*
2
 *
3
 * Copyright (C) 2003 the ffmpeg project
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 *
19
 * VP3 Video Decoder by Mike Melanson (melanson@pcisys.net)
20
 * For more information about the VP3 coding process, visit:
21
 *   http://www.pcisys.net/~melanson/codecs/
22
 *
23
 */
24

    
25
/**
26
 * @file vp3.c
27
 * On2 VP3 Video Decoder
28
 */
29

    
30
#include <stdio.h>
31
#include <stdlib.h>
32
#include <string.h>
33
#include <unistd.h>
34

    
35
#include "common.h"
36
#include "avcodec.h"
37
#include "dsputil.h"
38
#include "mpegvideo.h"
39
#include "dsputil.h"
40

    
41
#include "vp3data.h"
42

    
43
#define FRAGMENT_PIXELS 8
44

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

    
64
#define KEYFRAMES_ONLY 0
65

    
66
#define DEBUG_VP3 0
67
#define DEBUG_INIT 0
68
#define DEBUG_DEQUANTIZERS 0
69
#define DEBUG_BLOCK_CODING 0
70
#define DEBUG_MODES 0
71
#define DEBUG_VECTORS 0
72
#define DEBUG_TOKEN 0
73
#define DEBUG_VLC 0
74
#define DEBUG_DC_PRED 0
75
#define DEBUG_IDCT 0
76

    
77
#if DEBUG_VP3
78
#define debug_vp3 printf
79
#else
80
static inline void debug_vp3(const char *format, ...) { }
81
#endif
82

    
83
#if DEBUG_INIT
84
#define debug_init printf
85
#else
86
static inline void debug_init(const char *format, ...) { }
87
#endif
88

    
89
#if DEBUG_DEQUANTIZERS
90
#define debug_dequantizers printf 
91
#else
92
static inline void debug_dequantizers(const char *format, ...) { } 
93
#endif
94

    
95
#if DEBUG_BLOCK_CODING
96
#define debug_block_coding printf 
97
#else
98
static inline void debug_block_coding(const char *format, ...) { } 
99
#endif
100

    
101
#if DEBUG_MODES
102
#define debug_modes printf 
103
#else
104
static inline void debug_modes(const char *format, ...) { } 
105
#endif
106

    
107
#if DEBUG_VECTORS
108
#define debug_vectors printf 
109
#else
110
static inline void debug_vectors(const char *format, ...) { } 
111
#endif
112

    
113
#if DEBUG_TOKEN 
114
#define debug_token printf 
115
#else
116
static inline void debug_token(const char *format, ...) { } 
117
#endif
118

    
119
#if DEBUG_VLC
120
#define debug_vlc printf 
121
#else
122
static inline void debug_vlc(const char *format, ...) { } 
123
#endif
124

    
125
#if DEBUG_DC_PRED
126
#define debug_dc_pred printf 
127
#else
128
static inline void debug_dc_pred(const char *format, ...) { } 
129
#endif
130

    
131
#if DEBUG_IDCT
132
#define debug_idct printf 
133
#else
134
static inline void debug_idct(const char *format, ...) { } 
135
#endif
136

    
137
typedef struct Vp3Fragment {
138
    DCTELEM coeffs[64];
139
    int coding_method;
140
    int coeff_count;
141
    int last_coeff;
142
    int motion_x;
143
    int motion_y;
144
    /* address of first pixel taking into account which plane the fragment
145
     * lives on as well as the plane stride */
146
    int first_pixel;
147
    /* this is the macroblock that the fragment belongs to */
148
    int macroblock;
149
} Vp3Fragment;
150

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

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

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

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

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

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

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

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

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

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

    
210
};
211

    
212
#define MIN_DEQUANT_VAL 2
213

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

    
223
    int quality_index;
224
    int last_quality_index;
225

    
226
    int superblock_count;
227
    int superblock_width;
228
    int superblock_height;
229
    int y_superblock_width;
230
    int y_superblock_height;
231
    int c_superblock_width;
232
    int c_superblock_height;
233
    int u_superblock_start;
234
    int v_superblock_start;
235
    unsigned char *superblock_coding;
236

    
237
    int macroblock_count;
238
    int macroblock_width;
239
    int macroblock_height;
240

    
241
    int fragment_count;
242
    int fragment_width;
243
    int fragment_height;
244

    
245
    Vp3Fragment *all_fragments;
246
    int u_fragment_start;
247
    int v_fragment_start;
248

    
249
    /* this is a list of indices into the all_fragments array indicating
250
     * which of the fragments are coded */
251
    int *coded_fragment_list;
252
    int coded_fragment_list_index;
253
    int pixel_addresses_inited;
254

    
255
    VLC dc_vlc[16];
256
    VLC ac_vlc_1[16];
257
    VLC ac_vlc_2[16];
258
    VLC ac_vlc_3[16];
259
    VLC ac_vlc_4[16];
260

    
261
    int16_t intra_y_dequant[64];
262
    int16_t intra_c_dequant[64];
263
    int16_t inter_dequant[64];
264

    
265
    /* This table contains superblock_count * 16 entries. Each set of 16
266
     * numbers corresponds to the fragment indices 0..15 of the superblock.
267
     * An entry will be -1 to indicate that no entry corresponds to that
268
     * index. */
269
    int *superblock_fragments;
270

    
271
    /* This table contains superblock_count * 4 entries. Each set of 4
272
     * numbers corresponds to the macroblock indices 0..3 of the superblock.
273
     * An entry will be -1 to indicate that no entry corresponds to that
274
     * index. */
275
    int *superblock_macroblocks;
276

    
277
    /* This table contains macroblock_count * 6 entries. Each set of 6
278
     * numbers corresponds to the fragment indices 0..5 which comprise
279
     * the macroblock (4 Y fragments and 2 C fragments). */
280
    int *macroblock_fragments;
281
    /* This is an array that indicates how a particular macroblock 
282
     * is coded. */
283
    unsigned char *macroblock_coding;
284

    
285
    int first_coded_y_fragment;
286
    int first_coded_c_fragment;
287
    int last_coded_y_fragment;
288
    int last_coded_c_fragment;
289

    
290
} Vp3DecodeContext;
291

    
292
/************************************************************************
293
 * VP3 I/DCT
294
 ************************************************************************/
295

    
296
#define IdctAdjustBeforeShift 8
297
#define xC1S7 64277
298
#define xC2S6 60547
299
#define xC3S5 54491
300
#define xC4S4 46341
301
#define xC5S3 36410
302
#define xC6S2 25080
303
#define xC7S1 12785
304

    
305
void vp3_idct_c(int16_t *input_data, int16_t *dequant_matrix, 
306
    int16_t *output_data)
307
{
308
    int32_t intermediate_data[64];
309
    int32_t *ip = intermediate_data;
310
    int16_t *op = output_data;
311

    
312
    int32_t _A, _B, _C, _D, _Ad, _Bd, _Cd, _Dd, _E, _F, _G, _H;
313
    int32_t _Ed, _Gd, _Add, _Bdd, _Fd, _Hd;
314
    int32_t t1, t2;
315

    
316
    int i, j;
317

    
318
    debug_idct("raw coefficient block:\n");
319
    for (i = 0; i < 8; i++) {
320
        for (j = 0; j < 8; j++) {
321
            debug_idct(" %5d", input_data[i * 8 + j]);
322
        }
323
        debug_idct("\n");
324
    }
325
    debug_idct("\n");
326

    
327
    for (i = 0; i < 64; i++) {
328
        j = dezigzag_index[i];
329
        intermediate_data[j] = dequant_matrix[i] * input_data[i];
330
    }
331

    
332
    debug_idct("dequantized block:\n");
333
    for (i = 0; i < 8; i++) {
334
        for (j = 0; j < 8; j++) {
335
            debug_idct(" %5d", intermediate_data[i * 8 + j]);
336
        }
337
        debug_idct("\n");
338
    }
339
    debug_idct("\n");
340

    
341
    /* Inverse DCT on the rows now */
342
    for (i = 0; i < 8; i++) {
343
        /* Check for non-zero values */
344
        if ( ip[0] | ip[1] | ip[2] | ip[3] | ip[4] | ip[5] | ip[6] | ip[7] ) {
345
            t1 = (int32_t)(xC1S7 * ip[1]);
346
            t2 = (int32_t)(xC7S1 * ip[7]);
347
            t1 >>= 16;
348
            t2 >>= 16;
349
            _A = t1 + t2;
350

    
351
            t1 = (int32_t)(xC7S1 * ip[1]);
352
            t2 = (int32_t)(xC1S7 * ip[7]);
353
            t1 >>= 16;
354
            t2 >>= 16;
355
            _B = t1 - t2;
356

    
357
            t1 = (int32_t)(xC3S5 * ip[3]);
358
            t2 = (int32_t)(xC5S3 * ip[5]);
359
            t1 >>= 16;
360
            t2 >>= 16;
361
            _C = t1 + t2;
362

    
363
            t1 = (int32_t)(xC3S5 * ip[5]);
364
            t2 = (int32_t)(xC5S3 * ip[3]);
365
            t1 >>= 16;
366
            t2 >>= 16;
367
            _D = t1 - t2;
368

    
369

    
370
            t1 = (int32_t)(xC4S4 * (_A - _C));
371
            t1 >>= 16;
372
            _Ad = t1;
373

    
374
            t1 = (int32_t)(xC4S4 * (_B - _D));
375
            t1 >>= 16;
376
            _Bd = t1;
377

    
378

    
379
            _Cd = _A + _C;
380
            _Dd = _B + _D;
381

    
382
            t1 = (int32_t)(xC4S4 * (ip[0] + ip[4]));
383
            t1 >>= 16;
384
            _E = t1;
385

    
386
            t1 = (int32_t)(xC4S4 * (ip[0] - ip[4]));
387
            t1 >>= 16;
388
            _F = t1;
389

    
390
            t1 = (int32_t)(xC2S6 * ip[2]);
391
            t2 = (int32_t)(xC6S2 * ip[6]);
392
            t1 >>= 16;
393
            t2 >>= 16;
394
            _G = t1 + t2;
395

    
396
            t1 = (int32_t)(xC6S2 * ip[2]);
397
            t2 = (int32_t)(xC2S6 * ip[6]);
398
            t1 >>= 16;
399
            t2 >>= 16;
400
            _H = t1 - t2;
401

    
402

    
403
            _Ed = _E - _G;
404
            _Gd = _E + _G;
405

    
406
            _Add = _F + _Ad;
407
            _Bdd = _Bd - _H;
408

    
409
            _Fd = _F - _Ad;
410
            _Hd = _Bd + _H;
411

    
412
            /*  Final sequence of operations over-write original inputs. */
413
            ip[0] = (int16_t)((_Gd + _Cd )   >> 0);
414
            ip[7] = (int16_t)((_Gd - _Cd )   >> 0);
415

    
416
            ip[1] = (int16_t)((_Add + _Hd )  >> 0);
417
            ip[2] = (int16_t)((_Add - _Hd )  >> 0);
418

    
419
            ip[3] = (int16_t)((_Ed + _Dd )   >> 0);
420
            ip[4] = (int16_t)((_Ed - _Dd )   >> 0);
421

    
422
            ip[5] = (int16_t)((_Fd + _Bdd )  >> 0);
423
            ip[6] = (int16_t)((_Fd - _Bdd )  >> 0);
424

    
425
        }
426

    
427
        ip += 8;            /* next row */
428
    }
429

    
430
    ip = intermediate_data;
431

    
432
    for ( i = 0; i < 8; i++) {
433
        /* Check for non-zero values (bitwise or faster than ||) */
434
        if ( ip[0 * 8] | ip[1 * 8] | ip[2 * 8] | ip[3 * 8] |
435
             ip[4 * 8] | ip[5 * 8] | ip[6 * 8] | ip[7 * 8] ) {
436

    
437
            t1 = (int32_t)(xC1S7 * ip[1*8]);
438
            t2 = (int32_t)(xC7S1 * ip[7*8]);
439
            t1 >>= 16;
440
            t2 >>= 16;
441
            _A = t1 + t2;
442

    
443
            t1 = (int32_t)(xC7S1 * ip[1*8]);
444
            t2 = (int32_t)(xC1S7 * ip[7*8]);
445
            t1 >>= 16;
446
            t2 >>= 16;
447
            _B = t1 - t2;
448

    
449
            t1 = (int32_t)(xC3S5 * ip[3*8]);
450
            t2 = (int32_t)(xC5S3 * ip[5*8]);
451
            t1 >>= 16;
452
            t2 >>= 16;
453
            _C = t1 + t2;
454

    
455
            t1 = (int32_t)(xC3S5 * ip[5*8]);
456
            t2 = (int32_t)(xC5S3 * ip[3*8]);
457
            t1 >>= 16;
458
            t2 >>= 16;
459
            _D = t1 - t2;
460

    
461

    
462
            t1 = (int32_t)(xC4S4 * (_A - _C));
463
            t1 >>= 16;
464
            _Ad = t1;
465

    
466
            t1 = (int32_t)(xC4S4 * (_B - _D));
467
            t1 >>= 16;
468
            _Bd = t1;
469

    
470

    
471
            _Cd = _A + _C;
472
            _Dd = _B + _D;
473

    
474
            t1 = (int32_t)(xC4S4 * (ip[0*8] + ip[4*8]));
475
            t1 >>= 16;
476
            _E = t1;
477

    
478
            t1 = (int32_t)(xC4S4 * (ip[0*8] - ip[4*8]));
479
            t1 >>= 16;
480
            _F = t1;
481

    
482
            t1 = (int32_t)(xC2S6 * ip[2*8]);
483
            t2 = (int32_t)(xC6S2 * ip[6*8]);
484
            t1 >>= 16;
485
            t2 >>= 16;
486
            _G = t1 + t2;
487

    
488
            t1 = (int32_t)(xC6S2 * ip[2*8]);
489
            t2 = (int32_t)(xC2S6 * ip[6*8]);
490
            t1 >>= 16;
491
            t2 >>= 16;
492
            _H = t1 - t2;
493

    
494

    
495
            _Ed = _E - _G;
496
            _Gd = _E + _G;
497

    
498
            _Add = _F + _Ad;
499
            _Bdd = _Bd - _H;
500

    
501
            _Fd = _F - _Ad;
502
            _Hd = _Bd + _H;
503

    
504
            _Gd += IdctAdjustBeforeShift;
505
            _Add += IdctAdjustBeforeShift;
506
            _Ed += IdctAdjustBeforeShift;
507
            _Fd += IdctAdjustBeforeShift;
508

    
509
            /* Final sequence of operations over-write original inputs. */
510
            op[0*8] = (int16_t)((_Gd + _Cd )   >> 4);
511
            op[7*8] = (int16_t)((_Gd - _Cd )   >> 4);
512

    
513
            op[1*8] = (int16_t)((_Add + _Hd )  >> 4);
514
            op[2*8] = (int16_t)((_Add - _Hd )  >> 4);
515

    
516
            op[3*8] = (int16_t)((_Ed + _Dd )   >> 4);
517
            op[4*8] = (int16_t)((_Ed - _Dd )   >> 4);
518

    
519
            op[5*8] = (int16_t)((_Fd + _Bdd )  >> 4);
520
            op[6*8] = (int16_t)((_Fd - _Bdd )  >> 4);
521

    
522
        } else {
523

    
524
            op[0*8] = 0;
525
            op[7*8] = 0;
526
            op[1*8] = 0;
527
            op[2*8] = 0;
528
            op[3*8] = 0;
529
            op[4*8] = 0;
530
            op[5*8] = 0;
531
            op[6*8] = 0;
532
        }
533

    
534
        ip++;            /* next column */
535
        op++;
536
    }
537
}
538

    
539
void vp3_idct_put(int16_t *input_data, int16_t *dequant_matrix, 
540
    uint8_t *dest, int stride)
541
{
542
    int16_t transformed_data[64];
543
    int16_t *op;
544
    int i, j;
545

    
546
    vp3_idct_c(input_data, dequant_matrix, transformed_data);
547

    
548
    /* place in final output */
549
    op = transformed_data;
550
    for (i = 0; i < 8; i++) {
551
        for (j = 0; j < 8; j++) {
552
            if (*op < -128)
553
                *dest = 0;
554
            else if (*op > 127)
555
                *dest = 255;
556
            else
557
                *dest = (uint8_t)(*op + 128);
558
            op++;
559
            dest++;
560
        }
561
        dest += (stride - 8);
562
    }
563
}
564

    
565
void vp3_idct_add(int16_t *input_data, int16_t *dequant_matrix, 
566
    uint8_t *dest, int stride)
567
{
568
    int16_t transformed_data[64];
569
    int16_t *op;
570
    int i, j;
571
    int16_t sample;
572

    
573
    vp3_idct_c(input_data, dequant_matrix, transformed_data);
574

    
575
    /* place in final output */
576
    op = transformed_data;
577
    for (i = 0; i < 8; i++) {
578
        for (j = 0; j < 8; j++) {
579
            sample = *dest + *op;
580
            if (sample < 0)
581
                *dest = 0;
582
            else if (sample > 255)
583
                *dest = 255;
584
            else
585
                *dest = (uint8_t)(sample & 0xFF);
586
            op++;
587
            dest++;
588
        }
589
        dest += (stride - 8);
590
    }
591
}
592

    
593
/************************************************************************
594
 * VP3 specific functions
595
 ************************************************************************/
596

    
597
/*
598
 * This function sets up all of the various blocks mappings:
599
 * superblocks <-> fragments, macroblocks <-> fragments,
600
 * superblocks <-> macroblocks
601
 *
602
 * Returns 0 is successful; returns 1 if *anything* went wrong.
603
 */
604
static int init_block_mapping(Vp3DecodeContext *s) 
605
{
606
    int i, j;
607
    signed int hilbert_walk_y[16];
608
    signed int hilbert_walk_c[16];
609
    signed int hilbert_walk_mb[4];
610

    
611
    int current_fragment = 0;
612
    int current_width = 0;
613
    int current_height = 0;
614
    int right_edge = 0;
615
    int bottom_edge = 0;
616
    int superblock_row_inc = 0;
617
    int *hilbert = NULL;
618
    int mapping_index = 0;
619

    
620
    int current_macroblock;
621
    int c_fragment;
622

    
623
    signed char travel_width[16] = {
624
         1,  1,  0, -1, 
625
         0,  0,  1,  0,
626
         1,  0,  1,  0,
627
         0, -1,  0,  1
628
    };
629

    
630
    signed char travel_height[16] = {
631
         0,  0,  1,  0,
632
         1,  1,  0, -1,
633
         0,  1,  0, -1,
634
        -1,  0, -1,  0
635
    };
636

    
637
    signed char travel_width_mb[4] = {
638
         1,  0,  1,  0
639
    };
640

    
641
    signed char travel_height_mb[4] = {
642
         0,  1,  0, -1
643
    };
644

    
645
    debug_vp3("  vp3: initialize block mapping tables\n");
646

    
647
    /* figure out hilbert pattern per these frame dimensions */
648
    hilbert_walk_y[0]  = 1;
649
    hilbert_walk_y[1]  = 1;
650
    hilbert_walk_y[2]  = s->fragment_width;
651
    hilbert_walk_y[3]  = -1;
652
    hilbert_walk_y[4]  = s->fragment_width;
653
    hilbert_walk_y[5]  = s->fragment_width;
654
    hilbert_walk_y[6]  = 1;
655
    hilbert_walk_y[7]  = -s->fragment_width;
656
    hilbert_walk_y[8]  = 1;
657
    hilbert_walk_y[9]  = s->fragment_width;
658
    hilbert_walk_y[10]  = 1;
659
    hilbert_walk_y[11] = -s->fragment_width;
660
    hilbert_walk_y[12] = -s->fragment_width;
661
    hilbert_walk_y[13] = -1;
662
    hilbert_walk_y[14] = -s->fragment_width;
663
    hilbert_walk_y[15] = 1;
664

    
665
    hilbert_walk_c[0]  = 1;
666
    hilbert_walk_c[1]  = 1;
667
    hilbert_walk_c[2]  = s->fragment_width / 2;
668
    hilbert_walk_c[3]  = -1;
669
    hilbert_walk_c[4]  = s->fragment_width / 2;
670
    hilbert_walk_c[5]  = s->fragment_width / 2;
671
    hilbert_walk_c[6]  = 1;
672
    hilbert_walk_c[7]  = -s->fragment_width / 2;
673
    hilbert_walk_c[8]  = 1;
674
    hilbert_walk_c[9]  = s->fragment_width / 2;
675
    hilbert_walk_c[10]  = 1;
676
    hilbert_walk_c[11] = -s->fragment_width / 2;
677
    hilbert_walk_c[12] = -s->fragment_width / 2;
678
    hilbert_walk_c[13] = -1;
679
    hilbert_walk_c[14] = -s->fragment_width / 2;
680
    hilbert_walk_c[15] = 1;
681

    
682
    hilbert_walk_mb[0] = 1;
683
    hilbert_walk_mb[1] = s->macroblock_width;
684
    hilbert_walk_mb[2] = 1;
685
    hilbert_walk_mb[3] = -s->macroblock_width;
686

    
687
    /* iterate through each superblock (all planes) and map the fragments */
688
    for (i = 0; i < s->superblock_count; i++) {
689
        debug_init("    superblock %d (u starts @ %d, v starts @ %d)\n",
690
            i, s->u_superblock_start, s->v_superblock_start);
691

    
692
        /* time to re-assign the limits? */
693
        if (i == 0) {
694

    
695
            /* start of Y superblocks */
696
            right_edge = s->fragment_width;
697
            bottom_edge = s->fragment_height;
698
            current_width = -1;
699
            current_height = 0;
700
            superblock_row_inc = 3 * s->fragment_width - 
701
                (s->y_superblock_width * 4 - s->fragment_width);
702
            hilbert = hilbert_walk_y;
703

    
704
            /* the first operation for this variable is to advance by 1 */
705
            current_fragment = -1;
706

    
707
        } else if (i == s->u_superblock_start) {
708

    
709
            /* start of U superblocks */
710
            right_edge = s->fragment_width / 2;
711
            bottom_edge = s->fragment_height / 2;
712
            current_width = -1;
713
            current_height = 0;
714
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
715
                (s->c_superblock_width * 4 - s->fragment_width / 2);
716
            hilbert = hilbert_walk_c;
717

    
718
            /* the first operation for this variable is to advance by 1 */
719
            current_fragment = s->u_fragment_start - 1;
720

    
721
        } else if (i == s->v_superblock_start) {
722

    
723
            /* start of V superblocks */
724
            right_edge = s->fragment_width / 2;
725
            bottom_edge = s->fragment_height / 2;
726
            current_width = -1;
727
            current_height = 0;
728
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
729
                (s->c_superblock_width * 4 - s->fragment_width / 2);
730
            hilbert = hilbert_walk_c;
731

    
732
            /* the first operation for this variable is to advance by 1 */
733
            current_fragment = s->v_fragment_start - 1;
734

    
735
        }
736

    
737
        if (current_width >= right_edge - 1) {
738
            /* reset width and move to next superblock row */
739
            current_width = -1;
740
            current_height += 4;
741

    
742
            /* fragment is now at the start of a new superblock row */
743
            current_fragment += superblock_row_inc;
744
        }
745

    
746
        /* iterate through all 16 fragments in a superblock */
747
        for (j = 0; j < 16; j++) {
748
            current_fragment += hilbert[j];
749
            current_width += travel_width[j];
750
            current_height += travel_height[j];
751

    
752
            /* check if the fragment is in bounds */
753
            if ((current_width < right_edge) &&
754
                (current_height < bottom_edge)) {
755
                s->superblock_fragments[mapping_index] = current_fragment;
756
                debug_init("    mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n", 
757
                    s->superblock_fragments[mapping_index], i, j,
758
                    current_width, right_edge, current_height, bottom_edge);
759
            } else {
760
                s->superblock_fragments[mapping_index] = -1;
761
                debug_init("    superblock %d, position %d has no fragment (%d/%d x %d/%d)\n", 
762
                    i, j,
763
                    current_width, right_edge, current_height, bottom_edge);
764
            }
765

    
766
            mapping_index++;
767
        }
768
    }
769

    
770
    /* initialize the superblock <-> macroblock mapping; iterate through
771
     * all of the Y plane superblocks to build this mapping */
772
    right_edge = s->macroblock_width;
773
    bottom_edge = s->macroblock_height;
774
    current_width = -1;
775
    current_height = 0;
776
    superblock_row_inc = s->macroblock_width -
777
        (s->y_superblock_width * 2 - s->macroblock_width);;
778
    hilbert = hilbert_walk_mb;
779
    mapping_index = 0;
780
    current_macroblock = -1;
781
    for (i = 0; i < s->u_superblock_start; i++) {
782

    
783
        if (current_width >= right_edge - 1) {
784
            /* reset width and move to next superblock row */
785
            current_width = -1;
786
            current_height += 2;
787

    
788
            /* macroblock is now at the start of a new superblock row */
789
            current_macroblock += superblock_row_inc;
790
        }
791

    
792
        /* iterate through each potential macroblock in the superblock */
793
        for (j = 0; j < 4; j++) {
794
            current_macroblock += hilbert_walk_mb[j];
795
            current_width += travel_width_mb[j];
796
            current_height += travel_height_mb[j];
797

    
798
            /* check if the macroblock is in bounds */
799
            if ((current_width < right_edge) &&
800
                (current_height < bottom_edge)) {
801
                s->superblock_macroblocks[mapping_index] = current_macroblock;
802
                debug_init("    mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
803
                    s->superblock_macroblocks[mapping_index], i, j,
804
                    current_width, right_edge, current_height, bottom_edge);
805
            } else {
806
                s->superblock_macroblocks[mapping_index] = -1;
807
                debug_init("    superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
808
                    i, j,
809
                    current_width, right_edge, current_height, bottom_edge);
810
            }
811

    
812
            mapping_index++;
813
        }
814
    }
815

    
816
    /* initialize the macroblock <-> fragment mapping */
817
    current_fragment = 0;
818
    current_macroblock = 0;
819
    mapping_index = 0;
820
    for (i = 0; i < s->fragment_height; i += 2) {
821

    
822
        for (j = 0; j < s->fragment_width; j += 2) {
823

    
824
            debug_init("    macroblock %d contains fragments: ", current_macroblock);
825
            s->all_fragments[current_fragment].macroblock = current_macroblock;
826
            s->macroblock_fragments[mapping_index++] = current_fragment;
827
            debug_init("%d ", current_fragment);
828

    
829
            if (j + 1 < s->fragment_width) {
830
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
831
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
832
                debug_init("%d ", current_fragment + 1);
833
            } else
834
                s->macroblock_fragments[mapping_index++] = -1;
835

    
836
            if (i + 1 < s->fragment_height) {
837
                s->all_fragments[current_fragment + s->fragment_width].macroblock = 
838
                    current_macroblock;
839
                s->macroblock_fragments[mapping_index++] = 
840
                    current_fragment + s->fragment_width;
841
                debug_init("%d ", current_fragment + s->fragment_width);
842
            } else
843
                s->macroblock_fragments[mapping_index++] = -1;
844

    
845
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
846
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock = 
847
                    current_macroblock;
848
                s->macroblock_fragments[mapping_index++] = 
849
                    current_fragment + s->fragment_width + 1;
850
                debug_init("%d ", current_fragment + s->fragment_width + 1);
851
            } else
852
                s->macroblock_fragments[mapping_index++] = -1;
853

    
854
            /* C planes */
855
            c_fragment = s->u_fragment_start + 
856
                (i * s->fragment_width / 4) + (j / 2);
857
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
858
            s->macroblock_fragments[mapping_index++] = c_fragment;
859
            debug_init("%d ", c_fragment);
860

    
861
            c_fragment = s->v_fragment_start + 
862
                (i * s->fragment_width / 4) + (j / 2);
863
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
864
            s->macroblock_fragments[mapping_index++] = c_fragment;
865
            debug_init("%d ", c_fragment);
866

    
867
            debug_init("\n");
868

    
869
            if (j + 2 <= s->fragment_width)
870
                current_fragment += 2;
871
            else 
872
                current_fragment++;
873
            current_macroblock++;
874
        }
875

    
876
        current_fragment += s->fragment_width;
877
    }
878

    
879
    return 0;  /* successful path out */
880
}
881

    
882
/*
883
 * This function unpacks a single token (which should be in the range 0..31)
884
 * and returns a zero run (number of zero coefficients in current DCT matrix
885
 * before next non-zero coefficient), the next DCT coefficient, and the
886
 * number of consecutive, non-EOB'd DCT blocks to EOB.
887
 */
888
static void unpack_token(GetBitContext *gb, int token, int *zero_run,
889
                         DCTELEM *coeff, int *eob_run) 
890
{
891
    int sign;
892

    
893
    *zero_run = 0;
894
    *eob_run = 0;
895
    *coeff = 0;
896

    
897
    debug_token("    vp3 token %d: ", token);
898
    switch (token) {
899

    
900
    case 0:
901
        debug_token("DCT_EOB_TOKEN, EOB next block\n");
902
        *eob_run = 1;
903
        break;
904

    
905
    case 1:
906
        debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
907
        *eob_run = 2;
908
        break;
909

    
910
    case 2:
911
        debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
912
        *eob_run = 3;
913
        break;
914

    
915
    case 3:
916
        debug_token("DCT_REPEAT_RUN_TOKEN, ");
917
        *eob_run = get_bits(gb, 2) + 4;
918
        debug_token("EOB the next %d blocks\n", *eob_run);
919
        break;
920

    
921
    case 4:
922
        debug_token("DCT_REPEAT_RUN2_TOKEN, ");
923
        *eob_run = get_bits(gb, 3) + 8;
924
        debug_token("EOB the next %d blocks\n", *eob_run);
925
        break;
926

    
927
    case 5:
928
        debug_token("DCT_REPEAT_RUN3_TOKEN, ");
929
        *eob_run = get_bits(gb, 4) + 16;
930
        debug_token("EOB the next %d blocks\n", *eob_run);
931
        break;
932

    
933
    case 6:
934
        debug_token("DCT_REPEAT_RUN4_TOKEN, ");
935
        *eob_run = get_bits(gb, 12);
936
        debug_token("EOB the next %d blocks\n", *eob_run);
937
        break;
938

    
939
    case 7:
940
        debug_token("DCT_SHORT_ZRL_TOKEN, ");
941
        /* note that this token actually indicates that (3 extra bits) + 1 0s
942
         * should be output; this case specifies a run of (3 EBs) 0s and a
943
         * coefficient of 0. */
944
        *zero_run = get_bits(gb, 3);
945
        *coeff = 0;
946
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
947
        break;
948

    
949
    case 8:
950
        debug_token("DCT_ZRL_TOKEN, ");
951
        /* note that this token actually indicates that (6 extra bits) + 1 0s
952
         * should be output; this case specifies a run of (6 EBs) 0s and a
953
         * coefficient of 0. */
954
        *zero_run = get_bits(gb, 6);
955
        *coeff = 0;
956
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
957
        break;
958

    
959
    case 9:
960
        debug_token("ONE_TOKEN, output 1\n");
961
        *coeff = 1;
962
        break;
963

    
964
    case 10:
965
        debug_token("MINUS_ONE_TOKEN, output -1\n");
966
        *coeff = -1;
967
        break;
968

    
969
    case 11:
970
        debug_token("TWO_TOKEN, output 2\n");
971
        *coeff = 2;
972
        break;
973

    
974
    case 12:
975
        debug_token("MINUS_TWO_TOKEN, output -2\n");
976
        *coeff = -2;
977
        break;
978

    
979
    case 13:
980
    case 14:
981
    case 15:
982
    case 16:
983
        debug_token("LOW_VAL_TOKENS, ");
984
        if (get_bits(gb, 1))
985
            *coeff = -(3 + (token - 13));
986
        else
987
            *coeff = 3 + (token - 13);
988
        debug_token("output %d\n", *coeff);
989
        break;
990

    
991
    case 17:
992
        debug_token("DCT_VAL_CATEGORY3, ");
993
        sign = get_bits(gb, 1);
994
        *coeff = 7 + get_bits(gb, 1);
995
        if (sign)
996
            *coeff = -(*coeff);
997
        debug_token("output %d\n", *coeff);
998
        break;
999

    
1000
    case 18:
1001
        debug_token("DCT_VAL_CATEGORY4, ");
1002
        sign = get_bits(gb, 1);
1003
        *coeff = 9 + get_bits(gb, 2);
1004
        if (sign)
1005
            *coeff = -(*coeff);
1006
        debug_token("output %d\n", *coeff);
1007
        break;
1008

    
1009
    case 19:
1010
        debug_token("DCT_VAL_CATEGORY5, ");
1011
        sign = get_bits(gb, 1);
1012
        *coeff = 13 + get_bits(gb, 3);
1013
        if (sign)
1014
            *coeff = -(*coeff);
1015
        debug_token("output %d\n", *coeff);
1016
        break;
1017

    
1018
    case 20:
1019
        debug_token("DCT_VAL_CATEGORY6, ");
1020
        sign = get_bits(gb, 1);
1021
        *coeff = 21 + get_bits(gb, 4);
1022
        if (sign)
1023
            *coeff = -(*coeff);
1024
        debug_token("output %d\n", *coeff);
1025
        break;
1026

    
1027
    case 21:
1028
        debug_token("DCT_VAL_CATEGORY7, ");
1029
        sign = get_bits(gb, 1);
1030
        *coeff = 37 + get_bits(gb, 5);
1031
        if (sign)
1032
            *coeff = -(*coeff);
1033
        debug_token("output %d\n", *coeff);
1034
        break;
1035

    
1036
    case 22:
1037
        debug_token("DCT_VAL_CATEGORY8, ");
1038
        sign = get_bits(gb, 1);
1039
        *coeff = 69 + get_bits(gb, 9);
1040
        if (sign)
1041
            *coeff = -(*coeff);
1042
        debug_token("output %d\n", *coeff);
1043
        break;
1044

    
1045
    case 23:
1046
    case 24:
1047
    case 25:
1048
    case 26:
1049
    case 27:
1050
        debug_token("DCT_RUN_CATEGORY1, ");
1051
        *zero_run = token - 22;
1052
        if (get_bits(gb, 1))
1053
            *coeff = -1;
1054
        else
1055
            *coeff = 1;
1056
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1057
        break;
1058

    
1059
    case 28:
1060
        debug_token("DCT_RUN_CATEGORY1B, ");
1061
        if (get_bits(gb, 1))
1062
            *coeff = -1;
1063
        else
1064
            *coeff = 1;
1065
        *zero_run = 6 + get_bits(gb, 2);
1066
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1067
        break;
1068

    
1069
    case 29:
1070
        debug_token("DCT_RUN_CATEGORY1C, ");
1071
        if (get_bits(gb, 1))
1072
            *coeff = -1;
1073
        else
1074
            *coeff = 1;
1075
        *zero_run = 10 + get_bits(gb, 3);
1076
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1077
        break;
1078

    
1079
    case 30:
1080
        debug_token("DCT_RUN_CATEGORY2, ");
1081
        sign = get_bits(gb, 1);
1082
        *coeff = 2 + get_bits(gb, 1);
1083
        if (sign)
1084
            *coeff = -(*coeff);
1085
        *zero_run = 1;
1086
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1087
        break;
1088

    
1089
    case 31:
1090
        debug_token("DCT_RUN_CATEGORY2, ");
1091
        sign = get_bits(gb, 1);
1092
        *coeff = 2 + get_bits(gb, 1);
1093
        if (sign)
1094
            *coeff = -(*coeff);
1095
        *zero_run = 2 + get_bits(gb, 1);
1096
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1097
        break;
1098

    
1099
    default:
1100
        printf ("  vp3: help! Got a bad token: %d > 31\n", token);
1101
        break;
1102

    
1103
  }
1104
}
1105

    
1106
/*
1107
 * This function wipes out all of the fragment data.
1108
 */
1109
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
1110
{
1111
    int i;
1112

    
1113
    /* zero out all of the fragment information */
1114
    s->coded_fragment_list_index = 0;
1115
    for (i = 0; i < s->fragment_count; i++) {
1116
        memset(s->all_fragments[i].coeffs, 0, 64 * sizeof(DCTELEM));
1117
        s->all_fragments[i].coeff_count = 0;
1118
        s->all_fragments[i].last_coeff = 0;
1119
s->all_fragments[i].motion_x = 0xbeef;
1120
s->all_fragments[i].motion_y = 0xbeef;
1121
    }
1122
}
1123

    
1124
/*
1125
 * This function sets of the dequantization tables used for a particular
1126
 * frame.
1127
 */
1128
static void init_dequantizer(Vp3DecodeContext *s)
1129
{
1130

    
1131
    int quality_scale = vp31_quality_threshold[s->quality_index];
1132
    int dc_scale_factor = vp31_dc_scale_factor[s->quality_index];
1133
    int i, j;
1134

    
1135
    debug_vp3("  vp3: initializing dequantization tables\n");
1136

    
1137
    /* 
1138
     * Scale dequantizers:
1139
     *
1140
     *   quantizer * sf
1141
     *   --------------
1142
     *        100
1143
     *
1144
     * where sf = dc_scale_factor for DC quantizer
1145
     *           or quality_scale for AC quantizer
1146
     *
1147
     * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
1148
     */
1149
#define SCALER 4
1150

    
1151
    /* scale DC quantizers */
1152
    s->intra_y_dequant[0] = vp31_intra_y_dequant[0] * dc_scale_factor / 100;
1153
    if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
1154
        s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
1155
    s->intra_y_dequant[0] *= SCALER;
1156

    
1157
    s->intra_c_dequant[0] = vp31_intra_c_dequant[0] * dc_scale_factor / 100;
1158
    if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
1159
        s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
1160
    s->intra_c_dequant[0] *= SCALER;
1161

    
1162
    s->inter_dequant[0] = vp31_inter_dequant[0] * dc_scale_factor / 100;
1163
    if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
1164
        s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
1165
    s->inter_dequant[0] *= SCALER;
1166

    
1167
    /* scale AC quantizers, zigzag at the same time in preparation for
1168
     * the dequantization phase */
1169
    for (i = 1; i < 64; i++) {
1170

    
1171
        j = zigzag_index[i];
1172

    
1173
        s->intra_y_dequant[j] = vp31_intra_y_dequant[i] * quality_scale / 100;
1174
        if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
1175
            s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
1176
        s->intra_y_dequant[j] *= SCALER;
1177

    
1178
        s->intra_c_dequant[j] = vp31_intra_c_dequant[i] * quality_scale / 100;
1179
        if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
1180
            s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
1181
        s->intra_c_dequant[j] *= SCALER;
1182

    
1183
        s->inter_dequant[j] = vp31_inter_dequant[i] * quality_scale / 100;
1184
        if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
1185
            s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
1186
        s->inter_dequant[j] *= SCALER;
1187
    }
1188

    
1189
    /* print debug information as requested */
1190
    debug_dequantizers("intra Y dequantizers:\n");
1191
    for (i = 0; i < 8; i++) {
1192
      for (j = i * 8; j < i * 8 + 8; j++) {
1193
        debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
1194
      }
1195
      debug_dequantizers("\n");
1196
    }
1197
    debug_dequantizers("\n");
1198

    
1199
    debug_dequantizers("intra C dequantizers:\n");
1200
    for (i = 0; i < 8; i++) {
1201
      for (j = i * 8; j < i * 8 + 8; j++) {
1202
        debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
1203
      }
1204
      debug_dequantizers("\n");
1205
    }
1206
    debug_dequantizers("\n");
1207

    
1208
    debug_dequantizers("interframe dequantizers:\n");
1209
    for (i = 0; i < 8; i++) {
1210
      for (j = i * 8; j < i * 8 + 8; j++) {
1211
        debug_dequantizers(" %4d,", s->inter_dequant[j]);
1212
      }
1213
      debug_dequantizers("\n");
1214
    }
1215
    debug_dequantizers("\n");
1216
}
1217

    
1218
/*
1219
 * This function is used to fetch runs of 1s or 0s from the bitstream for
1220
 * use in determining which superblocks are fully and partially coded.
1221
 *
1222
 *  Codeword                RunLength
1223
 *  0                       1
1224
 *  10x                     2-3
1225
 *  110x                    4-5
1226
 *  1110xx                  6-9
1227
 *  11110xxx                10-17
1228
 *  111110xxxx              18-33
1229
 *  111111xxxxxxxxxxxx      34-4129
1230
 */
1231
static int get_superblock_run_length(GetBitContext *gb)
1232
{
1233

    
1234
    if (get_bits(gb, 1) == 0)
1235
        return 1;
1236

    
1237
    else if (get_bits(gb, 1) == 0)
1238
        return (2 + get_bits(gb, 1));
1239

    
1240
    else if (get_bits(gb, 1) == 0)
1241
        return (4 + get_bits(gb, 1));
1242

    
1243
    else if (get_bits(gb, 1) == 0)
1244
        return (6 + get_bits(gb, 2));
1245

    
1246
    else if (get_bits(gb, 1) == 0)
1247
        return (10 + get_bits(gb, 3));
1248

    
1249
    else if (get_bits(gb, 1) == 0)
1250
        return (18 + get_bits(gb, 4));
1251

    
1252
    else
1253
        return (34 + get_bits(gb, 12));
1254

    
1255
}
1256

    
1257
/*
1258
 * This function is used to fetch runs of 1s or 0s from the bitstream for
1259
 * use in determining which particular fragments are coded.
1260
 *
1261
 * Codeword                RunLength
1262
 * 0x                      1-2
1263
 * 10x                     3-4
1264
 * 110x                    5-6
1265
 * 1110xx                  7-10
1266
 * 11110xx                 11-14
1267
 * 11111xxxx               15-30
1268
 */
1269
static int get_fragment_run_length(GetBitContext *gb)
1270
{
1271

    
1272
    if (get_bits(gb, 1) == 0)
1273
        return (1 + get_bits(gb, 1));
1274

    
1275
    else if (get_bits(gb, 1) == 0)
1276
        return (3 + get_bits(gb, 1));
1277

    
1278
    else if (get_bits(gb, 1) == 0)
1279
        return (5 + get_bits(gb, 1));
1280

    
1281
    else if (get_bits(gb, 1) == 0)
1282
        return (7 + get_bits(gb, 2));
1283

    
1284
    else if (get_bits(gb, 1) == 0)
1285
        return (11 + get_bits(gb, 2));
1286

    
1287
    else
1288
        return (15 + get_bits(gb, 4));
1289

    
1290
}
1291

    
1292
/*
1293
 * This function decodes a VLC from the bitstream and returns a number
1294
 * that ranges from 0..7. The number indicates which of the 8 coding
1295
 * modes to use.
1296
 *
1297
 *  VLC       Number
1298
 *  0            0
1299
 *  10           1
1300
 *  110          2
1301
 *  1110         3
1302
 *  11110        4
1303
 *  111110       5
1304
 *  1111110      6
1305
 *  1111111      7
1306
 *
1307
 */
1308
static int get_mode_code(GetBitContext *gb)
1309
{
1310

    
1311
    if (get_bits(gb, 1) == 0)
1312
        return 0;
1313

    
1314
    else if (get_bits(gb, 1) == 0)
1315
        return 1;
1316

    
1317
    else if (get_bits(gb, 1) == 0)
1318
        return 2;
1319

    
1320
    else if (get_bits(gb, 1) == 0)
1321
        return 3;
1322

    
1323
    else if (get_bits(gb, 1) == 0)
1324
        return 4;
1325

    
1326
    else if (get_bits(gb, 1) == 0)
1327
        return 5;
1328

    
1329
    else if (get_bits(gb, 1) == 0)
1330
        return 6;
1331

    
1332
    else
1333
        return 7;
1334

    
1335
}
1336

    
1337
/*
1338
 * This function extracts a motion vector from the bitstream using a VLC
1339
 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1340
 * taken depending on the value on those 3 bits:
1341
 *
1342
 *  0: return 0
1343
 *  1: return 1
1344
 *  2: return -1
1345
 *  3: if (next bit is 1) return -2, else return 2
1346
 *  4: if (next bit is 1) return -3, else return 3
1347
 *  5: return 4 + (next 2 bits), next bit is sign
1348
 *  6: return 8 + (next 3 bits), next bit is sign
1349
 *  7: return 16 + (next 4 bits), next bit is sign
1350
 */
1351
static int get_motion_vector_vlc(GetBitContext *gb)
1352
{
1353
    int bits;
1354

    
1355
    bits = get_bits(gb, 3);
1356

    
1357
    switch(bits) {
1358

    
1359
    case 0:
1360
        bits = 0;
1361
        break;
1362

    
1363
    case 1:
1364
        bits = 1;
1365
        break;
1366

    
1367
    case 2:
1368
        bits = -1;
1369
        break;
1370

    
1371
    case 3:
1372
        if (get_bits(gb, 1) == 0)
1373
            bits = 2;
1374
        else
1375
            bits = -2;
1376
        break;
1377

    
1378
    case 4:
1379
        if (get_bits(gb, 1) == 0)
1380
            bits = 3;
1381
        else
1382
            bits = -3;
1383
        break;
1384

    
1385
    case 5:
1386
        bits = 4 + get_bits(gb, 2);
1387
        if (get_bits(gb, 1) == 1)
1388
            bits = -bits;
1389
        break;
1390

    
1391
    case 6:
1392
        bits = 8 + get_bits(gb, 3);
1393
        if (get_bits(gb, 1) == 1)
1394
            bits = -bits;
1395
        break;
1396

    
1397
    case 7:
1398
        bits = 16 + get_bits(gb, 4);
1399
        if (get_bits(gb, 1) == 1)
1400
            bits = -bits;
1401
        break;
1402

    
1403
    }
1404

    
1405
    return bits;
1406
}
1407

    
1408
/*
1409
 * This function fetches a 5-bit number from the stream followed by
1410
 * a sign and calls it a motion vector.
1411
 */
1412
static int get_motion_vector_fixed(GetBitContext *gb)
1413
{
1414

    
1415
    int bits;
1416

    
1417
    bits = get_bits(gb, 5);
1418

    
1419
    if (get_bits(gb, 1) == 1)
1420
        bits = -bits;
1421

    
1422
    return bits;
1423
}
1424

    
1425
/*
1426
 * This function unpacks all of the superblock/macroblock/fragment coding 
1427
 * information from the bitstream.
1428
 */
1429
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1430
{
1431
    int bit = 0;
1432
    int current_superblock = 0;
1433
    int current_run = 0;
1434
    int decode_fully_flags = 0;
1435
    int decode_partial_blocks = 0;
1436
    int first_c_fragment_seen;
1437

    
1438
    int i, j;
1439
    int current_fragment;
1440

    
1441
    debug_vp3("  vp3: unpacking superblock coding\n");
1442

    
1443
    if (s->keyframe) {
1444

    
1445
        debug_vp3("    keyframe-- all superblocks are fully coded\n");
1446
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1447

    
1448
    } else {
1449

    
1450
        /* unpack the list of partially-coded superblocks */
1451
        bit = get_bits(gb, 1);
1452
        /* toggle the bit because as soon as the first run length is 
1453
         * fetched the bit will be toggled again */
1454
        bit ^= 1;
1455
        while (current_superblock < s->superblock_count) {
1456
            if (current_run == 0) {
1457
                bit ^= 1;
1458
                current_run = get_superblock_run_length(gb);
1459
                debug_block_coding("      setting superblocks %d..%d to %s\n",
1460
                    current_superblock,
1461
                    current_superblock + current_run - 1,
1462
                    (bit) ? "partially coded" : "not coded");
1463

    
1464
                /* if any of the superblocks are not partially coded, flag
1465
                 * a boolean to decode the list of fully-coded superblocks */
1466
                if (bit == 0) {
1467
                    decode_fully_flags = 1;
1468
                } else {
1469

    
1470
                    /* make a note of the fact that there are partially coded
1471
                     * superblocks */
1472
                    decode_partial_blocks = 1;
1473
                }
1474
            }
1475
            s->superblock_coding[current_superblock++] = 
1476
                (bit) ? SB_PARTIALLY_CODED : SB_NOT_CODED;
1477
            current_run--;
1478
        }
1479

    
1480
        /* unpack the list of fully coded superblocks if any of the blocks were
1481
         * not marked as partially coded in the previous step */
1482
        if (decode_fully_flags) {
1483

    
1484
            current_superblock = 0;
1485
            current_run = 0;
1486
            bit = get_bits(gb, 1);
1487
            /* toggle the bit because as soon as the first run length is 
1488
             * fetched the bit will be toggled again */
1489
            bit ^= 1;
1490
            while (current_superblock < s->superblock_count) {
1491

    
1492
                /* skip any superblocks already marked as partially coded */
1493
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1494

    
1495
                    if (current_run == 0) {
1496
                        bit ^= 1;
1497
                        current_run = get_superblock_run_length(gb);
1498
                    }
1499

    
1500
                    debug_block_coding("      setting superblock %d to %s\n",
1501
                        current_superblock,
1502
                        (bit) ? "fully coded" : "not coded");
1503
                    s->superblock_coding[current_superblock] = 
1504
                        (bit) ? SB_FULLY_CODED : SB_NOT_CODED;
1505
                    current_run--;
1506
                }
1507
                current_superblock++;
1508
            }
1509
        }
1510

    
1511
        /* if there were partial blocks, initialize bitstream for
1512
         * unpacking fragment codings */
1513
        if (decode_partial_blocks) {
1514

    
1515
            current_run = 0;
1516
            bit = get_bits(gb, 1);
1517
            /* toggle the bit because as soon as the first run length is 
1518
             * fetched the bit will be toggled again */
1519
            bit ^= 1;
1520
        }
1521
    }
1522

    
1523
    /* figure out which fragments are coded; iterate through each
1524
     * superblock (all planes) */
1525
    s->coded_fragment_list_index = 0;
1526
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1527
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1528
    first_c_fragment_seen = 0;
1529
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1530
    for (i = 0; i < s->superblock_count; i++) {
1531

    
1532
        /* iterate through all 16 fragments in a superblock */
1533
        for (j = 0; j < 16; j++) {
1534

    
1535
            /* if the fragment is in bounds, check its coding status */
1536
            current_fragment = s->superblock_fragments[i * 16 + j];
1537
            if (current_fragment >= s->fragment_count) {
1538
                printf ("  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1539
                    current_fragment, s->fragment_count);
1540
                return 1;
1541
            }
1542
            if (current_fragment != -1) {
1543
                if (s->superblock_coding[i] == SB_NOT_CODED) {
1544

    
1545
                    /* copy all the fragments from the prior frame */
1546
                    s->all_fragments[current_fragment].coding_method = 
1547
                        MODE_COPY;
1548

    
1549
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1550

    
1551
                    /* fragment may or may not be coded; this is the case
1552
                     * that cares about the fragment coding runs */
1553
                    if (current_run == 0) {
1554
                        bit ^= 1;
1555
                        current_run = get_fragment_run_length(gb);
1556
                    }
1557

    
1558
                    if (bit) {
1559
                        /* default mode; actual mode will be decoded in 
1560
                         * the next phase */
1561
                        s->all_fragments[current_fragment].coding_method = 
1562
                            MODE_INTER_NO_MV;
1563
                        s->coded_fragment_list[s->coded_fragment_list_index] = 
1564
                            current_fragment;
1565
                        if ((current_fragment >= s->u_fragment_start) &&
1566
                            (s->last_coded_y_fragment == -1) &&
1567
                            (!first_c_fragment_seen)) {
1568
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
1569
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1570
                            first_c_fragment_seen = 1;
1571
                        }
1572
                        s->coded_fragment_list_index++;
1573
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1574
                        debug_block_coding("      superblock %d is partially coded, fragment %d is coded\n",
1575
                            i, current_fragment);
1576
                    } else {
1577
                        /* not coded; copy this fragment from the prior frame */
1578
                        s->all_fragments[current_fragment].coding_method =
1579
                            MODE_COPY;
1580
                        debug_block_coding("      superblock %d is partially coded, fragment %d is not coded\n",
1581
                            i, current_fragment);
1582
                    }
1583

    
1584
                    current_run--;
1585

    
1586
                } else {
1587

    
1588
                    /* fragments are fully coded in this superblock; actual
1589
                     * coding will be determined in next step */
1590
                    s->all_fragments[current_fragment].coding_method = 
1591
                        MODE_INTER_NO_MV;
1592
                    s->coded_fragment_list[s->coded_fragment_list_index] = 
1593
                        current_fragment;
1594
                    if ((current_fragment >= s->u_fragment_start) &&
1595
                        (s->last_coded_y_fragment == -1) &&
1596
                        (!first_c_fragment_seen)) {
1597
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
1598
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1599
                        first_c_fragment_seen = 1;
1600
                    }
1601
                    s->coded_fragment_list_index++;
1602
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1603
                    debug_block_coding("      superblock %d is fully coded, fragment %d is coded\n",
1604
                        i, current_fragment);
1605
                }
1606
            }
1607
        }
1608
    }
1609

    
1610
    if (!first_c_fragment_seen)
1611
        /* only Y fragments coded in this frame */
1612
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
1613
    else 
1614
        /* end the list of coded C fragments */
1615
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1616

    
1617
    debug_block_coding("    %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1618
        s->coded_fragment_list_index,
1619
        s->first_coded_y_fragment,
1620
        s->last_coded_y_fragment,
1621
        s->first_coded_c_fragment,
1622
        s->last_coded_c_fragment);
1623

    
1624
    return 0;
1625
}
1626

    
1627
/*
1628
 * This function unpacks all the coding mode data for individual macroblocks
1629
 * from the bitstream.
1630
 */
1631
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1632
{
1633
    int i, j, k;
1634
    int scheme;
1635
    int current_macroblock;
1636
    int current_fragment;
1637
    int coding_mode;
1638

    
1639
    debug_vp3("  vp3: unpacking encoding modes\n");
1640

    
1641
    if (s->keyframe) {
1642
        debug_vp3("    keyframe-- all blocks are coded as INTRA\n");
1643

    
1644
        for (i = 0; i < s->fragment_count; i++)
1645
            s->all_fragments[i].coding_method = MODE_INTRA;
1646

    
1647
    } else {
1648

    
1649
        /* fetch the mode coding scheme for this frame */
1650
        scheme = get_bits(gb, 3);
1651
        debug_modes("    using mode alphabet %d\n", scheme);
1652

    
1653
        /* is it a custom coding scheme? */
1654
        if (scheme == 0) {
1655
            debug_modes("    custom mode alphabet ahead:\n");
1656
            for (i = 0; i < 8; i++)
1657
                ModeAlphabet[scheme][get_bits(gb, 3)] = i;
1658
        }
1659

    
1660
        for (i = 0; i < 8; i++)
1661
            debug_modes("      mode[%d][%d] = %d\n", scheme, i, 
1662
                ModeAlphabet[scheme][i]);
1663

    
1664
        /* iterate through all of the macroblocks that contain 1 or more
1665
         * coded fragments */
1666
        for (i = 0; i < s->u_superblock_start; i++) {
1667

    
1668
            for (j = 0; j < 4; j++) {
1669
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1670
                if ((current_macroblock == -1) ||
1671
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1672
                    continue;
1673
                if (current_macroblock >= s->macroblock_count) {
1674
                    printf ("  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1675
                        current_macroblock, s->macroblock_count);
1676
                    return 1;
1677
                }
1678

    
1679
                /* mode 7 means get 3 bits for each coding mode */
1680
                if (scheme == 7)
1681
                    coding_mode = get_bits(gb, 3);
1682
                else
1683
                    coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
1684

    
1685
                s->macroblock_coding[current_macroblock] = coding_mode;
1686
                for (k = 0; k < 6; k++) {
1687
                    current_fragment = 
1688
                        s->macroblock_fragments[current_macroblock * 6 + k];
1689
                    if (current_fragment == -1)
1690
                        continue;
1691
                    if (current_fragment >= s->fragment_count) {
1692
                        printf ("  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1693
                            current_fragment, s->fragment_count);
1694
                        return 1;
1695
                    }
1696
                    if (s->all_fragments[current_fragment].coding_method != 
1697
                        MODE_COPY)
1698
                        s->all_fragments[current_fragment].coding_method =
1699
                            coding_mode;
1700
                }
1701

    
1702
                debug_modes("    coding method for macroblock starting @ fragment %d = %d\n",
1703
                    s->macroblock_fragments[current_macroblock * 6], coding_mode);
1704
            }
1705
        }
1706
    }
1707

    
1708
    return 0;
1709
}
1710

    
1711
/*
1712
 * This function unpacks all the motion vectors for the individual
1713
 * macroblocks from the bitstream.
1714
 */
1715
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1716
{
1717
    int i, j, k;
1718
    int coding_mode;
1719
    int motion_x[6];
1720
    int motion_y[6];
1721
    int last_motion_x = 0;
1722
    int last_motion_y = 0;
1723
    int prior_last_motion_x = 0;
1724
    int prior_last_motion_y = 0;
1725
    int current_macroblock;
1726
    int current_fragment;
1727

    
1728
    debug_vp3("  vp3: unpacking motion vectors\n");
1729
    if (s->keyframe) {
1730

    
1731
        debug_vp3("    keyframe-- there are no motion vectors\n");
1732

    
1733
    } else {
1734

    
1735
        memset(motion_x, 0, 6 * sizeof(int));
1736
        memset(motion_y, 0, 6 * sizeof(int));
1737

    
1738
        /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1739
        coding_mode = get_bits(gb, 1);
1740
        debug_vectors("    using %s scheme for unpacking motion vectors\n",
1741
            (coding_mode == 0) ? "VLC" : "fixed-length");
1742

    
1743
        /* iterate through all of the macroblocks that contain 1 or more
1744
         * coded fragments */
1745
        for (i = 0; i < s->u_superblock_start; i++) {
1746

    
1747
            for (j = 0; j < 4; j++) {
1748
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1749
                if ((current_macroblock == -1) ||
1750
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1751
                    continue;
1752
                if (current_macroblock >= s->macroblock_count) {
1753
                    printf ("  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1754
                        current_macroblock, s->macroblock_count);
1755
                    return 1;
1756
                }
1757

    
1758
                current_fragment = s->macroblock_fragments[current_macroblock * 6];
1759
                if (current_fragment >= s->fragment_count) {
1760
                    printf ("  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1761
                        current_fragment, s->fragment_count);
1762
                    return 1;
1763
                }
1764
                switch (s->macroblock_coding[current_macroblock]) {
1765

    
1766
                case MODE_INTER_PLUS_MV:
1767
                case MODE_GOLDEN_MV:
1768
                    /* all 6 fragments use the same motion vector */
1769
                    if (coding_mode == 0) {
1770
                        motion_x[0] = get_motion_vector_vlc(gb);
1771
                        motion_y[0] = get_motion_vector_vlc(gb);
1772
                    } else {
1773
                        motion_x[0] = get_motion_vector_fixed(gb);
1774
                        motion_y[0] = get_motion_vector_fixed(gb);
1775
                    }
1776
                    for (k = 1; k < 6; k++) {
1777
                        motion_x[k] = motion_x[0];
1778
                        motion_y[k] = motion_y[0];
1779
                    }
1780

    
1781
                    /* vector maintenance, only on MODE_INTER_PLUS_MV */
1782
                    if (s->macroblock_coding[current_macroblock] ==
1783
                        MODE_INTER_PLUS_MV) {
1784
                        prior_last_motion_x = last_motion_x;
1785
                        prior_last_motion_y = last_motion_y;
1786
                        last_motion_x = motion_x[0];
1787
                        last_motion_y = motion_y[0];
1788
                    }
1789
                    break;
1790

    
1791
                case MODE_INTER_FOURMV:
1792
                    /* fetch 4 vectors from the bitstream, one for each
1793
                     * Y fragment, then average for the C fragment vectors */
1794
                    motion_x[4] = motion_y[4] = 0;
1795
                    for (k = 0; k < 4; k++) {
1796
                        if (coding_mode == 0) {
1797
                            motion_x[k] = get_motion_vector_vlc(gb);
1798
                            motion_y[k] = get_motion_vector_vlc(gb);
1799
                        } else {
1800
                            motion_x[k] = get_motion_vector_fixed(gb);
1801
                            motion_y[k] = get_motion_vector_fixed(gb);
1802
                        }
1803
                        motion_x[4] += motion_x[k];
1804
                        motion_y[4] += motion_y[k];
1805
                    }
1806

    
1807
                    if (motion_x[4] >= 0) 
1808
                        motion_x[4] = (motion_x[4] + 2) / 4;
1809
                    else
1810
                        motion_x[4] = (motion_x[4] - 2) / 4;
1811
                    motion_x[5] = motion_x[4];
1812

    
1813
                    if (motion_y[4] >= 0) 
1814
                        motion_y[4] = (motion_y[4] + 2) / 4;
1815
                    else
1816
                        motion_y[4] = (motion_y[4] - 2) / 4;
1817
                    motion_y[5] = motion_y[4];
1818

    
1819
                    /* vector maintenance; vector[3] is treated as the
1820
                     * last vector in this case */
1821
                    prior_last_motion_x = last_motion_x;
1822
                    prior_last_motion_y = last_motion_y;
1823
                    last_motion_x = motion_x[3];
1824
                    last_motion_y = motion_y[3];
1825
                    break;
1826

    
1827
                case MODE_INTER_LAST_MV:
1828
                    /* all 6 fragments use the last motion vector */
1829
                    motion_x[0] = last_motion_x;
1830
                    motion_y[0] = last_motion_y;
1831
                    for (k = 1; k < 6; k++) {
1832
                        motion_x[k] = motion_x[0];
1833
                        motion_y[k] = motion_y[0];
1834
                    }
1835

    
1836
                    /* no vector maintenance (last vector remains the
1837
                     * last vector) */
1838
                    break;
1839

    
1840
                case MODE_INTER_PRIOR_LAST:
1841
                    /* all 6 fragments use the motion vector prior to the
1842
                     * last motion vector */
1843
                    motion_x[0] = prior_last_motion_x;
1844
                    motion_y[0] = prior_last_motion_y;
1845
                    for (k = 1; k < 6; k++) {
1846
                        motion_x[k] = motion_x[0];
1847
                        motion_y[k] = motion_y[0];
1848
                    }
1849

    
1850
                    /* vector maintenance */
1851
                    prior_last_motion_x = last_motion_x;
1852
                    prior_last_motion_y = last_motion_y;
1853
                    last_motion_x = motion_x[0];
1854
                    last_motion_y = motion_y[0];
1855
                    break;
1856

    
1857
                default:
1858
                    /* covers intra, inter without MV, golden without MV */
1859
                    memset(motion_x, 0, 6 * sizeof(int));
1860
                    memset(motion_y, 0, 6 * sizeof(int));
1861

    
1862
                    /* no vector maintenance */
1863
                    break;
1864
                }
1865

    
1866
                /* assign the motion vectors to the correct fragments */
1867
                debug_vectors("    vectors for macroblock starting @ fragment %d (coding method %d):\n",
1868
                    current_fragment,
1869
                    s->macroblock_coding[current_macroblock]);
1870
                for (k = 0; k < 6; k++) {
1871
                    current_fragment = 
1872
                        s->macroblock_fragments[current_macroblock * 6 + k];
1873
                    if (current_fragment == -1)
1874
                        continue;
1875
                    if (current_fragment >= s->fragment_count) {
1876
                        printf ("  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1877
                            current_fragment, s->fragment_count);
1878
                        return 1;
1879
                    }
1880
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
1881
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
1882
                    debug_vectors("    vector %d: fragment %d = (%d, %d)\n",
1883
                        k, current_fragment, motion_x[k], motion_y[k]);
1884
                }
1885
            }
1886
        }
1887
    }
1888

    
1889
    return 0;
1890
}
1891

    
1892
/* 
1893
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1894
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1895
 * data. This function unpacks all the VLCs for either the Y plane or both
1896
 * C planes, and is called for DC coefficients or different AC coefficient
1897
 * levels (since different coefficient types require different VLC tables.
1898
 *
1899
 * This function returns a residual eob run. E.g, if a particular token gave
1900
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1901
 * left in the current fragment range, 3 would be returned so that it could
1902
 * be passed into the next call to this same function.
1903
 */
1904
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1905
                        VLC *table, int coeff_index,
1906
                        int first_fragment, int last_fragment,
1907
                        int eob_run)
1908
{
1909
    int i;
1910
    int token;
1911
    int zero_run;
1912
    DCTELEM coeff;
1913
    Vp3Fragment *fragment;
1914

    
1915
    if ((first_fragment >= s->fragment_count) ||
1916
        (last_fragment >= s->fragment_count)) {
1917

    
1918
        printf ("  vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1919
            first_fragment, last_fragment);
1920
        return 0;
1921
    }
1922

    
1923
    for (i = first_fragment; i <= last_fragment; i++) {
1924

    
1925
        fragment = &s->all_fragments[s->coded_fragment_list[i]];
1926
        if (fragment->coeff_count > coeff_index)
1927
            continue;
1928

    
1929
        if (!eob_run) {
1930
            /* decode a VLC into a token */
1931
            token = get_vlc2(gb, table->table, 5, 3);
1932
            debug_vlc(" token = %2d, ", token);
1933
            /* use the token to get a zero run, a coefficient, and an eob run */
1934
            unpack_token(gb, token, &zero_run, &coeff, &eob_run);
1935
        }
1936

    
1937
        if (!eob_run) {
1938
            fragment->coeff_count += zero_run;
1939
            if (fragment->coeff_count < 64)
1940
                fragment->coeffs[fragment->coeff_count++] = coeff;
1941
            debug_vlc(" fragment %d coeff = %d\n",
1942
                s->coded_fragment_list[i], fragment->coeffs[coeff_index]);
1943
        } else {
1944
            fragment->last_coeff = fragment->coeff_count;
1945
            fragment->coeff_count = 64;
1946
            debug_vlc(" fragment %d eob with %d coefficients\n", 
1947
                s->coded_fragment_list[i], fragment->last_coeff);
1948
            eob_run--;
1949
        }
1950
    }
1951

    
1952
    return eob_run;
1953
}
1954

    
1955
/*
1956
 * This function unpacks all of the DCT coefficient data from the
1957
 * bitstream.
1958
 */
1959
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1960
{
1961
    int i;
1962
    int dc_y_table;
1963
    int dc_c_table;
1964
    int ac_y_table;
1965
    int ac_c_table;
1966
    int residual_eob_run = 0;
1967

    
1968
    /* fetch the DC table indices */
1969
    dc_y_table = get_bits(gb, 4);
1970
    dc_c_table = get_bits(gb, 4);
1971

    
1972
    /* unpack the Y plane DC coefficients */
1973
    debug_vp3("  vp3: unpacking Y plane DC coefficients using table %d\n",
1974
        dc_y_table);
1975
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, 
1976
        s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1977

    
1978
    /* unpack the C plane DC coefficients */
1979
    debug_vp3("  vp3: unpacking C plane DC coefficients using table %d\n",
1980
        dc_c_table);
1981
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1982
        s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1983

    
1984
    /* fetch the AC table indices */
1985
    ac_y_table = get_bits(gb, 4);
1986
    ac_c_table = get_bits(gb, 4);
1987

    
1988
    /* unpack the group 1 AC coefficients (coeffs 1-5) */
1989
    for (i = 1; i <= 5; i++) {
1990

    
1991
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1992
            i, ac_y_table);
1993
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i, 
1994
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1995

    
1996
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
1997
            i, ac_c_table);
1998
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i, 
1999
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2000
    }
2001

    
2002
    /* unpack the group 2 AC coefficients (coeffs 6-14) */
2003
    for (i = 6; i <= 14; i++) {
2004

    
2005
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
2006
            i, ac_y_table);
2007
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i, 
2008
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2009

    
2010
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
2011
            i, ac_c_table);
2012
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i, 
2013
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2014
    }
2015

    
2016
    /* unpack the group 3 AC coefficients (coeffs 15-27) */
2017
    for (i = 15; i <= 27; i++) {
2018

    
2019
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
2020
            i, ac_y_table);
2021
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i, 
2022
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2023

    
2024
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
2025
            i, ac_c_table);
2026
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i, 
2027
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2028
    }
2029

    
2030
    /* unpack the group 4 AC coefficients (coeffs 28-63) */
2031
    for (i = 28; i <= 63; i++) {
2032

    
2033
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
2034
            i, ac_y_table);
2035
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i, 
2036
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2037

    
2038
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
2039
            i, ac_c_table);
2040
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i, 
2041
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2042
    }
2043

    
2044
    return 0;
2045
}
2046

    
2047
/*
2048
 * This function reverses the DC prediction for each coded fragment in
2049
 * the frame. Much of this function is adapted directly from the original 
2050
 * VP3 source code.
2051
 */
2052
#define COMPATIBLE_FRAME(x) \
2053
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
2054
#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
2055
static inline int iabs (int x) { return ((x < 0) ? -x : x); }
2056

    
2057
static void reverse_dc_prediction(Vp3DecodeContext *s,
2058
                                  int first_fragment,
2059
                                  int fragment_width,
2060
                                  int fragment_height) 
2061
{
2062

    
2063
#define PUL 8
2064
#define PU 4
2065
#define PUR 2
2066
#define PL 1
2067

    
2068
    int x, y;
2069
    int i = first_fragment;
2070

    
2071
    /*
2072
     * Fragment prediction groups:
2073
     *
2074
     * 32222222226
2075
     * 10000000004
2076
     * 10000000004
2077
     * 10000000004
2078
     * 10000000004
2079
     *
2080
     * Note: Groups 5 and 7 do not exist as it would mean that the 
2081
     * fragment's x coordinate is both 0 and (width - 1) at the same time.
2082
     */
2083
    int predictor_group;
2084
    short predicted_dc;
2085

    
2086
    /* validity flags for the left, up-left, up, and up-right fragments */
2087
    int fl, ful, fu, fur;
2088

    
2089
    /* DC values for the left, up-left, up, and up-right fragments */
2090
    int vl, vul, vu, vur;
2091

    
2092
    /* indices for the left, up-left, up, and up-right fragments */
2093
    int l, ul, u, ur;
2094

    
2095
    /* 
2096
     * The 6 fields mean:
2097
     *   0: up-left multiplier
2098
     *   1: up multiplier
2099
     *   2: up-right multiplier
2100
     *   3: left multiplier
2101
     *   4: mask
2102
     *   5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
2103
     */
2104
    int predictor_transform[16][6] = {
2105
        {  0,  0,  0,  0,   0,  0 },
2106
        {  0,  0,  0,  1,   0,  0 },        // PL
2107
        {  0,  0,  1,  0,   0,  0 },        // PUR
2108
        {  0,  0, 53, 75, 127,  7 },        // PUR|PL
2109
        {  0,  1,  0,  0,   0,  0 },        // PU
2110
        {  0,  1,  0,  1,   1,  1 },        // PU|PL
2111
        {  0,  1,  0,  0,   0,  0 },        // PU|PUR
2112
        {  0,  0, 53, 75, 127,  7 },        // PU|PUR|PL
2113
        {  1,  0,  0,  0,   0,  0 },        // PUL
2114
        {  0,  0,  0,  1,   0,  0 },        // PUL|PL
2115
        {  1,  0,  1,  0,   1,  1 },        // PUL|PUR
2116
        {  0,  0, 53, 75, 127,  7 },        // PUL|PUR|PL
2117
        {  0,  1,  0,  0,   0,  0 },        // PUL|PU
2118
        {-26, 29,  0, 29,  31,  5 },        // PUL|PU|PL
2119
        {  3, 10,  3,  0,  15,  4 },        // PUL|PU|PUR
2120
        {-26, 29,  0, 29,  31,  5 }         // PUL|PU|PUR|PL
2121
    };
2122

    
2123
    /* This table shows which types of blocks can use other blocks for
2124
     * prediction. For example, INTRA is the only mode in this table to
2125
     * have a frame number of 0. That means INTRA blocks can only predict
2126
     * from other INTRA blocks. There are 2 golden frame coding types; 
2127
     * blocks encoding in these modes can only predict from other blocks
2128
     * that were encoded with these 1 of these 2 modes. */
2129
    unsigned char compatible_frame[8] = {
2130
        1,    /* MODE_INTER_NO_MV */
2131
        0,    /* MODE_INTRA */
2132
        1,    /* MODE_INTER_PLUS_MV */
2133
        1,    /* MODE_INTER_LAST_MV */
2134
        1,    /* MODE_INTER_PRIOR_MV */
2135
        2,    /* MODE_USING_GOLDEN */
2136
        2,    /* MODE_GOLDEN_MV */
2137
        1     /* MODE_INTER_FOUR_MV */
2138
    };
2139
    int current_frame_type;
2140

    
2141
    /* there is a last DC predictor for each of the 3 frame types */
2142
    short last_dc[3];
2143

    
2144
    int transform = 0;
2145

    
2146
    debug_vp3("  vp3: reversing DC prediction\n");
2147

    
2148
    vul = vu = vur = vl = 0;
2149
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
2150

    
2151
    /* for each fragment row... */
2152
    for (y = 0; y < fragment_height; y++) {
2153

    
2154
        /* for each fragment in a row... */
2155
        for (x = 0; x < fragment_width; x++, i++) {
2156

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

    
2160
                current_frame_type = 
2161
                    compatible_frame[s->all_fragments[i].coding_method];
2162
                predictor_group = (x == 0) + ((y == 0) << 1) +
2163
                    ((x + 1 == fragment_width) << 2);
2164
                debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
2165
                    i, predictor_group, s->all_fragments[i].coeffs[0]);
2166

    
2167
                switch (predictor_group) {
2168

    
2169
                case 0:
2170
                    /* main body of fragments; consider all 4 possible
2171
                     * fragments for prediction */
2172

    
2173
                    /* calculate the indices of the predicting fragments */
2174
                    ul = i - fragment_width - 1;
2175
                    u = i - fragment_width;
2176
                    ur = i - fragment_width + 1;
2177
                    l = i - 1;
2178

    
2179
                    /* fetch the DC values for the predicting fragments */
2180
                    vul = s->all_fragments[ul].coeffs[0];
2181
                    vu = s->all_fragments[u].coeffs[0];
2182
                    vur = s->all_fragments[ur].coeffs[0];
2183
                    vl = s->all_fragments[l].coeffs[0];
2184

    
2185
                    /* figure out which fragments are valid */
2186
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2187
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2188
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2189
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2190

    
2191
                    /* decide which predictor transform to use */
2192
                    transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
2193

    
2194
                    break;
2195

    
2196
                case 1:
2197
                    /* left column of fragments, not including top corner;
2198
                     * only consider up and up-right fragments */
2199

    
2200
                    /* calculate the indices of the predicting fragments */
2201
                    u = i - fragment_width;
2202
                    ur = i - fragment_width + 1;
2203

    
2204
                    /* fetch the DC values for the predicting fragments */
2205
                    vu = s->all_fragments[u].coeffs[0];
2206
                    vur = s->all_fragments[ur].coeffs[0];
2207

    
2208
                    /* figure out which fragments are valid */
2209
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2210
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2211

    
2212
                    /* decide which predictor transform to use */
2213
                    transform = (fu*PU) | (fur*PUR);
2214

    
2215
                    break;
2216

    
2217
                case 2:
2218
                case 6:
2219
                    /* top row of fragments, not including top-left frag;
2220
                     * only consider the left fragment for prediction */
2221

    
2222
                    /* calculate the indices of the predicting fragments */
2223
                    l = i - 1;
2224

    
2225
                    /* fetch the DC values for the predicting fragments */
2226
                    vl = s->all_fragments[l].coeffs[0];
2227

    
2228
                    /* figure out which fragments are valid */
2229
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2230

    
2231
                    /* decide which predictor transform to use */
2232
                    transform = (fl*PL);
2233

    
2234
                    break;
2235

    
2236
                case 3:
2237
                    /* top-left fragment */
2238

    
2239
                    /* nothing to predict from in this case */
2240
                    transform = 0;
2241

    
2242
                    break;
2243

    
2244
                case 4:
2245
                    /* right column of fragments, not including top corner;
2246
                     * consider up-left, up, and left fragments for
2247
                     * prediction */
2248

    
2249
                    /* calculate the indices of the predicting fragments */
2250
                    ul = i - fragment_width - 1;
2251
                    u = i - fragment_width;
2252
                    l = i - 1;
2253

    
2254
                    /* fetch the DC values for the predicting fragments */
2255
                    vul = s->all_fragments[ul].coeffs[0];
2256
                    vu = s->all_fragments[u].coeffs[0];
2257
                    vl = s->all_fragments[l].coeffs[0];
2258

    
2259
                    /* figure out which fragments are valid */
2260
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2261
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2262
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2263

    
2264
                    /* decide which predictor transform to use */
2265
                    transform = (fl*PL) | (fu*PU) | (ful*PUL);
2266

    
2267
                    break;
2268

    
2269
                }
2270

    
2271
                debug_dc_pred("transform = %d, ", transform);
2272

    
2273
                if (transform == 0) {
2274

    
2275
                    /* if there were no fragments to predict from, use last
2276
                     * DC saved */
2277
                    s->all_fragments[i].coeffs[0] += last_dc[current_frame_type];
2278
                    debug_dc_pred("from last DC (%d) = %d\n", 
2279
                        current_frame_type, s->all_fragments[i].coeffs[0]);
2280

    
2281
                } else {
2282

    
2283
                    /* apply the appropriate predictor transform */
2284
                    predicted_dc =
2285
                        (predictor_transform[transform][0] * vul) +
2286
                        (predictor_transform[transform][1] * vu) +
2287
                        (predictor_transform[transform][2] * vur) +
2288
                        (predictor_transform[transform][3] * vl);
2289

    
2290
                    /* if there is a shift value in the transform, add
2291
                     * the sign bit before the shift */
2292
                    if (predictor_transform[transform][5] != 0) {
2293
                        predicted_dc += ((predicted_dc >> 15) & 
2294
                            predictor_transform[transform][4]);
2295
                        predicted_dc >>= predictor_transform[transform][5];
2296
                    }
2297

    
2298
                    /* check for outranging on the [ul u l] and
2299
                     * [ul u ur l] predictors */
2300
                    if ((transform == 13) || (transform == 15)) {
2301
                        if (iabs(predicted_dc - vu) > 128)
2302
                            predicted_dc = vu;
2303
                        else if (iabs(predicted_dc - vl) > 128)
2304
                            predicted_dc = vl;
2305
                        else if (iabs(predicted_dc - vul) > 128)
2306
                            predicted_dc = vul;
2307
                    }
2308

    
2309
                    /* at long last, apply the predictor */
2310
                    s->all_fragments[i].coeffs[0] += predicted_dc;
2311
                    debug_dc_pred("from pred DC = %d\n", 
2312
                    s->all_fragments[i].coeffs[0]);
2313
                }
2314

    
2315
                /* save the DC */
2316
                last_dc[current_frame_type] = s->all_fragments[i].coeffs[0];
2317
            }
2318
        }
2319
    }
2320
}
2321

    
2322
/*
2323
 * This function performs the final rendering of each fragment's data
2324
 * onto the output frame.
2325
 */
2326
static void render_fragments(Vp3DecodeContext *s,
2327
                             int first_fragment,
2328
                             int width,
2329
                             int height,
2330
                             int plane /* 0 = Y, 1 = U, 2 = V */) 
2331
{
2332
    int x, y;
2333
    int m, n;
2334
    int i = first_fragment;
2335
    int16_t *dequantizer;
2336
    unsigned char *output_plane;
2337
    unsigned char *last_plane;
2338
    unsigned char *golden_plane;
2339
    int stride;
2340
    int motion_x, motion_y;
2341
    int upper_motion_limit, lower_motion_limit;
2342
    int motion_halfpel_index;
2343
    unsigned int motion_source;
2344

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

    
2348
    /* set up plane-specific parameters */
2349
    if (plane == 0) {
2350
        dequantizer = s->intra_y_dequant;
2351
        output_plane = s->current_frame.data[0];
2352
        last_plane = s->last_frame.data[0];
2353
        golden_plane = s->golden_frame.data[0];
2354
        stride = -s->current_frame.linesize[0];
2355
        upper_motion_limit = 7 * s->current_frame.linesize[0];
2356
        lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
2357
    } else if (plane == 1) {
2358
        dequantizer = s->intra_c_dequant;
2359
        output_plane = s->current_frame.data[1];
2360
        last_plane = s->last_frame.data[1];
2361
        golden_plane = s->golden_frame.data[1];
2362
        stride = -s->current_frame.linesize[1];
2363
        upper_motion_limit = 7 * s->current_frame.linesize[1];
2364
        lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
2365
    } else {
2366
        dequantizer = s->intra_c_dequant;
2367
        output_plane = s->current_frame.data[2];
2368
        last_plane = s->last_frame.data[2];
2369
        golden_plane = s->golden_frame.data[2];
2370
        stride = -s->current_frame.linesize[2];
2371
        upper_motion_limit = 7 * s->current_frame.linesize[2];
2372
        lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
2373
    }
2374

    
2375
    /* for each fragment row... */
2376
    for (y = 0; y < height; y += 8) {
2377

    
2378
        /* for each fragment in a row... */
2379
        for (x = 0; x < width; x += 8, i++) {
2380

    
2381
            if ((i < 0) || (i >= s->fragment_count)) {
2382
                printf ("  vp3:render_fragments(): bad fragment number (%d)\n", i);
2383
                return;
2384
            }
2385

    
2386
            /* transform if this block was coded */
2387
            if (s->all_fragments[i].coding_method != MODE_COPY) {
2388

    
2389
                motion_source = s->all_fragments[i].first_pixel;
2390
                motion_halfpel_index = 0;
2391

    
2392
                /* sort out the motion vector if this fragment is coded
2393
                 * using a motion vector method */
2394
                if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2395
                    (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2396
                    motion_x = s->all_fragments[i].motion_x;
2397
                    motion_y = s->all_fragments[i].motion_y;
2398
if ((motion_x == 0xbeef) || (motion_y == 0xbeef))
2399
printf (" help! got beefy vector! (%X, %X)\n", motion_x, motion_y);
2400

    
2401
                    if (motion_x >= 0) {
2402
                        motion_halfpel_index = motion_x & 0x01;
2403
                        motion_source += (motion_x >> 1);
2404
                    } else  {
2405
                        motion_x = -motion_x;
2406
                        motion_halfpel_index = motion_x & 0x01;
2407
                        motion_source -= ((motion_x + 1) >> 1);
2408
                    }
2409

    
2410
//                    motion_y = -motion_y;
2411
                    if (motion_y >= 0) {
2412
                        motion_halfpel_index |= (motion_y & 0x01) << 1;
2413
                        motion_source += ((motion_y >> 1) * stride);
2414
                    } else  {
2415
                        motion_y = -motion_y;
2416
                        motion_halfpel_index |= (motion_y & 0x01) << 1;
2417
                        motion_source -= (((motion_y + 1) >> 1) * stride);
2418
                    }
2419

    
2420
                    /* if the are any problems with a motion vector, refuse
2421
                     * to render the block */
2422
                    if ((motion_source < upper_motion_limit) ||
2423
                        (motion_source > lower_motion_limit)) {
2424
                        printf ("  vp3: help! motion source (%d) out of range (%d..%d), fragment %d\n",
2425
                            motion_source, upper_motion_limit, lower_motion_limit, i);
2426
                        continue;
2427
                    }
2428
                }
2429

    
2430
                /* first, take care of copying a block from either the
2431
                 * previous or the golden frame */
2432
                if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2433
                    (s->all_fragments[i].coding_method == MODE_GOLDEN_MV)) {
2434

    
2435
                    s->dsp.put_pixels_tab[1][motion_halfpel_index](
2436
                        output_plane + s->all_fragments[i].first_pixel,
2437
                        golden_plane + motion_source,
2438
                        stride, 8);
2439

    
2440
                } else 
2441
                if (s->all_fragments[i].coding_method != MODE_INTRA) {
2442

    
2443
                    s->dsp.put_pixels_tab[1][motion_halfpel_index](
2444
                        output_plane + s->all_fragments[i].first_pixel,
2445
                        last_plane + motion_source,
2446
                        stride, 8);
2447
                }
2448

    
2449
                /* dequantize the DCT coefficients */
2450
                debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n", 
2451
                    i, s->all_fragments[i].coding_method, 
2452
                    s->all_fragments[i].coeffs[0], dequantizer[0]);
2453

    
2454
                /* invert DCT and place (or add) in final output */
2455
                if (s->all_fragments[i].coding_method == MODE_INTRA) {
2456
                    vp3_idct_put(s->all_fragments[i].coeffs, dequantizer,
2457
                        output_plane + s->all_fragments[i].first_pixel,
2458
                        stride);
2459
                } else {
2460
                    vp3_idct_add(s->all_fragments[i].coeffs, dequantizer,
2461
                        output_plane + s->all_fragments[i].first_pixel,
2462
                        stride);
2463
                }
2464

    
2465
                debug_idct("block after idct_%s():\n",
2466
                    (s->all_fragments[i].coding_method == MODE_INTRA)?
2467
                    "put" : "add");
2468
                for (m = 0; m < 8; m++) {
2469
                    for (n = 0; n < 8; n++) {
2470
                        debug_idct(" %3d", *(output_plane + 
2471
                            s->all_fragments[i].first_pixel + (m * stride + n)));
2472
                    }
2473
                    debug_idct("\n");
2474
                }
2475
                debug_idct("\n");
2476

    
2477
            } else {
2478

    
2479
                /* copy directly from the previous frame */
2480
                s->dsp.put_pixels_tab[1][0](
2481
                    output_plane + s->all_fragments[i].first_pixel,
2482
                    last_plane + s->all_fragments[i].first_pixel,
2483
                    stride, 8);
2484

    
2485
            }
2486
        }
2487
    }
2488

    
2489
    emms_c();
2490

    
2491
}
2492

    
2493
/* 
2494
 * This function computes the first pixel addresses for each fragment.
2495
 * This function needs to be invoked after the first frame is allocated
2496
 * so that it has access to the plane strides.
2497
 */
2498
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s) 
2499
{
2500

    
2501
    int i, x, y;
2502

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

    
2517
    /* U plane */
2518
    i = s->u_fragment_start;
2519
    for (y = s->fragment_height / 2; y > 0; y--) {
2520
        for (x = 0; x < s->fragment_width / 2; x++) {
2521
            s->all_fragments[i++].first_pixel = 
2522
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2523
                    s->golden_frame.linesize[1] +
2524
                    x * FRAGMENT_PIXELS;
2525
            debug_init("  fragment %d, first pixel @ %d\n", 
2526
                i-1, s->all_fragments[i-1].first_pixel);
2527
        }
2528
    }
2529

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

    
2544
/*
2545
 * This is the ffmpeg/libavcodec API init function.
2546
 */
2547
static int vp3_decode_init(AVCodecContext *avctx)
2548
{
2549
    Vp3DecodeContext *s = avctx->priv_data;
2550
    int i;
2551
    int c_width;
2552
    int c_height;
2553
    int y_superblock_count;
2554
    int c_superblock_count;
2555

    
2556
    s->avctx = avctx;
2557
#if 0
2558
    s->width = avctx->width;
2559
    s->height = avctx->height;
2560
#else
2561
    s->width = (avctx->width + 15) & 0xFFFFFFF0;
2562
    s->height = (avctx->height + 15) & 0xFFFFFFF0;
2563
#endif
2564
    avctx->pix_fmt = PIX_FMT_YUV420P;
2565
    avctx->has_b_frames = 0;
2566
    dsputil_init(&s->dsp, avctx);
2567

    
2568
    /* initialize to an impossible value which will force a recalculation
2569
     * in the first frame decode */
2570
    s->quality_index = -1;
2571

    
2572
    s->y_superblock_width = (s->width + 31) / 32;
2573
    s->y_superblock_height = (s->height + 31) / 32;
2574
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2575

    
2576
    /* work out the dimensions for the C planes */
2577
    c_width = s->width / 2;
2578
    c_height = s->height / 2;
2579
    s->c_superblock_width = (c_width + 31) / 32;
2580
    s->c_superblock_height = (c_height + 31) / 32;
2581
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2582

    
2583
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2584
    s->u_superblock_start = y_superblock_count;
2585
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
2586
    s->superblock_coding = av_malloc(s->superblock_count);
2587

    
2588
    s->macroblock_width = (s->width + 15) / 16;
2589
    s->macroblock_height = (s->height + 15) / 16;
2590
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
2591

    
2592
    s->fragment_width = s->width / FRAGMENT_PIXELS;
2593
    s->fragment_height = s->height / FRAGMENT_PIXELS;
2594

    
2595
    /* fragment count covers all 8x8 blocks for all 3 planes */
2596
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2597
    s->u_fragment_start = s->fragment_width * s->fragment_height;
2598
    s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2599

    
2600
    debug_init("  Y plane: %d x %d\n", s->width, s->height);
2601
    debug_init("  C plane: %d x %d\n", c_width, c_height);
2602
    debug_init("  Y superblocks: %d x %d, %d total\n",
2603
        s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2604
    debug_init("  C superblocks: %d x %d, %d total\n",
2605
        s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2606
    debug_init("  total superblocks = %d, U starts @ %d, V starts @ %d\n", 
2607
        s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2608
    debug_init("  macroblocks: %d x %d, %d total\n",
2609
        s->macroblock_width, s->macroblock_height, s->macroblock_count);
2610
    debug_init("  %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2611
        s->fragment_count,
2612
        s->fragment_width,
2613
        s->fragment_height,
2614
        s->u_fragment_start,
2615
        s->v_fragment_start);
2616

    
2617
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2618
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2619
    s->pixel_addresses_inited = 0;
2620

    
2621
    /* init VLC tables */
2622
    for (i = 0; i < 16; i++) {
2623

    
2624
        /* DC histograms */
2625
        init_vlc(&s->dc_vlc[i], 5, 32,
2626
            &dc_bias[i][0][1], 4, 2,
2627
            &dc_bias[i][0][0], 4, 2);
2628

    
2629
        /* group 1 AC histograms */
2630
        init_vlc(&s->ac_vlc_1[i], 5, 32,
2631
            &ac_bias_0[i][0][1], 4, 2,
2632
            &ac_bias_0[i][0][0], 4, 2);
2633

    
2634
        /* group 2 AC histograms */
2635
        init_vlc(&s->ac_vlc_2[i], 5, 32,
2636
            &ac_bias_1[i][0][1], 4, 2,
2637
            &ac_bias_1[i][0][0], 4, 2);
2638

    
2639
        /* group 3 AC histograms */
2640
        init_vlc(&s->ac_vlc_3[i], 5, 32,
2641
            &ac_bias_2[i][0][1], 4, 2,
2642
            &ac_bias_2[i][0][0], 4, 2);
2643

    
2644
        /* group 4 AC histograms */
2645
        init_vlc(&s->ac_vlc_4[i], 5, 32,
2646
            &ac_bias_3[i][0][1], 4, 2,
2647
            &ac_bias_3[i][0][0], 4, 2);
2648
    }
2649

    
2650
    /* build quantization zigzag table */
2651
    for (i = 0; i < 64; i++)
2652
        zigzag_index[dezigzag_index[i]] = i;
2653

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

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

    
2667
    return 0;
2668
}
2669

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

    
2681
    *data_size = 0;
2682

    
2683
    init_get_bits(&gb, buf, buf_size * 8);
2684

    
2685
    s->keyframe = get_bits(&gb, 1);
2686
    s->keyframe ^= 1;
2687
    skip_bits(&gb, 1);
2688
    s->last_quality_index = s->quality_index;
2689
    s->quality_index = get_bits(&gb, 6);
2690

    
2691
    debug_vp3(" VP3 frame #%d: Q index = %d", counter, s->quality_index);
2692
    counter++;
2693

    
2694
    if (s->quality_index != s->last_quality_index)
2695
        init_dequantizer(s);
2696

    
2697
    if (s->keyframe) {
2698

    
2699
        debug_vp3(", keyframe\n");
2700
        /* skip the other 2 header bytes for now */
2701
        skip_bits(&gb, 16);
2702

    
2703
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2704
            if (s->golden_frame.data[0])
2705
                avctx->release_buffer(avctx, &s->golden_frame);
2706
        } else {
2707
            if (s->golden_frame.data[0])
2708
                avctx->release_buffer(avctx, &s->golden_frame);
2709
            if (s->last_frame.data[0])
2710
                avctx->release_buffer(avctx, &s->last_frame);
2711
        }
2712

    
2713
        s->golden_frame.reference = 0;
2714
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2715
            printf("vp3: get_buffer() failed\n");
2716
            return -1;
2717
        }
2718

    
2719
        /* golden frame is also the current frame */
2720
        memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
2721

    
2722
        /* time to figure out pixel addresses? */
2723
        if (!s->pixel_addresses_inited)
2724
            vp3_calculate_pixel_addresses(s);
2725

    
2726
    } else {
2727

    
2728
        debug_vp3("\n");
2729

    
2730
        /* allocate a new current frame */
2731
        s->current_frame.reference = 0;
2732
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2733
            printf("vp3: get_buffer() failed\n");
2734
            return -1;
2735
        }
2736
    }
2737

    
2738
    init_frame(s, &gb);
2739

    
2740
#if KEYFRAMES_ONLY
2741
if (!s->keyframe) {
2742

    
2743
    memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2744
        s->current_frame.linesize[0] * s->height);
2745
    memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2746
        s->current_frame.linesize[1] * s->height / 2);
2747
    memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2748
        s->current_frame.linesize[2] * s->height / 2);
2749

    
2750
} else {
2751
#endif
2752

    
2753
    if (unpack_superblocks(s, &gb) ||
2754
        unpack_modes(s, &gb) ||
2755
        unpack_vectors(s, &gb) ||
2756
        unpack_dct_coeffs(s, &gb)) {
2757

    
2758
        printf("  vp3: could not decode frame\n");
2759
        return -1;
2760
    }
2761

    
2762
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2763
    render_fragments(s, 0, s->width, s->height, 0);
2764

    
2765
    if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2766
        reverse_dc_prediction(s, s->u_fragment_start,
2767
            s->fragment_width / 2, s->fragment_height / 2);
2768
        reverse_dc_prediction(s, s->v_fragment_start,
2769
            s->fragment_width / 2, s->fragment_height / 2);
2770
        render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
2771
        render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
2772
    } else {
2773
        memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
2774
        memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
2775
    }
2776

    
2777
#if KEYFRAMES_ONLY
2778
}
2779
#endif
2780

    
2781
    *data_size=sizeof(AVFrame);
2782
    *(AVFrame*)data= s->current_frame;
2783

    
2784
    /* release the last frame, if it is allocated and if it is not the
2785
     * golden frame */
2786
    if ((s->last_frame.data[0]) &&
2787
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2788
        avctx->release_buffer(avctx, &s->last_frame);
2789

    
2790
    /* shuffle frames (last = current) */
2791
    memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));
2792

    
2793
    return buf_size;
2794
}
2795

    
2796
/*
2797
 * This is the ffmpeg/libavcodec API module cleanup function.
2798
 */
2799
static int vp3_decode_end(AVCodecContext *avctx)
2800
{
2801
    Vp3DecodeContext *s = avctx->priv_data;
2802

    
2803
    av_free(s->all_fragments);
2804
    av_free(s->coded_fragment_list);
2805
    av_free(s->superblock_fragments);
2806
    av_free(s->superblock_macroblocks);
2807
    av_free(s->macroblock_fragments);
2808
    av_free(s->macroblock_coding);
2809

    
2810
    /* release all frames */
2811
    if (s->golden_frame.data[0])
2812
        avctx->release_buffer(avctx, &s->golden_frame);
2813
    if (s->last_frame.data[0])
2814
        avctx->release_buffer(avctx, &s->last_frame);
2815
    /* no need to release the current_frame since it will always be pointing
2816
     * to the same frame as either the golden or last frame */
2817

    
2818
    return 0;
2819
}
2820

    
2821
AVCodec vp3_decoder = {
2822
    "vp3",
2823
    CODEC_TYPE_VIDEO,
2824
    CODEC_ID_VP3,
2825
    sizeof(Vp3DecodeContext),
2826
    vp3_decode_init,
2827
    NULL,
2828
    vp3_decode_end,
2829
    vp3_decode_frame,
2830
    0,
2831
    NULL
2832
};