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