render by the slice rather than the plane
[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
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
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
45/*
46 * Debugging Variables
47 *
48 * Define one or more of the following compile-time variables to 1 to obtain
49 * elaborate information about certain aspects of the decoding process.
50 *
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
d86053a4
MM
66#define DEBUG_VP3 0
67#define DEBUG_INIT 0
68#define DEBUG_DEQUANTIZERS 0
69#define DEBUG_BLOCK_CODING 0
70#define DEBUG_MODES 0
71#define DEBUG_VECTORS 0
72#define DEBUG_TOKEN 0
73#define DEBUG_VLC 0
74#define DEBUG_DC_PRED 0
75#define DEBUG_IDCT 0
76
77#if DEBUG_VP3
78#define debug_vp3 printf
79#else
80static inline void debug_vp3(const char *format, ...) { }
81#endif
82
83#if DEBUG_INIT
84#define debug_init printf
85#else
86static inline void debug_init(const char *format, ...) { }
87#endif
88
89#if DEBUG_DEQUANTIZERS
90#define debug_dequantizers printf
91#else
92static inline void debug_dequantizers(const char *format, ...) { }
93#endif
94
95#if DEBUG_BLOCK_CODING
96#define debug_block_coding printf
97#else
98static inline void debug_block_coding(const char *format, ...) { }
99#endif
100
101#if DEBUG_MODES
102#define debug_modes printf
103#else
104static inline void debug_modes(const char *format, ...) { }
105#endif
106
107#if DEBUG_VECTORS
108#define debug_vectors printf
109#else
110static inline void debug_vectors(const char *format, ...) { }
111#endif
112
113#if DEBUG_TOKEN
114#define debug_token printf
115#else
116static inline void debug_token(const char *format, ...) { }
117#endif
118
119#if DEBUG_VLC
120#define debug_vlc printf
121#else
122static inline void debug_vlc(const char *format, ...) { }
123#endif
124
125#if DEBUG_DC_PRED
126#define debug_dc_pred printf
127#else
128static inline void debug_dc_pred(const char *format, ...) { }
129#endif
130
131#if DEBUG_IDCT
132#define debug_idct printf
133#else
134static inline void debug_idct(const char *format, ...) { }
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 */
181 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
182 MODE_INTER_PLUS_MV, MODE_INTER_NO_MV,
183 MODE_INTRA, MODE_USING_GOLDEN,
184 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
185
186 /* scheme 2 */
187 { MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
188 MODE_INTER_NO_MV, MODE_INTER_PLUS_MV,
189 MODE_INTRA, MODE_USING_GOLDEN,
190 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
191
192 /* scheme 3 */
193 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
194 MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
195 MODE_INTRA, MODE_USING_GOLDEN,
196 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
197
198 /* scheme 4 */
199 { MODE_INTER_LAST_MV, MODE_INTER_PLUS_MV,
200 MODE_INTER_NO_MV, MODE_INTER_PRIOR_LAST,
201 MODE_INTRA, MODE_USING_GOLDEN,
202 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
203
204 /* scheme 5: No motion vector dominates */
205 { MODE_INTER_NO_MV, MODE_INTER_LAST_MV,
206 MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
207 MODE_INTRA, MODE_USING_GOLDEN,
208 MODE_GOLDEN_MV, MODE_INTER_FOURMV },
209
210 /* scheme 6 */
211 { MODE_INTER_NO_MV, MODE_USING_GOLDEN,
212 MODE_INTER_LAST_MV, MODE_INTER_PRIOR_LAST,
213 MODE_INTER_PLUS_MV, MODE_INTRA,
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;
f44ee2c3 259
36af0c95
MN
260 ScanTable scantable;
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 */
288 int16_t __align16 intra_y_dequant[64];
289 int16_t __align16 intra_c_dequant[64];
290 int16_t __align16 inter_dequant[64];
d86053a4
MM
291
292 /* This table contains superblock_count * 16 entries. Each set of 16
293 * numbers corresponds to the fragment indices 0..15 of the superblock.
294 * An entry will be -1 to indicate that no entry corresponds to that
295 * index. */
296 int *superblock_fragments;
297
298 /* This table contains superblock_count * 4 entries. Each set of 4
299 * numbers corresponds to the macroblock indices 0..3 of the superblock.
300 * An entry will be -1 to indicate that no entry corresponds to that
301 * index. */
302 int *superblock_macroblocks;
303
304 /* This table contains macroblock_count * 6 entries. Each set of 6
305 * numbers corresponds to the fragment indices 0..5 which comprise
306 * the macroblock (4 Y fragments and 2 C fragments). */
307 int *macroblock_fragments;
74c0ac12
MM
308 /* This is an array that indicates how a particular macroblock
309 * is coded. */
96a7e73b 310 unsigned char *macroblock_coding;
d86053a4 311
04331882
MM
312 int first_coded_y_fragment;
313 int first_coded_c_fragment;
314 int last_coded_y_fragment;
315 int last_coded_c_fragment;
316
a2f11b3c 317 uint8_t edge_emu_buffer[9*2048]; //FIXME dynamic alloc
b928ec64 318 uint8_t qscale_table[2048]; //FIXME dynamic alloc (width+15)/16
39922395
MM
319
320 /* Huffman decode */
321 int hti;
322 unsigned int hbits;
323 int entries;
324 int huff_code_size;
325 uint16_t huffman_table[80][32][2];
d86053a4
MM
326} Vp3DecodeContext;
327
3c3f113e
AB
328static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb);
329static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb);
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 */
892fc83e 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] = {
362 1, 1, 0, -1,
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;
892fc83e
MM
438 superblock_row_inc = 3 * s->fragment_width -
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;
892fc83e
MM
452 superblock_row_inc = 3 * (s->fragment_width / 2) -
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;
892fc83e
MM
466 superblock_row_inc = 3 * (s->fragment_width / 2) -
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;
892fc83e
MM
494 debug_init(" mapping fragment %d to superblock %d, position %d (%d/%d x %d/%d)\n",
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;
892fc83e
MM
499 debug_init(" superblock %d, position %d has no fragment (%d/%d x %d/%d)\n",
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) {
575 s->all_fragments[current_fragment + s->fragment_width].macroblock =
576 current_macroblock;
577 s->macroblock_fragments[mapping_index++] =
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)) {
584 s->all_fragments[current_fragment + s->fragment_width + 1].macroblock =
585 current_macroblock;
586 s->macroblock_fragments[mapping_index++] =
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 */
593 c_fragment = s->u_fragment_start +
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
599 c_fragment = s->v_fragment_start +
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;
609 else
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/*
621 * This function unpacks a single token (which should be in the range 0..31)
622 * and returns a zero run (number of zero coefficients in current DCT matrix
623 * before next non-zero coefficient), the next DCT coefficient, and the
624 * number of consecutive, non-EOB'd DCT blocks to EOB.
625 */
626static void unpack_token(GetBitContext *gb, int token, int *zero_run,
627 DCTELEM *coeff, int *eob_run)
628{
629 int sign;
630
631 *zero_run = 0;
632 *eob_run = 0;
633 *coeff = 0;
634
635 debug_token(" vp3 token %d: ", token);
636 switch (token) {
637
638 case 0:
639 debug_token("DCT_EOB_TOKEN, EOB next block\n");
640 *eob_run = 1;
641 break;
642
643 case 1:
644 debug_token("DCT_EOB_PAIR_TOKEN, EOB next 2 blocks\n");
645 *eob_run = 2;
646 break;
647
648 case 2:
649 debug_token("DCT_EOB_TRIPLE_TOKEN, EOB next 3 blocks\n");
650 *eob_run = 3;
651 break;
652
653 case 3:
654 debug_token("DCT_REPEAT_RUN_TOKEN, ");
655 *eob_run = get_bits(gb, 2) + 4;
656 debug_token("EOB the next %d blocks\n", *eob_run);
657 break;
658
659 case 4:
660 debug_token("DCT_REPEAT_RUN2_TOKEN, ");
661 *eob_run = get_bits(gb, 3) + 8;
662 debug_token("EOB the next %d blocks\n", *eob_run);
663 break;
664
665 case 5:
666 debug_token("DCT_REPEAT_RUN3_TOKEN, ");
667 *eob_run = get_bits(gb, 4) + 16;
668 debug_token("EOB the next %d blocks\n", *eob_run);
669 break;
670
671 case 6:
672 debug_token("DCT_REPEAT_RUN4_TOKEN, ");
673 *eob_run = get_bits(gb, 12);
674 debug_token("EOB the next %d blocks\n", *eob_run);
675 break;
676
677 case 7:
678 debug_token("DCT_SHORT_ZRL_TOKEN, ");
679 /* note that this token actually indicates that (3 extra bits) + 1 0s
680 * should be output; this case specifies a run of (3 EBs) 0s and a
681 * coefficient of 0. */
682 *zero_run = get_bits(gb, 3);
683 *coeff = 0;
684 debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
685 break;
686
687 case 8:
688 debug_token("DCT_ZRL_TOKEN, ");
689 /* note that this token actually indicates that (6 extra bits) + 1 0s
690 * should be output; this case specifies a run of (6 EBs) 0s and a
691 * coefficient of 0. */
692 *zero_run = get_bits(gb, 6);
693 *coeff = 0;
694 debug_token("skip the next %d positions in output matrix\n", *zero_run + 1);
695 break;
696
697 case 9:
698 debug_token("ONE_TOKEN, output 1\n");
699 *coeff = 1;
700 break;
701
702 case 10:
703 debug_token("MINUS_ONE_TOKEN, output -1\n");
704 *coeff = -1;
705 break;
706
707 case 11:
708 debug_token("TWO_TOKEN, output 2\n");
709 *coeff = 2;
710 break;
711
712 case 12:
713 debug_token("MINUS_TWO_TOKEN, output -2\n");
714 *coeff = -2;
715 break;
716
717 case 13:
718 case 14:
719 case 15:
720 case 16:
721 debug_token("LOW_VAL_TOKENS, ");
722 if (get_bits(gb, 1))
723 *coeff = -(3 + (token - 13));
724 else
725 *coeff = 3 + (token - 13);
726 debug_token("output %d\n", *coeff);
727 break;
728
729 case 17:
730 debug_token("DCT_VAL_CATEGORY3, ");
731 sign = get_bits(gb, 1);
732 *coeff = 7 + get_bits(gb, 1);
733 if (sign)
734 *coeff = -(*coeff);
735 debug_token("output %d\n", *coeff);
736 break;
737
738 case 18:
739 debug_token("DCT_VAL_CATEGORY4, ");
740 sign = get_bits(gb, 1);
741 *coeff = 9 + get_bits(gb, 2);
742 if (sign)
743 *coeff = -(*coeff);
744 debug_token("output %d\n", *coeff);
745 break;
746
747 case 19:
748 debug_token("DCT_VAL_CATEGORY5, ");
749 sign = get_bits(gb, 1);
750 *coeff = 13 + get_bits(gb, 3);
751 if (sign)
752 *coeff = -(*coeff);
753 debug_token("output %d\n", *coeff);
754 break;
755
756 case 20:
757 debug_token("DCT_VAL_CATEGORY6, ");
758 sign = get_bits(gb, 1);
759 *coeff = 21 + get_bits(gb, 4);
760 if (sign)
761 *coeff = -(*coeff);
762 debug_token("output %d\n", *coeff);
763 break;
764
765 case 21:
766 debug_token("DCT_VAL_CATEGORY7, ");
767 sign = get_bits(gb, 1);
768 *coeff = 37 + get_bits(gb, 5);
769 if (sign)
770 *coeff = -(*coeff);
771 debug_token("output %d\n", *coeff);
772 break;
773
774 case 22:
775 debug_token("DCT_VAL_CATEGORY8, ");
776 sign = get_bits(gb, 1);
777 *coeff = 69 + get_bits(gb, 9);
778 if (sign)
779 *coeff = -(*coeff);
780 debug_token("output %d\n", *coeff);
781 break;
782
783 case 23:
784 case 24:
785 case 25:
786 case 26:
787 case 27:
788 debug_token("DCT_RUN_CATEGORY1, ");
789 *zero_run = token - 22;
790 if (get_bits(gb, 1))
791 *coeff = -1;
792 else
793 *coeff = 1;
794 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
795 break;
796
797 case 28:
798 debug_token("DCT_RUN_CATEGORY1B, ");
799 if (get_bits(gb, 1))
800 *coeff = -1;
801 else
802 *coeff = 1;
803 *zero_run = 6 + get_bits(gb, 2);
804 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
805 break;
806
807 case 29:
808 debug_token("DCT_RUN_CATEGORY1C, ");
809 if (get_bits(gb, 1))
810 *coeff = -1;
811 else
812 *coeff = 1;
813 *zero_run = 10 + get_bits(gb, 3);
814 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
815 break;
816
817 case 30:
818 debug_token("DCT_RUN_CATEGORY2, ");
819 sign = get_bits(gb, 1);
820 *coeff = 2 + get_bits(gb, 1);
821 if (sign)
822 *coeff = -(*coeff);
823 *zero_run = 1;
824 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
825 break;
826
827 case 31:
828 debug_token("DCT_RUN_CATEGORY2, ");
829 sign = get_bits(gb, 1);
830 *coeff = 2 + get_bits(gb, 1);
831 if (sign)
832 *coeff = -(*coeff);
833 *zero_run = 2 + get_bits(gb, 1);
834 debug_token("output %d 0s, then %d\n", *zero_run, *coeff);
835 break;
836
837 default:
9b879566 838 av_log(NULL, AV_LOG_ERROR, " vp3: help! Got a bad token: %d > 31\n", token);
d86053a4
MM
839 break;
840
841 }
842}
843
844/*
845 * This function wipes out all of the fragment data.
846 */
847static void init_frame(Vp3DecodeContext *s, GetBitContext *gb)
848{
849 int i;
850
851 /* zero out all of the fragment information */
852 s->coded_fragment_list_index = 0;
853 for (i = 0; i < s->fragment_count; i++) {
d86053a4 854 s->all_fragments[i].coeff_count = 0;
7dc9ed11
MM
855 s->all_fragments[i].motion_x = 127;
856 s->all_fragments[i].motion_y = 127;
857 s->all_fragments[i].next_coeff= NULL;
7beddb12
MN
858 s->coeffs[i].index=
859 s->coeffs[i].coeff=0;
860 s->coeffs[i].next= NULL;
d86053a4
MM
861 }
862}
863
864/*
865 * This function sets of the dequantization tables used for a particular
866 * frame.
867 */
868static void init_dequantizer(Vp3DecodeContext *s)
869{
870
67335dbc 871 int ac_scale_factor = s->coded_ac_scale_factor[s->quality_index];
f44ee2c3 872 int dc_scale_factor = s->coded_dc_scale_factor[s->quality_index];
d86053a4
MM
873 int i, j;
874
875 debug_vp3(" vp3: initializing dequantization tables\n");
876
877 /*
878 * Scale dequantizers:
879 *
880 * quantizer * sf
881 * --------------
882 * 100
883 *
884 * where sf = dc_scale_factor for DC quantizer
67335dbc 885 * or ac_scale_factor for AC quantizer
d86053a4
MM
886 *
887 * Then, saturate the result to a lower limit of MIN_DEQUANT_VAL.
888 */
3d32b429 889#define SCALER 4
d86053a4
MM
890
891 /* scale DC quantizers */
f44ee2c3 892 s->intra_y_dequant[0] = s->coded_intra_y_dequant[0] * dc_scale_factor / 100;
d86053a4
MM
893 if (s->intra_y_dequant[0] < MIN_DEQUANT_VAL * 2)
894 s->intra_y_dequant[0] = MIN_DEQUANT_VAL * 2;
895 s->intra_y_dequant[0] *= SCALER;
896
f44ee2c3 897 s->intra_c_dequant[0] = s->coded_intra_c_dequant[0] * dc_scale_factor / 100;
d86053a4
MM
898 if (s->intra_c_dequant[0] < MIN_DEQUANT_VAL * 2)
899 s->intra_c_dequant[0] = MIN_DEQUANT_VAL * 2;
900 s->intra_c_dequant[0] *= SCALER;
901
f44ee2c3 902 s->inter_dequant[0] = s->coded_inter_dequant[0] * dc_scale_factor / 100;
d86053a4
MM
903 if (s->inter_dequant[0] < MIN_DEQUANT_VAL * 4)
904 s->inter_dequant[0] = MIN_DEQUANT_VAL * 4;
905 s->inter_dequant[0] *= SCALER;
906
907 /* scale AC quantizers, zigzag at the same time in preparation for
908 * the dequantization phase */
909 for (i = 1; i < 64; i++) {
36af0c95
MN
910 int k= s->scantable.scantable[i];
911 j = s->scantable.permutated[i];
d86053a4 912
36af0c95 913 s->intra_y_dequant[j] = s->coded_intra_y_dequant[k] * ac_scale_factor / 100;
d86053a4
MM
914 if (s->intra_y_dequant[j] < MIN_DEQUANT_VAL)
915 s->intra_y_dequant[j] = MIN_DEQUANT_VAL;
916 s->intra_y_dequant[j] *= SCALER;
917
36af0c95 918 s->intra_c_dequant[j] = s->coded_intra_c_dequant[k] * ac_scale_factor / 100;
d86053a4
MM
919 if (s->intra_c_dequant[j] < MIN_DEQUANT_VAL)
920 s->intra_c_dequant[j] = MIN_DEQUANT_VAL;
921 s->intra_c_dequant[j] *= SCALER;
922
36af0c95 923 s->inter_dequant[j] = s->coded_inter_dequant[k] * ac_scale_factor / 100;
d86053a4
MM
924 if (s->inter_dequant[j] < MIN_DEQUANT_VAL * 2)
925 s->inter_dequant[j] = MIN_DEQUANT_VAL * 2;
926 s->inter_dequant[j] *= SCALER;
927 }
b928ec64
MN
928
929 memset(s->qscale_table, (FFMAX(s->intra_y_dequant[1], s->intra_c_dequant[1])+8)/16, 512); //FIXME finetune
d86053a4
MM
930
931 /* print debug information as requested */
932 debug_dequantizers("intra Y dequantizers:\n");
933 for (i = 0; i < 8; i++) {
934 for (j = i * 8; j < i * 8 + 8; j++) {
935 debug_dequantizers(" %4d,", s->intra_y_dequant[j]);
936 }
937 debug_dequantizers("\n");
938 }
939 debug_dequantizers("\n");
940
941 debug_dequantizers("intra C dequantizers:\n");
942 for (i = 0; i < 8; i++) {
943 for (j = i * 8; j < i * 8 + 8; j++) {
944 debug_dequantizers(" %4d,", s->intra_c_dequant[j]);
945 }
946 debug_dequantizers("\n");
947 }
948 debug_dequantizers("\n");
949
950 debug_dequantizers("interframe dequantizers:\n");
951 for (i = 0; i < 8; i++) {
952 for (j = i * 8; j < i * 8 + 8; j++) {
953 debug_dequantizers(" %4d,", s->inter_dequant[j]);
954 }
955 debug_dequantizers("\n");
956 }
957 debug_dequantizers("\n");
958}
959
960/*
961 * This function is used to fetch runs of 1s or 0s from the bitstream for
962 * use in determining which superblocks are fully and partially coded.
963 *
964 * Codeword RunLength
965 * 0 1
966 * 10x 2-3
967 * 110x 4-5
968 * 1110xx 6-9
969 * 11110xxx 10-17
970 * 111110xxxx 18-33
971 * 111111xxxxxxxxxxxx 34-4129
972 */
973static int get_superblock_run_length(GetBitContext *gb)
974{
975
976 if (get_bits(gb, 1) == 0)
977 return 1;
978
979 else if (get_bits(gb, 1) == 0)
980 return (2 + get_bits(gb, 1));
981
982 else if (get_bits(gb, 1) == 0)
983 return (4 + get_bits(gb, 1));
984
985 else if (get_bits(gb, 1) == 0)
986 return (6 + get_bits(gb, 2));
987
988 else if (get_bits(gb, 1) == 0)
989 return (10 + get_bits(gb, 3));
990
991 else if (get_bits(gb, 1) == 0)
992 return (18 + get_bits(gb, 4));
993
994 else
995 return (34 + get_bits(gb, 12));
996
997}
998
999/*
1000 * This function is used to fetch runs of 1s or 0s from the bitstream for
1001 * use in determining which particular fragments are coded.
1002 *
1003 * Codeword RunLength
1004 * 0x 1-2
1005 * 10x 3-4
1006 * 110x 5-6
1007 * 1110xx 7-10
1008 * 11110xx 11-14
1009 * 11111xxxx 15-30
1010 */
1011static int get_fragment_run_length(GetBitContext *gb)
1012{
1013
1014 if (get_bits(gb, 1) == 0)
1015 return (1 + get_bits(gb, 1));
1016
1017 else if (get_bits(gb, 1) == 0)
1018 return (3 + get_bits(gb, 1));
1019
1020 else if (get_bits(gb, 1) == 0)
1021 return (5 + get_bits(gb, 1));
1022
1023 else if (get_bits(gb, 1) == 0)
1024 return (7 + get_bits(gb, 2));
1025
1026 else if (get_bits(gb, 1) == 0)
1027 return (11 + get_bits(gb, 2));
1028
1029 else
1030 return (15 + get_bits(gb, 4));
1031
1032}
1033
1034/*
1035 * This function decodes a VLC from the bitstream and returns a number
1036 * that ranges from 0..7. The number indicates which of the 8 coding
1037 * modes to use.
1038 *
1039 * VLC Number
1040 * 0 0
1041 * 10 1
1042 * 110 2
1043 * 1110 3
1044 * 11110 4
1045 * 111110 5
1046 * 1111110 6
1047 * 1111111 7
1048 *
1049 */
1050static int get_mode_code(GetBitContext *gb)
1051{
1052
1053 if (get_bits(gb, 1) == 0)
1054 return 0;
1055
1056 else if (get_bits(gb, 1) == 0)
1057 return 1;
1058
1059 else if (get_bits(gb, 1) == 0)
1060 return 2;
1061
1062 else if (get_bits(gb, 1) == 0)
1063 return 3;
1064
1065 else if (get_bits(gb, 1) == 0)
1066 return 4;
1067
1068 else if (get_bits(gb, 1) == 0)
1069 return 5;
1070
1071 else if (get_bits(gb, 1) == 0)
1072 return 6;
1073
1074 else
1075 return 7;
1076
1077}
1078
1079/*
1080 * This function extracts a motion vector from the bitstream using a VLC
1081 * scheme. 3 bits are fetched from the bitstream and 1 of 8 actions is
1082 * taken depending on the value on those 3 bits:
1083 *
1084 * 0: return 0
1085 * 1: return 1
1086 * 2: return -1
1087 * 3: if (next bit is 1) return -2, else return 2
1088 * 4: if (next bit is 1) return -3, else return 3
1089 * 5: return 4 + (next 2 bits), next bit is sign
1090 * 6: return 8 + (next 3 bits), next bit is sign
1091 * 7: return 16 + (next 4 bits), next bit is sign
1092 */
1093static int get_motion_vector_vlc(GetBitContext *gb)
1094{
1095 int bits;
1096
1097 bits = get_bits(gb, 3);
1098
1099 switch(bits) {
1100
1101 case 0:
1102 bits = 0;
1103 break;
1104
1105 case 1:
1106 bits = 1;
1107 break;
1108
1109 case 2:
1110 bits = -1;
1111 break;
1112
1113 case 3:
1114 if (get_bits(gb, 1) == 0)
1115 bits = 2;
1116 else
1117 bits = -2;
1118 break;
1119
1120 case 4:
1121 if (get_bits(gb, 1) == 0)
1122 bits = 3;
1123 else
1124 bits = -3;
1125 break;
1126
1127 case 5:
1128 bits = 4 + get_bits(gb, 2);
1129 if (get_bits(gb, 1) == 1)
1130 bits = -bits;
1131 break;
1132
1133 case 6:
1134 bits = 8 + get_bits(gb, 3);
1135 if (get_bits(gb, 1) == 1)
1136 bits = -bits;
1137 break;
1138
1139 case 7:
1140 bits = 16 + get_bits(gb, 4);
1141 if (get_bits(gb, 1) == 1)
1142 bits = -bits;
1143 break;
1144
1145 }
1146
1147 return bits;
1148}
1149
1150/*
1151 * This function fetches a 5-bit number from the stream followed by
1152 * a sign and calls it a motion vector.
1153 */
1154static int get_motion_vector_fixed(GetBitContext *gb)
1155{
1156
1157 int bits;
1158
1159 bits = get_bits(gb, 5);
1160
1161 if (get_bits(gb, 1) == 1)
1162 bits = -bits;
1163
1164 return bits;
1165}
1166
1167/*
1168 * This function unpacks all of the superblock/macroblock/fragment coding
1169 * information from the bitstream.
1170 */
892fc83e 1171static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
d86053a4
MM
1172{
1173 int bit = 0;
1174 int current_superblock = 0;
1175 int current_run = 0;
1176 int decode_fully_flags = 0;
1177 int decode_partial_blocks = 0;
22493ab9 1178 int first_c_fragment_seen;
d86053a4
MM
1179
1180 int i, j;
1181 int current_fragment;
1182
1183 debug_vp3(" vp3: unpacking superblock coding\n");
1184
1185 if (s->keyframe) {
1186
1187 debug_vp3(" keyframe-- all superblocks are fully coded\n");
1188 memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
1189
1190 } else {
1191
1192 /* unpack the list of partially-coded superblocks */
1193 bit = get_bits(gb, 1);
1194 /* toggle the bit because as soon as the first run length is
1195 * fetched the bit will be toggled again */
1196 bit ^= 1;
1197 while (current_superblock < s->superblock_count) {
b5da3635 1198 if (current_run-- == 0) {
d86053a4 1199 bit ^= 1;
d8278bab
MM
1200#if 1
1201 current_run = get_vlc2(gb,
b5da3635
MN
1202 s->superblock_run_length_vlc.table, 6, 2);
1203 if (current_run == 33)
d8278bab
MM
1204 current_run += get_bits(gb, 12);
1205#else
d86053a4 1206 current_run = get_superblock_run_length(gb);
d8278bab 1207#endif
d86053a4
MM
1208 debug_block_coding(" setting superblocks %d..%d to %s\n",
1209 current_superblock,
1210 current_superblock + current_run - 1,
1211 (bit) ? "partially coded" : "not coded");
1212
1213 /* if any of the superblocks are not partially coded, flag
1214 * a boolean to decode the list of fully-coded superblocks */
642d7e84 1215 if (bit == 0) {
d86053a4 1216 decode_fully_flags = 1;
642d7e84 1217 } else {
d86053a4 1218
642d7e84
MM
1219 /* make a note of the fact that there are partially coded
1220 * superblocks */
1221 decode_partial_blocks = 1;
1222 }
d86053a4 1223 }
b5da3635 1224 s->superblock_coding[current_superblock++] = bit;
d86053a4
MM
1225 }
1226
1227 /* unpack the list of fully coded superblocks if any of the blocks were
1228 * not marked as partially coded in the previous step */
1229 if (decode_fully_flags) {
1230
1231 current_superblock = 0;
1232 current_run = 0;
1233 bit = get_bits(gb, 1);
1234 /* toggle the bit because as soon as the first run length is
1235 * fetched the bit will be toggled again */
1236 bit ^= 1;
1237 while (current_superblock < s->superblock_count) {
1238
1239 /* skip any superblocks already marked as partially coded */
1240 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
1241
b5da3635 1242 if (current_run-- == 0) {
d86053a4 1243 bit ^= 1;
d8278bab
MM
1244#if 1
1245 current_run = get_vlc2(gb,
b5da3635
MN
1246 s->superblock_run_length_vlc.table, 6, 2);
1247 if (current_run == 33)
d8278bab
MM
1248 current_run += get_bits(gb, 12);
1249#else
d86053a4 1250 current_run = get_superblock_run_length(gb);
d8278bab 1251#endif
d86053a4
MM
1252 }
1253
1254 debug_block_coding(" setting superblock %d to %s\n",
1255 current_superblock,
1256 (bit) ? "fully coded" : "not coded");
b5da3635 1257 s->superblock_coding[current_superblock] = 2*bit;
d86053a4
MM
1258 }
1259 current_superblock++;
1260 }
1261 }
1262
1263 /* if there were partial blocks, initialize bitstream for
1264 * unpacking fragment codings */
1265 if (decode_partial_blocks) {
1266
1267 current_run = 0;
1268 bit = get_bits(gb, 1);
1269 /* toggle the bit because as soon as the first run length is
1270 * fetched the bit will be toggled again */
1271 bit ^= 1;
1272 }
1273 }
1274
1275 /* figure out which fragments are coded; iterate through each
1276 * superblock (all planes) */
1277 s->coded_fragment_list_index = 0;
7beddb12 1278 s->next_coeff= s->coeffs + s->fragment_count;
04331882
MM
1279 s->first_coded_y_fragment = s->first_coded_c_fragment = 0;
1280 s->last_coded_y_fragment = s->last_coded_c_fragment = -1;
22493ab9 1281 first_c_fragment_seen = 0;
96a7e73b 1282 memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
d86053a4
MM
1283 for (i = 0; i < s->superblock_count; i++) {
1284
1285 /* iterate through all 16 fragments in a superblock */
1286 for (j = 0; j < 16; j++) {
1287
1288 /* if the fragment is in bounds, check its coding status */
1289 current_fragment = s->superblock_fragments[i * 16 + j];
892fc83e 1290 if (current_fragment >= s->fragment_count) {
9b879566 1291 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_superblocks(): bad fragment number (%d >= %d)\n",
892fc83e
MM
1292 current_fragment, s->fragment_count);
1293 return 1;
1294 }
d86053a4
MM
1295 if (current_fragment != -1) {
1296 if (s->superblock_coding[i] == SB_NOT_CODED) {
1297
1298 /* copy all the fragments from the prior frame */
1299 s->all_fragments[current_fragment].coding_method =
1300 MODE_COPY;
1301
1302 } else if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
1303
1304 /* fragment may or may not be coded; this is the case
1305 * that cares about the fragment coding runs */
b5da3635 1306 if (current_run-- == 0) {
d86053a4 1307 bit ^= 1;
0ad72bdd
MM
1308#if 1
1309 current_run = get_vlc2(gb,
b5da3635 1310 s->fragment_run_length_vlc.table, 5, 2);
0ad72bdd 1311#else
d86053a4 1312 current_run = get_fragment_run_length(gb);
0ad72bdd 1313#endif
d86053a4
MM
1314 }
1315
1316 if (bit) {
22493ab9
MM
1317 /* default mode; actual mode will be decoded in
1318 * the next phase */
d86053a4
MM
1319 s->all_fragments[current_fragment].coding_method =
1320 MODE_INTER_NO_MV;
7beddb12 1321 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
04331882 1322 s->coded_fragment_list[s->coded_fragment_list_index] =
d86053a4 1323 current_fragment;
04331882 1324 if ((current_fragment >= s->u_fragment_start) &&
22493ab9
MM
1325 (s->last_coded_y_fragment == -1) &&
1326 (!first_c_fragment_seen)) {
04331882
MM
1327 s->first_coded_c_fragment = s->coded_fragment_list_index;
1328 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
22493ab9 1329 first_c_fragment_seen = 1;
04331882
MM
1330 }
1331 s->coded_fragment_list_index++;
96a7e73b 1332 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
d86053a4
MM
1333 debug_block_coding(" superblock %d is partially coded, fragment %d is coded\n",
1334 i, current_fragment);
1335 } else {
1336 /* not coded; copy this fragment from the prior frame */
1337 s->all_fragments[current_fragment].coding_method =
1338 MODE_COPY;
1339 debug_block_coding(" superblock %d is partially coded, fragment %d is not coded\n",
1340 i, current_fragment);
1341 }
1342
d86053a4
MM
1343 } else {
1344
1345 /* fragments are fully coded in this superblock; actual
1346 * coding will be determined in next step */
1347 s->all_fragments[current_fragment].coding_method =
1348 MODE_INTER_NO_MV;
7beddb12 1349 s->all_fragments[current_fragment].next_coeff= s->coeffs + current_fragment;
04331882 1350 s->coded_fragment_list[s->coded_fragment_list_index] =
d86053a4 1351 current_fragment;
04331882 1352 if ((current_fragment >= s->u_fragment_start) &&
22493ab9
MM
1353 (s->last_coded_y_fragment == -1) &&
1354 (!first_c_fragment_seen)) {
04331882
MM
1355 s->first_coded_c_fragment = s->coded_fragment_list_index;
1356 s->last_coded_y_fragment = s->first_coded_c_fragment - 1;
22493ab9 1357 first_c_fragment_seen = 1;
04331882
MM
1358 }
1359 s->coded_fragment_list_index++;
96a7e73b 1360 s->macroblock_coding[s->all_fragments[current_fragment].macroblock] = MODE_INTER_NO_MV;
d86053a4
MM
1361 debug_block_coding(" superblock %d is fully coded, fragment %d is coded\n",
1362 i, current_fragment);
1363 }
1364 }
1365 }
1366 }
04331882 1367
22493ab9
MM
1368 if (!first_c_fragment_seen)
1369 /* only Y fragments coded in this frame */
04331882 1370 s->last_coded_y_fragment = s->coded_fragment_list_index - 1;
22493ab9 1371 else
642d7e84 1372 /* end the list of coded C fragments */
04331882 1373 s->last_coded_c_fragment = s->coded_fragment_list_index - 1;
22493ab9 1374
04331882
MM
1375 debug_block_coding(" %d total coded fragments, y: %d -> %d, c: %d -> %d\n",
1376 s->coded_fragment_list_index,
1377 s->first_coded_y_fragment,
1378 s->last_coded_y_fragment,
1379 s->first_coded_c_fragment,
1380 s->last_coded_c_fragment);
892fc83e
MM
1381
1382 return 0;
d86053a4
MM
1383}
1384
1385/*
1386 * This function unpacks all the coding mode data for individual macroblocks
1387 * from the bitstream.
1388 */
892fc83e 1389static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
d86053a4
MM
1390{
1391 int i, j, k;
1392 int scheme;
1393 int current_macroblock;
1394 int current_fragment;
1395 int coding_mode;
1396
1397 debug_vp3(" vp3: unpacking encoding modes\n");
1398
1399 if (s->keyframe) {
1400 debug_vp3(" keyframe-- all blocks are coded as INTRA\n");
1401
1402 for (i = 0; i < s->fragment_count; i++)
1403 s->all_fragments[i].coding_method = MODE_INTRA;
1404
1405 } else {
1406
1407 /* fetch the mode coding scheme for this frame */
1408 scheme = get_bits(gb, 3);
1409 debug_modes(" using mode alphabet %d\n", scheme);
1410
1411 /* is it a custom coding scheme? */
1412 if (scheme == 0) {
1413 debug_modes(" custom mode alphabet ahead:\n");
1414 for (i = 0; i < 8; i++)
a466e345 1415 ModeAlphabet[scheme][get_bits(gb, 3)] = i;
d86053a4
MM
1416 }
1417
1418 for (i = 0; i < 8; i++)
1419 debug_modes(" mode[%d][%d] = %d\n", scheme, i,
1420 ModeAlphabet[scheme][i]);
1421
1422 /* iterate through all of the macroblocks that contain 1 or more
1423 * coded fragments */
1424 for (i = 0; i < s->u_superblock_start; i++) {
1425
1426 for (j = 0; j < 4; j++) {
1427 current_macroblock = s->superblock_macroblocks[i * 4 + j];
1428 if ((current_macroblock == -1) ||
96a7e73b 1429 (s->macroblock_coding[current_macroblock] == MODE_COPY))
d86053a4 1430 continue;
892fc83e 1431 if (current_macroblock >= s->macroblock_count) {
9b879566 1432 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad macroblock number (%d >= %d)\n",
892fc83e
MM
1433 current_macroblock, s->macroblock_count);
1434 return 1;
1435 }
d86053a4
MM
1436
1437 /* mode 7 means get 3 bits for each coding mode */
1438 if (scheme == 7)
1439 coding_mode = get_bits(gb, 3);
1440 else
0ad72bdd
MM
1441{
1442#if 1
1443 coding_mode = ModeAlphabet[scheme]
1444 [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
1445#else
d86053a4 1446 coding_mode = ModeAlphabet[scheme][get_mode_code(gb)];
0ad72bdd
MM
1447#endif
1448}
d86053a4 1449
96a7e73b 1450 s->macroblock_coding[current_macroblock] = coding_mode;
d86053a4
MM
1451 for (k = 0; k < 6; k++) {
1452 current_fragment =
1453 s->macroblock_fragments[current_macroblock * 6 + k];
892fc83e
MM
1454 if (current_fragment == -1)
1455 continue;
1456 if (current_fragment >= s->fragment_count) {
9b879566 1457 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_modes(): bad fragment number (%d >= %d)\n",
892fc83e
MM
1458 current_fragment, s->fragment_count);
1459 return 1;
1460 }
d86053a4
MM
1461 if (s->all_fragments[current_fragment].coding_method !=
1462 MODE_COPY)
1463 s->all_fragments[current_fragment].coding_method =
1464 coding_mode;
1465 }
1466
1467 debug_modes(" coding method for macroblock starting @ fragment %d = %d\n",
1468 s->macroblock_fragments[current_macroblock * 6], coding_mode);
1469 }
1470 }
1471 }
892fc83e
MM
1472
1473 return 0;
44ae98dd
MM
1474}
1475
1476/*
d86053a4
MM
1477 * This function unpacks all the motion vectors for the individual
1478 * macroblocks from the bitstream.
1479 */
892fc83e 1480static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
d86053a4
MM
1481{
1482 int i, j, k;
1483 int coding_mode;
1484 int motion_x[6];
1485 int motion_y[6];
1486 int last_motion_x = 0;
1487 int last_motion_y = 0;
1488 int prior_last_motion_x = 0;
1489 int prior_last_motion_y = 0;
1490 int current_macroblock;
1491 int current_fragment;
1492
1493 debug_vp3(" vp3: unpacking motion vectors\n");
d86053a4
MM
1494 if (s->keyframe) {
1495
1496 debug_vp3(" keyframe-- there are no motion vectors\n");
1497
1498 } else {
1499
1500 memset(motion_x, 0, 6 * sizeof(int));
1501 memset(motion_y, 0, 6 * sizeof(int));
1502
1503 /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
1504 coding_mode = get_bits(gb, 1);
1505 debug_vectors(" using %s scheme for unpacking motion vectors\n",
1506 (coding_mode == 0) ? "VLC" : "fixed-length");
1507
1508 /* iterate through all of the macroblocks that contain 1 or more
1509 * coded fragments */
1510 for (i = 0; i < s->u_superblock_start; i++) {
1511
1512 for (j = 0; j < 4; j++) {
1513 current_macroblock = s->superblock_macroblocks[i * 4 + j];
1514 if ((current_macroblock == -1) ||
96a7e73b 1515 (s->macroblock_coding[current_macroblock] == MODE_COPY))
d86053a4 1516 continue;
892fc83e 1517 if (current_macroblock >= s->macroblock_count) {
9b879566 1518 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad macroblock number (%d >= %d)\n",
892fc83e
MM
1519 current_macroblock, s->macroblock_count);
1520 return 1;
1521 }
d86053a4
MM
1522
1523 current_fragment = s->macroblock_fragments[current_macroblock * 6];
892fc83e 1524 if (current_fragment >= s->fragment_count) {
9b879566 1525 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d\n",
892fc83e
MM
1526 current_fragment, s->fragment_count);
1527 return 1;
1528 }
96a7e73b 1529 switch (s->macroblock_coding[current_macroblock]) {
d86053a4
MM
1530
1531 case MODE_INTER_PLUS_MV:
1532 case MODE_GOLDEN_MV:
1533 /* all 6 fragments use the same motion vector */
1534 if (coding_mode == 0) {
f4daf33e 1535#if 1
0ad72bdd
MM
1536 motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1537 motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1538#else
d86053a4
MM
1539 motion_x[0] = get_motion_vector_vlc(gb);
1540 motion_y[0] = get_motion_vector_vlc(gb);
0ad72bdd 1541#endif
d86053a4 1542 } else {
7f9926a4
MM
1543#if 1
1544 motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1545 motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
1546#else
d86053a4
MM
1547 motion_x[0] = get_motion_vector_fixed(gb);
1548 motion_y[0] = get_motion_vector_fixed(gb);
7f9926a4 1549#endif
d86053a4 1550 }
7f9926a4 1551
d86053a4
MM
1552 for (k = 1; k < 6; k++) {
1553 motion_x[k] = motion_x[0];
1554 motion_y[k] = motion_y[0];
1555 }
1556
1557 /* vector maintenance, only on MODE_INTER_PLUS_MV */
642d7e84 1558 if (s->macroblock_coding[current_macroblock] ==
d86053a4
MM
1559 MODE_INTER_PLUS_MV) {
1560 prior_last_motion_x = last_motion_x;
1561 prior_last_motion_y = last_motion_y;
1562 last_motion_x = motion_x[0];
1563 last_motion_y = motion_y[0];
1564 }
1565 break;
1566
1567 case MODE_INTER_FOURMV:
1568 /* fetch 4 vectors from the bitstream, one for each
1569 * Y fragment, then average for the C fragment vectors */
1570 motion_x[4] = motion_y[4] = 0;
1571 for (k = 0; k < 4; k++) {
1572 if (coding_mode == 0) {
f4daf33e
MM
1573#if 1
1574 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
1575 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
0ad72bdd 1576#else
d86053a4
MM
1577 motion_x[k] = get_motion_vector_vlc(gb);
1578 motion_y[k] = get_motion_vector_vlc(gb);
0ad72bdd 1579#endif
d86053a4 1580 } else {
7f9926a4
MM
1581#if 1
1582 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1583 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
1584#else
d86053a4
MM
1585 motion_x[k] = get_motion_vector_fixed(gb);
1586 motion_y[k] = get_motion_vector_fixed(gb);
7f9926a4 1587#endif
d86053a4
MM
1588 }
1589 motion_x[4] += motion_x[k];
1590 motion_y[4] += motion_y[k];
1591 }
1592
1593 if (motion_x[4] >= 0)
1594 motion_x[4] = (motion_x[4] + 2) / 4;
1595 else
1596 motion_x[4] = (motion_x[4] - 2) / 4;
1597 motion_x[5] = motion_x[4];
1598
1599 if (motion_y[4] >= 0)
1600 motion_y[4] = (motion_y[4] + 2) / 4;
1601 else
1602 motion_y[4] = (motion_y[4] - 2) / 4;
1603 motion_y[5] = motion_y[4];
1604
1605 /* vector maintenance; vector[3] is treated as the
1606 * last vector in this case */
1607 prior_last_motion_x = last_motion_x;
1608 prior_last_motion_y = last_motion_y;
1609 last_motion_x = motion_x[3];
1610 last_motion_y = motion_y[3];
1611 break;
1612
1613 case MODE_INTER_LAST_MV:
1614 /* all 6 fragments use the last motion vector */
1615 motion_x[0] = last_motion_x;
1616 motion_y[0] = last_motion_y;
1617 for (k = 1; k < 6; k++) {
1618 motion_x[k] = motion_x[0];
1619 motion_y[k] = motion_y[0];
1620 }
1621
1622 /* no vector maintenance (last vector remains the
1623 * last vector) */
1624 break;
1625
1626 case MODE_INTER_PRIOR_LAST:
1627 /* all 6 fragments use the motion vector prior to the
1628 * last motion vector */
1629 motion_x[0] = prior_last_motion_x;
1630 motion_y[0] = prior_last_motion_y;
1631 for (k = 1; k < 6; k++) {
1632 motion_x[k] = motion_x[0];
1633 motion_y[k] = motion_y[0];
1634 }
1635
1636 /* vector maintenance */
1637 prior_last_motion_x = last_motion_x;
1638 prior_last_motion_y = last_motion_y;
1639 last_motion_x = motion_x[0];
1640 last_motion_y = motion_y[0];
1641 break;
44ae98dd
MM
1642
1643 default:
1644 /* covers intra, inter without MV, golden without MV */
1645 memset(motion_x, 0, 6 * sizeof(int));
1646 memset(motion_y, 0, 6 * sizeof(int));
1647
1648 /* no vector maintenance */
1649 break;
d86053a4
MM
1650 }
1651
1652 /* assign the motion vectors to the correct fragments */
1653 debug_vectors(" vectors for macroblock starting @ fragment %d (coding method %d):\n",
1654 current_fragment,
642d7e84 1655 s->macroblock_coding[current_macroblock]);
d86053a4
MM
1656 for (k = 0; k < 6; k++) {
1657 current_fragment =
1658 s->macroblock_fragments[current_macroblock * 6 + k];
892fc83e
MM
1659 if (current_fragment == -1)
1660 continue;
1661 if (current_fragment >= s->fragment_count) {
9b879566 1662 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vectors(): bad fragment number (%d >= %d)\n",
892fc83e
MM
1663 current_fragment, s->fragment_count);
1664 return 1;
1665 }
d86053a4 1666 s->all_fragments[current_fragment].motion_x = motion_x[k];
44ae98dd 1667 s->all_fragments[current_fragment].motion_y = motion_y[k];
642d7e84
MM
1668 debug_vectors(" vector %d: fragment %d = (%d, %d)\n",
1669 k, current_fragment, motion_x[k], motion_y[k]);
d86053a4
MM
1670 }
1671 }
1672 }
1673 }
892fc83e
MM
1674
1675 return 0;
d86053a4
MM
1676}
1677
1678/*
1679 * This function is called by unpack_dct_coeffs() to extract the VLCs from
1680 * the bitstream. The VLCs encode tokens which are used to unpack DCT
1681 * data. This function unpacks all the VLCs for either the Y plane or both
1682 * C planes, and is called for DC coefficients or different AC coefficient
1683 * levels (since different coefficient types require different VLC tables.
1684 *
1685 * This function returns a residual eob run. E.g, if a particular token gave
1686 * instructions to EOB the next 5 fragments and there were only 2 fragments
1687 * left in the current fragment range, 3 would be returned so that it could
1688 * be passed into the next call to this same function.
1689 */
1690static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
1691 VLC *table, int coeff_index,
1692 int first_fragment, int last_fragment,
1693 int eob_run)
1694{
1695 int i;
1696 int token;
d3076955
MM
1697 int zero_run = 0;
1698 DCTELEM coeff = 0;
d86053a4 1699 Vp3Fragment *fragment;
36af0c95 1700 uint8_t *perm= s->scantable.permutated;
d3076955 1701 int bits_to_get;
d86053a4 1702
22493ab9 1703 if ((first_fragment >= s->fragment_count) ||
74c0ac12
MM
1704 (last_fragment >= s->fragment_count)) {
1705
9b879566 1706 av_log(s->avctx, AV_LOG_ERROR, " vp3:unpack_vlcs(): bad fragment number (%d -> %d ?)\n",
74c0ac12 1707 first_fragment, last_fragment);
22493ab9 1708 return 0;
74c0ac12
MM
1709 }
1710
04331882 1711 for (i = first_fragment; i <= last_fragment; i++) {
d86053a4
MM
1712
1713 fragment = &s->all_fragments[s->coded_fragment_list[i]];
1714 if (fragment->coeff_count > coeff_index)
1715 continue;
1716
1717 if (!eob_run) {
1718 /* decode a VLC into a token */
1719 token = get_vlc2(gb, table->table, 5, 3);
1720 debug_vlc(" token = %2d, ", token);
1721 /* use the token to get a zero run, a coefficient, and an eob run */
d3076955
MM
1722#if 1
1723 if (token <= 6) {
1724 eob_run = eob_run_base[token];
1725 if (eob_run_get_bits[token])
1726 eob_run += get_bits(gb, eob_run_get_bits[token]);
1727 coeff = zero_run = 0;
1728 } else {
1729 bits_to_get = coeff_get_bits[token];
1730 if (!bits_to_get)
1731 coeff = coeff_tables[token][0];
1732 else
1733 coeff = coeff_tables[token][get_bits(gb, bits_to_get)];
1734
1735 zero_run = zero_run_base[token];
1736 if (zero_run_get_bits[token])
1737 zero_run += get_bits(gb, zero_run_get_bits[token]);
1738 }
1739#else
d86053a4 1740 unpack_token(gb, token, &zero_run, &coeff, &eob_run);
d3076955 1741#endif
d86053a4
MM
1742 }
1743
1744 if (!eob_run) {
1745 fragment->coeff_count += zero_run;
7beddb12
MN
1746 if (fragment->coeff_count < 64){
1747 fragment->next_coeff->coeff= coeff;
1748 fragment->next_coeff->index= perm[fragment->coeff_count++]; //FIXME perm here already?
1749 fragment->next_coeff->next= s->next_coeff;
1750 s->next_coeff->next=NULL;
1751 fragment->next_coeff= s->next_coeff++;
1752 }
d86053a4 1753 debug_vlc(" fragment %d coeff = %d\n",
7beddb12 1754 s->coded_fragment_list[i], fragment->next_coeff[coeff_index]);
d86053a4 1755 } else {
7beddb12 1756 fragment->coeff_count |= 128;
d86053a4 1757 debug_vlc(" fragment %d eob with %d coefficients\n",
7beddb12 1758 s->coded_fragment_list[i], fragment->coeff_count&127);
d86053a4
MM
1759 eob_run--;
1760 }
1761 }
1762
1763 return eob_run;
1764}
1765
1766/*
1767 * This function unpacks all of the DCT coefficient data from the
1768 * bitstream.
1769 */
892fc83e 1770static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
d86053a4
MM
1771{
1772 int i;
1773 int dc_y_table;
1774 int dc_c_table;
1775 int ac_y_table;
1776 int ac_c_table;
1777 int residual_eob_run = 0;
1778
d86053a4
MM
1779 /* fetch the DC table indices */
1780 dc_y_table = get_bits(gb, 4);
1781 dc_c_table = get_bits(gb, 4);
1782
1783 /* unpack the Y plane DC coefficients */
1784 debug_vp3(" vp3: unpacking Y plane DC coefficients using table %d\n",
1785 dc_y_table);
1786 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
04331882 1787 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
d86053a4
MM
1788
1789 /* unpack the C plane DC coefficients */
1790 debug_vp3(" vp3: unpacking C plane DC coefficients using table %d\n",
1791 dc_c_table);
1792 residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
04331882 1793 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
d86053a4 1794
a466e345 1795 /* fetch the AC table indices */
d86053a4
MM
1796 ac_y_table = get_bits(gb, 4);
1797 ac_c_table = get_bits(gb, 4);
1798
a466e345 1799 /* unpack the group 1 AC coefficients (coeffs 1-5) */
d86053a4
MM
1800 for (i = 1; i <= 5; i++) {
1801
1802 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1803 i, ac_y_table);
1804 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_y_table], i,
04331882 1805 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
d86053a4
MM
1806
1807 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1808 i, ac_c_table);
1809 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_1[ac_c_table], i,
04331882 1810 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
d86053a4
MM
1811 }
1812
a466e345 1813 /* unpack the group 2 AC coefficients (coeffs 6-14) */
d86053a4
MM
1814 for (i = 6; i <= 14; i++) {
1815
1816 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1817 i, ac_y_table);
1818 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_y_table], i,
04331882 1819 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
d86053a4
MM
1820
1821 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1822 i, ac_c_table);
1823 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_2[ac_c_table], i,
04331882 1824 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
d86053a4
MM
1825 }
1826
a466e345 1827 /* unpack the group 3 AC coefficients (coeffs 15-27) */
d86053a4
MM
1828 for (i = 15; i <= 27; i++) {
1829
1830 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1831 i, ac_y_table);
1832 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_y_table], i,
04331882 1833 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
d86053a4
MM
1834
1835 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1836 i, ac_c_table);
1837 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_3[ac_c_table], i,
04331882 1838 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
d86053a4
MM
1839 }
1840
a466e345 1841 /* unpack the group 4 AC coefficients (coeffs 28-63) */
d86053a4
MM
1842 for (i = 28; i <= 63; i++) {
1843
1844 debug_vp3(" vp3: unpacking level %d Y plane AC coefficients using table %d\n",
1845 i, ac_y_table);
1846 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_y_table], i,
04331882 1847 s->first_coded_y_fragment, s->last_coded_y_fragment, residual_eob_run);
d86053a4
MM
1848
1849 debug_vp3(" vp3: unpacking level %d C plane AC coefficients using table %d\n",
1850 i, ac_c_table);
1851 residual_eob_run = unpack_vlcs(s, gb, &s->ac_vlc_4[ac_c_table], i,
04331882 1852 s->first_coded_c_fragment, s->last_coded_c_fragment, residual_eob_run);
d86053a4 1853 }
892fc83e
MM
1854
1855 return 0;
d86053a4
MM
1856}
1857
1858/*
1859 * This function reverses the DC prediction for each coded fragment in
1860 * the frame. Much of this function is adapted directly from the original
1861 * VP3 source code.
1862 */
1863#define COMPATIBLE_FRAME(x) \
1864 (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
1865#define FRAME_CODED(x) (s->all_fragments[x].coding_method != MODE_COPY)
7beddb12 1866#define DC_COEFF(u) (s->coeffs[u].index ? 0 : s->coeffs[u].coeff) //FIXME do somethin to simplify this
d86053a4
MM
1867static inline int iabs (int x) { return ((x < 0) ? -x : x); }
1868
1869static void reverse_dc_prediction(Vp3DecodeContext *s,
1870 int first_fragment,
1871 int fragment_width,
1872 int fragment_height)
1873{
1874
1875#define PUL 8
1876#define PU 4
1877#define PUR 2
1878#define PL 1
1879
1880 int x, y;
1881 int i = first_fragment;
1882
1883 /*
1884 * Fragment prediction groups:
1885 *
1886 * 32222222226
1887 * 10000000004
1888 * 10000000004
1889 * 10000000004
1890 * 10000000004
1891 *
1892 * Note: Groups 5 and 7 do not exist as it would mean that the
1893 * fragment's x coordinate is both 0 and (width - 1) at the same time.
1894 */
1895 int predictor_group;
1896 short predicted_dc;
1897
1898 /* validity flags for the left, up-left, up, and up-right fragments */
1899 int fl, ful, fu, fur;
1900
1901 /* DC values for the left, up-left, up, and up-right fragments */
1902 int vl, vul, vu, vur;
1903
1904 /* indices for the left, up-left, up, and up-right fragments */
1905 int l, ul, u, ur;
1906
1907 /*
1908 * The 6 fields mean:
1909 * 0: up-left multiplier
1910 * 1: up multiplier
1911 * 2: up-right multiplier
1912 * 3: left multiplier
1913 * 4: mask
1914 * 5: right bit shift divisor (e.g., 7 means >>=7, a.k.a. div by 128)
1915 */
1916 int predictor_transform[16][6] = {
1917 { 0, 0, 0, 0, 0, 0 },
1918 { 0, 0, 0, 1, 0, 0 }, // PL
1919 { 0, 0, 1, 0, 0, 0 }, // PUR
1920 { 0, 0, 53, 75, 127, 7 }, // PUR|PL
1921 { 0, 1, 0, 0, 0, 0 }, // PU
1922 { 0, 1, 0, 1, 1, 1 }, // PU|PL
1923 { 0, 1, 0, 0, 0, 0 }, // PU|PUR
1924 { 0, 0, 53, 75, 127, 7 }, // PU|PUR|PL
1925 { 1, 0, 0, 0, 0, 0 }, // PUL
1926 { 0, 0, 0, 1, 0, 0 }, // PUL|PL
1927 { 1, 0, 1, 0, 1, 1 }, // PUL|PUR
1928 { 0, 0, 53, 75, 127, 7 }, // PUL|PUR|PL
1929 { 0, 1, 0, 0, 0, 0 }, // PUL|PU
1930 {-26, 29, 0, 29, 31, 5 }, // PUL|PU|PL
1931 { 3, 10, 3, 0, 15, 4 }, // PUL|PU|PUR
1932 {-26, 29, 0, 29, 31, 5 } // PUL|PU|PUR|PL
1933 };
1934
1935 /* This table shows which types of blocks can use other blocks for
1936 * prediction. For example, INTRA is the only mode in this table to
1937 * have a frame number of 0. That means INTRA blocks can only predict
1938 * from other INTRA blocks. There are 2 golden frame coding types;
1939 * blocks encoding in these modes can only predict from other blocks
1940 * that were encoded with these 1 of these 2 modes. */
1941 unsigned char compatible_frame[8] = {
1942 1, /* MODE_INTER_NO_MV */
1943 0, /* MODE_INTRA */
1944 1, /* MODE_INTER_PLUS_MV */
1945 1, /* MODE_INTER_LAST_MV */
1946 1, /* MODE_INTER_PRIOR_MV */
1947 2, /* MODE_USING_GOLDEN */
1948 2, /* MODE_GOLDEN_MV */
1949 1 /* MODE_INTER_FOUR_MV */
1950 };
1951 int current_frame_type;
1952
1953 /* there is a last DC predictor for each of the 3 frame types */
1954 short last_dc[3];
1955
1956 int transform = 0;
1957
1958 debug_vp3(" vp3: reversing DC prediction\n");
1959
1960 vul = vu = vur = vl = 0;
1961 last_dc[0] = last_dc[1] = last_dc[2] = 0;
1962
1963 /* for each fragment row... */
1964 for (y = 0; y < fragment_height; y++) {
1965
1966 /* for each fragment in a row... */
1967 for (x = 0; x < fragment_width; x++, i++) {
1968
1969 /* reverse prediction if this block was coded */
1970 if (s->all_fragments[i].coding_method != MODE_COPY) {
1971
1972 current_frame_type =
1973 compatible_frame[s->all_fragments[i].coding_method];
1974 predictor_group = (x == 0) + ((y == 0) << 1) +
1975 ((x + 1 == fragment_width) << 2);
1976 debug_dc_pred(" frag %d: group %d, orig DC = %d, ",
7beddb12 1977 i, predictor_group, DC_COEFF(i));
d86053a4
MM
1978
1979 switch (predictor_group) {
1980
1981 case 0:
1982 /* main body of fragments; consider all 4 possible
1983 * fragments for prediction */
1984
1985 /* calculate the indices of the predicting fragments */
1986 ul = i - fragment_width - 1;
1987 u = i - fragment_width;
1988 ur = i - fragment_width + 1;
1989 l = i - 1;
1990
1991 /* fetch the DC values for the predicting fragments */
7beddb12
MN
1992 vul = DC_COEFF(ul);
1993 vu = DC_COEFF(u);
1994 vur = DC_COEFF(ur);
1995 vl = DC_COEFF(l);
d86053a4
MM
1996
1997 /* figure out which fragments are valid */
1998 ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
1999 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2000 fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2001 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2002
2003 /* decide which predictor transform to use */
2004 transform = (fl*PL) | (fu*PU) | (ful*PUL) | (fur*PUR);
2005
2006 break;
2007
2008 case 1:
2009 /* left column of fragments, not including top corner;
2010 * only consider up and up-right fragments */
2011
2012 /* calculate the indices of the predicting fragments */
2013 u = i - fragment_width;
2014 ur = i - fragment_width + 1;
2015
2016 /* fetch the DC values for the predicting fragments */
7beddb12
MN
2017 vu = DC_COEFF(u);
2018 vur = DC_COEFF(ur);
d86053a4
MM
2019
2020 /* figure out which fragments are valid */
2021 fur = FRAME_CODED(ur) && COMPATIBLE_FRAME(ur);
2022 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2023
2024 /* decide which predictor transform to use */
2025 transform = (fu*PU) | (fur*PUR);
2026
2027 break;
2028
2029 case 2:
2030 case 6:
2031 /* top row of fragments, not including top-left frag;
2032 * only consider the left fragment for prediction */
2033
2034 /* calculate the indices of the predicting fragments */
2035 l = i - 1;
2036
2037 /* fetch the DC values for the predicting fragments */
7beddb12 2038 vl = DC_COEFF(l);
d86053a4
MM
2039
2040 /* figure out which fragments are valid */
2041 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2042
2043 /* decide which predictor transform to use */
2044 transform = (fl*PL);
2045
2046 break;
2047
2048 case 3:
2049 /* top-left fragment */
2050
2051 /* nothing to predict from in this case */
2052 transform = 0;
2053
2054 break;
2055
2056 case 4:
2057 /* right column of fragments, not including top corner;
2058 * consider up-left, up, and left fragments for
2059 * prediction */
2060
2061 /* calculate the indices of the predicting fragments */
2062 ul = i - fragment_width - 1;
2063 u = i - fragment_width;
2064 l = i - 1;
2065
2066 /* fetch the DC values for the predicting fragments */
7beddb12
MN
2067 vul = DC_COEFF(ul);
2068 vu = DC_COEFF(u);
2069 vl = DC_COEFF(l);
d86053a4
MM
2070
2071 /* figure out which fragments are valid */
2072 ful = FRAME_CODED(ul) && COMPATIBLE_FRAME(ul);
2073 fu = FRAME_CODED(u) && COMPATIBLE_FRAME(u);
2074 fl = FRAME_CODED(l) && COMPATIBLE_FRAME(l);
2075
2076 /* decide which predictor transform to use */
2077 transform = (fl*PL) | (fu*PU) | (ful*PUL);
2078
2079 break;
2080
2081 }
2082
2083 debug_dc_pred("transform = %d, ", transform);
2084
2085 if (transform == 0) {
2086
2087 /* if there were no fragments to predict from, use last
2088 * DC saved */
7beddb12 2089 predicted_dc = last_dc[current_frame_type];
d86053a4 2090 debug_dc_pred("from last DC (%d) = %d\n",
7beddb12 2091 current_frame_type, DC_COEFF(i));
d86053a4
MM
2092
2093 } else {
2094
2095 /* apply the appropriate predictor transform */
2096 predicted_dc =
2097 (predictor_transform[transform][0] * vul) +
2098 (predictor_transform[transform][1] * vu) +
2099 (predictor_transform[transform][2] * vur) +
2100 (predictor_transform[transform][3] * vl);
2101
2102 /* if there is a shift value in the transform, add
2103 * the sign bit before the shift */
2104 if (predictor_transform[transform][5] != 0) {
2105 predicted_dc += ((predicted_dc >> 15) &
2106 predictor_transform[transform][4]);
2107 predicted_dc >>= predictor_transform[transform][5];
2108 }
2109
2110 /* check for outranging on the [ul u l] and
2111 * [ul u ur l] predictors */
2112 if ((transform == 13) || (transform == 15)) {
2113 if (iabs(predicted_dc - vu) > 128)
2114 predicted_dc = vu;
2115 else if (iabs(predicted_dc - vl) > 128)
2116 predicted_dc = vl;
2117 else if (iabs(predicted_dc - vul) > 128)
2118 predicted_dc = vul;
2119 }
2120
d86053a4 2121 debug_dc_pred("from pred DC = %d\n",
7beddb12 2122 DC_COEFF(i));
d86053a4
MM
2123 }
2124
7beddb12
MN
2125 /* at long last, apply the predictor */
2126 if(s->coeffs[i].index){
2127 *s->next_coeff= s->coeffs[i];
2128 s->coeffs[i].index=0;
2129 s->coeffs[i].coeff=0;
2130 s->coeffs[i].next= s->next_coeff++;
2131 }
2132 s->coeffs[i].coeff += predicted_dc;
d86053a4 2133 /* save the DC */
7beddb12
MN
2134 last_dc[current_frame_type] = DC_COEFF(i);
2135 if(DC_COEFF(i) && !(s->all_fragments[i].coeff_count&127)){
2136 s->all_fragments[i].coeff_count= 129;
2137// s->all_fragments[i].next_coeff= s->next_coeff;
2138 s->coeffs[i].next= s->next_coeff;
2139 (s->next_coeff++)->next=NULL;
2140 }
d86053a4
MM
2141 }
2142 }
2143 }
2144}
2145
2146/*
dc4b78d9
MM
2147 * Perform the final rendering for a particular slice of data.
2148 * The slice number ranges from 0..(macroblock_height - 1).
2149 */
2150static void render_slice(Vp3DecodeContext *s, int slice)
2151{
2152 int x, y;
2153 int m, n;
2154 int i; /* indicates current fragment */
2155 int16_t *dequantizer;
2156 DCTELEM __align16 block[64];
2157 unsigned char *output_plane;
2158 unsigned char *last_plane;
2159 unsigned char *golden_plane;
2160 int stride;
2161 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
2162 int upper_motion_limit, lower_motion_limit;
2163 int motion_halfpel_index;
2164 uint8_t *motion_source;
2165 int plane;
2166 int plane_width;
2167 int plane_height;
2168 int slice_height;
2169 int current_macroblock_entry = slice * s->macroblock_width * 6;
2170
2171 if (slice >= s->macroblock_height)
2172 return;
2173
2174 for (plane = 0; plane < 3; plane++) {
2175
2176 /* set up plane-specific parameters */
2177 if (plane == 0) {
2178 output_plane = s->current_frame.data[0];
2179 last_plane = s->last_frame.data[0];
2180 golden_plane = s->golden_frame.data[0];
2181 stride = s->current_frame.linesize[0];
2182 if (!s->flipped_image) stride = -stride;
2183 upper_motion_limit = 7 * s->current_frame.linesize[0];
2184 lower_motion_limit = s->height * s->current_frame.linesize[0] + s->width - 8;
2185 y = slice * FRAGMENT_PIXELS * 2;
2186 plane_width = s->width;
2187 plane_height = s->height;
2188 slice_height = y + FRAGMENT_PIXELS * 2;
2189 i = s->macroblock_fragments[current_macroblock_entry + 0];
2190 } else if (plane == 1) {
2191 output_plane = s->current_frame.data[1];
2192 last_plane = s->last_frame.data[1];
2193 golden_plane = s->golden_frame.data[1];
2194 stride = s->current_frame.linesize[1];
2195 if (!s->flipped_image) stride = -stride;
2196 upper_motion_limit = 7 * s->current_frame.linesize[1];
2197 lower_motion_limit = (s->height / 2) * s->current_frame.linesize[1] + (s->width / 2) - 8;
2198 y = slice * FRAGMENT_PIXELS;
2199 plane_width = s->width / 2;
2200 plane_height = s->height / 2;
2201 slice_height = y + FRAGMENT_PIXELS;
2202 i = s->macroblock_fragments[current_macroblock_entry + 4];
2203 } else {
2204 output_plane = s->current_frame.data[2];
2205 last_plane = s->last_frame.data[2];
2206 golden_plane = s->golden_frame.data[2];
2207 stride = s->current_frame.linesize[2];
2208 if (!s->flipped_image) stride = -stride;
2209 upper_motion_limit = 7 * s->current_frame.linesize[2];
2210 lower_motion_limit = (s->height / 2) * s->current_frame.linesize[2] + (s->width / 2) - 8;
2211 y = slice * FRAGMENT_PIXELS;
2212 plane_width = s->width / 2;
2213 plane_height = s->height / 2;
2214 slice_height = y + FRAGMENT_PIXELS;
2215 i = s->macroblock_fragments[current_macroblock_entry + 5];
2216 }
2217
2218 if(ABS(stride) > 2048)
2219 return; //various tables are fixed size
2220
2221 /* for each fragment row in the slice (both of them)... */
2222 for (; y < slice_height; y += 8) {
2223
2224 /* for each fragment in a row... */
2225 for (x = 0; x < plane_width; x += 8, i++) {
2226
2227 if ((i < 0) || (i >= s->fragment_count)) {
2228 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_slice(): bad fragment number (%d)\n", i);
2229 return;
2230 }
2231
2232 /* transform if this block was coded */
2233 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2234 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
2235
2236 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2237 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2238 motion_source= golden_plane;
2239 else
2240 motion_source= last_plane;
2241
2242 motion_source += s->all_fragments[i].first_pixel;
2243 motion_halfpel_index = 0;
2244
2245 /* sort out the motion vector if this fragment is coded
2246 * using a motion vector method */
2247 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2248 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
2249 int src_x, src_y;
2250 motion_x = s->all_fragments[i].motion_x;
2251 motion_y = s->all_fragments[i].motion_y;
2252 if(plane){
2253 motion_x= (motion_x>>1) | (motion_x&1);
2254 motion_y= (motion_y>>1) | (motion_y&1);
2255 }
2256
2257 src_x= (motion_x>>1) + x;
2258 src_y= (motion_y>>1) + y;
2259 if ((motion_x == 127) || (motion_y == 127))
2260 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
2261
2262 motion_halfpel_index = motion_x & 0x01;
2263 motion_source += (motion_x >> 1);
2264
2265 motion_halfpel_index |= (motion_y & 0x01) << 1;
2266 motion_source += ((motion_y >> 1) * stride);
2267
2268 if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){
2269 uint8_t *temp= s->edge_emu_buffer;
2270 if(stride<0) temp -= 9*stride;
2271 else temp += 9*stride;
2272
2273 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);
2274 motion_source= temp;
2275 }
2276 }
2277
2278
2279 /* first, take care of copying a block from either the
2280 * previous or the golden frame */
2281 if (s->all_fragments[i].coding_method != MODE_INTRA) {
2282 /* Note, it is possible to implement all MC cases with
2283 put_no_rnd_pixels_l2 which would look more like the
2284 VP3 source but this would be slower as
2285 put_no_rnd_pixels_tab is better optimzed */
2286 if(motion_halfpel_index != 3){
2287 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2288 output_plane + s->all_fragments[i].first_pixel,
2289 motion_source, stride, 8);
2290 }else{
2291 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2292 s->dsp.put_no_rnd_pixels_l2[1](
2293 output_plane + s->all_fragments[i].first_pixel,
2294 motion_source - d,
2295 motion_source + stride + 1 + d,
2296 stride, 8);
2297 }
2298 dequantizer = s->inter_dequant;
2299 }else{
2300 if (plane == 0)
2301 dequantizer = s->intra_y_dequant;
2302 else
2303 dequantizer = s->intra_c_dequant;
2304 }
2305
2306 /* dequantize the DCT coefficients */
2307 debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
2308 i, s->all_fragments[i].coding_method,
2309 DC_COEFF(i), dequantizer[0]);
2310
2311 if(s->avctx->idct_algo==FF_IDCT_VP3){
2312 Coeff *coeff= s->coeffs + i;
2313 memset(block, 0, sizeof(block));
2314 while(coeff->next){
2315 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
2316 coeff= coeff->next;
2317 }
2318 }else{
2319 Coeff *coeff= s->coeffs + i;
2320 memset(block, 0, sizeof(block));
2321 while(coeff->next){
2322 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
2323 coeff= coeff->next;
2324 }
2325 }
2326
2327 /* invert DCT and place (or add) in final output */
2328
2329 if (s->all_fragments[i].coding_method == MODE_INTRA) {
2330 if(s->avctx->idct_algo!=FF_IDCT_VP3)
2331 block[0] += 128<<3;
2332 s->dsp.idct_put(
2333 output_plane + s->all_fragments[i].first_pixel,
2334 stride,
2335 block);
2336 } else {
2337 s->dsp.idct_add(
2338 output_plane + s->all_fragments[i].first_pixel,
2339 stride,
2340 block);
2341 }
2342
2343 debug_idct("block after idct_%s():\n",
2344 (s->all_fragments[i].coding_method == MODE_INTRA)?
2345 "put" : "add");
2346 for (m = 0; m < 8; m++) {
2347 for (n = 0; n < 8; n++) {
2348 debug_idct(" %3d", *(output_plane +
2349 s->all_fragments[i].first_pixel + (m * stride + n)));
2350 }
2351 debug_idct("\n");
2352 }
2353 debug_idct("\n");
2354
2355 } else {
2356
2357 /* copy directly from the previous frame */
2358 s->dsp.put_pixels_tab[1][0](
2359 output_plane + s->all_fragments[i].first_pixel,
2360 last_plane + s->all_fragments[i].first_pixel,
2361 stride, 8);
2362
2363 }
2364 }
2365 }
2366 }
2367
2368 /* future loop filter logic goes here... */
2369 /* algorithm:
2370 * if (slice != 0)
2371 * run filter on 1st row of Y slice
2372 * run filter on U slice
2373 * run filter on V slice
2374 * run filter on 2nd row of Y slice
2375 */
2376
2377 /* this looks like a good place for slice dispatch... */
2378 /* algorithm:
2379 * if (slice > 0)
2380 * dispatch (slice - 1);
2381 * if (slice == s->macroblock_height - 1)
2382 * dispatch (slice); // handle last slice
2383 */
2384
2385 emms_c();
2386}
2387
2388/*
d86053a4
MM
2389 * This function performs the final rendering of each fragment's data
2390 * onto the output frame.
2391 */
2392static void render_fragments(Vp3DecodeContext *s,
2393 int first_fragment,
44ae98dd
MM
2394 int width,
2395 int height,
d86053a4
MM
2396 int plane /* 0 = Y, 1 = U, 2 = V */)
2397{
7dc9ed11 2398 int x, y;
d86053a4
MM
2399 int m, n;
2400 int i = first_fragment;
d86053a4 2401 int16_t *dequantizer;
7beddb12 2402 DCTELEM __align16 block[64];
d86053a4
MM
2403 unsigned char *output_plane;
2404 unsigned char *last_plane;
2405 unsigned char *golden_plane;
2406 int stride;
4df8ca9d 2407 int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
a466e345 2408 int upper_motion_limit, lower_motion_limit;
44ae98dd 2409 int motion_halfpel_index;
a2f11b3c 2410 uint8_t *motion_source;
d86053a4
MM
2411
2412 debug_vp3(" vp3: rendering final fragments for %s\n",
2413 (plane == 0) ? "Y plane" : (plane == 1) ? "U plane" : "V plane");
2414
2415 /* set up plane-specific parameters */
2416 if (plane == 0) {
d86053a4 2417 output_plane = s->current_frame.data[0];
61873c4a
MM
2418 last_plane = s->last_frame.data[0];
2419 golden_plane = s->golden_frame.data[0];
9a7ad925
AB
2420 stride = s->current_frame.linesize[0];
2421 if (!s->flipped_image) stride = -stride;
a466e345
MM
2422 upper_motion_limit = 7 * s->current_frame.linesize[0];
2423 lower_motion_limit = height * s->current_frame.linesize[0] + width - 8;
d86053a4 2424 } else if (plane == 1) {
d86053a4 2425 output_plane = s->current_frame.data[1];
61873c4a
MM
2426 last_plane = s->last_frame.data[1];
2427 golden_plane = s->golden_frame.data[1];
9a7ad925
AB
2428 stride = s->current_frame.linesize[1];
2429 if (!s->flipped_image) stride = -stride;
a466e345
MM
2430 upper_motion_limit = 7 * s->current_frame.linesize[1];
2431 lower_motion_limit = height * s->current_frame.linesize[1] + width - 8;
d86053a4 2432 } else {
d86053a4 2433 output_plane = s->current_frame.data[2];
61873c4a
MM
2434 last_plane = s->last_frame.data[2];
2435 golden_plane = s->golden_frame.data[2];
9a7ad925
AB
2436 stride = s->current_frame.linesize[2];
2437 if (!s->flipped_image) stride = -stride;
a466e345
MM
2438 upper_motion_limit = 7 * s->current_frame.linesize[2];
2439 lower_motion_limit = height * s->current_frame.linesize[2] + width - 8;
d86053a4 2440 }
0ecca7a4 2441
edaf11e8 2442 if(ABS(stride) > 2048)
0ecca7a4 2443 return; //various tables are fixed size
d86053a4
MM
2444
2445 /* for each fragment row... */
44ae98dd 2446 for (y = 0; y < height; y += 8) {
d86053a4
MM
2447
2448 /* for each fragment in a row... */
44ae98dd 2449 for (x = 0; x < width; x += 8, i++) {
d86053a4 2450
74c0ac12 2451 if ((i < 0) || (i >= s->fragment_count)) {
9b879566 2452 av_log(s->avctx, AV_LOG_ERROR, " vp3:render_fragments(): bad fragment number (%d)\n", i);
74c0ac12
MM
2453 return;
2454 }
2455
d86053a4 2456 /* transform if this block was coded */
f8830383
AB
2457 if ((s->all_fragments[i].coding_method != MODE_COPY) &&
2458 !((s->avctx->flags & CODEC_FLAG_GRAY) && plane)) {
44ae98dd 2459
a2f11b3c
MN
2460 if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
2461 (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
2462 motion_source= golden_plane;
2463 else
2464 motion_source= last_plane;
2465
2466 motion_source += s->all_fragments[i].first_pixel;
642d7e84
MM
2467 motion_halfpel_index = 0;
2468
2469 /* sort out the motion vector if this fragment is coded
2470 * using a motion vector method */
2471 if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
2472 (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
a2f11b3c 2473 int src_x, src_y;
642d7e84
MM
2474 motion_x = s->all_fragments[i].motion_x;
2475 motion_y = s->all_fragments[i].motion_y;
b928ec64
MN
2476 if(plane){
2477 motion_x= (motion_x>>1) | (motion_x&1);
2478 motion_y= (motion_y>>1) | (motion_y&1);
2479 }
2480
a2f11b3c
MN
2481 src_x= (motion_x>>1) + x;
2482 src_y= (motion_y>>1) + y;
7dc9ed11
MM
2483 if ((motion_x == 127) || (motion_y == 127))
2484 av_log(s->avctx, AV_LOG_ERROR, " help! got invalid motion vector! (%X, %X)\n", motion_x, motion_y);
642d7e84 2485
b928ec64
MN
2486 motion_halfpel_index = motion_x & 0x01;
2487 motion_source += (motion_x >> 1);
642d7e84 2488
b928ec64
MN
2489 motion_halfpel_index |= (motion_y & 0x01) << 1;
2490 motion_source += ((motion_y >> 1) * stride);
642d7e84 2491
a2f11b3c
MN
2492 if(src_x<0 || src_y<0 || src_x + 9 >= width || src_y + 9 >= height){
2493 uint8_t *temp= s->edge_emu_buffer;
2494 if(stride<0) temp -= 9*stride;
9a7ad925 2495 else temp += 9*stride;
a2f11b3c
MN
2496
2497 ff_emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, width, height);
2498 motion_source= temp;
642d7e84 2499 }
a466e345 2500 }
c0a0170c 2501
a466e345 2502
44ae98dd
MM
2503 /* first, take care of copying a block from either the
2504 * previous or the golden frame */
44ae98dd 2505 if (s->all_fragments[i].coding_method != MODE_INTRA) {
c0a0170c
MN
2506 //Note, it is possible to implement all MC cases with put_no_rnd_pixels_l2 which would look more like the VP3 source but this would be slower as put_no_rnd_pixels_tab is better optimzed
2507 if(motion_halfpel_index != 3){
2508 s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
2509 output_plane + s->all_fragments[i].first_pixel,
2510 motion_source, stride, 8);
2511 }else{
2512 int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1
2513 s->dsp.put_no_rnd_pixels_l2[1](
2514 output_plane + s->all_fragments[i].first_pixel,
2515 motion_source - d,
2516 motion_source + stride + 1 + d,
2517 stride, 8);
2518 }
7bad42cf
MN
2519 dequantizer = s->inter_dequant;
2520 }else{
2521 if (plane == 0)
2522 dequantizer = s->intra_y_dequant;
2523 else
2524 dequantizer = s->intra_c_dequant;
44ae98dd
MM
2525 }
2526
d86053a4 2527 /* dequantize the DCT coefficients */
44ae98dd
MM
2528 debug_idct("fragment %d, coding mode %d, DC = %d, dequant = %d:\n",
2529 i, s->all_fragments[i].coding_method,
7beddb12 2530 DC_COEFF(i), dequantizer[0]);
d86053a4 2531
8b6103da 2532 if(s->avctx->idct_algo==FF_IDCT_VP3){
7beddb12
MN
2533 Coeff *coeff= s->coeffs + i;
2534 memset(block, 0, sizeof(block));
2535 while(coeff->next){
2536 block[coeff->index]= coeff->coeff * dequantizer[coeff->index];
2537 coeff= coeff->next;
8b6103da
MN
2538 }
2539 }else{
7beddb12
MN
2540 Coeff *coeff= s->coeffs + i;
2541 memset(block, 0, sizeof(block));
2542 while(coeff->next){
2543 block[coeff->index]= (coeff->coeff * dequantizer[coeff->index] + 2)>>2;
2544 coeff= coeff->next;
8b6103da
MN
2545 }
2546 }
2547
4e80eb21 2548 /* invert DCT and place (or add) in final output */
8b6103da 2549
4e80eb21 2550 if (s->all_fragments[i].coding_method == MODE_INTRA) {
8b6103da 2551 if(s->avctx->idct_algo!=FF_IDCT_VP3)
7beddb12 2552 block[0] += 128<<3;
8b6103da 2553 s->dsp.idct_put(
f9ed9d85 2554 output_plane + s->all_fragments[i].first_pixel,
8b6103da 2555 stride,
7beddb12 2556 block);
4e80eb21 2557 } else {
8b6103da 2558 s->dsp.idct_add(
44ae98dd 2559 output_plane + s->all_fragments[i].first_pixel,
8b6103da 2560 stride,
7beddb12 2561 block);
4e80eb21 2562 }
44ae98dd
MM
2563
2564 debug_idct("block after idct_%s():\n",
2565 (s->all_fragments[i].coding_method == MODE_INTRA)?
2566 "put" : "add");
d86053a4
MM
2567 for (m = 0; m < 8; m++) {
2568 for (n = 0; n < 8; n++) {
44ae98dd
MM
2569 debug_idct(" %3d", *(output_plane +
2570 s->all_fragments[i].first_pixel + (m * stride + n)));
d86053a4
MM
2571 }
2572 debug_idct("\n");
2573 }
2574 debug_idct("\n");
d86053a4
MM
2575
2576 } else {
2577
44ae98dd
MM
2578 /* copy directly from the previous frame */
2579 s->dsp.put_pixels_tab[1][0](
2580 output_plane + s->all_fragments[i].first_pixel,
2581 last_plane + s->all_fragments[i].first_pixel,
2582 stride, 8);
d86053a4
MM
2583
2584 }
2585 }
2586 }
2587
2588 emms_c();
a54ea19a
MM
2589}
2590
a54ea19a
MM
2591static void horizontal_filter(unsigned char *first_pixel, int stride,
2592 int *bounding_values)
2593{
6f7aa589 2594 unsigned char *end;
a54ea19a
MM
2595 int filter_value;
2596
6f7aa589 2597 for (end= first_pixel + 8*stride; first_pixel < end; first_pixel += stride) {
a54ea19a 2598 filter_value =
6f7aa589
MN
2599 (first_pixel[-2] - first_pixel[ 1])
2600 +3*(first_pixel[ 0] - first_pixel[-1]);
a54ea19a 2601 filter_value = bounding_values[(filter_value + 4) >> 3];
ee408ead
MN
2602 first_pixel[-1] = clip_uint8(first_pixel[-1] + filter_value);
2603 first_pixel[ 0] = clip_uint8(first_pixel[ 0] - filter_value);
a54ea19a
MM
2604 }
2605}
2606
2607static void vertical_filter(unsigned char *first_pixel, int stride,
2608 int *bounding_values)
2609{
6f7aa589 2610 unsigned char *end;
a54ea19a 2611 int filter_value;
6f7aa589 2612 const int nstride= -stride;
a54ea19a 2613
6f7aa589 2614 for (end= first_pixel + 8; first_pixel < end; first_pixel++) {
a54ea19a 2615 filter_value =
6f7aa589
MN
2616 (first_pixel[2 * nstride] - first_pixel[ stride])
2617 +3*(first_pixel[0 ] - first_pixel[nstride]);
a54ea19a 2618 filter_value = bounding_values[(filter_value + 4) >> 3];
6f7aa589 2619 first_pixel[nstride] = clip_uint8(first_pixel[nstride] + filter_value);
ee408ead 2620 first_pixel[0] = clip_uint8(first_pixel[0] - filter_value);
a54ea19a
MM
2621 }
2622}
2623
2624static void apply_loop_filter(Vp3DecodeContext *s)
2625{
2626 int x, y, plane;
2627 int width, height;
2628 int fragment;
2629 int stride;
2630 unsigned char *plane_data;
d5e18835
MN
2631
2632 int bounding_values_array[256];
2633 int *bounding_values= bounding_values_array+127;
a54ea19a
MM
2634 int filter_limit;
2635
2636 /* find the right loop limit value */
2637 for (x = 63; x >= 0; x--) {
2638 if (vp31_ac_scale_factor[x] >= s->quality_index)
2639 break;
2640 }
d5e18835 2641 filter_limit = vp31_filter_limit_values[s->quality_index];
a54ea19a
MM
2642
2643 /* set up the bounding values */
d5e18835 2644 memset(bounding_values_array, 0, 256 * sizeof(int));
a54ea19a
MM
2645 for (x = 0; x < filter_limit; x++) {
2646 bounding_values[-x - filter_limit] = -filter_limit + x;
2647 bounding_values[-x] = -x;
2648 bounding_values[x] = x;
2649 bounding_values[x + filter_limit] = filter_limit - x;
2650 }
2651
2652 for (plane = 0; plane < 3; plane++) {
2653
2654 if (plane == 0) {
2655 /* Y plane parameters */
2656 fragment = 0;
2657 width = s->fragment_width;
2658 height = s->fragment_height;
2659 stride = s->current_frame.linesize[0];
2660 plane_data = s->current_frame.data[0];
2661 } else if (plane == 1) {
2662 /* U plane parameters */
2663 fragment = s->u_fragment_start;
2664 width = s->fragment_width / 2;
2665 height = s->fragment_height / 2;
2666 stride = s->current_frame.linesize[1];
2667 plane_data = s->current_frame.data[1];
2668 } else {
2669 /* V plane parameters */
2670 fragment = s->v_fragment_start;
2671 width = s->fragment_width / 2;
2672 height = s->fragment_height / 2;
2673 stride = s->current_frame.linesize[2];
2674 plane_data = s->current_frame.data[2];
2675 }
2676
2677 for (y = 0; y < height; y++) {
d86053a4 2678
a54ea19a 2679 for (x = 0; x < width; x++) {
220a6f40 2680START_TIMER
a54ea19a
MM
2681 /* do not perform left edge filter for left columns frags */
2682 if ((x > 0) &&
2683 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2684 horizontal_filter(
d5e18835 2685 plane_data + s->all_fragments[fragment].first_pixel - 7*stride,
a54ea19a
MM
2686 stride, bounding_values);
2687 }
2688
2689 /* do not perform top edge filter for top row fragments */
2690 if ((y > 0) &&
2691 (s->all_fragments[fragment].coding_method != MODE_COPY)) {
2692 vertical_filter(
d5e18835 2693 plane_data + s->all_fragments[fragment].first_pixel + stride,
a54ea19a
MM
2694 stride, bounding_values);
2695 }
2696
2697 /* do not perform right edge filter for right column
2698 * fragments or if right fragment neighbor is also coded
2699 * in this frame (it will be filtered in next iteration) */
2700 if ((x < width - 1) &&
2701 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2702 (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
2703 horizontal_filter(
d5e18835 2704 plane_data + s->all_fragments[fragment + 1].first_pixel - 7*stride,
a54ea19a
MM
2705 stride, bounding_values);
2706 }
2707
2708 /* do not perform bottom edge filter for bottom row
2709 * fragments or if bottom fragment neighbor is also coded
2710 * in this frame (it will be filtered in the next row) */
2711 if ((y < height - 1) &&
2712 (s->all_fragments[fragment].coding_method != MODE_COPY) &&
2713 (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
2714 vertical_filter(
d5e18835 2715 plane_data + s->all_fragments[fragment + width].first_pixel + stride,
a54ea19a
MM
2716 stride, bounding_values);
2717 }
2718
2719 fragment++;
220a6f40 2720STOP_TIMER("loop filter")
a54ea19a
MM
2721 }
2722 }
2723 }
d86053a4
MM
2724}
2725
2726/*
2727 * This function computes the first pixel addresses for each fragment.
2728 * This function needs to be invoked after the first frame is allocated
2729 * so that it has access to the plane strides.
2730 */
2731static void vp3_calculate_pixel_addresses(Vp3DecodeContext *s)
2732{
2733
2734 int i, x, y;
2735
2736 /* figure out the first pixel addresses for each of the fragments */
2737 /* Y plane */
2738 i = 0;
2739 for (y = s->fragment_height; y > 0; y--) {
2740 for (x = 0; x < s->fragment_width; x++) {
2741 s->all_fragments[i++].first_pixel =
2742 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2743 s->golden_frame.linesize[0] +
2744 x * FRAGMENT_PIXELS;
2745 debug_init(" fragment %d, first pixel @ %d\n",
2746 i-1, s->all_fragments[i-1].first_pixel);
2747 }
2748 }
2749
2750 /* U plane */
2751 i = s->u_fragment_start;
2752 for (y = s->fragment_height / 2; y > 0; y--) {
2753 for (x = 0; x < s->fragment_width / 2; x++) {
2754 s->all_fragments[i++].first_pixel =
2755 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2756 s->golden_frame.linesize[1] +
2757 x * FRAGMENT_PIXELS;
2758 debug_init(" fragment %d, first pixel @ %d\n",
2759 i-1, s->all_fragments[i-1].first_pixel);
2760 }
2761 }
2762
2763 /* V plane */
2764 i = s->v_fragment_start;
2765 for (y = s->fragment_height / 2; y > 0; y--) {
2766 for (x = 0; x < s->fragment_width / 2; x++) {
2767 s->all_fragments[i++].first_pixel =
2768 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2769 s->golden_frame.linesize[2] +
2770 x * FRAGMENT_PIXELS;
2771 debug_init(" fragment %d, first pixel @ %d\n",
2772 i-1, s->all_fragments[i-1].first_pixel);
2773 }
2774 }
2775}
2776
9a7ad925
AB
2777/* FIXME: this should be merged with the above! */
2778static void theora_calculate_pixel_addresses(Vp3DecodeContext *s)
2779{
2780
2781 int i, x, y;
2782
2783 /* figure out the first pixel addresses for each of the fragments */
2784 /* Y plane */
2785 i = 0;
2786 for (y = 1; y <= s->fragment_height; y++) {
2787 for (x = 0; x < s->fragment_width; x++) {
2788 s->all_fragments[i++].first_pixel =
2789 s->golden_frame.linesize[0] * y * FRAGMENT_PIXELS -
2790 s->golden_frame.linesize[0] +
2791 x * FRAGMENT_PIXELS;
2792 debug_init(" fragment %d, first pixel @ %d\n",
2793 i-1, s->all_fragments[i-1].first_pixel);
2794 }
2795 }
2796
2797 /* U plane */
2798 i = s->u_fragment_start;
2799 for (y = 1; y <= s->fragment_height / 2; y++) {
2800 for (x = 0; x < s->fragment_width / 2; x++) {
2801 s->all_fragments[i++].first_pixel =
2802 s->golden_frame.linesize[1] * y * FRAGMENT_PIXELS -
2803 s->golden_frame.linesize[1] +
2804 x * FRAGMENT_PIXELS;
2805 debug_init(" fragment %d, first pixel @ %d\n",
2806 i-1, s->all_fragments[i-1].first_pixel);
2807 }
2808 }
2809
2810 /* V plane */
2811 i = s->v_fragment_start;
2812 for (y = 1; y <= s->fragment_height / 2; y++) {
2813 for (x = 0; x < s->fragment_width / 2; x++) {
2814 s->all_fragments[i++].first_pixel =
2815 s->golden_frame.linesize[2] * y * FRAGMENT_PIXELS -
2816 s->golden_frame.linesize[2] +
2817 x * FRAGMENT_PIXELS;
2818 debug_init(" fragment %d, first pixel @ %d\n",
2819 i-1, s->all_fragments[i-1].first_pixel);
2820 }
2821 }
2822}
2823
d86053a4
MM
2824/*
2825 * This is the ffmpeg/libavcodec API init function.
2826 */
2827static int vp3_decode_init(AVCodecContext *avctx)
2828{
2829 Vp3DecodeContext *s = avctx->priv_data;
2830 int i;
892fc83e
MM
2831 int c_width;
2832 int c_height;
2833 int y_superblock_count;
2834 int c_superblock_count;
d86053a4 2835
3c3f113e
AB
2836 if (avctx->codec_tag == MKTAG('V','P','3','0'))
2837 s->version = 0;
2838 else
2839 s->version = 1;
2840
d86053a4 2841 s->avctx = avctx;
642d7e84
MM
2842 s->width = (avctx->width + 15) & 0xFFFFFFF0;
2843 s->height = (avctx->height + 15) & 0xFFFFFFF0;
d86053a4
MM
2844 avctx->pix_fmt = PIX_FMT_YUV420P;
2845 avctx->has_b_frames = 0;
8b6103da
MN
2846 if(avctx->idct_algo==FF_IDCT_AUTO)
2847 avctx->idct_algo=FF_IDCT_VP3;
d86053a4 2848 dsputil_init(&s->dsp, avctx);
36af0c95
MN
2849
2850 ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
d86053a4
MM
2851
2852 /* initialize to an impossible value which will force a recalculation
2853 * in the first frame decode */
2854 s->quality_index = -1;
2855
892fc83e
MM
2856 s->y_superblock_width = (s->width + 31) / 32;
2857 s->y_superblock_height = (s->height + 31) / 32;
2858 y_superblock_count = s->y_superblock_width * s->y_superblock_height;
2859
2860 /* work out the dimensions for the C planes */
2861 c_width = s->width / 2;
2862 c_height = s->height / 2;
2863 s->c_superblock_width = (c_width + 31) / 32;
2864 s->c_superblock_height = (c_height + 31) / 32;
2865 c_superblock_count = s->c_superblock_width * s->c_superblock_height;
2866
2867 s->superblock_count = y_superblock_count + (c_superblock_count * 2);
2868 s->u_superblock_start = y_superblock_count;
2869 s->v_superblock_start = s->u_superblock_start + c_superblock_count;
d86053a4
MM
2870 s->superblock_coding = av_malloc(s->superblock_count);
2871
2872 s->macroblock_width = (s->width + 15) / 16;
2873 s->macroblock_height = (s->height + 15) / 16;
2874 s->macroblock_count = s->macroblock_width * s->macroblock_height;
2875
2876 s->fragment_width = s->width / FRAGMENT_PIXELS;
2877 s->fragment_height = s->height / FRAGMENT_PIXELS;
2878
2879 /* fragment count covers all 8x8 blocks for all 3 planes */
2880 s->fragment_count = s->fragment_width * s->fragment_height * 3 / 2;
2881 s->u_fragment_start = s->fragment_width * s->fragment_height;
2882 s->v_fragment_start = s->fragment_width * s->fragment_height * 5 / 4;
2883
892fc83e
MM
2884 debug_init(" Y plane: %d x %d\n", s->width, s->height);
2885 debug_init(" C plane: %d x %d\n", c_width, c_height);
2886 debug_init(" Y superblocks: %d x %d, %d total\n",
2887 s->y_superblock_width, s->y_superblock_height, y_superblock_count);
2888 debug_init(" C superblocks: %d x %d, %d total\n",
2889 s->c_superblock_width, s->c_superblock_height, c_superblock_count);
2890 debug_init(" total superblocks = %d, U starts @ %d, V starts @ %d\n",
2891 s->superblock_count, s->u_superblock_start, s->v_superblock_start);
d86053a4
MM
2892 debug_init(" macroblocks: %d x %d, %d total\n",
2893 s->macroblock_width, s->macroblock_height, s->macroblock_count);
2894 debug_init(" %d fragments, %d x %d, u starts @ %d, v starts @ %d\n",
2895 s->fragment_count,
2896 s->fragment_width,
2897 s->fragment_height,
2898 s->u_fragment_start,
2899 s->v_fragment_start);
2900
2901 s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));
7beddb12 2902 s->coeffs = av_malloc(s->fragment_count * sizeof(Coeff) * 65);
d86053a4
MM
2903 s->coded_fragment_list = av_malloc(s->fragment_count * sizeof(int));
2904 s->pixel_addresses_inited = 0;
2905
f44ee2c3
AB
2906 if (!s->theora_tables)
2907 {
2908 for (i = 0; i < 64; i++)
2909 s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
2910 for (i = 0; i < 64; i++)
67335dbc 2911 s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
f44ee2c3
AB
2912 for (i = 0; i < 64; i++)
2913 s->coded_intra_y_dequant[i] = vp31_intra_y_dequant[i];
2914 for (i = 0; i < 64; i++)
2915 s->coded_intra_c_dequant[i] = vp31_intra_c_dequant[i];
2916 for (i = 0; i < 64; i++)
2917 s->coded_inter_dequant[i] = vp31_inter_dequant[i];
f44ee2c3 2918
39922395
MM
2919 /* init VLC tables */
2920 for (i = 0; i < 16; i++) {
2921
2922 /* DC histograms */
2923 init_vlc(&s->dc_vlc[i], 5, 32,
2924 &dc_bias[i][0][1], 4, 2,
2925 &dc_bias[i][0][0], 4, 2, 0);
2926
2927 /* group 1 AC histograms */
2928 init_vlc(&s->ac_vlc_1[i], 5, 32,
2929 &ac_bias_0[i][0][1], 4, 2,
2930 &ac_bias_0[i][0][0], 4, 2, 0);
2931
2932 /* group 2 AC histograms */
2933 init_vlc(&s->ac_vlc_2[i], 5, 32,
2934 &ac_bias_1[i][0][1], 4, 2,
2935 &ac_bias_1[i][0][0], 4, 2, 0);
2936
2937 /* group 3 AC histograms */
2938 init_vlc(&s->ac_vlc_3[i], 5, 32,
2939 &ac_bias_2[i][0][1], 4, 2,
2940 &ac_bias_2[i][0][0], 4, 2, 0);
2941
2942 /* group 4 AC histograms */
2943 init_vlc(&s->ac_vlc_4[i], 5, 32,
2944 &ac_bias_3[i][0][1], 4, 2,
2945 &ac_bias_3[i][0][0], 4, 2, 0);
2946 }
2947 } else {
2948 for (i = 0; i < 16; i++) {
2949
2950 /* DC histograms */
2951 init_vlc(&s->dc_vlc[i], 5, 32,
2952 &s->huffman_table[i][0][1], 4, 2,
2953 &s->huffman_table[i][0][0], 4, 2, 0);
2954
2955 /* group 1 AC histograms */
2956 init_vlc(&s->ac_vlc_1[i], 5, 32,
2957 &s->huffman_table[i+16][0][1], 4, 2,
2958 &s->huffman_table[i+16][0][0], 4, 2, 0);
2959
2960 /* group 2 AC histograms */
2961 init_vlc(&s->ac_vlc_2[i], 5, 32,
2962 &s->huffman_table[i+16*2][0][1], 4, 2,
2963 &s->huffman_table[i+16*2][0][0], 4, 2, 0);
2964
2965 /* group 3 AC histograms */
2966 init_vlc(&s->ac_vlc_3[i], 5, 32,
2967 &s->huffman_table[i+16*3][0][1], 4, 2,
2968 &s->huffman_table[i+16*3][0][0], 4, 2, 0);
2969
2970 /* group 4 AC histograms */
2971 init_vlc(&s->ac_vlc_4[i], 5, 32,
2972 &s->huffman_table[i+16*4][0][1], 4, 2,
2973 &s->huffman_table[i+16*4][0][0], 4, 2, 0);
2974 }
d86053a4
MM
2975 }
2976
d8278bab
MM
2977 init_vlc(&s->superblock_run_length_vlc, 6, 34,
2978 &superblock_run_length_vlc_table[0][1], 4, 2,
2979 &superblock_run_length_vlc_table[0][0], 4, 2, 0);
2980
0ad72bdd
MM
2981 init_vlc(&s->fragment_run_length_vlc, 5, 31,
2982 &fragment_run_length_vlc_table[0][1], 4, 2,
2983 &fragment_run_length_vlc_table[0][0], 4, 2, 0);
2984
2985 init_vlc(&s->mode_code_vlc, 3, 8,
2986 &mode_code_vlc_table[0][1], 2, 1,
2987 &mode_code_vlc_table[0][0], 2, 1, 0);
2988
2989 init_vlc(&s->motion_vector_vlc, 6, 63,
2990 &motion_vector_vlc_table[0][1], 2, 1,
2991 &motion_vector_vlc_table[0][0], 2, 1, 0);
2992
d86053a4
MM
2993 /* work out the block mapping tables */
2994 s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));
2995 s->superblock_macroblocks = av_malloc(s->superblock_count * 4 * sizeof(int));
2996 s->macroblock_fragments = av_malloc(s->macroblock_count * 6 * sizeof(int));
96a7e73b 2997 s->macroblock_coding = av_malloc(s->macroblock_count + 1);
d86053a4
MM
2998 init_block_mapping(s);
2999
44ae98dd
MM
3000 for (i = 0; i < 3; i++) {
3001 s->current_frame.data[i] = NULL;
3002 s->last_frame.data[i] = NULL;
3003 s->golden_frame.data[i] = NULL;
61873c4a
MM
3004 }
3005
d86053a4
MM
3006 return 0;
3007}
3008
3009/*
3010 * This is the ffmpeg/libavcodec API frame decode function.
3011 */
3012static int vp3_decode_frame(AVCodecContext *avctx,
3013 void *data, int *data_size,
3014 uint8_t *buf, int buf_size)
3015{
3016 Vp3DecodeContext *s = avctx->priv_data;
3017 GetBitContext gb;
3018 static int counter = 0;
dc4b78d9 3019 int i;
d86053a4 3020
d86053a4 3021 init_get_bits(&gb, buf, buf_size * 8);
f44ee2c3
AB
3022
3023 if (s->theora && get_bits1(&gb))
3024 {
3c3f113e 3025 int ptype = get_bits(&gb, 7);
d86053a4 3026
3c3f113e
AB
3027 skip_bits(&gb, 6*8); /* "theora" */
3028
3029 switch(ptype)
9a7ad925 3030 {
3c3f113e
AB
3031 case 1:
3032 theora_decode_comments(avctx, gb);
3033 break;
3034 case 2:
3035 theora_decode_tables(avctx, gb);
3036 init_dequantizer(s);
3037 break;
3038 default:
3039 av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype);
9a7ad925 3040 }
3c3f113e 3041 return buf_size;
f44ee2c3 3042 }
3c3f113e
AB
3043
3044 s->keyframe = !get_bits1(&gb);
3045 if (!s->theora)
f44ee2c3 3046 skip_bits(&gb, 1);
3c3f113e
AB
3047 s->last_quality_index = s->quality_index;
3048 s->quality_index = get_bits(&gb, 6);
ba7ee4a4 3049 if (s->theora >= 0x030200)
3c3f113e 3050 skip_bits1(&gb);
d86053a4 3051
f8830383
AB
3052 if (s->avctx->debug & FF_DEBUG_PICT_INFO)
3053 av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
3054 s->keyframe?"key":"", counter, s->quality_index);
d86053a4
MM
3055 counter++;
3056
642d7e84
MM
3057 if (s->quality_index != s->last_quality_index)
3058 init_dequantizer(s);
3059
d86053a4 3060 if (s->keyframe) {
3c3f113e
AB
3061 if (!s->theora)
3062 {
3063 skip_bits(&gb, 4); /* width code */
3064 skip_bits(&gb, 4); /* height code */
3065 if (s->version)
3066 {
3067 s->version = get_bits(&gb, 5);
3068 if (counter == 1)
3069 av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);
3070 }
3071 }
3072 if (s->version || s->theora)
3073 {
3074 if (get_bits1(&gb))
3075 av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");
3076 skip_bits(&gb, 2); /* reserved? */
3077 }
3078
74c0ac12
MM
3079 if (s->last_frame.data[0] == s->golden_frame.data[0]) {
3080 if (s->golden_frame.data[0])
3081 avctx->release_buffer(avctx, &s->golden_frame);
8e39d4a7 3082 s->last_frame= s->golden_frame; /* ensure that we catch any access to this released frame */
74c0ac12
MM
3083 } else {
3084 if (s->golden_frame.data[0])
3085 avctx->release_buffer(avctx, &s->golden_frame);
3086 if (s->last_frame.data[0])
3087 avctx->release_buffer(avctx, &s->last_frame);
3088 }
d86053a4 3089
8e39d4a7 3090 s->golden_frame.reference = 3;
d86053a4 3091 if(avctx->get_buffer(avctx, &s->golden_frame) < 0) {
9b879566 3092 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
d86053a4
MM
3093 return -1;
3094 }
3095
d86053a4 3096 /* golden frame is also the current frame */
61873c4a 3097 memcpy(&s->current_frame, &s->golden_frame, sizeof(AVFrame));
d86053a4
MM
3098
3099 /* time to figure out pixel addresses? */
3100 if (!s->pixel_addresses_inited)
9a7ad925
AB
3101 {
3102 if (!s->flipped_image)
3103 vp3_calculate_pixel_addresses(s);
3104 else
3105 theora_calculate_pixel_addresses(s);
3106 }
d86053a4 3107 } else {
d86053a4 3108 /* allocate a new current frame */
8e39d4a7 3109 s->current_frame.reference = 3;
d86053a4 3110 if(avctx->get_buffer(avctx, &s->current_frame) < 0) {
9b879566 3111 av_log(s->avctx, AV_LOG_ERROR, "vp3: get_buffer() failed\n");
d86053a4
MM
3112 return -1;
3113 }
d86053a4
MM
3114 }
3115
b928ec64
MN
3116 s->current_frame.qscale_table= s->qscale_table; //FIXME allocate individual tables per AVFrame
3117 s->current_frame.qstride= 0;
3118
220a6f40 3119 {START_TIMER
d86053a4 3120 init_frame(s, &gb);
220a6f40 3121 STOP_TIMER("init_frame")}
d86053a4 3122
892fc83e
MM
3123#if KEYFRAMES_ONLY
3124if (!s->keyframe) {
3125
3126 memcpy(s->current_frame.data[0], s->golden_frame.data[0],
3127 s->current_frame.linesize[0] * s->height);
3128 memcpy(s->current_frame.data[1], s->golden_frame.data[1],
3129 s->current_frame.linesize[1] * s->height / 2);
3130 memcpy(s->current_frame.data[2], s->golden_frame.data[2],
3131 s->current_frame.linesize[2] * s->height / 2);
3132
3133} else {
3134#endif
3135
220a6f40
MN
3136 {START_TIMER
3137 if (unpack_superblocks(s, &gb)){
3138 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
3139 return -1;
3140 }
3141 STOP_TIMER("unpack_superblocks")}
3142 {START_TIMER
3143 if (unpack_modes(s, &gb)){
3144 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
3145 return -1;
3146 }
3147 STOP_TIMER("unpack_modes")}
3148 {START_TIMER
3149 if (unpack_vectors(s, &gb)){
3150 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
3151 return -1;
3152 }
3153 STOP_TIMER("unpack_vectors")}
3154 {START_TIMER
3155 if (unpack_dct_coeffs(s, &gb)){
3156 av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
892fc83e
MM
3157 return -1;
3158 }
220a6f40
MN
3159 STOP_TIMER("unpack_dct_coeffs")}
3160 {START_TIMER
d86053a4
MM
3161
3162 reverse_dc_prediction(s, 0, s->fragment_width, s->fragment_height);
3d32b429
MM
3163 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
3164 reverse_dc_prediction(s, s->u_fragment_start,
3165 s->fragment_width / 2, s->fragment_height / 2);
3166 reverse_dc_prediction(s, s->v_fragment_start,
3167 s->fragment_width / 2, s->fragment_height / 2);
dc4b78d9
MM
3168 }
3169 STOP_TIMER("reverse_dc_prediction")}
3170 {START_TIMER
3171
3172#if 1
3173 for (i = 0; i < s->macroblock_height; i++)
3174 render_slice(s, i);
3175#else
3176 render_fragments(s, 0, s->width, s->height, 0);
3177 if ((avctx->flags & CODEC_FLAG_GRAY) == 0) {
3d32b429
MM
3178 render_fragments(s, s->u_fragment_start, s->width / 2, s->height / 2, 1);
3179 render_fragments(s, s->v_fragment_start, s->width / 2, s->height / 2, 2);
3180 } else {
3181 memset(s->current_frame.data[1], 0x80, s->width * s->height / 4);
3182 memset(s->current_frame.data[2], 0x80, s->width * s->height / 4);
3183 }
dc4b78d9
MM
3184#endif
3185 STOP_TIMER("render_fragments")}
d86053a4 3186
220a6f40 3187 {START_TIMER
d5e18835 3188 apply_loop_filter(s);
220a6f40 3189 STOP_TIMER("apply_loop_filter")}
892fc83e
MM
3190#if KEYFRAMES_ONLY
3191}
3192#endif
3193
d86053a4
MM
3194 *data_size=sizeof(AVFrame);
3195 *(AVFrame*)data= s->current_frame;
3196
44ae98dd
MM
3197 /* release the last frame, if it is allocated and if it is not the
3198 * golden frame */
3199 if ((s->last_frame.data[0]) &&
3200 (s->last_frame.data[0] != s->golden_frame.data[0]))
3201 avctx->release_buffer(avctx, &s->last_frame);
d86053a4 3202
61873c4a
MM
3203 /* shuffle frames (last = current) */
3204 memcpy(&s->last_frame, &s->current_frame, sizeof(AVFrame));
8e39d4a7 3205 s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */
d86053a4
MM
3206
3207 return buf_size;
3208}
3209
3210/*
3211 * This is the ffmpeg/libavcodec API module cleanup function.
3212 */
3213static int vp3_decode_end(AVCodecContext *avctx)
3214{
3215 Vp3DecodeContext *s = avctx->priv_data;
3216
3217 av_free(s->all_fragments);
a2df5a50 3218 av_free(s->coeffs);
d86053a4
MM
3219 av_free(s->coded_fragment_list);
3220 av_free(s->superblock_fragments);
3221 av_free(s->superblock_macroblocks);
3222 av_free(s->macroblock_fragments);
96a7e73b 3223 av_free(s->macroblock_coding);
8e39d4a7 3224
d86053a4 3225 /* release all frames */
8e39d4a7 3226 if (s->golden_frame.data[0] && s->golden_frame.data[0] != s->last_frame.data[0])
892fc83e
MM
3227 avctx->release_buffer(avctx, &s->golden_frame);
3228 if (s->last_frame.data[0])
3229 avctx->release_buffer(avctx, &s->last_frame);
3230 /* no need to release the current_frame since it will always be pointing
3231 * to the same frame as either the golden or last frame */
d86053a4
MM
3232
3233 return 0;
3234}
3235
39922395
MM
3236static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
3237{
3238 Vp3DecodeContext *s = avctx->priv_data;
3239
3240 if (get_bits(gb, 1)) {
3241 int token;
3242 if (s->entries >= 32) { /* overflow */
3243 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
3244 return -1;
3245 }
3246 token = get_bits(gb, 5);
3247 //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);
3248 s->huffman_table[s->hti][token][0] = s->hbits;
3249 s->huffman_table[s->hti][token][1] = s->huff_code_size;
3250 s->entries++;
3251 }
3252 else {
3253 if (s->huff_code_size >= 32) {/* overflow */
3254 av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
3255 return -1;
3256 }
3257 s->huff_code_size++;
3258 s->hbits <<= 1;
3259 read_huffman_tree(avctx, gb);
3260 s->hbits |= 1;
3261 read_huffman_tree(avctx, gb);
3262 s->hbits >>= 1;
3263 s->huff_code_size--;
3264 }
3265 return 0;
3266}
3267
f44ee2c3
AB
3268static int theora_decode_header(AVCodecContext *avctx, GetBitContext gb)
3269{
3270 Vp3DecodeContext *s = avctx->priv_data;
9a7ad925
AB
3271 int major, minor, micro;
3272
3273 major = get_bits(&gb, 8); /* version major */
3274 minor = get_bits(&gb, 8); /* version minor */
3275 micro = get_bits(&gb, 8); /* version micro */
3276 av_log(avctx, AV_LOG_INFO, "Theora bitstream version %d.%d.%d\n",
3277 major, minor, micro);
3278
105c3d25
AB
3279 /* FIXME: endianess? */
3280 s->theora = (major << 16) | (minor << 8) | micro;
3281
ba7ee4a4 3282 /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */
9a7ad925 3283 /* but previous versions have the image flipped relative to vp3 */
ba7ee4a4 3284 if (s->theora < 0x030200)
9a7ad925
AB
3285 {
3286 s->flipped_image = 1;
3287 av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");
3288 }
f44ee2c3 3289
f44ee2c3
AB
3290 s->width = get_bits(&gb, 16) << 4;
3291 s->height = get_bits(&gb, 16) << 4;
3292
0ecca7a4
MN
3293 if(avcodec_check_dimensions(avctx, s->width, s->height)){
3294 s->width= s->height= 0;
3295 return -1;
3296 }
3297
f44ee2c3
AB
3298 skip_bits(&gb, 24); /* frame width */
3299 skip_bits(&gb, 24); /* frame height */
3300
3301 skip_bits(&gb, 8); /* offset x */
3302 skip_bits(&gb, 8); /* offset y */
3303
3304 skip_bits(&gb, 32); /* fps numerator */
3305 skip_bits(&gb, 32); /* fps denumerator */
3306 skip_bits(&gb, 24); /* aspect numerator */
3307 skip_bits(&gb, 24); /* aspect denumerator */
3308
ba7ee4a4 3309 if (s->theora < 0x030200)
105c3d25 3310 skip_bits(&gb, 5); /* keyframe frequency force */
f44ee2c3
AB
3311 skip_bits(&gb, 8); /* colorspace */
3312 skip_bits(&gb, 24); /* bitrate */
3313
3314 skip_bits(&gb, 6); /* last(?) quality index */
3315
ba7ee4a4 3316 if (s->theora >= 0x030200)
105c3d25
AB
3317 {
3318 skip_bits(&gb, 5); /* keyframe frequency force */
3319 skip_bits(&gb, 5); /* spare bits */
3320 }
3321
f44ee2c3
AB
3322// align_get_bits(&gb);
3323
3324 avctx->width = s->width;
3325 avctx->height = s->height;
3326
f44ee2c3
AB
3327 return 0;
3328}
3329
91381201
AB
3330static int theora_decode_comments(AVCodecContext *avctx, GetBitContext gb)
3331{
3332 int nb_comments, i, tmp;
3333
8a515d2d 3334 tmp = get_bits_long(&gb, 32);
3c3f113e
AB
3335 tmp = be2me_32(tmp);
3336 while(tmp--)
3337 skip_bits(&gb, 8);
91381201 3338
8a515d2d 3339 nb_comments = get_bits_long(&gb, 32);
3c3f113e 3340 nb_comments = be2me_32(nb_comments);
91381201
AB
3341 for (i = 0; i < nb_comments; i++)
3342 {
8a515d2d 3343 tmp = get_bits_long(&gb, 32);
3c3f113e
AB
3344 tmp = be2me_32(tmp);
3345 while(tmp--)
91381201
AB
3346 skip_bits(&gb, 8);
3347 }
3348
3349 return 0;
3350}
3351
f44ee2c3
AB
3352static int theora_decode_tables(AVCodecContext *avctx, GetBitContext gb)
3353{
3354 Vp3DecodeContext *s = avctx->priv_data;
ba7ee4a4
MC
3355 int i, n;
3356
3357 if (s->theora >= 0x030200) {
3358 n = get_bits(&gb, 3);
3359 /* loop filter table */
3360 for (i = 0; i < 64; i++)
3361 skip_bits(&gb, n);
3362 }
f44ee2c3 3363
ba7ee4a4
MC
3364 if (s->theora >= 0x030200)
3365 n = get_bits(&gb, 4) + 1;
3366 else
3367 n = 16;
f44ee2c3
AB
3368 /* quality threshold table */
3369 for (i = 0; i < 64; i++)
ba7ee4a4 3370 s->coded_ac_scale_factor[i] = get_bits(&gb, n);
f44ee2c3 3371
ba7ee4a4
MC
3372 if (s->theora >= 0x030200)
3373 n = get_bits(&gb, 4) + 1;
3374 else
3375 n = 16;
f44ee2c3
AB
3376 /* dc scale factor table */
3377 for (i = 0; i < 64; i++)
ba7ee4a4 3378 s->coded_dc_scale_factor[i] = get_bits(&gb, n);
f44ee2c3 3379
ba7ee4a4
MC
3380 if (s->theora >= 0x030200)
3381 n = get_bits(&gb, 9) + 1;
3382 else
3383 n = 3;
3384 if (n != 3) {
3385 av_log(NULL,AV_LOG_ERROR, "unsupported nbms : %d\n", n);
3386 return -1;
3387 }
f44ee2c3
AB
3388 /* y coeffs */
3389 for (i = 0; i < 64; i++)
3390 s->coded_intra_y_dequant[i] = get_bits(&gb, 8);
3391
3392 /* uv coeffs */
3393 for (i = 0; i < 64; i++)
3394 s->coded_intra_c_dequant[i] = get_bits(&gb, 8);
3395
3396 /* inter coeffs */
3397 for (i = 0; i < 64; i++)
3398 s->coded_inter_dequant[i] = get_bits(&gb, 8);
3c3f113e 3399
39922395
MM
3400 /* Huffman tables */
3401 for (i = 0; i <= 1; i++) {
3402 for (n = 0; n <= 2; n++) {
3403 int newqr;
3404 if (i > 0 || n > 0)
3405 newqr = get_bits(&gb, 1);
3406 else
3407 newqr = 1;
3408 if (!newqr) {
3409 if (i > 0)
3410 get_bits(&gb, 1);
3411 }
3412 else {
3413 int qi = 0;
3414 skip_bits(&gb, av_log2(2)+1);
3415 while (qi < 63) {
3416 qi += get_bits(&gb, av_log2(63-qi)+1) + 1;
3417 skip_bits(&gb, av_log2(2)+1);
3418 }
3419 if (qi > 63)
3420 av_log(NULL, AV_LOG_ERROR, "error...\n");
3421 }
3422 }
3423 }
3424
3425 for (s->hti = 0; s->hti < 80; s->hti++) {
3426 s->entries = 0;
3427 s->huff_code_size = 1;
3428 if (!get_bits(&gb, 1)) {
3429 s->hbits = 0;
3430 read_huffman_tree(avctx, &gb);
3431 s->hbits = 1;
3432 read_huffman_tree(avctx, &gb);
3433 }
3434 }
f44ee2c3
AB
3435
3436 s->theora_tables = 1;
3437
3438 return 0;
3439}
3440
3441static int theora_decode_init(AVCodecContext *avctx)
3442{
3443 Vp3DecodeContext *s = avctx->priv_data;
3444 GetBitContext gb;
3445 int ptype;
ee89b2b9
MN
3446 uint8_t *p= avctx->extradata;
3447 int op_bytes, i;
f44ee2c3
AB
3448
3449 s->theora = 1;
3450
3451 if (!avctx->extradata_size)
3452 return -1;
3453
ee89b2b9
MN
3454 for(i=0;i<3;i++) {
3455 op_bytes = *(p++)<<8;
3456 op_bytes += *(p++);
3457
3458 init_get_bits(&gb, p, op_bytes);
3459 p += op_bytes;
f44ee2c3
AB
3460
3461 ptype = get_bits(&gb, 8);
3462 debug_vp3("Theora headerpacket type: %x\n", ptype);
3463
3464 if (!(ptype & 0x80))
3465 return -1;
3466
3467 skip_bits(&gb, 6*8); /* "theora" */
3468
3469 switch(ptype)
3470 {
3471 case 0x80:
3472 theora_decode_header(avctx, gb);
f44ee2c3
AB
3473 break;
3474 case 0x81:
91381201 3475 theora_decode_comments(avctx, gb);
f44ee2c3
AB
3476 break;
3477 case 0x82:
3478 theora_decode_tables(avctx, gb);
3479 break;
3480 }
ee89b2b9 3481 }
f44ee2c3 3482
ba7ee4a4 3483 vp3_decode_init(avctx);
f44ee2c3
AB
3484 return 0;
3485}
3486
d86053a4
MM
3487AVCodec vp3_decoder = {
3488 "vp3",
3489 CODEC_TYPE_VIDEO,
3490 CODEC_ID_VP3,
3491 sizeof(Vp3DecodeContext),
3492 vp3_decode_init,
3493 NULL,
3494 vp3_decode_end,
3495 vp3_decode_frame,
3496 0,
3497 NULL
3498};
f44ee2c3 3499
aac064b5 3500#ifndef CONFIG_LIBTHEORA
f44ee2c3
AB
3501AVCodec theora_decoder = {
3502 "theora",
3503 CODEC_TYPE_VIDEO,
3504 CODEC_ID_THEORA,
3505 sizeof(Vp3DecodeContext),
3506 theora_decode_init,
3507 NULL,
3508 vp3_decode_end,
3509 vp3_decode_frame,
3510 0,
3511 NULL
3512};
aac064b5 3513#endif