Statistics
| Branch: | Revision:

ffmpeg / libavcodec / vp3.c @ 11e29a41

History | View | Annotate | Download (96.7 KB)

1 d86053a4 Mike Melanson
/*
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 3d32b429 Mike Melanson
 * For more information about the VP3 coding process, visit:
21
 *   http://www.pcisys.net/~melanson/codecs/
22 d86053a4 Mike Melanson
 *
23 f44ee2c3 Alex Beregszaszi
 * Theora decoder by Alex Beregszaszi
24
 *
25 d86053a4 Mike Melanson
 */
26
27
/**
28
 * @file vp3.c
29
 * On2 VP3 Video Decoder
30
 */
31
32
#include <stdio.h>
33
#include <stdlib.h>
34
#include <string.h>
35
#include <unistd.h>
36
37
#include "common.h"
38
#include "avcodec.h"
39
#include "dsputil.h"
40
#include "mpegvideo.h"
41
#include "dsputil.h"
42
43
#include "vp3data.h"
44
45
#define FRAGMENT_PIXELS 8
46
47
/* 
48
 * Debugging Variables
49
 * 
50
 * Define one or more of the following compile-time variables to 1 to obtain
51
 * elaborate information about certain aspects of the decoding process.
52
 *
53 96a7e73b Mike Melanson
 * KEYFRAMES_ONLY: set this to 1 to only see keyframes (VP3 slideshow mode)
54 d86053a4 Mike Melanson
 * DEBUG_VP3: high-level decoding flow
55
 * DEBUG_INIT: initialization parameters
56
 * DEBUG_DEQUANTIZERS: display how the dequanization tables are built
57
 * DEBUG_BLOCK_CODING: unpacking the superblock/macroblock/fragment coding
58
 * DEBUG_MODES: unpacking the coding modes for individual fragments
59
 * DEBUG_VECTORS: display the motion vectors
60
 * DEBUG_TOKEN: display exhaustive information about each DCT token
61
 * DEBUG_VLC: display the VLCs as they are extracted from the stream
62
 * DEBUG_DC_PRED: display the process of reversing DC prediction
63
 * DEBUG_IDCT: show every detail of the IDCT process
64
 */
65
66 96a7e73b Mike Melanson
#define KEYFRAMES_ONLY 0
67
68 d86053a4 Mike Melanson
#define DEBUG_VP3 0
69
#define DEBUG_INIT 0
70
#define DEBUG_DEQUANTIZERS 0
71
#define DEBUG_BLOCK_CODING 0
72
#define DEBUG_MODES 0
73
#define DEBUG_VECTORS 0
74
#define DEBUG_TOKEN 0
75
#define DEBUG_VLC 0
76
#define DEBUG_DC_PRED 0
77
#define DEBUG_IDCT 0
78
79
#if DEBUG_VP3
80
#define debug_vp3 printf
81
#else
82
static inline void debug_vp3(const char *format, ...) { }
83
#endif
84
85
#if DEBUG_INIT
86
#define debug_init printf
87
#else
88
static inline void debug_init(const char *format, ...) { }
89
#endif
90
91
#if DEBUG_DEQUANTIZERS
92
#define debug_dequantizers printf 
93
#else
94
static inline void debug_dequantizers(const char *format, ...) { } 
95
#endif
96
97
#if DEBUG_BLOCK_CODING
98
#define debug_block_coding printf 
99
#else
100
static inline void debug_block_coding(const char *format, ...) { } 
101
#endif
102
103
#if DEBUG_MODES
104
#define debug_modes printf 
105
#else
106
static inline void debug_modes(const char *format, ...) { } 
107
#endif
108
109
#if DEBUG_VECTORS
110
#define debug_vectors printf 
111
#else
112
static inline void debug_vectors(const char *format, ...) { } 
113
#endif
114
115
#if DEBUG_TOKEN 
116
#define debug_token printf 
117
#else
118
static inline void debug_token(const char *format, ...) { } 
119
#endif
120
121
#if DEBUG_VLC
122
#define debug_vlc printf 
123
#else
124
static inline void debug_vlc(const char *format, ...) { } 
125
#endif
126
127
#if DEBUG_DC_PRED
128
#define debug_dc_pred printf 
129
#else
130
static inline void debug_dc_pred(const char *format, ...) { } 
131
#endif
132
133
#if DEBUG_IDCT
134
#define debug_idct printf 
135
#else
136
static inline void debug_idct(const char *format, ...) { } 
137
#endif
138
139
typedef struct Vp3Fragment {
140
    DCTELEM coeffs[64];
141
    int coding_method;
142
    int coeff_count;
143
    int last_coeff;
144
    int motion_x;
145
    int motion_y;
146
    /* address of first pixel taking into account which plane the fragment
147
     * lives on as well as the plane stride */
148
    int first_pixel;
149
    /* this is the macroblock that the fragment belongs to */
150
    int macroblock;
151
} Vp3Fragment;
152
153
#define SB_NOT_CODED        0
154
#define SB_PARTIALLY_CODED  1
155
#define SB_FULLY_CODED      2
156
157
#define MODE_INTER_NO_MV      0
158
#define MODE_INTRA            1
159
#define MODE_INTER_PLUS_MV    2
160
#define MODE_INTER_LAST_MV    3
161
#define MODE_INTER_PRIOR_LAST 4
162
#define MODE_USING_GOLDEN     5
163
#define MODE_GOLDEN_MV        6
164
#define MODE_INTER_FOURMV     7
165
#define CODING_MODE_COUNT     8
166
167
/* special internal mode */
168
#define MODE_COPY             8
169
170
/* There are 6 preset schemes, plus a free-form scheme */
171
static int ModeAlphabet[7][CODING_MODE_COUNT] =
172
{
173
    /* this is the custom scheme */
174
    { 0, 0, 0, 0, 0, 0, 0, 0 },
175
176
    /* scheme 1: Last motion vector dominates */
177
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,  
178
         MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
179
         MODE_INTRA,            MODE_USING_GOLDEN,      
180
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
181
182
    /* scheme 2 */
183
    {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,  
184
         MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,
185
         MODE_INTRA,            MODE_USING_GOLDEN,      
186
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
187
188
    /* scheme 3 */
189
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,     
190
         MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
191
         MODE_INTRA,            MODE_USING_GOLDEN,      
192
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
193
194
    /* scheme 4 */
195
    {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,     
196
         MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
197
         MODE_INTRA,            MODE_USING_GOLDEN,      
198
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
199
200
    /* scheme 5: No motion vector dominates */
201
    {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,     
202
         MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
203
         MODE_INTRA,            MODE_USING_GOLDEN,      
204
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
205
206
    /* scheme 6 */
207
    {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,      
208
         MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
209
         MODE_INTER_PLUS_MV,    MODE_INTRA,             
210
         MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
211
212
};
213
214
#define MIN_DEQUANT_VAL 2
215
216
typedef struct Vp3DecodeContext {
217
    AVCodecContext *avctx;
218 f44ee2c3 Alex Beregszaszi
    int theora, theora_tables;
219 d86053a4 Mike Melanson
    int width, height;
220
    AVFrame golden_frame;
221
    AVFrame last_frame;
222
    AVFrame current_frame;
223
    int keyframe;
224
    DSPContext dsp;
225
226
    int quality_index;
227
    int last_quality_index;
228
229
    int superblock_count;
230
    int superblock_width;
231
    int superblock_height;
232 892fc83e Mike Melanson
    int y_superblock_width;
233
    int y_superblock_height;
234
    int c_superblock_width;
235
    int c_superblock_height;
236 d86053a4 Mike Melanson
    int u_superblock_start;
237
    int v_superblock_start;
238
    unsigned char *superblock_coding;
239
240
    int macroblock_count;
241
    int macroblock_width;
242
    int macroblock_height;
243
244
    int fragment_count;
245
    int fragment_width;
246
    int fragment_height;
247
248
    Vp3Fragment *all_fragments;
249
    int u_fragment_start;
250
    int v_fragment_start;
251 f44ee2c3 Alex Beregszaszi
    
252
    /* tables */
253
    uint16_t coded_dc_scale_factor[64];
254
    uint32_t coded_quality_threshold[64];
255
    uint16_t coded_intra_y_dequant[64];
256
    uint16_t coded_intra_c_dequant[64];
257
    uint16_t coded_inter_dequant[64];
258 d86053a4 Mike Melanson
259
    /* this is a list of indices into the all_fragments array indicating
260
     * which of the fragments are coded */
261
    int *coded_fragment_list;
262
    int coded_fragment_list_index;
263
    int pixel_addresses_inited;
264
265
    VLC dc_vlc[16];
266
    VLC ac_vlc_1[16];
267
    VLC ac_vlc_2[16];
268
    VLC ac_vlc_3[16];
269
    VLC ac_vlc_4[16];
270
271
    int16_t intra_y_dequant[64];
272
    int16_t intra_c_dequant[64];
273
    int16_t inter_dequant[64];
274
275
    /* This table contains superblock_count * 16 entries. Each set of 16
276
     * numbers corresponds to the fragment indices 0..15 of the superblock.
277
     * An entry will be -1 to indicate that no entry corresponds to that
278
     * index. */
279
    int *superblock_fragments;
280
281
    /* This table contains superblock_count * 4 entries. Each set of 4
282
     * numbers corresponds to the macroblock indices 0..3 of the superblock.
283
     * An entry will be -1 to indicate that no entry corresponds to that
284
     * index. */
285
    int *superblock_macroblocks;
286
287
    /* This table contains macroblock_count * 6 entries. Each set of 6
288
     * numbers corresponds to the fragment indices 0..5 which comprise
289
     * the macroblock (4 Y fragments and 2 C fragments). */
290
    int *macroblock_fragments;
291 74c0ac12 Mike Melanson
    /* This is an array that indicates how a particular macroblock 
292
     * is coded. */
293 96a7e73b Mike Melanson
    unsigned char *macroblock_coding;
294 d86053a4 Mike Melanson
295 04331882 Mike Melanson
    int first_coded_y_fragment;
296
    int first_coded_c_fragment;
297
    int last_coded_y_fragment;
298
    int last_coded_c_fragment;
299
300 a2f11b3c Michael Niedermayer
    uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
301 b928ec64 Michael Niedermayer
    uint8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
302 d86053a4 Mike Melanson
} Vp3DecodeContext;
303
304
/************************************************************************
305 3d32b429 Mike Melanson
 * VP3 I/DCT
306
 ************************************************************************/
307
308
#define IdctAdjustBeforeShift 8
309
#define xC1S7 64277
310
#define xC2S6 60547
311
#define xC3S5 54491
312
#define xC4S4 46341
313
#define xC5S3 36410
314
#define xC6S2 25080
315
#define xC7S1 12785
316
317
void vp3_idct_c(int16_t *input_data, int16_t *dequant_matrix, 
318
    int16_t *output_data)
319
{
320
    int32_t intermediate_data[64];
321
    int32_t *ip = intermediate_data;
322
    int16_t *op = output_data;
323
324 e7015b41 Roman Shaposhnik
    int32_t A_, B_, C_, D_, _Ad, _Bd, _Cd, _Dd, E_, F_, G_, H_;
325 3d32b429 Mike Melanson
    int32_t _Ed, _Gd, _Add, _Bdd, _Fd, _Hd;
326
    int32_t t1, t2;
327
328
    int i, j;
329
330
    debug_idct("raw coefficient block:\n");
331
    for (i = 0; i < 8; i++) {
332
        for (j = 0; j < 8; j++) {
333
            debug_idct(" %5d", input_data[i * 8 + j]);
334
        }
335
        debug_idct("\n");
336
    }
337
    debug_idct("\n");
338
339
    for (i = 0; i < 64; i++) {
340
        j = dezigzag_index[i];
341
        intermediate_data[j] = dequant_matrix[i] * input_data[i];
342
    }
343
344
    debug_idct("dequantized block:\n");
345
    for (i = 0; i < 8; i++) {
346
        for (j = 0; j < 8; j++) {
347
            debug_idct(" %5d", intermediate_data[i * 8 + j]);
348
        }
349
        debug_idct("\n");
350
    }
351
    debug_idct("\n");
352
353
    /* Inverse DCT on the rows now */
354
    for (i = 0; i < 8; i++) {
355
        /* Check for non-zero values */
356
        if ( ip[0] | ip[1] | ip[2] | ip[3] | ip[4] | ip[5] | ip[6] | ip[7] ) {
357
            t1 = (int32_t)(xC1S7 * ip[1]);
358
            t2 = (int32_t)(xC7S1 * ip[7]);
359
            t1 >>= 16;
360
            t2 >>= 16;
361 e7015b41 Roman Shaposhnik
            A_ = t1 + t2;
362 3d32b429 Mike Melanson
363
            t1 = (int32_t)(xC7S1 * ip[1]);
364
            t2 = (int32_t)(xC1S7 * ip[7]);
365
            t1 >>= 16;
366
            t2 >>= 16;
367 e7015b41 Roman Shaposhnik
            B_ = t1 - t2;
368 3d32b429 Mike Melanson
369
            t1 = (int32_t)(xC3S5 * ip[3]);
370
            t2 = (int32_t)(xC5S3 * ip[5]);
371
            t1 >>= 16;
372
            t2 >>= 16;
373 e7015b41 Roman Shaposhnik
            C_ = t1 + t2;
374 3d32b429 Mike Melanson
375
            t1 = (int32_t)(xC3S5 * ip[5]);
376
            t2 = (int32_t)(xC5S3 * ip[3]);
377
            t1 >>= 16;
378
            t2 >>= 16;
379 e7015b41 Roman Shaposhnik
            D_ = t1 - t2;
380 3d32b429 Mike Melanson
381
382 e7015b41 Roman Shaposhnik
            t1 = (int32_t)(xC4S4 * (A_ - C_));
383 3d32b429 Mike Melanson
            t1 >>= 16;
384
            _Ad = t1;
385
386 e7015b41 Roman Shaposhnik
            t1 = (int32_t)(xC4S4 * (B_ - D_));
387 3d32b429 Mike Melanson
            t1 >>= 16;
388
            _Bd = t1;
389
390
391 e7015b41 Roman Shaposhnik
            _Cd = A_ + C_;
392
            _Dd = B_ + D_;
393 3d32b429 Mike Melanson
394
            t1 = (int32_t)(xC4S4 * (ip[0] + ip[4]));
395
            t1 >>= 16;
396 e7015b41 Roman Shaposhnik
            E_ = t1;
397 3d32b429 Mike Melanson
398
            t1 = (int32_t)(xC4S4 * (ip[0] - ip[4]));
399
            t1 >>= 16;
400 e7015b41 Roman Shaposhnik
            F_ = t1;
401 3d32b429 Mike Melanson
402
            t1 = (int32_t)(xC2S6 * ip[2]);
403
            t2 = (int32_t)(xC6S2 * ip[6]);
404
            t1 >>= 16;
405
            t2 >>= 16;
406 e7015b41 Roman Shaposhnik
            G_ = t1 + t2;
407 3d32b429 Mike Melanson
408
            t1 = (int32_t)(xC6S2 * ip[2]);
409
            t2 = (int32_t)(xC2S6 * ip[6]);
410
            t1 >>= 16;
411
            t2 >>= 16;
412 e7015b41 Roman Shaposhnik
            H_ = t1 - t2;
413 3d32b429 Mike Melanson
414
415 e7015b41 Roman Shaposhnik
            _Ed = E_ - G_;
416
            _Gd = E_ + G_;
417 3d32b429 Mike Melanson
418 e7015b41 Roman Shaposhnik
            _Add = F_ + _Ad;
419
            _Bdd = _Bd - H_;
420 3d32b429 Mike Melanson
421 e7015b41 Roman Shaposhnik
            _Fd = F_ - _Ad;
422
            _Hd = _Bd + H_;
423 3d32b429 Mike Melanson
424
            /*  Final sequence of operations over-write original inputs. */
425
            ip[0] = (int16_t)((_Gd + _Cd )   >> 0);
426
            ip[7] = (int16_t)((_Gd - _Cd )   >> 0);
427
428
            ip[1] = (int16_t)((_Add + _Hd )  >> 0);
429
            ip[2] = (int16_t)((_Add - _Hd )  >> 0);
430
431
            ip[3] = (int16_t)((_Ed + _Dd )   >> 0);
432
            ip[4] = (int16_t)((_Ed - _Dd )   >> 0);
433
434
            ip[5] = (int16_t)((_Fd + _Bdd )  >> 0);
435
            ip[6] = (int16_t)((_Fd - _Bdd )  >> 0);
436
437
        }
438
439
        ip += 8;            /* next row */
440
    }
441
442
    ip = intermediate_data;
443
444
    for ( i = 0; i < 8; i++) {
445
        /* Check for non-zero values (bitwise or faster than ||) */
446
        if ( ip[0 * 8] | ip[1 * 8] | ip[2 * 8] | ip[3 * 8] |
447
             ip[4 * 8] | ip[5 * 8] | ip[6 * 8] | ip[7 * 8] ) {
448
449
            t1 = (int32_t)(xC1S7 * ip[1*8]);
450
            t2 = (int32_t)(xC7S1 * ip[7*8]);
451
            t1 >>= 16;
452
            t2 >>= 16;
453 e7015b41 Roman Shaposhnik
            A_ = t1 + t2;
454 3d32b429 Mike Melanson
455
            t1 = (int32_t)(xC7S1 * ip[1*8]);
456
            t2 = (int32_t)(xC1S7 * ip[7*8]);
457
            t1 >>= 16;
458
            t2 >>= 16;
459 e7015b41 Roman Shaposhnik
            B_ = t1 - t2;
460 3d32b429 Mike Melanson
461
            t1 = (int32_t)(xC3S5 * ip[3*8]);
462
            t2 = (int32_t)(xC5S3 * ip[5*8]);
463
            t1 >>= 16;
464
            t2 >>= 16;
465 e7015b41 Roman Shaposhnik
            C_ = t1 + t2;
466 3d32b429 Mike Melanson
467
            t1 = (int32_t)(xC3S5 * ip[5*8]);
468
            t2 = (int32_t)(xC5S3 * ip[3*8]);
469
            t1 >>= 16;
470
            t2 >>= 16;
471 e7015b41 Roman Shaposhnik
            D_ = t1 - t2;
472 3d32b429 Mike Melanson
473
474 e7015b41 Roman Shaposhnik
            t1 = (int32_t)(xC4S4 * (A_ - C_));
475 3d32b429 Mike Melanson
            t1 >>= 16;
476
            _Ad = t1;
477
478 e7015b41 Roman Shaposhnik
            t1 = (int32_t)(xC4S4 * (B_ - D_));
479 3d32b429 Mike Melanson
            t1 >>= 16;
480
            _Bd = t1;
481
482
483 e7015b41 Roman Shaposhnik
            _Cd = A_ + C_;
484
            _Dd = B_ + D_;
485 3d32b429 Mike Melanson
486
            t1 = (int32_t)(xC4S4 * (ip[0*8] + ip[4*8]));
487
            t1 >>= 16;
488 e7015b41 Roman Shaposhnik
            E_ = t1;
489 3d32b429 Mike Melanson
490
            t1 = (int32_t)(xC4S4 * (ip[0*8] - ip[4*8]));
491
            t1 >>= 16;
492 e7015b41 Roman Shaposhnik
            F_ = t1;
493 3d32b429 Mike Melanson
494
            t1 = (int32_t)(xC2S6 * ip[2*8]);
495
            t2 = (int32_t)(xC6S2 * ip[6*8]);
496
            t1 >>= 16;
497
            t2 >>= 16;
498 e7015b41 Roman Shaposhnik
            G_ = t1 + t2;
499 3d32b429 Mike Melanson
500
            t1 = (int32_t)(xC6S2 * ip[2*8]);
501
            t2 = (int32_t)(xC2S6 * ip[6*8]);
502
            t1 >>= 16;
503
            t2 >>= 16;
504 e7015b41 Roman Shaposhnik
            H_ = t1 - t2;
505 3d32b429 Mike Melanson
506
507 e7015b41 Roman Shaposhnik
            _Ed = E_ - G_;
508
            _Gd = E_ + G_;
509 3d32b429 Mike Melanson
510 e7015b41 Roman Shaposhnik
            _Add = F_ + _Ad;
511
            _Bdd = _Bd - H_;
512 3d32b429 Mike Melanson
513 e7015b41 Roman Shaposhnik
            _Fd = F_ - _Ad;
514
            _Hd = _Bd + H_;
515 3d32b429 Mike Melanson
516
            _Gd += IdctAdjustBeforeShift;
517
            _Add += IdctAdjustBeforeShift;
518
            _Ed += IdctAdjustBeforeShift;
519
            _Fd += IdctAdjustBeforeShift;
520
521
            /* Final sequence of operations over-write original inputs. */
522
            op[0*8] = (int16_t)((_Gd + _Cd )   >> 4);
523
            op[7*8] = (int16_t)((_Gd - _Cd )   >> 4);
524
525
            op[1*8] = (int16_t)((_Add + _Hd )  >> 4);
526
            op[2*8] = (int16_t)((_Add - _Hd )  >> 4);
527
528
            op[3*8] = (int16_t)((_Ed + _Dd )   >> 4);
529
            op[4*8] = (int16_t)((_Ed - _Dd )   >> 4);
530
531
            op[5*8] = (int16_t)((_Fd + _Bdd )  >> 4);
532
            op[6*8] = (int16_t)((_Fd - _Bdd )  >> 4);
533
534
        } else {
535
536
            op[0*8] = 0;
537
            op[7*8] = 0;
538
            op[1*8] = 0;
539
            op[2*8] = 0;
540
            op[3*8] = 0;
541
            op[4*8] = 0;
542
            op[5*8] = 0;
543
            op[6*8] = 0;
544
        }
545
546
        ip++;            /* next column */
547
        op++;
548
    }
549
}
550
551
void vp3_idct_put(int16_t *input_data, int16_t *dequant_matrix, 
552
    uint8_t *dest, int stride)
553
{
554
    int16_t transformed_data[64];
555
    int16_t *op;
556
    int i, j;
557
558
    vp3_idct_c(input_data, dequant_matrix, transformed_data);
559
560
    /* place in final output */
561
    op = transformed_data;
562
    for (i = 0; i < 8; i++) {
563
        for (j = 0; j < 8; j++) {
564
            if (*op < -128)
565
                *dest = 0;
566
            else if (*op > 127)
567
                *dest = 255;
568
            else
569
                *dest = (uint8_t)(*op + 128);
570
            op++;
571
            dest++;
572
        }
573
        dest += (stride - 8);
574
    }
575
}
576
577
void vp3_idct_add(int16_t *input_data, int16_t *dequant_matrix, 
578
    uint8_t *dest, int stride)
579
{
580
    int16_t transformed_data[64];
581
    int16_t *op;
582
    int i, j;
583
    int16_t sample;
584
585
    vp3_idct_c(input_data, dequant_matrix, transformed_data);
586
587
    /* place in final output */
588
    op = transformed_data;
589
    for (i = 0; i < 8; i++) {
590
        for (j = 0; j < 8; j++) {
591
            sample = *dest + *op;
592
            if (sample < 0)
593
                *dest = 0;
594
            else if (sample > 255)
595
                *dest = 255;
596
            else
597
                *dest = (uint8_t)(sample & 0xFF);
598
            op++;
599
            dest++;
600
        }
601
        dest += (stride - 8);
602
    }
603
}
604
605
/************************************************************************
606 d86053a4 Mike Melanson
 * VP3 specific functions
607
 ************************************************************************/
608
609
/*
610
 * This function sets up all of the various blocks mappings:
611
 * superblocks <-> fragments, macroblocks <-> fragments,
612
 * superblocks <-> macroblocks
613 892fc83e Mike Melanson
 *
614
 * Returns 0 is successful; returns 1 if *anything* went wrong.
615 d86053a4 Mike Melanson
 */
616 892fc83e Mike Melanson
static int init_block_mapping(Vp3DecodeContext *s) 
617 d86053a4 Mike Melanson
{
618
    int i, j;
619
    signed int hilbert_walk_y[16];
620
    signed int hilbert_walk_c[16];
621
    signed int hilbert_walk_mb[4];
622
623
    int current_fragment = 0;
624
    int current_width = 0;
625
    int current_height = 0;
626
    int right_edge = 0;
627
    int bottom_edge = 0;
628
    int superblock_row_inc = 0;
629
    int *hilbert = NULL;
630
    int mapping_index = 0;
631
632
    int current_macroblock;
633
    int c_fragment;
634
635
    signed char travel_width[16] = {
636
         1,  1,  0, -1, 
637
         0,  0,  1,  0,
638
         1,  0,  1,  0,
639
         0, -1,  0,  1
640
    };
641
642
    signed char travel_height[16] = {
643
         0,  0,  1,  0,
644
         1,  1,  0, -1,
645
         0,  1,  0, -1,
646
        -1,  0, -1,  0
647
    };
648
649
    signed char travel_width_mb[4] = {
650
         1,  0,  1,  0
651
    };
652
653
    signed char travel_height_mb[4] = {
654
         0,  1,  0, -1
655
    };
656
657
    debug_vp3("  vp3: initialize block mapping tables\n");
658
659
    /* figure out hilbert pattern per these frame dimensions */
660
    hilbert_walk_y[0]  = 1;
661
    hilbert_walk_y[1]  = 1;
662
    hilbert_walk_y[2]  = s->fragment_width;
663
    hilbert_walk_y[3]  = -1;
664
    hilbert_walk_y[4]  = s->fragment_width;
665
    hilbert_walk_y[5]  = s->fragment_width;
666
    hilbert_walk_y[6]  = 1;
667
    hilbert_walk_y[7]  = -s->fragment_width;
668
    hilbert_walk_y[8]  = 1;
669
    hilbert_walk_y[9]  = s->fragment_width;
670
    hilbert_walk_y[10]  = 1;
671
    hilbert_walk_y[11] = -s->fragment_width;
672
    hilbert_walk_y[12] = -s->fragment_width;
673
    hilbert_walk_y[13] = -1;
674
    hilbert_walk_y[14] = -s->fragment_width;
675
    hilbert_walk_y[15] = 1;
676
677
    hilbert_walk_c[0]  = 1;
678
    hilbert_walk_c[1]  = 1;
679
    hilbert_walk_c[2]  = s->fragment_width / 2;
680
    hilbert_walk_c[3]  = -1;
681
    hilbert_walk_c[4]  = s->fragment_width / 2;
682
    hilbert_walk_c[5]  = s->fragment_width / 2;
683
    hilbert_walk_c[6]  = 1;
684
    hilbert_walk_c[7]  = -s->fragment_width / 2;
685
    hilbert_walk_c[8]  = 1;
686
    hilbert_walk_c[9]  = s->fragment_width / 2;
687
    hilbert_walk_c[10]  = 1;
688
    hilbert_walk_c[11] = -s->fragment_width / 2;
689
    hilbert_walk_c[12] = -s->fragment_width / 2;
690
    hilbert_walk_c[13] = -1;
691
    hilbert_walk_c[14] = -s->fragment_width / 2;
692
    hilbert_walk_c[15] = 1;
693
694
    hilbert_walk_mb[0] = 1;
695
    hilbert_walk_mb[1] = s->macroblock_width;
696
    hilbert_walk_mb[2] = 1;
697
    hilbert_walk_mb[3] = -s->macroblock_width;
698
699
    /* iterate through each superblock (all planes) and map the fragments */
700
    for (i = 0; i < s->superblock_count; i++) {
701
        debug_init("    superblock %d (u starts @ %d, v starts @ %d)\n",
702
            i, s->u_superblock_start, s->v_superblock_start);
703
704
        /* time to re-assign the limits? */
705
        if (i == 0) {
706
707
            /* start of Y superblocks */
708
            right_edge = s->fragment_width;
709
            bottom_edge = s->fragment_height;
710 892fc83e Mike Melanson
            current_width = -1;
711 d86053a4 Mike Melanson
            current_height = 0;
712 892fc83e Mike Melanson
            superblock_row_inc = 3 * s->fragment_width - 
713
                (s->y_superblock_width * 4 - s->fragment_width);
714 d86053a4 Mike Melanson
            hilbert = hilbert_walk_y;
715
716
            /* the first operation for this variable is to advance by 1 */
717
            current_fragment = -1;
718
719
        } else if (i == s->u_superblock_start) {
720
721
            /* start of U superblocks */
722
            right_edge = s->fragment_width / 2;
723
            bottom_edge = s->fragment_height / 2;
724 892fc83e Mike Melanson
            current_width = -1;
725 d86053a4 Mike Melanson
            current_height = 0;
726 892fc83e Mike Melanson
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
727
                (s->c_superblock_width * 4 - s->fragment_width / 2);
728 d86053a4 Mike Melanson
            hilbert = hilbert_walk_c;
729
730
            /* the first operation for this variable is to advance by 1 */
731
            current_fragment = s->u_fragment_start - 1;
732
733
        } else if (i == s->v_superblock_start) {
734
735
            /* start of V superblocks */
736
            right_edge = s->fragment_width / 2;
737
            bottom_edge = s->fragment_height / 2;
738 892fc83e Mike Melanson
            current_width = -1;
739 d86053a4 Mike Melanson
            current_height = 0;
740 892fc83e Mike Melanson
            superblock_row_inc = 3 * (s->fragment_width / 2) - 
741
                (s->c_superblock_width * 4 - s->fragment_width / 2);
742 d86053a4 Mike Melanson
            hilbert = hilbert_walk_c;
743
744
            /* the first operation for this variable is to advance by 1 */
745
            current_fragment = s->v_fragment_start - 1;
746
747
        }
748
749 892fc83e Mike Melanson
        if (current_width >= right_edge - 1) {
750 d86053a4 Mike Melanson
            /* reset width and move to next superblock row */
751 892fc83e Mike Melanson
            current_width = -1;
752 d86053a4 Mike Melanson
            current_height += 4;
753
754
            /* fragment is now at the start of a new superblock row */
755
            current_fragment += superblock_row_inc;
756
        }
757
758
        /* iterate through all 16 fragments in a superblock */
759
        for (j = 0; j < 16; j++) {
760
            current_fragment += hilbert[j];
761 892fc83e Mike Melanson
            current_width += travel_width[j];
762 d86053a4 Mike Melanson
            current_height += travel_height[j];
763
764
            /* check if the fragment is in bounds */
765 892fc83e Mike Melanson
            if ((current_width < right_edge) &&
766 d86053a4 Mike Melanson
                (current_height < bottom_edge)) {
767
                s->superblock_fragments[mapping_index] = current_fragment;
768 892fc83e Mike Melanson
                debug_init("    mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n", 
769
                    s->superblock_fragments[mapping_index], i, j,
770
                    current_width, right_edge, current_height, bottom_edge);
771 d86053a4 Mike Melanson
            } else {
772
                s->superblock_fragments[mapping_index] = -1;
773 892fc83e Mike Melanson
                debug_init("    superblock %d, position %d has no fragment (%d/%d x %d/%d)\n", 
774
                    i, j,
775
                    current_width, right_edge, current_height, bottom_edge);
776 d86053a4 Mike Melanson
            }
777
778
            mapping_index++;
779
        }
780
    }
781
782
    /* initialize the superblock <-> macroblock mapping; iterate through
783
     * all of the Y plane superblocks to build this mapping */
784
    right_edge = s->macroblock_width;
785
    bottom_edge = s->macroblock_height;
786 892fc83e Mike Melanson
    current_width = -1;
787 d86053a4 Mike Melanson
    current_height = 0;
788 892fc83e Mike Melanson
    superblock_row_inc = s->macroblock_width -
789
        (s->y_superblock_width * 2 - s->macroblock_width);;
790 d86053a4 Mike Melanson
    hilbert = hilbert_walk_mb;
791
    mapping_index = 0;
792
    current_macroblock = -1;
793
    for (i = 0; i < s->u_superblock_start; i++) {
794
795 96a7e73b Mike Melanson
        if (current_width >= right_edge - 1) {
796 d86053a4 Mike Melanson
            /* reset width and move to next superblock row */
797 96a7e73b Mike Melanson
            current_width = -1;
798 d86053a4 Mike Melanson
            current_height += 2;
799
800
            /* macroblock is now at the start of a new superblock row */
801
            current_macroblock += superblock_row_inc;
802
        }
803
804
        /* iterate through each potential macroblock in the superblock */
805
        for (j = 0; j < 4; j++) {
806
            current_macroblock += hilbert_walk_mb[j];
807 892fc83e Mike Melanson
            current_width += travel_width_mb[j];
808 d86053a4 Mike Melanson
            current_height += travel_height_mb[j];
809
810
            /* check if the macroblock is in bounds */
811 892fc83e Mike Melanson
            if ((current_width < right_edge) &&
812 d86053a4 Mike Melanson
                (current_height < bottom_edge)) {
813
                s->superblock_macroblocks[mapping_index] = current_macroblock;
814 96a7e73b Mike Melanson
                debug_init("    mapping macroblock %d to superblock %d, position %d (%d/%d x %d/%d)\n",
815
                    s->superblock_macroblocks[mapping_index], i, j,
816
                    current_width, right_edge, current_height, bottom_edge);
817 d86053a4 Mike Melanson
            } else {
818
                s->superblock_macroblocks[mapping_index] = -1;
819 96a7e73b Mike Melanson
                debug_init("    superblock %d, position %d has no macroblock (%d/%d x %d/%d)\n",
820
                    i, j,
821
                    current_width, right_edge, current_height, bottom_edge);
822 d86053a4 Mike Melanson
            }
823
824
            mapping_index++;
825
        }
826
    }
827
828
    /* initialize the macroblock <-> fragment mapping */
829
    current_fragment = 0;
830
    current_macroblock = 0;
831
    mapping_index = 0;
832
    for (i = 0; i < s->fragment_height; i += 2) {
833
834
        for (j = 0; j < s->fragment_width; j += 2) {
835
836
            debug_init("    macroblock %d contains fragments: ", current_macroblock);
837
            s->all_fragments[current_fragment].macroblock = current_macroblock;
838
            s->macroblock_fragments[mapping_index++] = current_fragment;
839
            debug_init("%d ", current_fragment);
840
841
            if (j + 1 < s->fragment_width) {
842
                s->all_fragments[current_fragment + 1].macroblock = current_macroblock;
843
                s->macroblock_fragments[mapping_index++] = current_fragment + 1;
844
                debug_init("%d ", current_fragment + 1);
845
            } else
846
                s->macroblock_fragments[mapping_index++] = -1;
847
848
            if (i + 1 < s->fragment_height) {
849
                s->all_fragments[current_fragment + s->fragment_width].macroblock = 
850
                    current_macroblock;
851
                s->macroblock_fragments[mapping_index++] = 
852
                    current_fragment + s->fragment_width;
853
                debug_init("%d ", current_fragment + s->fragment_width);
854
            } else
855
                s->macroblock_fragments[mapping_index++] = -1;
856
857
            if ((j + 1 < s->fragment_width) && (i + 1 < s->fragment_height)) {
858
                s->all_fragments[current_fragment + s->fragment_width + 1].macroblock = 
859
                    current_macroblock;
860
                s->macroblock_fragments[mapping_index++] = 
861
                    current_fragment + s->fragment_width + 1;
862
                debug_init("%d ", current_fragment + s->fragment_width + 1);
863
            } else
864
                s->macroblock_fragments[mapping_index++] = -1;
865
866
            /* C planes */
867
            c_fragment = s->u_fragment_start + 
868
                (i * s->fragment_width / 4) + (j / 2);
869 892fc83e Mike Melanson
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
870 d86053a4 Mike Melanson
            s->macroblock_fragments[mapping_index++] = c_fragment;
871
            debug_init("%d ", c_fragment);
872
873
            c_fragment = s->v_fragment_start + 
874
                (i * s->fragment_width / 4) + (j / 2);
875 892fc83e Mike Melanson
            s->all_fragments[c_fragment].macroblock = s->macroblock_count;
876 d86053a4 Mike Melanson
            s->macroblock_fragments[mapping_index++] = c_fragment;
877
            debug_init("%d ", c_fragment);
878
879
            debug_init("\n");
880
881
            if (j + 2 <= s->fragment_width)
882
                current_fragment += 2;
883
            else 
884
                current_fragment++;
885
            current_macroblock++;
886
        }
887
888
        current_fragment += s->fragment_width;
889
    }
890 892fc83e Mike Melanson
891
    return 0;  /* successful path out */
892 d86053a4 Mike Melanson
}
893
894
/*
895
 * This function unpacks a single token (which should be in the range 0..31)
896
 * and returns a zero run (number of zero coefficients in current DCT matrix
897
 * before next non-zero coefficient), the next DCT coefficient, and the
898
 * number of consecutive, non-EOB'd DCT blocks to EOB.
899
 */
900
static void unpack_token(GetBitContext *gb, int token, int *zero_run,
901
                         DCTELEM *coeff, int *eob_run) 
902
{
903
    int sign;
904
905
    *zero_run = 0;
906
    *eob_run = 0;
907
    *coeff = 0;
908
909
    debug_token("    vp3 token %d: ", token);
910
    switch (token) {
911
912
    case 0:
913
        debug_token("DCT_EOB_TOKEN, EOB next block\n");
914
        *eob_run = 1;
915
        break;
916
917
    case 1:
918
        debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
919
        *eob_run = 2;
920
        break;
921
922
    case 2:
923
        debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
924
        *eob_run = 3;
925
        break;
926
927
    case 3:
928
        debug_token("DCT_REPEAT_RUN_TOKEN, ");
929
        *eob_run = get_bits(gb, 2) + 4;
930
        debug_token("EOB the next %d blocks\n", *eob_run);
931
        break;
932
933
    case 4:
934
        debug_token("DCT_REPEAT_RUN2_TOKEN, ");
935
        *eob_run = get_bits(gb, 3) + 8;
936
        debug_token("EOB the next %d blocks\n", *eob_run);
937
        break;
938
939
    case 5:
940
        debug_token("DCT_REPEAT_RUN3_TOKEN, ");
941
        *eob_run = get_bits(gb, 4) + 16;
942
        debug_token("EOB the next %d blocks\n", *eob_run);
943
        break;
944
945
    case 6:
946
        debug_token("DCT_REPEAT_RUN4_TOKEN, ");
947
        *eob_run = get_bits(gb, 12);
948
        debug_token("EOB the next %d blocks\n", *eob_run);
949
        break;
950
951
    case 7:
952
        debug_token("DCT_SHORT_ZRL_TOKEN, ");
953
        /* note that this token actually indicates that (3 extra bits) + 1 0s
954
         * should be output; this case specifies a run of (3 EBs) 0s and a
955
         * coefficient of 0. */
956
        *zero_run = get_bits(gb, 3);
957
        *coeff = 0;
958
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
959
        break;
960
961
    case 8:
962
        debug_token("DCT_ZRL_TOKEN, ");
963
        /* note that this token actually indicates that (6 extra bits) + 1 0s
964
         * should be output; this case specifies a run of (6 EBs) 0s and a
965
         * coefficient of 0. */
966
        *zero_run = get_bits(gb, 6);
967
        *coeff = 0;
968
        debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
969
        break;
970
971
    case 9:
972
        debug_token("ONE_TOKEN, output 1\n");
973
        *coeff = 1;
974
        break;
975
976
    case 10:
977
        debug_token("MINUS_ONE_TOKEN, output -1\n");
978
        *coeff = -1;
979
        break;
980
981
    case 11:
982
        debug_token("TWO_TOKEN, output 2\n");
983
        *coeff = 2;
984
        break;
985
986
    case 12:
987
        debug_token("MINUS_TWO_TOKEN, output -2\n");
988
        *coeff = -2;
989
        break;
990
991
    case 13:
992
    case 14:
993
    case 15:
994
    case 16:
995
        debug_token("LOW_VAL_TOKENS, ");
996
        if (get_bits(gb, 1))
997
            *coeff = -(3 + (token - 13));
998
        else
999
            *coeff = 3 + (token - 13);
1000
        debug_token("output %d\n", *coeff);
1001
        break;
1002
1003
    case 17:
1004
        debug_token("DCT_VAL_CATEGORY3, ");
1005
        sign = get_bits(gb, 1);
1006
        *coeff = 7 + get_bits(gb, 1);
1007
        if (sign)
1008
            *coeff = -(*coeff);
1009
        debug_token("output %d\n", *coeff);
1010
        break;
1011
1012
    case 18:
1013
        debug_token("DCT_VAL_CATEGORY4, ");
1014
        sign = get_bits(gb, 1);
1015
        *coeff = 9 + get_bits(gb, 2);
1016
        if (sign)
1017
            *coeff = -(*coeff);
1018
        debug_token("output %d\n", *coeff);
1019
        break;
1020
1021
    case 19:
1022
        debug_token("DCT_VAL_CATEGORY5, ");
1023
        sign = get_bits(gb, 1);
1024
        *coeff = 13 + get_bits(gb, 3);
1025
        if (sign)
1026
            *coeff = -(*coeff);
1027
        debug_token("output %d\n", *coeff);
1028
        break;
1029
1030
    case 20:
1031
        debug_token("DCT_VAL_CATEGORY6, ");
1032
        sign = get_bits(gb, 1);
1033
        *coeff = 21 + get_bits(gb, 4);
1034
        if (sign)
1035
            *coeff = -(*coeff);
1036
        debug_token("output %d\n", *coeff);
1037
        break;
1038
1039
    case 21:
1040
        debug_token("DCT_VAL_CATEGORY7, ");
1041
        sign = get_bits(gb, 1);
1042
        *coeff = 37 + get_bits(gb, 5);
1043
        if (sign)
1044
            *coeff = -(*coeff);
1045
        debug_token("output %d\n", *coeff);
1046
        break;
1047
1048
    case 22:
1049
        debug_token("DCT_VAL_CATEGORY8, ");
1050
        sign = get_bits(gb, 1);
1051
        *coeff = 69 + get_bits(gb, 9);
1052
        if (sign)
1053
            *coeff = -(*coeff);
1054
        debug_token("output %d\n", *coeff);
1055
        break;
1056
1057
    case 23:
1058
    case 24:
1059
    case 25:
1060
    case 26:
1061
    case 27:
1062
        debug_token("DCT_RUN_CATEGORY1, ");
1063
        *zero_run = token - 22;
1064
        if (get_bits(gb, 1))
1065
            *coeff = -1;
1066
        else
1067
            *coeff = 1;
1068
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1069
        break;
1070
1071
    case 28:
1072
        debug_token("DCT_RUN_CATEGORY1B, ");
1073
        if (get_bits(gb, 1))
1074
            *coeff = -1;
1075
        else
1076
            *coeff = 1;
1077
        *zero_run = 6 + get_bits(gb, 2);
1078
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1079
        break;
1080
1081
    case 29:
1082
        debug_token("DCT_RUN_CATEGORY1C, ");
1083
        if (get_bits(gb, 1))
1084
            *coeff = -1;
1085
        else
1086
            *coeff = 1;
1087
        *zero_run = 10 + get_bits(gb, 3);
1088
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1089
        break;
1090
1091
    case 30:
1092
        debug_token("DCT_RUN_CATEGORY2, ");
1093
        sign = get_bits(gb, 1);
1094
        *coeff = 2 + get_bits(gb, 1);
1095
        if (sign)
1096
            *coeff = -(*coeff);
1097
        *zero_run = 1;
1098
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1099
        break;
1100
1101
    case 31:
1102
        debug_token("DCT_RUN_CATEGORY2, ");
1103
        sign = get_bits(gb, 1);
1104
        *coeff = 2 + get_bits(gb, 1);
1105
        if (sign)
1106
            *coeff = -(*coeff);
1107
        *zero_run = 2 + get_bits(gb, 1);
1108
        debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
1109
        break;
1110
1111
    default:
1112 9b879566 Michel Bardiaux
        av_log(NULL, AV_LOG_ERROR, "  vp3: help! Got a bad token: %d > 31\n", token);
1113 d86053a4 Mike Melanson
        break;
1114
1115
  }
1116
}
1117
1118
/*
1119
 * This function wipes out all of the fragment data.
1120
 */
1121
static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
1122
{
1123
    int i;
1124
1125
    /* zero out all of the fragment information */
1126
    s->coded_fragment_list_index = 0;
1127
    for (i = 0; i < s->fragment_count; i++) {
1128
        memset(s->all_fragments[i].coeffs, 0, 64 * sizeof(DCTELEM));
1129
        s->all_fragments[i].coeff_count = 0;
1130
        s->all_fragments[i].last_coeff = 0;
1131 642d7e84 Mike Melanson
s->all_fragments[i].motion_x = 0xbeef;
1132
s->all_fragments[i].motion_y = 0xbeef;
1133 d86053a4 Mike Melanson
    }
1134
}
1135
1136
/*
1137
 * This function sets of the dequantization tables used for a particular
1138
 * frame.
1139
 */
1140
static void init_dequantizer(Vp3DecodeContext *s)
1141
{
1142
1143 f44ee2c3 Alex Beregszaszi
    int quality_scale = s->coded_quality_threshold[s->quality_index];
1144
    int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
1145 d86053a4 Mike Melanson
    int i, j;
1146
1147
    debug_vp3("  vp3: initializing dequantization tables\n");
1148
1149
    /* 
1150
     * Scale dequantizers:
1151
     *
1152
     *   quantizer * sf
1153
     *   --------------
1154
     *        100
1155
     *
1156
     * where sf = dc_scale_factor for DC quantizer
1157
     *           or quality_scale for AC quantizer
1158
     *
1159
     * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
1160
     */
1161 3d32b429 Mike Melanson
#define SCALER 4
1162 d86053a4 Mike Melanson
1163
    /* scale DC quantizers */
1164 f44ee2c3 Alex Beregszaszi
    s->intra_y_dequant[0] = s->coded_intra_y_dequant[0] * dc_scale_factor / 100;
1165 d86053a4 Mike Melanson
    if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
1166
        s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
1167
    s->intra_y_dequant[0] *= SCALER;
1168
1169 f44ee2c3 Alex Beregszaszi
    s->intra_c_dequant[0] = s->coded_intra_c_dequant[0] * dc_scale_factor / 100;
1170 d86053a4 Mike Melanson
    if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
1171
        s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
1172
    s->intra_c_dequant[0] *= SCALER;
1173
1174 f44ee2c3 Alex Beregszaszi
    s->inter_dequant[0] = s->coded_inter_dequant[0] * dc_scale_factor / 100;
1175 d86053a4 Mike Melanson
    if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
1176
        s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
1177
    s->inter_dequant[0] *= SCALER;
1178
1179
    /* scale AC quantizers, zigzag at the same time in preparation for
1180
     * the dequantization phase */
1181
    for (i = 1; i < 64; i++) {
1182
1183 463d086b Mike Melanson
        j = zigzag_index[i];
1184 d86053a4 Mike Melanson
1185 f44ee2c3 Alex Beregszaszi
        s->intra_y_dequant[j] = s->coded_intra_y_dequant[i] * quality_scale / 100;
1186 d86053a4 Mike Melanson
        if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
1187
            s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
1188
        s->intra_y_dequant[j] *= SCALER;
1189
1190 f44ee2c3 Alex Beregszaszi
        s->intra_c_dequant[j] = s->coded_intra_c_dequant[i] * quality_scale / 100;
1191 d86053a4 Mike Melanson
        if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
1192
            s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
1193
        s->intra_c_dequant[j] *= SCALER;
1194
1195 f44ee2c3 Alex Beregszaszi
        s->inter_dequant[j] = s->coded_inter_dequant[i] * quality_scale / 100;
1196 d86053a4 Mike Melanson
        if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
1197
            s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
1198
        s->inter_dequant[j] *= SCALER;
1199
    }
1200 b928ec64 Michael Niedermayer
    
1201
    memset(s->qscale_table, (FFMAX(s->intra_y_dequant[1], s->intra_c_dequant[1])+8)/16, 512); //FIXME finetune
1202 d86053a4 Mike Melanson
1203
    /* print debug information as requested */
1204
    debug_dequantizers("intra Y dequantizers:\n");
1205
    for (i = 0; i < 8; i++) {
1206
      for (j = i * 8; j < i * 8 + 8; j++) {
1207
        debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
1208
      }
1209
      debug_dequantizers("\n");
1210
    }
1211
    debug_dequantizers("\n");
1212
1213
    debug_dequantizers("intra C dequantizers:\n");
1214
    for (i = 0; i < 8; i++) {
1215
      for (j = i * 8; j < i * 8 + 8; j++) {
1216
        debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
1217
      }
1218
      debug_dequantizers("\n");
1219
    }
1220
    debug_dequantizers("\n");
1221
1222
    debug_dequantizers("interframe dequantizers:\n");
1223
    for (i = 0; i < 8; i++) {
1224
      for (j = i * 8; j < i * 8 + 8; j++) {
1225
        debug_dequantizers(" %4d,", s->inter_dequant[j]);
1226
      }
1227
      debug_dequantizers("\n");
1228
    }
1229
    debug_dequantizers("\n");
1230
}
1231
1232
/*
1233
 * This function is used to fetch runs of 1s or 0s from the bitstream for
1234
 * use in determining which superblocks are fully and partially coded.
1235
 *
1236
 *  Codeword                RunLength
1237
 *  0                       1
1238
 *  10x                     2-3
1239
 *  110x                    4-5
1240
 *  1110xx                  6-9
1241
 *  11110xxx                10-17
1242
 *  111110xxxx              18-33
1243
 *  111111xxxxxxxxxxxx      34-4129
1244
 */
1245
static int get_superblock_run_length(GetBitContext *gb)
1246
{
1247
1248
    if (get_bits(gb, 1) == 0)
1249
        return 1;
1250
1251
    else if (get_bits(gb, 1) == 0)
1252
        return (2 + get_bits(gb, 1));
1253
1254
    else if (get_bits(gb, 1) == 0)
1255
        return (4 + get_bits(gb, 1));
1256
1257
    else if (get_bits(gb, 1) == 0)
1258
        return (6 + get_bits(gb, 2));
1259
1260
    else if (get_bits(gb, 1) == 0)
1261
        return (10 + get_bits(gb, 3));
1262
1263
    else if (get_bits(gb, 1) == 0)
1264
        return (18 + get_bits(gb, 4));
1265
1266
    else
1267
        return (34 + get_bits(gb, 12));
1268
1269
}
1270
1271
/*
1272
 * This function is used to fetch runs of 1s or 0s from the bitstream for
1273
 * use in determining which particular fragments are coded.
1274
 *
1275
 * Codeword                RunLength
1276
 * 0x                      1-2
1277
 * 10x                     3-4
1278
 * 110x                    5-6
1279
 * 1110xx                  7-10
1280
 * 11110xx                 11-14
1281
 * 11111xxxx               15-30
1282
 */
1283
static int get_fragment_run_length(GetBitContext *gb)
1284
{
1285
1286
    if (get_bits(gb, 1) == 0)
1287
        return (1 + get_bits(gb, 1));
1288
1289
    else if (get_bits(gb, 1) == 0)
1290
        return (3 + get_bits(gb, 1));
1291
1292
    else if (get_bits(gb, 1) == 0)
1293
        return (5 + get_bits(gb, 1));
1294
1295
    else if (get_bits(gb, 1) == 0)
1296
        return (7 + get_bits(gb, 2));
1297
1298
    else if (get_bits(gb, 1) == 0)
1299
        return (11 + get_bits(gb, 2));
1300
1301
    else
1302
        return (15 + get_bits(gb, 4));
1303
1304
}
1305
1306
/*
1307
 * This function decodes a VLC from the bitstream and returns a number
1308
 * that ranges from 0..7. The number indicates which of the 8 coding
1309
 * modes to use.
1310
 *
1311
 *  VLC       Number
1312
 *  0            0
1313
 *  10           1
1314
 *  110          2
1315
 *  1110         3
1316
 *  11110        4
1317
 *  111110       5
1318
 *  1111110      6
1319
 *  1111111      7
1320
 *
1321
 */
1322
static int get_mode_code(GetBitContext *gb)
1323
{
1324
1325
    if (get_bits(gb, 1) == 0)
1326
        return 0;
1327
1328
    else if (get_bits(gb, 1) == 0)
1329
        return 1;
1330
1331
    else if (get_bits(gb, 1) == 0)
1332
        return 2;
1333
1334
    else if (get_bits(gb, 1) == 0)
1335
        return 3;
1336
1337
    else if (get_bits(gb, 1) == 0)
1338
        return 4;
1339
1340
    else if (get_bits(gb, 1) == 0)
1341
        return 5;
1342
1343
    else if (get_bits(gb, 1) == 0)
1344
        return 6;
1345
1346
    else
1347
        return 7;
1348
1349
}
1350
1351
/*
1352
 * This function extracts a motion vector from the bitstream using a VLC
1353
 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1354
 * taken depending on the value on those 3 bits:
1355
 *
1356
 *  0: return 0
1357
 *  1: return 1
1358
 *  2: return -1
1359
 *  3: if (next bit is 1) return -2, else return 2
1360
 *  4: if (next bit is 1) return -3, else return 3
1361
 *  5: return 4 + (next 2 bits), next bit is sign
1362
 *  6: return 8 + (next 3 bits), next bit is sign
1363
 *  7: return 16 + (next 4 bits), next bit is sign
1364
 */
1365
static int get_motion_vector_vlc(GetBitContext *gb)
1366
{
1367
    int bits;
1368
1369
    bits = get_bits(gb, 3);
1370
1371
    switch(bits) {
1372
1373
    case 0:
1374
        bits = 0;
1375
        break;
1376
1377
    case 1:
1378
        bits = 1;
1379
        break;
1380
1381
    case 2:
1382
        bits = -1;
1383
        break;
1384
1385
    case 3:
1386
        if (get_bits(gb, 1) == 0)
1387
            bits = 2;
1388
        else
1389
            bits = -2;
1390
        break;
1391
1392
    case 4:
1393
        if (get_bits(gb, 1) == 0)
1394
            bits = 3;
1395
        else
1396
            bits = -3;
1397
        break;
1398
1399
    case 5:
1400
        bits = 4 + get_bits(gb, 2);
1401
        if (get_bits(gb, 1) == 1)
1402
            bits = -bits;
1403
        break;
1404
1405
    case 6:
1406
        bits = 8 + get_bits(gb, 3);
1407
        if (get_bits(gb, 1) == 1)
1408
            bits = -bits;
1409
        break;
1410
1411
    case 7:
1412
        bits = 16 + get_bits(gb, 4);
1413
        if (get_bits(gb, 1) == 1)
1414
            bits = -bits;
1415
        break;
1416
1417
    }
1418
1419
    return bits;
1420
}
1421
1422
/*
1423
 * This function fetches a 5-bit number from the stream followed by
1424
 * a sign and calls it a motion vector.
1425
 */
1426
static int get_motion_vector_fixed(GetBitContext *gb)
1427
{
1428
1429
    int bits;
1430
1431
    bits = get_bits(gb, 5);
1432
1433
    if (get_bits(gb, 1) == 1)
1434
        bits = -bits;
1435
1436
    return bits;
1437
}
1438
1439
/*
1440
 * This function unpacks all of the superblock/macroblock/fragment coding 
1441
 * information from the bitstream.
1442
 */
1443 892fc83e Mike Melanson
static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
1444 d86053a4 Mike Melanson
{
1445
    int bit = 0;
1446
    int current_superblock = 0;
1447
    int current_run = 0;
1448
    int decode_fully_flags = 0;
1449
    int decode_partial_blocks = 0;
1450 22493ab9 Mike Melanson
    int first_c_fragment_seen;
1451 d86053a4 Mike Melanson
1452
    int i, j;
1453
    int current_fragment;
1454
1455
    debug_vp3("  vp3: unpacking superblock coding\n");
1456
1457
    if (s->keyframe) {
1458
1459
        debug_vp3("    keyframe-- all superblocks are fully coded\n");
1460
        memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1461
1462
    } else {
1463
1464
        /* unpack the list of partially-coded superblocks */
1465
        bit = get_bits(gb, 1);
1466
        /* toggle the bit because as soon as the first run length is 
1467
         * fetched the bit will be toggled again */
1468
        bit ^= 1;
1469
        while (current_superblock < s->superblock_count) {
1470
            if (current_run == 0) {
1471
                bit ^= 1;
1472
                current_run = get_superblock_run_length(gb);
1473
                debug_block_coding("      setting superblocks %d..%d to %s\n",
1474
                    current_superblock,
1475
                    current_superblock + current_run - 1,
1476
                    (bit) ? "partially coded" : "not coded");
1477
1478
                /* if any of the superblocks are not partially coded, flag
1479
                 * a boolean to decode the list of fully-coded superblocks */
1480 642d7e84 Mike Melanson
                if (bit == 0) {
1481 d86053a4 Mike Melanson
                    decode_fully_flags = 1;
1482 642d7e84 Mike Melanson
                } else {
1483 d86053a4 Mike Melanson
1484 642d7e84 Mike Melanson
                    /* make a note of the fact that there are partially coded
1485
                     * superblocks */
1486
                    decode_partial_blocks = 1;
1487
                }
1488 d86053a4 Mike Melanson
            }
1489
            s->superblock_coding[current_superblock++] = 
1490
                (bit) ? SB_PARTIALLY_CODED : SB_NOT_CODED;
1491
            current_run--;
1492
        }
1493
1494
        /* unpack the list of fully coded superblocks if any of the blocks were
1495
         * not marked as partially coded in the previous step */
1496
        if (decode_fully_flags) {
1497
1498
            current_superblock = 0;
1499
            current_run = 0;
1500
            bit = get_bits(gb, 1);
1501
            /* toggle the bit because as soon as the first run length is 
1502
             * fetched the bit will be toggled again */
1503
            bit ^= 1;
1504
            while (current_superblock < s->superblock_count) {
1505
1506
                /* skip any superblocks already marked as partially coded */
1507
                if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1508
1509
                    if (current_run == 0) {
1510
                        bit ^= 1;
1511
                        current_run = get_superblock_run_length(gb);
1512
                    }
1513
1514
                    debug_block_coding("      setting superblock %d to %s\n",
1515
                        current_superblock,
1516
                        (bit) ? "fully coded" : "not coded");
1517
                    s->superblock_coding[current_superblock] = 
1518
                        (bit) ? SB_FULLY_CODED : SB_NOT_CODED;
1519
                    current_run--;
1520
                }
1521
                current_superblock++;
1522
            }
1523
        }
1524
1525
        /* if there were partial blocks, initialize bitstream for
1526
         * unpacking fragment codings */
1527
        if (decode_partial_blocks) {
1528
1529
            current_run = 0;
1530
            bit = get_bits(gb, 1);
1531
            /* toggle the bit because as soon as the first run length is 
1532
             * fetched the bit will be toggled again */
1533
            bit ^= 1;
1534
        }
1535
    }
1536
1537
    /* figure out which fragments are coded; iterate through each
1538
     * superblock (all planes) */
1539
    s->coded_fragment_list_index = 0;
1540 04331882 Mike Melanson
    s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1541
    s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
1542 22493ab9 Mike Melanson
    first_c_fragment_seen = 0;
1543 96a7e73b Mike Melanson
    memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
1544 d86053a4 Mike Melanson
    for (i = 0; i < s->superblock_count; i++) {
1545
1546
        /* iterate through all 16 fragments in a superblock */
1547
        for (j = 0; j < 16; j++) {
1548
1549
            /* if the fragment is in bounds, check its coding status */
1550
            current_fragment = s->superblock_fragments[i * 16 + j];
1551 892fc83e Mike Melanson
            if (current_fragment >= s->fragment_count) {
1552 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
1553 892fc83e Mike Melanson
                    current_fragment, s->fragment_count);
1554
                return 1;
1555
            }
1556 d86053a4 Mike Melanson
            if (current_fragment != -1) {
1557
                if (s->superblock_coding[i] == SB_NOT_CODED) {
1558
1559
                    /* copy all the fragments from the prior frame */
1560
                    s->all_fragments[current_fragment].coding_method = 
1561
                        MODE_COPY;
1562
1563
                } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1564
1565
                    /* fragment may or may not be coded; this is the case
1566
                     * that cares about the fragment coding runs */
1567
                    if (current_run == 0) {
1568
                        bit ^= 1;
1569
                        current_run = get_fragment_run_length(gb);
1570
                    }
1571
1572
                    if (bit) {
1573 22493ab9 Mike Melanson
                        /* default mode; actual mode will be decoded in 
1574
                         * the next phase */
1575 d86053a4 Mike Melanson
                        s->all_fragments[current_fragment].coding_method = 
1576
                            MODE_INTER_NO_MV;
1577 04331882 Mike Melanson
                        s->coded_fragment_list[s->coded_fragment_list_index] = 
1578 d86053a4 Mike Melanson
                            current_fragment;
1579 04331882 Mike Melanson
                        if ((current_fragment >= s->u_fragment_start) &&
1580 22493ab9 Mike Melanson
                            (s->last_coded_y_fragment == -1) &&
1581
                            (!first_c_fragment_seen)) {
1582 04331882 Mike Melanson
                            s->first_coded_c_fragment = s->coded_fragment_list_index;
1583
                            s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1584 22493ab9 Mike Melanson
                            first_c_fragment_seen = 1;
1585 04331882 Mike Melanson
                        }
1586
                        s->coded_fragment_list_index++;
1587 96a7e73b Mike Melanson
                        s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1588 d86053a4 Mike Melanson
                        debug_block_coding("      superblock %d is partially coded, fragment %d is coded\n",
1589
                            i, current_fragment);
1590
                    } else {
1591
                        /* not coded; copy this fragment from the prior frame */
1592
                        s->all_fragments[current_fragment].coding_method =
1593
                            MODE_COPY;
1594
                        debug_block_coding("      superblock %d is partially coded, fragment %d is not coded\n",
1595
                            i, current_fragment);
1596
                    }
1597
1598
                    current_run--;
1599
1600
                } else {
1601
1602
                    /* fragments are fully coded in this superblock; actual
1603
                     * coding will be determined in next step */
1604
                    s->all_fragments[current_fragment].coding_method = 
1605
                        MODE_INTER_NO_MV;
1606 04331882 Mike Melanson
                    s->coded_fragment_list[s->coded_fragment_list_index] = 
1607 d86053a4 Mike Melanson
                        current_fragment;
1608 04331882 Mike Melanson
                    if ((current_fragment >= s->u_fragment_start) &&
1609 22493ab9 Mike Melanson
                        (s->last_coded_y_fragment == -1) &&
1610
                        (!first_c_fragment_seen)) {
1611 04331882 Mike Melanson
                        s->first_coded_c_fragment = s->coded_fragment_list_index;
1612
                        s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
1613 22493ab9 Mike Melanson
                        first_c_fragment_seen = 1;
1614 04331882 Mike Melanson
                    }
1615
                    s->coded_fragment_list_index++;
1616 96a7e73b Mike Melanson
                    s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
1617 d86053a4 Mike Melanson
                    debug_block_coding("      superblock %d is fully coded, fragment %d is coded\n",
1618
                        i, current_fragment);
1619
                }
1620
            }
1621
        }
1622
    }
1623 04331882 Mike Melanson
1624 22493ab9 Mike Melanson
    if (!first_c_fragment_seen)
1625
        /* only Y fragments coded in this frame */
1626 04331882 Mike Melanson
        s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
1627 22493ab9 Mike Melanson
    else 
1628 642d7e84 Mike Melanson
        /* end the list of coded C fragments */
1629 04331882 Mike Melanson
        s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
1630 22493ab9 Mike Melanson
1631 04331882 Mike Melanson
    debug_block_coding("    %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1632
        s->coded_fragment_list_index,
1633
        s->first_coded_y_fragment,
1634
        s->last_coded_y_fragment,
1635
        s->first_coded_c_fragment,
1636
        s->last_coded_c_fragment);
1637 892fc83e Mike Melanson
1638
    return 0;
1639 d86053a4 Mike Melanson
}
1640
1641
/*
1642
 * This function unpacks all the coding mode data for individual macroblocks
1643
 * from the bitstream.
1644
 */
1645 892fc83e Mike Melanson
static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
1646 d86053a4 Mike Melanson
{
1647
    int i, j, k;
1648
    int scheme;
1649
    int current_macroblock;
1650
    int current_fragment;
1651
    int coding_mode;
1652
1653
    debug_vp3("  vp3: unpacking encoding modes\n");
1654
1655
    if (s->keyframe) {
1656
        debug_vp3("    keyframe-- all blocks are coded as INTRA\n");
1657
1658
        for (i = 0; i < s->fragment_count; i++)
1659
            s->all_fragments[i].coding_method = MODE_INTRA;
1660
1661
    } else {
1662
1663
        /* fetch the mode coding scheme for this frame */
1664
        scheme = get_bits(gb, 3);
1665
        debug_modes("    using mode alphabet %d\n", scheme);
1666
1667
        /* is it a custom coding scheme? */
1668
        if (scheme == 0) {
1669
            debug_modes("    custom mode alphabet ahead:\n");
1670
            for (i = 0; i < 8; i++)
1671 a466e345 Mike Melanson
                ModeAlphabet[scheme][get_bits(gb, 3)] = i;
1672 d86053a4 Mike Melanson
        }
1673
1674
        for (i = 0; i < 8; i++)
1675
            debug_modes("      mode[%d][%d] = %d\n", scheme, i, 
1676
                ModeAlphabet[scheme][i]);
1677
1678
        /* iterate through all of the macroblocks that contain 1 or more
1679
         * coded fragments */
1680
        for (i = 0; i < s->u_superblock_start; i++) {
1681
1682
            for (j = 0; j < 4; j++) {
1683
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1684
                if ((current_macroblock == -1) ||
1685 96a7e73b Mike Melanson
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1686 d86053a4 Mike Melanson
                    continue;
1687 892fc83e Mike Melanson
                if (current_macroblock >= s->macroblock_count) {
1688 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
1689 892fc83e Mike Melanson
                        current_macroblock, s->macroblock_count);
1690
                    return 1;
1691
                }
1692 d86053a4 Mike Melanson
1693
                /* mode 7 means get 3 bits for each coding mode */
1694
                if (scheme == 7)
1695
                    coding_mode = get_bits(gb, 3);
1696
                else
1697
                    coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
1698
1699 96a7e73b Mike Melanson
                s->macroblock_coding[current_macroblock] = coding_mode;
1700 d86053a4 Mike Melanson
                for (k = 0; k < 6; k++) {
1701
                    current_fragment = 
1702
                        s->macroblock_fragments[current_macroblock * 6 + k];
1703 892fc83e Mike Melanson
                    if (current_fragment == -1)
1704
                        continue;
1705
                    if (current_fragment >= s->fragment_count) {
1706 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
1707 892fc83e Mike Melanson
                            current_fragment, s->fragment_count);
1708
                        return 1;
1709
                    }
1710 d86053a4 Mike Melanson
                    if (s->all_fragments[current_fragment].coding_method != 
1711
                        MODE_COPY)
1712
                        s->all_fragments[current_fragment].coding_method =
1713
                            coding_mode;
1714
                }
1715
1716
                debug_modes("    coding method for macroblock starting @ fragment %d = %d\n",
1717
                    s->macroblock_fragments[current_macroblock * 6], coding_mode);
1718
            }
1719
        }
1720
    }
1721 892fc83e Mike Melanson
1722
    return 0;
1723 44ae98dd Mike Melanson
}
1724
1725
/*
1726 d86053a4 Mike Melanson
 * This function unpacks all the motion vectors for the individual
1727
 * macroblocks from the bitstream.
1728
 */
1729 892fc83e Mike Melanson
static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
1730 d86053a4 Mike Melanson
{
1731
    int i, j, k;
1732
    int coding_mode;
1733
    int motion_x[6];
1734
    int motion_y[6];
1735
    int last_motion_x = 0;
1736
    int last_motion_y = 0;
1737
    int prior_last_motion_x = 0;
1738
    int prior_last_motion_y = 0;
1739
    int current_macroblock;
1740
    int current_fragment;
1741
1742
    debug_vp3("  vp3: unpacking motion vectors\n");
1743
    if (s->keyframe) {
1744
1745
        debug_vp3("    keyframe-- there are no motion vectors\n");
1746
1747
    } else {
1748
1749
        memset(motion_x, 0, 6 * sizeof(int));
1750
        memset(motion_y, 0, 6 * sizeof(int));
1751
1752
        /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1753
        coding_mode = get_bits(gb, 1);
1754
        debug_vectors("    using %s scheme for unpacking motion vectors\n",
1755
            (coding_mode == 0) ? "VLC" : "fixed-length");
1756
1757
        /* iterate through all of the macroblocks that contain 1 or more
1758
         * coded fragments */
1759
        for (i = 0; i < s->u_superblock_start; i++) {
1760
1761
            for (j = 0; j < 4; j++) {
1762
                current_macroblock = s->superblock_macroblocks[i * 4 + j];
1763
                if ((current_macroblock == -1) ||
1764 96a7e73b Mike Melanson
                    (s->macroblock_coding[current_macroblock] == MODE_COPY))
1765 d86053a4 Mike Melanson
                    continue;
1766 892fc83e Mike Melanson
                if (current_macroblock >= s->macroblock_count) {
1767 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
1768 892fc83e Mike Melanson
                        current_macroblock, s->macroblock_count);
1769
                    return 1;
1770
                }
1771 d86053a4 Mike Melanson
1772
                current_fragment = s->macroblock_fragments[current_macroblock * 6];
1773 892fc83e Mike Melanson
                if (current_fragment >= s->fragment_count) {
1774 9b879566 Michel Bardiaux
                    av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
1775 892fc83e Mike Melanson
                        current_fragment, s->fragment_count);
1776
                    return 1;
1777
                }
1778 96a7e73b Mike Melanson
                switch (s->macroblock_coding[current_macroblock]) {
1779 d86053a4 Mike Melanson
1780
                case MODE_INTER_PLUS_MV:
1781
                case MODE_GOLDEN_MV:
1782
                    /* all 6 fragments use the same motion vector */
1783
                    if (coding_mode == 0) {
1784
                        motion_x[0] = get_motion_vector_vlc(gb);
1785
                        motion_y[0] = get_motion_vector_vlc(gb);
1786
                    } else {
1787
                        motion_x[0] = get_motion_vector_fixed(gb);
1788
                        motion_y[0] = get_motion_vector_fixed(gb);
1789
                    }
1790
                    for (k = 1; k < 6; k++) {
1791
                        motion_x[k] = motion_x[0];
1792
                        motion_y[k] = motion_y[0];
1793
                    }
1794
1795
                    /* vector maintenance, only on MODE_INTER_PLUS_MV */
1796 642d7e84 Mike Melanson
                    if (s->macroblock_coding[current_macroblock] ==
1797 d86053a4 Mike Melanson
                        MODE_INTER_PLUS_MV) {
1798
                        prior_last_motion_x = last_motion_x;
1799
                        prior_last_motion_y = last_motion_y;
1800
                        last_motion_x = motion_x[0];
1801
                        last_motion_y = motion_y[0];
1802
                    }
1803
                    break;
1804
1805
                case MODE_INTER_FOURMV:
1806
                    /* fetch 4 vectors from the bitstream, one for each
1807
                     * Y fragment, then average for the C fragment vectors */
1808
                    motion_x[4] = motion_y[4] = 0;
1809
                    for (k = 0; k < 4; k++) {
1810
                        if (coding_mode == 0) {
1811
                            motion_x[k] = get_motion_vector_vlc(gb);
1812
                            motion_y[k] = get_motion_vector_vlc(gb);
1813
                        } else {
1814
                            motion_x[k] = get_motion_vector_fixed(gb);
1815
                            motion_y[k] = get_motion_vector_fixed(gb);
1816
                        }
1817
                        motion_x[4] += motion_x[k];
1818
                        motion_y[4] += motion_y[k];
1819
                    }
1820
1821
                    if (motion_x[4] >= 0) 
1822
                        motion_x[4] = (motion_x[4] + 2) / 4;
1823
                    else
1824
                        motion_x[4] = (motion_x[4] - 2) / 4;
1825
                    motion_x[5] = motion_x[4];
1826
1827
                    if (motion_y[4] >= 0) 
1828
                        motion_y[4] = (motion_y[4] + 2) / 4;
1829
                    else
1830
                        motion_y[4] = (motion_y[4] - 2) / 4;
1831
                    motion_y[5] = motion_y[4];
1832
1833
                    /* vector maintenance; vector[3] is treated as the
1834
                     * last vector in this case */
1835
                    prior_last_motion_x = last_motion_x;
1836
                    prior_last_motion_y = last_motion_y;
1837
                    last_motion_x = motion_x[3];
1838
                    last_motion_y = motion_y[3];
1839
                    break;
1840
1841
                case MODE_INTER_LAST_MV:
1842
                    /* all 6 fragments use the last motion vector */
1843
                    motion_x[0] = last_motion_x;
1844
                    motion_y[0] = 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
                    /* no vector maintenance (last vector remains the
1851
                     * last vector) */
1852
                    break;
1853
1854
                case MODE_INTER_PRIOR_LAST:
1855
                    /* all 6 fragments use the motion vector prior to the
1856
                     * last motion vector */
1857
                    motion_x[0] = prior_last_motion_x;
1858
                    motion_y[0] = prior_last_motion_y;
1859
                    for (k = 1; k < 6; k++) {
1860
                        motion_x[k] = motion_x[0];
1861
                        motion_y[k] = motion_y[0];
1862
                    }
1863
1864
                    /* vector maintenance */
1865
                    prior_last_motion_x = last_motion_x;
1866
                    prior_last_motion_y = last_motion_y;
1867
                    last_motion_x = motion_x[0];
1868
                    last_motion_y = motion_y[0];
1869
                    break;
1870 44ae98dd Mike Melanson
1871
                default:
1872
                    /* covers intra, inter without MV, golden without MV */
1873
                    memset(motion_x, 0, 6 * sizeof(int));
1874
                    memset(motion_y, 0, 6 * sizeof(int));
1875
1876
                    /* no vector maintenance */
1877
                    break;
1878 d86053a4 Mike Melanson
                }
1879
1880
                /* assign the motion vectors to the correct fragments */
1881
                debug_vectors("    vectors for macroblock starting @ fragment %d (coding method %d):\n",
1882
                    current_fragment,
1883 642d7e84 Mike Melanson
                    s->macroblock_coding[current_macroblock]);
1884 d86053a4 Mike Melanson
                for (k = 0; k < 6; k++) {
1885
                    current_fragment = 
1886
                        s->macroblock_fragments[current_macroblock * 6 + k];
1887 892fc83e Mike Melanson
                    if (current_fragment == -1)
1888
                        continue;
1889
                    if (current_fragment >= s->fragment_count) {
1890 9b879566 Michel Bardiaux
                        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
1891 892fc83e Mike Melanson
                            current_fragment, s->fragment_count);
1892
                        return 1;
1893
                    }
1894 d86053a4 Mike Melanson
                    s->all_fragments[current_fragment].motion_x = motion_x[k];
1895 44ae98dd Mike Melanson
                    s->all_fragments[current_fragment].motion_y = motion_y[k];
1896 642d7e84 Mike Melanson
                    debug_vectors("    vector %d: fragment %d = (%d, %d)\n",
1897
                        k, current_fragment, motion_x[k], motion_y[k]);
1898 d86053a4 Mike Melanson
                }
1899
            }
1900
        }
1901
    }
1902 892fc83e Mike Melanson
1903
    return 0;
1904 d86053a4 Mike Melanson
}
1905
1906
/* 
1907
 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1908
 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1909
 * data. This function unpacks all the VLCs for either the Y plane or both
1910
 * C planes, and is called for DC coefficients or different AC coefficient
1911
 * levels (since different coefficient types require different VLC tables.
1912
 *
1913
 * This function returns a residual eob run. E.g, if a particular token gave
1914
 * instructions to EOB the next 5 fragments and there were only 2 fragments
1915
 * left in the current fragment range, 3 would be returned so that it could
1916
 * be passed into the next call to this same function.
1917
 */
1918
static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1919
                        VLC *table, int coeff_index,
1920
                        int first_fragment, int last_fragment,
1921
                        int eob_run)
1922
{
1923
    int i;
1924
    int token;
1925
    int zero_run;
1926
    DCTELEM coeff;
1927
    Vp3Fragment *fragment;
1928
1929 22493ab9 Mike Melanson
    if ((first_fragment >= s->fragment_count) ||
1930 74c0ac12 Mike Melanson
        (last_fragment >= s->fragment_count)) {
1931
1932 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "  vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
1933 74c0ac12 Mike Melanson
            first_fragment, last_fragment);
1934 22493ab9 Mike Melanson
        return 0;
1935 74c0ac12 Mike Melanson
    }
1936
1937 04331882 Mike Melanson
    for (i = first_fragment; i <= last_fragment; i++) {
1938 d86053a4 Mike Melanson
1939
        fragment = &s->all_fragments[s->coded_fragment_list[i]];
1940
        if (fragment->coeff_count > coeff_index)
1941
            continue;
1942
1943
        if (!eob_run) {
1944
            /* decode a VLC into a token */
1945
            token = get_vlc2(gb, table->table, 5, 3);
1946
            debug_vlc(" token = %2d, ", token);
1947
            /* use the token to get a zero run, a coefficient, and an eob run */
1948
            unpack_token(gb, token, &zero_run, &coeff, &eob_run);
1949
        }
1950
1951
        if (!eob_run) {
1952
            fragment->coeff_count += zero_run;
1953
            if (fragment->coeff_count < 64)
1954
                fragment->coeffs[fragment->coeff_count++] = coeff;
1955
            debug_vlc(" fragment %d coeff = %d\n",
1956
                s->coded_fragment_list[i], fragment->coeffs[coeff_index]);
1957
        } else {
1958
            fragment->last_coeff = fragment->coeff_count;
1959
            fragment->coeff_count = 64;
1960
            debug_vlc(" fragment %d eob with %d coefficients\n", 
1961
                s->coded_fragment_list[i], fragment->last_coeff);
1962
            eob_run--;
1963
        }
1964
    }
1965
1966
    return eob_run;
1967
}
1968
1969
/*
1970
 * This function unpacks all of the DCT coefficient data from the
1971
 * bitstream.
1972
 */
1973 892fc83e Mike Melanson
static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
1974 d86053a4 Mike Melanson
{
1975
    int i;
1976
    int dc_y_table;
1977
    int dc_c_table;
1978
    int ac_y_table;
1979
    int ac_c_table;
1980
    int residual_eob_run = 0;
1981
1982
    /* fetch the DC table indices */
1983
    dc_y_table = get_bits(gb, 4);
1984
    dc_c_table = get_bits(gb, 4);
1985
1986
    /* unpack the Y plane DC coefficients */
1987
    debug_vp3("  vp3: unpacking Y plane DC coefficients using table %d\n",
1988
        dc_y_table);
1989
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0, 
1990 04331882 Mike Melanson
        s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
1991 d86053a4 Mike Melanson
1992
    /* unpack the C plane DC coefficients */
1993
    debug_vp3("  vp3: unpacking C plane DC coefficients using table %d\n",
1994
        dc_c_table);
1995
    residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
1996 04331882 Mike Melanson
        s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
1997 d86053a4 Mike Melanson
1998 a466e345 Mike Melanson
    /* fetch the AC table indices */
1999 d86053a4 Mike Melanson
    ac_y_table = get_bits(gb, 4);
2000
    ac_c_table = get_bits(gb, 4);
2001
2002 a466e345 Mike Melanson
    /* unpack the group 1 AC coefficients (coeffs 1-5) */
2003 d86053a4 Mike Melanson
    for (i = 1; i <= 5; 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_1[ac_y_table], i, 
2008 04331882 Mike Melanson
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2009 d86053a4 Mike Melanson
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_1[ac_c_table], i, 
2013 04331882 Mike Melanson
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2014 d86053a4 Mike Melanson
    }
2015
2016 a466e345 Mike Melanson
    /* unpack the group 2 AC coefficients (coeffs 6-14) */
2017 d86053a4 Mike Melanson
    for (i = 6; i <= 14; 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_2[ac_y_table], i, 
2022 04331882 Mike Melanson
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2023 d86053a4 Mike Melanson
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_2[ac_c_table], i, 
2027 04331882 Mike Melanson
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2028 d86053a4 Mike Melanson
    }
2029
2030 a466e345 Mike Melanson
    /* unpack the group 3 AC coefficients (coeffs 15-27) */
2031 d86053a4 Mike Melanson
    for (i = 15; i <= 27; 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_3[ac_y_table], i, 
2036 04331882 Mike Melanson
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2037 d86053a4 Mike Melanson
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_3[ac_c_table], i, 
2041 04331882 Mike Melanson
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2042 d86053a4 Mike Melanson
    }
2043
2044 a466e345 Mike Melanson
    /* unpack the group 4 AC coefficients (coeffs 28-63) */
2045 d86053a4 Mike Melanson
    for (i = 28; i <= 63; i++) {
2046
2047
        debug_vp3("  vp3: unpacking level %d Y plane AC coefficients using table %d\n",
2048
            i, ac_y_table);
2049
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i, 
2050 04331882 Mike Melanson
            s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
2051 d86053a4 Mike Melanson
2052
        debug_vp3("  vp3: unpacking level %d C plane AC coefficients using table %d\n",
2053
            i, ac_c_table);
2054
        residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i, 
2055 04331882 Mike Melanson
            s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
2056 d86053a4 Mike Melanson
    }
2057 892fc83e Mike Melanson
2058
    return 0;
2059 d86053a4 Mike Melanson
}
2060
2061
/*
2062
 * This function reverses the DC prediction for each coded fragment in
2063
 * the frame. Much of this function is adapted directly from the original 
2064
 * VP3 source code.
2065
 */
2066
#define COMPATIBLE_FRAME(x) \
2067
  (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
2068
#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
2069
static inline int iabs (int x) { return ((x < 0) ? -x : x); }
2070
2071
static void reverse_dc_prediction(Vp3DecodeContext *s,
2072
                                  int first_fragment,
2073
                                  int fragment_width,
2074
                                  int fragment_height) 
2075
{
2076
2077
#define PUL 8
2078
#define PU 4
2079
#define PUR 2
2080
#define PL 1
2081
2082
    int x, y;
2083
    int i = first_fragment;
2084
2085
    /*
2086
     * Fragment prediction groups:
2087
     *
2088
     * 32222222226
2089
     * 10000000004
2090
     * 10000000004
2091
     * 10000000004
2092
     * 10000000004
2093
     *
2094
     * Note: Groups 5 and 7 do not exist as it would mean that the 
2095
     * fragment's x coordinate is both 0 and (width - 1) at the same time.
2096
     */
2097
    int predictor_group;
2098
    short predicted_dc;
2099
2100
    /* validity flags for the left, up-left, up, and up-right fragments */
2101
    int fl, ful, fu, fur;
2102
2103
    /* DC values for the left, up-left, up, and up-right fragments */
2104
    int vl, vul, vu, vur;
2105
2106
    /* indices for the left, up-left, up, and up-right fragments */
2107
    int l, ul, u, ur;
2108
2109
    /* 
2110
     * The 6 fields mean:
2111
     *   0: up-left multiplier
2112
     *   1: up multiplier
2113
     *   2: up-right multiplier
2114
     *   3: left multiplier
2115
     *   4: mask
2116
     *   5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
2117
     */
2118
    int predictor_transform[16][6] = {
2119
        {  0,  0,  0,  0,   0,  0 },
2120
        {  0,  0,  0,  1,   0,  0 },        // PL
2121
        {  0,  0,  1,  0,   0,  0 },        // PUR
2122
        {  0,  0, 53, 75, 127,  7 },        // PUR|PL
2123
        {  0,  1,  0,  0,   0,  0 },        // PU
2124
        {  0,  1,  0,  1,   1,  1 },        // PU|PL
2125
        {  0,  1,  0,  0,   0,  0 },        // PU|PUR
2126
        {  0,  0, 53, 75, 127,  7 },        // PU|PUR|PL
2127
        {  1,  0,  0,  0,   0,  0 },        // PUL
2128
        {  0,  0,  0,  1,   0,  0 },        // PUL|PL
2129
        {  1,  0,  1,  0,   1,  1 },        // PUL|PUR
2130
        {  0,  0, 53, 75, 127,  7 },        // PUL|PUR|PL
2131
        {  0,  1,  0,  0,   0,  0 },        // PUL|PU
2132
        {-26, 29,  0, 29,  31,  5 },        // PUL|PU|PL
2133
        {  3, 10,  3,  0,  15,  4 },        // PUL|PU|PUR
2134
        {-26, 29,  0, 29,  31,  5 }         // PUL|PU|PUR|PL
2135
    };
2136
2137
    /* This table shows which types of blocks can use other blocks for
2138
     * prediction. For example, INTRA is the only mode in this table to
2139
     * have a frame number of 0. That means INTRA blocks can only predict
2140
     * from other INTRA blocks. There are 2 golden frame coding types; 
2141
     * blocks encoding in these modes can only predict from other blocks
2142
     * that were encoded with these 1 of these 2 modes. */
2143
    unsigned char compatible_frame[8] = {
2144
        1,    /* MODE_INTER_NO_MV */
2145
        0,    /* MODE_INTRA */
2146
        1,    /* MODE_INTER_PLUS_MV */
2147
        1,    /* MODE_INTER_LAST_MV */
2148
        1,    /* MODE_INTER_PRIOR_MV */
2149
        2,    /* MODE_USING_GOLDEN */
2150
        2,    /* MODE_GOLDEN_MV */
2151
        1     /* MODE_INTER_FOUR_MV */
2152
    };
2153
    int current_frame_type;
2154
2155
    /* there is a last DC predictor for each of the 3 frame types */
2156
    short last_dc[3];
2157
2158
    int transform = 0;
2159
2160
    debug_vp3("  vp3: reversing DC prediction\n");
2161
2162
    vul = vu = vur = vl = 0;
2163
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
2164
2165
    /* for each fragment row... */
2166
    for (y = 0; y < fragment_height; y++) {
2167
2168
        /* for each fragment in a row... */
2169
        for (x = 0; x < fragment_width; x++, i++) {
2170
2171
            /* reverse prediction if this block was coded */
2172
            if (s->all_fragments[i].coding_method != MODE_COPY) {
2173
2174
                current_frame_type = 
2175
                    compatible_frame[s->all_fragments[i].coding_method];
2176
                predictor_group = (x == 0) + ((y == 0) << 1) +
2177
                    ((x + 1 == fragment_width) << 2);
2178
                debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
2179
                    i, predictor_group, s->all_fragments[i].coeffs[0]);
2180
2181
                switch (predictor_group) {
2182
2183
                case 0:
2184
                    /* main body of fragments; consider all 4 possible
2185
                     * fragments for prediction */
2186
2187
                    /* calculate the indices of the predicting fragments */
2188
                    ul = i - fragment_width - 1;
2189
                    u = i - fragment_width;
2190
                    ur = i - fragment_width + 1;
2191
                    l = i - 1;
2192
2193
                    /* fetch the DC values for the predicting fragments */
2194
                    vul = s->all_fragments[ul].coeffs[0];
2195
                    vu = s->all_fragments[u].coeffs[0];
2196
                    vur = s->all_fragments[ur].coeffs[0];
2197
                    vl = s->all_fragments[l].coeffs[0];
2198
2199
                    /* figure out which fragments are valid */
2200
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2201
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2202
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2203
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2204
2205
                    /* decide which predictor transform to use */
2206
                    transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
2207
2208
                    break;
2209
2210
                case 1:
2211
                    /* left column of fragments, not including top corner;
2212
                     * only consider up and up-right fragments */
2213
2214
                    /* calculate the indices of the predicting fragments */
2215
                    u = i - fragment_width;
2216
                    ur = i - fragment_width + 1;
2217
2218
                    /* fetch the DC values for the predicting fragments */
2219
                    vu = s->all_fragments[u].coeffs[0];
2220
                    vur = s->all_fragments[ur].coeffs[0];
2221
2222
                    /* figure out which fragments are valid */
2223
                    fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2224
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2225
2226
                    /* decide which predictor transform to use */
2227
                    transform = (fu*PU) | (fur*PUR);
2228
2229
                    break;
2230
2231
                case 2:
2232
                case 6:
2233
                    /* top row of fragments, not including top-left frag;
2234
                     * only consider the left fragment for prediction */
2235
2236
                    /* calculate the indices of the predicting fragments */
2237
                    l = i - 1;
2238
2239
                    /* fetch the DC values for the predicting fragments */
2240
                    vl = s->all_fragments[l].coeffs[0];
2241
2242
                    /* figure out which fragments are valid */
2243
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2244
2245
                    /* decide which predictor transform to use */
2246
                    transform = (fl*PL);
2247
2248
                    break;
2249
2250
                case 3:
2251
                    /* top-left fragment */
2252
2253
                    /* nothing to predict from in this case */
2254
                    transform = 0;
2255
2256
                    break;
2257
2258
                case 4:
2259
                    /* right column of fragments, not including top corner;
2260
                     * consider up-left, up, and left fragments for
2261
                     * prediction */
2262
2263
                    /* calculate the indices of the predicting fragments */
2264
                    ul = i - fragment_width - 1;
2265
                    u = i - fragment_width;
2266
                    l = i - 1;
2267
2268
                    /* fetch the DC values for the predicting fragments */
2269
                    vul = s->all_fragments[ul].coeffs[0];
2270
                    vu = s->all_fragments[u].coeffs[0];
2271
                    vl = s->all_fragments[l].coeffs[0];
2272
2273
                    /* figure out which fragments are valid */
2274
                    ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2275
                    fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2276
                    fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2277
2278
                    /* decide which predictor transform to use */
2279
                    transform = (fl*PL) | (fu*PU) | (ful*PUL);
2280
2281
                    break;
2282
2283
                }
2284
2285
                debug_dc_pred("transform = %d, ", transform);
2286
2287
                if (transform == 0) {
2288
2289
                    /* if there were no fragments to predict from, use last
2290
                     * DC saved */
2291
                    s->all_fragments[i].coeffs[0] += last_dc[current_frame_type];
2292
                    debug_dc_pred("from last DC (%d) = %d\n", 
2293
                        current_frame_type, s->all_fragments[i].coeffs[0]);
2294
2295
                } else {
2296
2297
                    /* apply the appropriate predictor transform */
2298
                    predicted_dc =
2299
                        (predictor_transform[transform][0] * vul) +
2300
                        (predictor_transform[transform][1] * vu) +
2301
                        (predictor_transform[transform][2] * vur) +
2302
                        (predictor_transform[transform][3] * vl);
2303
2304
                    /* if there is a shift value in the transform, add
2305
                     * the sign bit before the shift */
2306
                    if (predictor_transform[transform][5] != 0) {
2307
                        predicted_dc += ((predicted_dc >> 15) & 
2308
                            predictor_transform[transform][4]);
2309
                        predicted_dc >>= predictor_transform[transform][5];
2310
                    }
2311
2312
                    /* check for outranging on the [ul u l] and
2313
                     * [ul u ur l] predictors */
2314
                    if ((transform == 13) || (transform == 15)) {
2315
                        if (iabs(predicted_dc - vu) > 128)
2316
                            predicted_dc = vu;
2317
                        else if (iabs(predicted_dc - vl) > 128)
2318
                            predicted_dc = vl;
2319
                        else if (iabs(predicted_dc - vul) > 128)
2320
                            predicted_dc = vul;
2321
                    }
2322
2323
                    /* at long last, apply the predictor */
2324
                    s->all_fragments[i].coeffs[0] += predicted_dc;
2325
                    debug_dc_pred("from pred DC = %d\n", 
2326
                    s->all_fragments[i].coeffs[0]);
2327
                }
2328
2329
                /* save the DC */
2330
                last_dc[current_frame_type] = s->all_fragments[i].coeffs[0];
2331
            }
2332
        }
2333
    }
2334
}
2335
2336
/*
2337
 * This function performs the final rendering of each fragment's data
2338
 * onto the output frame.
2339
 */
2340
static void render_fragments(Vp3DecodeContext *s,
2341
                             int first_fragment,
2342 44ae98dd Mike Melanson
                             int width,
2343
                             int height,
2344 d86053a4 Mike Melanson
                             int plane /* 0 = Y, 1 = U, 2 = V */) 
2345
{
2346
    int x, y;
2347
    int m, n;
2348
    int i = first_fragment;
2349
    int16_t *dequantizer;
2350
    unsigned char *output_plane;
2351
    unsigned char *last_plane;
2352
    unsigned char *golden_plane;
2353
    int stride;
2354 44ae98dd Mike Melanson
    int motion_x, motion_y;
2355 a466e345 Mike Melanson
    int upper_motion_limit, lower_motion_limit;
2356 44ae98dd Mike Melanson
    int motion_halfpel_index;
2357 a2f11b3c Michael Niedermayer
    uint8_t *motion_source;
2358 d86053a4 Mike Melanson
2359
    debug_vp3("  vp3: rendering final fragments for %s\n",
2360
        (plane == 0) ? "Y plane" : (plane == 1) ? "U plane" : "V plane");
2361
2362
    /* set up plane-specific parameters */
2363
    if (plane == 0) {
2364
        dequantizer = s->intra_y_dequant;
2365
        output_plane = s->current_frame.data[0];
2366 61873c4a Mike Melanson
        last_plane = s->last_frame.data[0];
2367
        golden_plane = s->golden_frame.data[0];
2368 d86053a4 Mike Melanson
        stride = -s->current_frame.linesize[0];
2369 a466e345 Mike Melanson
        upper_motion_limit = 7 * s->current_frame.linesize[0];
2370
        lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
2371 d86053a4 Mike Melanson
    } else if (plane == 1) {
2372
        dequantizer = s->intra_c_dequant;
2373
        output_plane = s->current_frame.data[1];
2374 61873c4a Mike Melanson
        last_plane = s->last_frame.data[1];
2375
        golden_plane = s->golden_frame.data[1];
2376 d86053a4 Mike Melanson
        stride = -s->current_frame.linesize[1];
2377 a466e345 Mike Melanson
        upper_motion_limit = 7 * s->current_frame.linesize[1];
2378
        lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
2379 d86053a4 Mike Melanson
    } else {
2380
        dequantizer = s->intra_c_dequant;
2381
        output_plane = s->current_frame.data[2];
2382 61873c4a Mike Melanson
        last_plane = s->last_frame.data[2];
2383
        golden_plane = s->golden_frame.data[2];
2384 d86053a4 Mike Melanson
        stride = -s->current_frame.linesize[2];
2385 a466e345 Mike Melanson
        upper_motion_limit = 7 * s->current_frame.linesize[2];
2386
        lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
2387 d86053a4 Mike Melanson
    }
2388
2389
    /* for each fragment row... */
2390 44ae98dd Mike Melanson
    for (y = 0; y < height; y += 8) {
2391 d86053a4 Mike Melanson
2392
        /* for each fragment in a row... */
2393 44ae98dd Mike Melanson
        for (x = 0; x < width; x += 8, i++) {
2394 d86053a4 Mike Melanson
2395 74c0ac12 Mike Melanson
            if ((i < 0) || (i >= s->fragment_count)) {
2396 9b879566 Michel Bardiaux
                av_log(s->avctx, AV_LOG_ERROR, "  vp3:render_fragments(): bad fragment number (%d)\n", i);
2397 74c0ac12 Mike Melanson
                return;
2398
            }
2399
2400 d86053a4 Mike Melanson
            /* transform if this block was coded */
2401 44ae98dd Mike Melanson
            if (s->all_fragments[i].coding_method != MODE_COPY) {
2402
2403 a2f11b3c Michael Niedermayer
                if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2404
                    (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2405
                    motion_source= golden_plane;
2406
                else 
2407
                    motion_source= last_plane;
2408
2409
                motion_source += s->all_fragments[i].first_pixel;
2410 642d7e84 Mike Melanson
                motion_halfpel_index = 0;
2411
2412
                /* sort out the motion vector if this fragment is coded
2413
                 * using a motion vector method */
2414
                if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2415
                    (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2416 a2f11b3c Michael Niedermayer
                    int src_x, src_y;
2417 642d7e84 Mike Melanson
                    motion_x = s->all_fragments[i].motion_x;
2418
                    motion_y = s->all_fragments[i].motion_y;
2419 b928ec64 Michael Niedermayer
                    if(plane){
2420
                        motion_x= (motion_x>>1) | (motion_x&1);
2421
                        motion_y= (motion_y>>1) | (motion_y&1);
2422
                    }
2423
2424 a2f11b3c Michael Niedermayer
                    src_x= (motion_x>>1) + x;
2425
                    src_y= (motion_y>>1) + y;
2426 642d7e84 Mike Melanson
if ((motion_x == 0xbeef) || (motion_y == 0xbeef))
2427 9b879566 Michel Bardiaux
av_log(s->avctx, AV_LOG_ERROR, " help! got beefy vector! (%X, %X)\n", motion_x, motion_y);
2428 642d7e84 Mike Melanson
2429 b928ec64 Michael Niedermayer
                    motion_halfpel_index = motion_x & 0x01;
2430
                    motion_source += (motion_x >> 1);
2431 642d7e84 Mike Melanson
2432
//                    motion_y = -motion_y;
2433 b928ec64 Michael Niedermayer
                    motion_halfpel_index |= (motion_y & 0x01) << 1;
2434
                    motion_source += ((motion_y >> 1) * stride);
2435 642d7e84 Mike Melanson
2436 a2f11b3c Michael Niedermayer
                    if(src_x<0 || src_y<0 || src_x + 9 >= width || src_y + 9 >= height){
2437
                        uint8_t *temp= s->edge_emu_buffer;
2438
                        if(stride<0) temp -= 9*stride;
2439
2440
                        ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, width, height);
2441
                        motion_source= temp;
2442 642d7e84 Mike Melanson
                    }
2443 a466e345 Mike Melanson
                }
2444
2445 44ae98dd Mike Melanson
                /* first, take care of copying a block from either the
2446
                 * previous or the golden frame */
2447
                if (s->all_fragments[i].coding_method != MODE_INTRA) {
2448
2449 a2f11b3c Michael Niedermayer
                    s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2450 44ae98dd Mike Melanson
                        output_plane + s->all_fragments[i].first_pixel,
2451 a2f11b3c Michael Niedermayer
                        motion_source,
2452 44ae98dd Mike Melanson
                        stride, 8);
2453
                }
2454
2455 d86053a4 Mike Melanson
                /* dequantize the DCT coefficients */
2456 44ae98dd Mike Melanson
                debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n", 
2457
                    i, s->all_fragments[i].coding_method, 
2458
                    s->all_fragments[i].coeffs[0], dequantizer[0]);
2459 d86053a4 Mike Melanson
2460 4e80eb21 Mike Melanson
                /* invert DCT and place (or add) in final output */
2461
                if (s->all_fragments[i].coding_method == MODE_INTRA) {
2462 3d32b429 Mike Melanson
                    vp3_idct_put(s->all_fragments[i].coeffs, dequantizer,
2463 44ae98dd Mike Melanson
                        output_plane + s->all_fragments[i].first_pixel,
2464 3d32b429 Mike Melanson
                        stride);
2465 4e80eb21 Mike Melanson
                } else {
2466 3d32b429 Mike Melanson
                    vp3_idct_add(s->all_fragments[i].coeffs, dequantizer,
2467 44ae98dd Mike Melanson
                        output_plane + s->all_fragments[i].first_pixel,
2468 3d32b429 Mike Melanson
                        stride);
2469 4e80eb21 Mike Melanson
                }
2470 44ae98dd Mike Melanson
2471
                debug_idct("block after idct_%s():\n",
2472
                    (s->all_fragments[i].coding_method == MODE_INTRA)?
2473
                    "put" : "add");
2474 d86053a4 Mike Melanson
                for (m = 0; m < 8; m++) {
2475
                    for (n = 0; n < 8; n++) {
2476 44ae98dd Mike Melanson
                        debug_idct(" %3d", *(output_plane + 
2477
                            s->all_fragments[i].first_pixel + (m * stride + n)));
2478 d86053a4 Mike Melanson
                    }
2479
                    debug_idct("\n");
2480
                }
2481
                debug_idct("\n");
2482
2483
            } else {
2484
2485 44ae98dd Mike Melanson
                /* copy directly from the previous frame */
2486
                s->dsp.put_pixels_tab[1][0](
2487
                    output_plane + s->all_fragments[i].first_pixel,
2488
                    last_plane + s->all_fragments[i].first_pixel,
2489
                    stride, 8);
2490 d86053a4 Mike Melanson
2491
            }
2492
        }
2493
    }
2494
2495
    emms_c();
2496
2497
}
2498
2499
/* 
2500
 * This function computes the first pixel addresses for each fragment.
2501
 * This function needs to be invoked after the first frame is allocated
2502
 * so that it has access to the plane strides.
2503
 */
2504
static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s) 
2505
{
2506
2507
    int i, x, y;
2508
2509
    /* figure out the first pixel addresses for each of the fragments */
2510
    /* Y plane */
2511
    i = 0;
2512
    for (y = s->fragment_height; y > 0; y--) {
2513
        for (x = 0; x < s->fragment_width; x++) {
2514
            s->all_fragments[i++].first_pixel = 
2515
                s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2516
                    s->golden_frame.linesize[0] +
2517
                    x * FRAGMENT_PIXELS;
2518
            debug_init("  fragment %d, first pixel @ %d\n", 
2519
                i-1, s->all_fragments[i-1].first_pixel);
2520
        }
2521
    }
2522
2523
    /* U plane */
2524
    i = s->u_fragment_start;
2525
    for (y = s->fragment_height / 2; y > 0; y--) {
2526
        for (x = 0; x < s->fragment_width / 2; x++) {
2527
            s->all_fragments[i++].first_pixel = 
2528
                s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2529
                    s->golden_frame.linesize[1] +
2530
                    x * FRAGMENT_PIXELS;
2531
            debug_init("  fragment %d, first pixel @ %d\n", 
2532
                i-1, s->all_fragments[i-1].first_pixel);
2533
        }
2534
    }
2535
2536
    /* V plane */
2537
    i = s->v_fragment_start;
2538
    for (y = s->fragment_height / 2; y > 0; y--) {
2539
        for (x = 0; x < s->fragment_width / 2; x++) {
2540
            s->all_fragments[i++].first_pixel = 
2541
                s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2542
                    s->golden_frame.linesize[2] +
2543
                    x * FRAGMENT_PIXELS;
2544
            debug_init("  fragment %d, first pixel @ %d\n", 
2545
                i-1, s->all_fragments[i-1].first_pixel);
2546
        }
2547
    }
2548
}
2549
2550
/*
2551
 * This is the ffmpeg/libavcodec API init function.
2552
 */
2553
static int vp3_decode_init(AVCodecContext *avctx)
2554
{
2555
    Vp3DecodeContext *s = avctx->priv_data;
2556
    int i;
2557 892fc83e Mike Melanson
    int c_width;
2558
    int c_height;
2559
    int y_superblock_count;
2560
    int c_superblock_count;
2561 d86053a4 Mike Melanson
2562
    s->avctx = avctx;
2563 642d7e84 Mike Melanson
#if 0
2564 d86053a4 Mike Melanson
    s->width = avctx->width;
2565
    s->height = avctx->height;
2566 642d7e84 Mike Melanson
#else
2567
    s->width = (avctx->width + 15) & 0xFFFFFFF0;
2568
    s->height = (avctx->height + 15) & 0xFFFFFFF0;
2569
#endif
2570 d86053a4 Mike Melanson
    avctx->pix_fmt = PIX_FMT_YUV420P;
2571
    avctx->has_b_frames = 0;
2572
    dsputil_init(&s->dsp, avctx);
2573
2574
    /* initialize to an impossible value which will force a recalculation
2575
     * in the first frame decode */
2576
    s->quality_index = -1;
2577
2578 892fc83e Mike Melanson
    s->y_superblock_width = (s->width + 31) / 32;
2579
    s->y_superblock_height = (s->height + 31) / 32;
2580
    y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2581
2582
    /* work out the dimensions for the C planes */
2583
    c_width = s->width / 2;
2584
    c_height = s->height / 2;
2585
    s->c_superblock_width = (c_width + 31) / 32;
2586
    s->c_superblock_height = (c_height + 31) / 32;
2587
    c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2588
2589
    s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2590
    s->u_superblock_start = y_superblock_count;
2591
    s->v_superblock_start = s->u_superblock_start + c_superblock_count;
2592 d86053a4 Mike Melanson
    s->superblock_coding = av_malloc(s->superblock_count);
2593
2594
    s->macroblock_width = (s->width + 15) / 16;
2595
    s->macroblock_height = (s->height + 15) / 16;
2596
    s->macroblock_count = s->macroblock_width * s->macroblock_height;
2597
2598
    s->fragment_width = s->width / FRAGMENT_PIXELS;
2599
    s->fragment_height = s->height / FRAGMENT_PIXELS;
2600
2601
    /* fragment count covers all 8x8 blocks for all 3 planes */
2602
    s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2603
    s->u_fragment_start = s->fragment_width * s->fragment_height;
2604
    s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2605
2606 892fc83e Mike Melanson
    debug_init("  Y plane: %d x %d\n", s->width, s->height);
2607
    debug_init("  C plane: %d x %d\n", c_width, c_height);
2608
    debug_init("  Y superblocks: %d x %d, %d total\n",
2609
        s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2610
    debug_init("  C superblocks: %d x %d, %d total\n",
2611
        s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2612
    debug_init("  total superblocks = %d, U starts @ %d, V starts @ %d\n", 
2613
        s->superblock_count, s->u_superblock_start, s->v_superblock_start);
2614 d86053a4 Mike Melanson
    debug_init("  macroblocks: %d x %d, %d total\n",
2615
        s->macroblock_width, s->macroblock_height, s->macroblock_count);
2616
    debug_init("  %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2617
        s->fragment_count,
2618
        s->fragment_width,
2619
        s->fragment_height,
2620
        s->u_fragment_start,
2621
        s->v_fragment_start);
2622
2623
    s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
2624
    s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2625
    s->pixel_addresses_inited = 0;
2626
2627 f44ee2c3 Alex Beregszaszi
    if (!s->theora_tables)
2628
    {
2629
        for (i = 0; i < 64; i++)
2630
            s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2631
        for (i = 0; i < 64; i++)
2632
            s->coded_quality_threshold[i] = vp31_quality_threshold[i];
2633
        for (i = 0; i < 64; i++)
2634
            s->coded_intra_y_dequant[i] = vp31_intra_y_dequant[i];
2635
        for (i = 0; i < 64; i++)
2636
            s->coded_intra_c_dequant[i] = vp31_intra_c_dequant[i];
2637
        for (i = 0; i < 64; i++)
2638
            s->coded_inter_dequant[i] = vp31_inter_dequant[i];
2639
    }
2640
2641 d86053a4 Mike Melanson
    /* init VLC tables */
2642
    for (i = 0; i < 16; i++) {
2643
2644 96a7e73b Mike Melanson
        /* DC histograms */
2645 d86053a4 Mike Melanson
        init_vlc(&s->dc_vlc[i], 5, 32,
2646
            &dc_bias[i][0][1], 4, 2,
2647
            &dc_bias[i][0][0], 4, 2);
2648
2649 a466e345 Mike Melanson
        /* group 1 AC histograms */
2650 d86053a4 Mike Melanson
        init_vlc(&s->ac_vlc_1[i], 5, 32,
2651
            &ac_bias_0[i][0][1], 4, 2,
2652
            &ac_bias_0[i][0][0], 4, 2);
2653
2654 a466e345 Mike Melanson
        /* group 2 AC histograms */
2655 d86053a4 Mike Melanson
        init_vlc(&s->ac_vlc_2[i], 5, 32,
2656
            &ac_bias_1[i][0][1], 4, 2,
2657
            &ac_bias_1[i][0][0], 4, 2);
2658
2659 a466e345 Mike Melanson
        /* group 3 AC histograms */
2660 d86053a4 Mike Melanson
        init_vlc(&s->ac_vlc_3[i], 5, 32,
2661
            &ac_bias_2[i][0][1], 4, 2,
2662
            &ac_bias_2[i][0][0], 4, 2);
2663
2664 a466e345 Mike Melanson
        /* group 4 AC histograms */
2665 d86053a4 Mike Melanson
        init_vlc(&s->ac_vlc_4[i], 5, 32,
2666
            &ac_bias_3[i][0][1], 4, 2,
2667
            &ac_bias_3[i][0][0], 4, 2);
2668
    }
2669
2670 96a7e73b Mike Melanson
    /* build quantization zigzag table */
2671 d86053a4 Mike Melanson
    for (i = 0; i < 64; i++)
2672 463d086b Mike Melanson
        zigzag_index[dezigzag_index[i]] = i;
2673 d86053a4 Mike Melanson
2674
    /* work out the block mapping tables */
2675
    s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2676
    s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2677
    s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
2678 96a7e73b Mike Melanson
    s->macroblock_coding = av_malloc(s->macroblock_count + 1);
2679 d86053a4 Mike Melanson
    init_block_mapping(s);
2680
2681 44ae98dd Mike Melanson
    for (i = 0; i < 3; i++) {
2682
        s->current_frame.data[i] = NULL;
2683
        s->last_frame.data[i] = NULL;
2684
        s->golden_frame.data[i] = NULL;
2685 61873c4a Mike Melanson
    }
2686
2687 d86053a4 Mike Melanson
    return 0;
2688
}
2689
2690
/*
2691
 * This is the ffmpeg/libavcodec API frame decode function.
2692
 */
2693
static int vp3_decode_frame(AVCodecContext *avctx, 
2694
                            void *data, int *data_size,
2695
                            uint8_t *buf, int buf_size)
2696
{
2697
    Vp3DecodeContext *s = avctx->priv_data;
2698
    GetBitContext gb;
2699
    static int counter = 0;
2700
2701
    *data_size = 0;
2702
2703
    init_get_bits(&gb, buf, buf_size * 8);
2704 f44ee2c3 Alex Beregszaszi
    
2705
    if (s->theora && get_bits1(&gb))
2706
    {
2707 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "Theora: bad frame indicator\n");
2708 f44ee2c3 Alex Beregszaszi
        return -1;
2709
    }
2710 d86053a4 Mike Melanson
2711 f44ee2c3 Alex Beregszaszi
    s->keyframe = !get_bits1(&gb);
2712
    if (s->theora && s->keyframe)
2713
    {
2714
        if (get_bits1(&gb))
2715 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "Theora: warning, unsupported keyframe coding type?!\n");
2716 f44ee2c3 Alex Beregszaszi
        skip_bits(&gb, 2); /* reserved? */
2717
    }
2718
    else
2719
        skip_bits(&gb, 1);
2720 d86053a4 Mike Melanson
    s->last_quality_index = s->quality_index;
2721
    s->quality_index = get_bits(&gb, 6);
2722
2723 f44ee2c3 Alex Beregszaszi
    debug_vp3(" VP3 %sframe #%d: Q index = %d\n",
2724
        s->keyframe?"key":"", counter, s->quality_index);
2725 d86053a4 Mike Melanson
    counter++;
2726
2727 642d7e84 Mike Melanson
    if (s->quality_index != s->last_quality_index)
2728
        init_dequantizer(s);
2729
2730 d86053a4 Mike Melanson
    if (s->keyframe) {
2731 22493ab9 Mike Melanson
        /* skip the other 2 header bytes for now */
2732 f44ee2c3 Alex Beregszaszi
        if (!s->theora) skip_bits(&gb, 16);
2733 74c0ac12 Mike Melanson
        if (s->last_frame.data[0] == s->golden_frame.data[0]) {
2734
            if (s->golden_frame.data[0])
2735
                avctx->release_buffer(avctx, &s->golden_frame);
2736 8e39d4a7 Michael Niedermayer
            s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
2737 74c0ac12 Mike Melanson
        } else {
2738
            if (s->golden_frame.data[0])
2739
                avctx->release_buffer(avctx, &s->golden_frame);
2740
            if (s->last_frame.data[0])
2741
                avctx->release_buffer(avctx, &s->last_frame);
2742
        }
2743 d86053a4 Mike Melanson
2744 8e39d4a7 Michael Niedermayer
        s->golden_frame.reference = 3;
2745 d86053a4 Mike Melanson
        if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
2746 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2747 d86053a4 Mike Melanson
            return -1;
2748
        }
2749
2750
        /* golden frame is also the current frame */
2751 61873c4a Mike Melanson
        memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
2752 d86053a4 Mike Melanson
2753
        /* time to figure out pixel addresses? */
2754
        if (!s->pixel_addresses_inited)
2755
            vp3_calculate_pixel_addresses(s);
2756
2757
    } else {
2758
        /* allocate a new current frame */
2759 8e39d4a7 Michael Niedermayer
        s->current_frame.reference = 3;
2760 d86053a4 Mike Melanson
        if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
2761 9b879566 Michel Bardiaux
            av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
2762 d86053a4 Mike Melanson
            return -1;
2763
        }
2764
    }
2765
2766 b928ec64 Michael Niedermayer
    s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
2767
    s->current_frame.qstride= 0;
2768
2769 d86053a4 Mike Melanson
    init_frame(s, &gb);
2770
2771 892fc83e Mike Melanson
#if KEYFRAMES_ONLY
2772
if (!s->keyframe) {
2773
2774
    memcpy(s->current_frame.data[0], s->golden_frame.data[0],
2775
        s->current_frame.linesize[0] * s->height);
2776
    memcpy(s->current_frame.data[1], s->golden_frame.data[1],
2777
        s->current_frame.linesize[1] * s->height / 2);
2778
    memcpy(s->current_frame.data[2], s->golden_frame.data[2],
2779
        s->current_frame.linesize[2] * s->height / 2);
2780
2781
} else {
2782
#endif
2783
2784
    if (unpack_superblocks(s, &gb) ||
2785
        unpack_modes(s, &gb) ||
2786
        unpack_vectors(s, &gb) ||
2787
        unpack_dct_coeffs(s, &gb)) {
2788
2789 9b879566 Michel Bardiaux
        av_log(s->avctx, AV_LOG_ERROR, "  vp3: could not decode frame\n");
2790 892fc83e Mike Melanson
        return -1;
2791
    }
2792 d86053a4 Mike Melanson
2793
    reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
2794 44ae98dd Mike Melanson
    render_fragments(s, 0, s->width, s->height, 0);
2795 3d32b429 Mike Melanson
2796
    if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
2797
        reverse_dc_prediction(s, s->u_fragment_start,
2798
            s->fragment_width / 2, s->fragment_height / 2);
2799
        reverse_dc_prediction(s, s->v_fragment_start,
2800
            s->fragment_width / 2, s->fragment_height / 2);
2801
        render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
2802
        render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
2803
    } else {
2804
        memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
2805
        memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
2806
    }
2807 d86053a4 Mike Melanson
2808 892fc83e Mike Melanson
#if KEYFRAMES_ONLY
2809
}
2810
#endif
2811
2812 d86053a4 Mike Melanson
    *data_size=sizeof(AVFrame);
2813
    *(AVFrame*)data= s->current_frame;
2814
2815 44ae98dd Mike Melanson
    /* release the last frame, if it is allocated and if it is not the
2816
     * golden frame */
2817
    if ((s->last_frame.data[0]) &&
2818
        (s->last_frame.data[0] != s->golden_frame.data[0]))
2819
        avctx->release_buffer(avctx, &s->last_frame);
2820 d86053a4 Mike Melanson
2821 61873c4a Mike Melanson
    /* shuffle frames (last = current) */
2822
    memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));
2823 8e39d4a7 Michael Niedermayer
    s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
2824 d86053a4 Mike Melanson
2825
    return buf_size;
2826
}
2827
2828
/*
2829
 * This is the ffmpeg/libavcodec API module cleanup function.
2830
 */
2831
static int vp3_decode_end(AVCodecContext *avctx)
2832
{
2833
    Vp3DecodeContext *s = avctx->priv_data;
2834
2835
    av_free(s->all_fragments);
2836
    av_free(s->coded_fragment_list);
2837
    av_free(s->superblock_fragments);
2838
    av_free(s->superblock_macroblocks);
2839
    av_free(s->macroblock_fragments);
2840 96a7e73b Mike Melanson
    av_free(s->macroblock_coding);
2841 8e39d4a7 Michael Niedermayer
    
2842 d86053a4 Mike Melanson
    /* release all frames */
2843 8e39d4a7 Michael Niedermayer
    if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
2844 892fc83e Mike Melanson
        avctx->release_buffer(avctx, &s->golden_frame);
2845
    if (s->last_frame.data[0])
2846
        avctx->release_buffer(avctx, &s->last_frame);
2847
    /* no need to release the current_frame since it will always be pointing
2848
     * to the same frame as either the golden or last frame */
2849 d86053a4 Mike Melanson
2850
    return 0;
2851
}
2852
2853 f44ee2c3 Alex Beregszaszi
/* current version is 3.2.0 */
2854
2855
static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
2856
{
2857
    Vp3DecodeContext *s = avctx->priv_data;
2858
2859
    skip_bits(&gb, 8); /* version major */
2860
    skip_bits(&gb, 8); /* version minor */
2861
    skip_bits(&gb, 8); /* version micro */
2862
    
2863
    s->width = get_bits(&gb, 16) << 4;
2864
    s->height = get_bits(&gb, 16) << 4;
2865
    
2866
    skip_bits(&gb, 24); /* frame width */
2867
    skip_bits(&gb, 24); /* frame height */
2868
2869
    skip_bits(&gb, 8); /* offset x */
2870
    skip_bits(&gb, 8); /* offset y */
2871
2872
    skip_bits(&gb, 32); /* fps numerator */
2873
    skip_bits(&gb, 32); /* fps denumerator */
2874
    skip_bits(&gb, 24); /* aspect numerator */
2875
    skip_bits(&gb, 24); /* aspect denumerator */
2876
    
2877
    skip_bits(&gb, 5); /* keyframe frequency force */
2878
    skip_bits(&gb, 8); /* colorspace */
2879
    skip_bits(&gb, 24); /* bitrate */
2880
2881
    skip_bits(&gb, 6); /* last(?) quality index */
2882
    
2883
//    align_get_bits(&gb);
2884
    
2885
    avctx->width = s->width;
2886
    avctx->height = s->height;
2887
2888
    vp3_decode_init(avctx);
2889
2890
    return 0;
2891
}
2892
2893 91381201 Alex Beregszaszi
static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb)
2894
{
2895
    int nb_comments, i, tmp;
2896
2897
    tmp = get_bits(&gb, 32);
2898
    while(tmp-=8)
2899
        skip_bits(&gb, 8);
2900
2901
    nb_comments = get_bits(&gb, 32);
2902
    for (i = 0; i < nb_comments; i++)
2903
    {
2904
        tmp = get_bits(&gb, 32);
2905
        while(tmp-=8)
2906
            skip_bits(&gb, 8);
2907
    }
2908
    
2909
    return 0;
2910
}
2911
2912 f44ee2c3 Alex Beregszaszi
static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb)
2913
{
2914
    Vp3DecodeContext *s = avctx->priv_data;
2915
    int i;
2916
    
2917
    /* quality threshold table */
2918
    for (i = 0; i < 64; i++)
2919
        s->coded_quality_threshold[i] = get_bits(&gb, 16);
2920
2921
    /* dc scale factor table */
2922
    for (i = 0; i < 64; i++)
2923
        s->coded_dc_scale_factor[i] = get_bits(&gb, 16);
2924
2925
    /* y coeffs */
2926
    for (i = 0; i < 64; i++)
2927
        s->coded_intra_y_dequant[i] = get_bits(&gb, 8);
2928
2929
    /* uv coeffs */
2930
    for (i = 0; i < 64; i++)
2931
        s->coded_intra_c_dequant[i] = get_bits(&gb, 8);
2932
2933
    /* inter coeffs */
2934
    for (i = 0; i < 64; i++)
2935
        s->coded_inter_dequant[i] = get_bits(&gb, 8);
2936
    
2937
    s->theora_tables = 1;
2938
    
2939
    return 0;
2940
}
2941
2942
static int theora_decode_init(AVCodecContext *avctx)
2943
{
2944
    Vp3DecodeContext *s = avctx->priv_data;
2945
    GetBitContext gb;
2946
    int ptype;
2947
    
2948
    s->theora = 1;
2949
2950
    if (!avctx->extradata_size)
2951
        return -1;
2952
2953
    init_get_bits(&gb, avctx->extradata, avctx->extradata_size);
2954
2955
    ptype = get_bits(&gb, 8);
2956
    debug_vp3("Theora headerpacket type: %x\n", ptype);
2957
            
2958
    if (!(ptype & 0x80))
2959
        return -1;
2960
        
2961
    skip_bits(&gb, 6*8); /* "theora" */
2962
        
2963
    switch(ptype)
2964
    {
2965
        case 0x80:
2966
            theora_decode_header(avctx, gb);
2967
            vp3_decode_init(avctx);
2968
                break;
2969
        case 0x81:
2970 91381201 Alex Beregszaszi
            theora_decode_comments(avctx, gb);
2971 f44ee2c3 Alex Beregszaszi
            break;
2972
        case 0x82:
2973
            theora_decode_tables(avctx, gb);
2974
            break;
2975
    }
2976
2977
    return 0;
2978
}
2979
2980 d86053a4 Mike Melanson
AVCodec vp3_decoder = {
2981
    "vp3",
2982
    CODEC_TYPE_VIDEO,
2983
    CODEC_ID_VP3,
2984
    sizeof(Vp3DecodeContext),
2985
    vp3_decode_init,
2986
    NULL,
2987
    vp3_decode_end,
2988
    vp3_decode_frame,
2989
    0,
2990
    NULL
2991
};
2992 f44ee2c3 Alex Beregszaszi
2993
AVCodec theora_decoder = {
2994
    "theora",
2995
    CODEC_TYPE_VIDEO,
2996
    CODEC_ID_THEORA,
2997
    sizeof(Vp3DecodeContext),
2998
    theora_decode_init,
2999
    NULL,
3000
    vp3_decode_end,
3001
    vp3_decode_frame,
3002
    0,
3003
    NULL
3004
};