git.sesse.net Git - ffmpeg/blob - libavcodec/vp3.c

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