Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2003-2004 The FFmpeg Project
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. /**
  22.  * @file
  23.  * On2 VP3 Video Decoder
  24.  *
  25.  * VP3 Video Decoder by Mike Melanson (mike at multimedia.cx)
  26.  * For more information about the VP3 coding process, visit:
  27.  *   http://wiki.multimedia.cx/index.php?title=On2_VP3
  28.  *
  29.  * Theora decoder by Alex Beregszaszi
  30.  */
  31.  
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  35.  
  36. #include "libavutil/imgutils.h"
  37.  
  38. #include "avcodec.h"
  39. #include "get_bits.h"
  40. #include "hpeldsp.h"
  41. #include "internal.h"
  42. #include "mathops.h"
  43. #include "thread.h"
  44. #include "videodsp.h"
  45. #include "vp3data.h"
  46. #include "vp3dsp.h"
  47. #include "xiph.h"
  48.  
  49. #define FRAGMENT_PIXELS 8
  50.  
  51. // FIXME split things out into their own arrays
  52. typedef struct Vp3Fragment {
  53.     int16_t dc;
  54.     uint8_t coding_method;
  55.     uint8_t qpi;
  56. } Vp3Fragment;
  57.  
  58. #define SB_NOT_CODED        0
  59. #define SB_PARTIALLY_CODED  1
  60. #define SB_FULLY_CODED      2
  61.  
  62. // This is the maximum length of a single long bit run that can be encoded
  63. // for superblock coding or block qps. Theora special-cases this to read a
  64. // bit instead of flipping the current bit to allow for runs longer than 4129.
  65. #define MAXIMUM_LONG_BIT_RUN 4129
  66.  
  67. #define MODE_INTER_NO_MV      0
  68. #define MODE_INTRA            1
  69. #define MODE_INTER_PLUS_MV    2
  70. #define MODE_INTER_LAST_MV    3
  71. #define MODE_INTER_PRIOR_LAST 4
  72. #define MODE_USING_GOLDEN     5
  73. #define MODE_GOLDEN_MV        6
  74. #define MODE_INTER_FOURMV     7
  75. #define CODING_MODE_COUNT     8
  76.  
  77. /* special internal mode */
  78. #define MODE_COPY             8
  79.  
  80. static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb);
  81. static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb);
  82.  
  83.  
  84. /* There are 6 preset schemes, plus a free-form scheme */
  85. static const int ModeAlphabet[6][CODING_MODE_COUNT] = {
  86.     /* scheme 1: Last motion vector dominates */
  87.     { MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
  88.       MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,
  89.       MODE_INTRA,            MODE_USING_GOLDEN,
  90.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  91.  
  92.     /* scheme 2 */
  93.     { MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
  94.       MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,
  95.       MODE_INTRA,            MODE_USING_GOLDEN,
  96.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  97.  
  98.     /* scheme 3 */
  99.     { MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
  100.       MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,
  101.       MODE_INTRA,            MODE_USING_GOLDEN,
  102.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  103.  
  104.     /* scheme 4 */
  105.     { MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,
  106.       MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,
  107.       MODE_INTRA,            MODE_USING_GOLDEN,
  108.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  109.  
  110.     /* scheme 5: No motion vector dominates */
  111.     { MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,
  112.       MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,
  113.       MODE_INTRA,            MODE_USING_GOLDEN,
  114.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  115.  
  116.     /* scheme 6 */
  117.     { MODE_INTER_NO_MV,      MODE_USING_GOLDEN,
  118.       MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,
  119.       MODE_INTER_PLUS_MV,    MODE_INTRA,
  120.       MODE_GOLDEN_MV,        MODE_INTER_FOURMV },
  121. };
  122.  
  123. static const uint8_t hilbert_offset[16][2] = {
  124.     { 0, 0 }, { 1, 0 }, { 1, 1 }, { 0, 1 },
  125.     { 0, 2 }, { 0, 3 }, { 1, 3 }, { 1, 2 },
  126.     { 2, 2 }, { 2, 3 }, { 3, 3 }, { 3, 2 },
  127.     { 3, 1 }, { 2, 1 }, { 2, 0 }, { 3, 0 }
  128. };
  129.  
  130. #define MIN_DEQUANT_VAL 2
  131.  
  132. typedef struct Vp3DecodeContext {
  133.     AVCodecContext *avctx;
  134.     int theora, theora_tables, theora_header;
  135.     int version;
  136.     int width, height;
  137.     int chroma_x_shift, chroma_y_shift;
  138.     ThreadFrame golden_frame;
  139.     ThreadFrame last_frame;
  140.     ThreadFrame current_frame;
  141.     int keyframe;
  142.     uint8_t idct_permutation[64];
  143.     uint8_t idct_scantable[64];
  144.     HpelDSPContext hdsp;
  145.     VideoDSPContext vdsp;
  146.     VP3DSPContext vp3dsp;
  147.     DECLARE_ALIGNED(16, int16_t, block)[64];
  148.     int flipped_image;
  149.     int last_slice_end;
  150.     int skip_loop_filter;
  151.  
  152.     int qps[3];
  153.     int nqps;
  154.     int last_qps[3];
  155.  
  156.     int superblock_count;
  157.     int y_superblock_width;
  158.     int y_superblock_height;
  159.     int y_superblock_count;
  160.     int c_superblock_width;
  161.     int c_superblock_height;
  162.     int c_superblock_count;
  163.     int u_superblock_start;
  164.     int v_superblock_start;
  165.     unsigned char *superblock_coding;
  166.  
  167.     int macroblock_count;
  168.     int macroblock_width;
  169.     int macroblock_height;
  170.  
  171.     int fragment_count;
  172.     int fragment_width[2];
  173.     int fragment_height[2];
  174.  
  175.     Vp3Fragment *all_fragments;
  176.     int fragment_start[3];
  177.     int data_offset[3];
  178.     uint8_t offset_x;
  179.     uint8_t offset_y;
  180.     int offset_x_warned;
  181.  
  182.     int8_t (*motion_val[2])[2];
  183.  
  184.     /* tables */
  185.     uint16_t coded_dc_scale_factor[64];
  186.     uint32_t coded_ac_scale_factor[64];
  187.     uint8_t base_matrix[384][64];
  188.     uint8_t qr_count[2][3];
  189.     uint8_t qr_size[2][3][64];
  190.     uint16_t qr_base[2][3][64];
  191.  
  192.     /**
  193.      * This is a list of all tokens in bitstream order. Reordering takes place
  194.      * by pulling from each level during IDCT. As a consequence, IDCT must be
  195.      * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32
  196.      * otherwise. The 32 different tokens with up to 12 bits of extradata are
  197.      * collapsed into 3 types, packed as follows:
  198.      *   (from the low to high bits)
  199.      *
  200.      * 2 bits: type (0,1,2)
  201.      *   0: EOB run, 14 bits for run length (12 needed)
  202.      *   1: zero run, 7 bits for run length
  203.      *                7 bits for the next coefficient (3 needed)
  204.      *   2: coefficient, 14 bits (11 needed)
  205.      *
  206.      * Coefficients are signed, so are packed in the highest bits for automatic
  207.      * sign extension.
  208.      */
  209.     int16_t *dct_tokens[3][64];
  210.     int16_t *dct_tokens_base;
  211. #define TOKEN_EOB(eob_run)              ((eob_run) << 2)
  212. #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) * 512) + ((zero_run) << 2) + 1)
  213. #define TOKEN_COEFF(coeff)              (((coeff) * 4) + 2)
  214.  
  215.     /**
  216.      * number of blocks that contain DCT coefficients at
  217.      * the given level or higher
  218.      */
  219.     int num_coded_frags[3][64];
  220.     int total_num_coded_frags;
  221.  
  222.     /* this is a list of indexes into the all_fragments array indicating
  223.      * which of the fragments are coded */
  224.     int *coded_fragment_list[3];
  225.  
  226.     VLC dc_vlc[16];
  227.     VLC ac_vlc_1[16];
  228.     VLC ac_vlc_2[16];
  229.     VLC ac_vlc_3[16];
  230.     VLC ac_vlc_4[16];
  231.  
  232.     VLC superblock_run_length_vlc;
  233.     VLC fragment_run_length_vlc;
  234.     VLC mode_code_vlc;
  235.     VLC motion_vector_vlc;
  236.  
  237.     /* these arrays need to be on 16-byte boundaries since SSE2 operations
  238.      * index into them */
  239.     DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64];     ///< qmat[qpi][is_inter][plane]
  240.  
  241.     /* This table contains superblock_count * 16 entries. Each set of 16
  242.      * numbers corresponds to the fragment indexes 0..15 of the superblock.
  243.      * An entry will be -1 to indicate that no entry corresponds to that
  244.      * index. */
  245.     int *superblock_fragments;
  246.  
  247.     /* This is an array that indicates how a particular macroblock
  248.      * is coded. */
  249.     unsigned char *macroblock_coding;
  250.  
  251.     uint8_t *edge_emu_buffer;
  252.  
  253.     /* Huffman decode */
  254.     int hti;
  255.     unsigned int hbits;
  256.     int entries;
  257.     int huff_code_size;
  258.     uint32_t huffman_table[80][32][2];
  259.  
  260.     uint8_t filter_limit_values[64];
  261.     DECLARE_ALIGNED(8, int, bounding_values_array)[256 + 2];
  262. } Vp3DecodeContext;
  263.  
  264. /************************************************************************
  265.  * VP3 specific functions
  266.  ************************************************************************/
  267.  
  268. static av_cold void free_tables(AVCodecContext *avctx)
  269. {
  270.     Vp3DecodeContext *s = avctx->priv_data;
  271.  
  272.     av_freep(&s->superblock_coding);
  273.     av_freep(&s->all_fragments);
  274.     av_freep(&s->coded_fragment_list[0]);
  275.     av_freep(&s->dct_tokens_base);
  276.     av_freep(&s->superblock_fragments);
  277.     av_freep(&s->macroblock_coding);
  278.     av_freep(&s->motion_val[0]);
  279.     av_freep(&s->motion_val[1]);
  280. }
  281.  
  282. static void vp3_decode_flush(AVCodecContext *avctx)
  283. {
  284.     Vp3DecodeContext *s = avctx->priv_data;
  285.  
  286.     if (s->golden_frame.f)
  287.         ff_thread_release_buffer(avctx, &s->golden_frame);
  288.     if (s->last_frame.f)
  289.         ff_thread_release_buffer(avctx, &s->last_frame);
  290.     if (s->current_frame.f)
  291.         ff_thread_release_buffer(avctx, &s->current_frame);
  292. }
  293.  
  294. static av_cold int vp3_decode_end(AVCodecContext *avctx)
  295. {
  296.     Vp3DecodeContext *s = avctx->priv_data;
  297.     int i;
  298.  
  299.     free_tables(avctx);
  300.     av_freep(&s->edge_emu_buffer);
  301.  
  302.     s->theora_tables = 0;
  303.  
  304.     /* release all frames */
  305.     vp3_decode_flush(avctx);
  306.     av_frame_free(&s->current_frame.f);
  307.     av_frame_free(&s->last_frame.f);
  308.     av_frame_free(&s->golden_frame.f);
  309.  
  310.     if (avctx->internal->is_copy)
  311.         return 0;
  312.  
  313.     for (i = 0; i < 16; i++) {
  314.         ff_free_vlc(&s->dc_vlc[i]);
  315.         ff_free_vlc(&s->ac_vlc_1[i]);
  316.         ff_free_vlc(&s->ac_vlc_2[i]);
  317.         ff_free_vlc(&s->ac_vlc_3[i]);
  318.         ff_free_vlc(&s->ac_vlc_4[i]);
  319.     }
  320.  
  321.     ff_free_vlc(&s->superblock_run_length_vlc);
  322.     ff_free_vlc(&s->fragment_run_length_vlc);
  323.     ff_free_vlc(&s->mode_code_vlc);
  324.     ff_free_vlc(&s->motion_vector_vlc);
  325.  
  326.     return 0;
  327. }
  328.  
  329. /**
  330.  * This function sets up all of the various blocks mappings:
  331.  * superblocks <-> fragments, macroblocks <-> fragments,
  332.  * superblocks <-> macroblocks
  333.  *
  334.  * @return 0 is successful; returns 1 if *anything* went wrong.
  335.  */
  336. static int init_block_mapping(Vp3DecodeContext *s)
  337. {
  338.     int sb_x, sb_y, plane;
  339.     int x, y, i, j = 0;
  340.  
  341.     for (plane = 0; plane < 3; plane++) {
  342.         int sb_width    = plane ? s->c_superblock_width
  343.                                 : s->y_superblock_width;
  344.         int sb_height   = plane ? s->c_superblock_height
  345.                                 : s->y_superblock_height;
  346.         int frag_width  = s->fragment_width[!!plane];
  347.         int frag_height = s->fragment_height[!!plane];
  348.  
  349.         for (sb_y = 0; sb_y < sb_height; sb_y++)
  350.             for (sb_x = 0; sb_x < sb_width; sb_x++)
  351.                 for (i = 0; i < 16; i++) {
  352.                     x = 4 * sb_x + hilbert_offset[i][0];
  353.                     y = 4 * sb_y + hilbert_offset[i][1];
  354.  
  355.                     if (x < frag_width && y < frag_height)
  356.                         s->superblock_fragments[j++] = s->fragment_start[plane] +
  357.                                                        y * frag_width + x;
  358.                     else
  359.                         s->superblock_fragments[j++] = -1;
  360.                 }
  361.     }
  362.  
  363.     return 0;  /* successful path out */
  364. }
  365.  
  366. /*
  367.  * This function sets up the dequantization tables used for a particular
  368.  * frame.
  369.  */
  370. static void init_dequantizer(Vp3DecodeContext *s, int qpi)
  371. {
  372.     int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];
  373.     int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]];
  374.     int i, plane, inter, qri, bmi, bmj, qistart;
  375.  
  376.     for (inter = 0; inter < 2; inter++) {
  377.         for (plane = 0; plane < 3; plane++) {
  378.             int sum = 0;
  379.             for (qri = 0; qri < s->qr_count[inter][plane]; qri++) {
  380.                 sum += s->qr_size[inter][plane][qri];
  381.                 if (s->qps[qpi] <= sum)
  382.                     break;
  383.             }
  384.             qistart = sum - s->qr_size[inter][plane][qri];
  385.             bmi     = s->qr_base[inter][plane][qri];
  386.             bmj     = s->qr_base[inter][plane][qri + 1];
  387.             for (i = 0; i < 64; i++) {
  388.                 int coeff = (2 * (sum     - s->qps[qpi]) * s->base_matrix[bmi][i] -
  389.                              2 * (qistart - s->qps[qpi]) * s->base_matrix[bmj][i] +
  390.                              s->qr_size[inter][plane][qri]) /
  391.                             (2 * s->qr_size[inter][plane][qri]);
  392.  
  393.                 int qmin   = 8 << (inter + !i);
  394.                 int qscale = i ? ac_scale_factor : dc_scale_factor;
  395.  
  396.                 s->qmat[qpi][inter][plane][s->idct_permutation[i]] =
  397.                     av_clip((qscale * coeff) / 100 * 4, qmin, 4096);
  398.             }
  399.             /* all DC coefficients use the same quant so as not to interfere
  400.              * with DC prediction */
  401.             s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];
  402.         }
  403.     }
  404. }
  405.  
  406. /*
  407.  * This function initializes the loop filter boundary limits if the frame's
  408.  * quality index is different from the previous frame's.
  409.  *
  410.  * The filter_limit_values may not be larger than 127.
  411.  */
  412. static void init_loop_filter(Vp3DecodeContext *s)
  413. {
  414.     int *bounding_values = s->bounding_values_array + 127;
  415.     int filter_limit;
  416.     int x;
  417.     int value;
  418.  
  419.     filter_limit = s->filter_limit_values[s->qps[0]];
  420.     av_assert0(filter_limit < 128U);
  421.  
  422.     /* set up the bounding values */
  423.     memset(s->bounding_values_array, 0, 256 * sizeof(int));
  424.     for (x = 0; x < filter_limit; x++) {
  425.         bounding_values[-x] = -x;
  426.         bounding_values[x] = x;
  427.     }
  428.     for (x = value = filter_limit; x < 128 && value; x++, value--) {
  429.         bounding_values[ x] =  value;
  430.         bounding_values[-x] = -value;
  431.     }
  432.     if (value)
  433.         bounding_values[128] = value;
  434.     bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;
  435. }
  436.  
  437. /*
  438.  * This function unpacks all of the superblock/macroblock/fragment coding
  439.  * information from the bitstream.
  440.  */
  441. static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)
  442. {
  443.     int superblock_starts[3] = {
  444.         0, s->u_superblock_start, s->v_superblock_start
  445.     };
  446.     int bit = 0;
  447.     int current_superblock = 0;
  448.     int current_run = 0;
  449.     int num_partial_superblocks = 0;
  450.  
  451.     int i, j;
  452.     int current_fragment;
  453.     int plane;
  454.  
  455.     if (s->keyframe) {
  456.         memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);
  457.     } else {
  458.         /* unpack the list of partially-coded superblocks */
  459.         bit         = get_bits1(gb) ^ 1;
  460.         current_run = 0;
  461.  
  462.         while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {
  463.             if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
  464.                 bit = get_bits1(gb);
  465.             else
  466.                 bit ^= 1;
  467.  
  468.             current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
  469.                                    6, 2) + 1;
  470.             if (current_run == 34)
  471.                 current_run += get_bits(gb, 12);
  472.  
  473.             if (current_run > s->superblock_count - current_superblock) {
  474.                 av_log(s->avctx, AV_LOG_ERROR,
  475.                        "Invalid partially coded superblock run length\n");
  476.                 return -1;
  477.             }
  478.  
  479.             memset(s->superblock_coding + current_superblock, bit, current_run);
  480.  
  481.             current_superblock += current_run;
  482.             if (bit)
  483.                 num_partial_superblocks += current_run;
  484.         }
  485.  
  486.         /* unpack the list of fully coded superblocks if any of the blocks were
  487.          * not marked as partially coded in the previous step */
  488.         if (num_partial_superblocks < s->superblock_count) {
  489.             int superblocks_decoded = 0;
  490.  
  491.             current_superblock = 0;
  492.             bit                = get_bits1(gb) ^ 1;
  493.             current_run        = 0;
  494.  
  495.             while (superblocks_decoded < s->superblock_count - num_partial_superblocks &&
  496.                    get_bits_left(gb) > 0) {
  497.                 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)
  498.                     bit = get_bits1(gb);
  499.                 else
  500.                     bit ^= 1;
  501.  
  502.                 current_run = get_vlc2(gb, s->superblock_run_length_vlc.table,
  503.                                        6, 2) + 1;
  504.                 if (current_run == 34)
  505.                     current_run += get_bits(gb, 12);
  506.  
  507.                 for (j = 0; j < current_run; current_superblock++) {
  508.                     if (current_superblock >= s->superblock_count) {
  509.                         av_log(s->avctx, AV_LOG_ERROR,
  510.                                "Invalid fully coded superblock run length\n");
  511.                         return -1;
  512.                     }
  513.  
  514.                     /* skip any superblocks already marked as partially coded */
  515.                     if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {
  516.                         s->superblock_coding[current_superblock] = 2 * bit;
  517.                         j++;
  518.                     }
  519.                 }
  520.                 superblocks_decoded += current_run;
  521.             }
  522.         }
  523.  
  524.         /* if there were partial blocks, initialize bitstream for
  525.          * unpacking fragment codings */
  526.         if (num_partial_superblocks) {
  527.             current_run = 0;
  528.             bit         = get_bits1(gb);
  529.             /* toggle the bit because as soon as the first run length is
  530.              * fetched the bit will be toggled again */
  531.             bit ^= 1;
  532.         }
  533.     }
  534.  
  535.     /* figure out which fragments are coded; iterate through each
  536.      * superblock (all planes) */
  537.     s->total_num_coded_frags = 0;
  538.     memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);
  539.  
  540.     for (plane = 0; plane < 3; plane++) {
  541.         int sb_start = superblock_starts[plane];
  542.         int sb_end   = sb_start + (plane ? s->c_superblock_count
  543.                                          : s->y_superblock_count);
  544.         int num_coded_frags = 0;
  545.  
  546.         for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {
  547.             /* iterate through all 16 fragments in a superblock */
  548.             for (j = 0; j < 16; j++) {
  549.                 /* if the fragment is in bounds, check its coding status */
  550.                 current_fragment = s->superblock_fragments[i * 16 + j];
  551.                 if (current_fragment != -1) {
  552.                     int coded = s->superblock_coding[i];
  553.  
  554.                     if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {
  555.                         /* fragment may or may not be coded; this is the case
  556.                          * that cares about the fragment coding runs */
  557.                         if (current_run-- == 0) {
  558.                             bit        ^= 1;
  559.                             current_run = get_vlc2(gb, s->fragment_run_length_vlc.table, 5, 2);
  560.                         }
  561.                         coded = bit;
  562.                     }
  563.  
  564.                     if (coded) {
  565.                         /* default mode; actual mode will be decoded in
  566.                          * the next phase */
  567.                         s->all_fragments[current_fragment].coding_method =
  568.                             MODE_INTER_NO_MV;
  569.                         s->coded_fragment_list[plane][num_coded_frags++] =
  570.                             current_fragment;
  571.                     } else {
  572.                         /* not coded; copy this fragment from the prior frame */
  573.                         s->all_fragments[current_fragment].coding_method =
  574.                             MODE_COPY;
  575.                     }
  576.                 }
  577.             }
  578.         }
  579.         s->total_num_coded_frags += num_coded_frags;
  580.         for (i = 0; i < 64; i++)
  581.             s->num_coded_frags[plane][i] = num_coded_frags;
  582.         if (plane < 2)
  583.             s->coded_fragment_list[plane + 1] = s->coded_fragment_list[plane] +
  584.                                                 num_coded_frags;
  585.     }
  586.     return 0;
  587. }
  588.  
  589. /*
  590.  * This function unpacks all the coding mode data for individual macroblocks
  591.  * from the bitstream.
  592.  */
  593. static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
  594. {
  595.     int i, j, k, sb_x, sb_y;
  596.     int scheme;
  597.     int current_macroblock;
  598.     int current_fragment;
  599.     int coding_mode;
  600.     int custom_mode_alphabet[CODING_MODE_COUNT];
  601.     const int *alphabet;
  602.     Vp3Fragment *frag;
  603.  
  604.     if (s->keyframe) {
  605.         for (i = 0; i < s->fragment_count; i++)
  606.             s->all_fragments[i].coding_method = MODE_INTRA;
  607.     } else {
  608.         /* fetch the mode coding scheme for this frame */
  609.         scheme = get_bits(gb, 3);
  610.  
  611.         /* is it a custom coding scheme? */
  612.         if (scheme == 0) {
  613.             for (i = 0; i < 8; i++)
  614.                 custom_mode_alphabet[i] = MODE_INTER_NO_MV;
  615.             for (i = 0; i < 8; i++)
  616.                 custom_mode_alphabet[get_bits(gb, 3)] = i;
  617.             alphabet = custom_mode_alphabet;
  618.         } else
  619.             alphabet = ModeAlphabet[scheme - 1];
  620.  
  621.         /* iterate through all of the macroblocks that contain 1 or more
  622.          * coded fragments */
  623.         for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
  624.             for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
  625.                 if (get_bits_left(gb) <= 0)
  626.                     return -1;
  627.  
  628.                 for (j = 0; j < 4; j++) {
  629.                     int mb_x = 2 * sb_x + (j >> 1);
  630.                     int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
  631.                     current_macroblock = mb_y * s->macroblock_width + mb_x;
  632.  
  633.                     if (mb_x >= s->macroblock_width ||
  634.                         mb_y >= s->macroblock_height)
  635.                         continue;
  636.  
  637. #define BLOCK_X (2 * mb_x + (k & 1))
  638. #define BLOCK_Y (2 * mb_y + (k >> 1))
  639.                     /* coding modes are only stored if the macroblock has
  640.                      * at least one luma block coded, otherwise it must be
  641.                      * INTER_NO_MV */
  642.                     for (k = 0; k < 4; k++) {
  643.                         current_fragment = BLOCK_Y *
  644.                                            s->fragment_width[0] + BLOCK_X;
  645.                         if (s->all_fragments[current_fragment].coding_method != MODE_COPY)
  646.                             break;
  647.                     }
  648.                     if (k == 4) {
  649.                         s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;
  650.                         continue;
  651.                     }
  652.  
  653.                     /* mode 7 means get 3 bits for each coding mode */
  654.                     if (scheme == 7)
  655.                         coding_mode = get_bits(gb, 3);
  656.                     else
  657.                         coding_mode = alphabet[get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];
  658.  
  659.                     s->macroblock_coding[current_macroblock] = coding_mode;
  660.                     for (k = 0; k < 4; k++) {
  661.                         frag = s->all_fragments + BLOCK_Y * s->fragment_width[0] + BLOCK_X;
  662.                         if (frag->coding_method != MODE_COPY)
  663.                             frag->coding_method = coding_mode;
  664.                     }
  665.  
  666. #define SET_CHROMA_MODES                                                      \
  667.     if (frag[s->fragment_start[1]].coding_method != MODE_COPY)                \
  668.         frag[s->fragment_start[1]].coding_method = coding_mode;               \
  669.     if (frag[s->fragment_start[2]].coding_method != MODE_COPY)                \
  670.         frag[s->fragment_start[2]].coding_method = coding_mode;
  671.  
  672.                     if (s->chroma_y_shift) {
  673.                         frag = s->all_fragments + mb_y *
  674.                                s->fragment_width[1] + mb_x;
  675.                         SET_CHROMA_MODES
  676.                     } else if (s->chroma_x_shift) {
  677.                         frag = s->all_fragments +
  678.                                2 * mb_y * s->fragment_width[1] + mb_x;
  679.                         for (k = 0; k < 2; k++) {
  680.                             SET_CHROMA_MODES
  681.                             frag += s->fragment_width[1];
  682.                         }
  683.                     } else {
  684.                         for (k = 0; k < 4; k++) {
  685.                             frag = s->all_fragments +
  686.                                    BLOCK_Y * s->fragment_width[1] + BLOCK_X;
  687.                             SET_CHROMA_MODES
  688.                         }
  689.                     }
  690.                 }
  691.             }
  692.         }
  693.     }
  694.  
  695.     return 0;
  696. }
  697.  
  698. /*
  699.  * This function unpacks all the motion vectors for the individual
  700.  * macroblocks from the bitstream.
  701.  */
  702. static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)
  703. {
  704.     int j, k, sb_x, sb_y;
  705.     int coding_mode;
  706.     int motion_x[4];
  707.     int motion_y[4];
  708.     int last_motion_x = 0;
  709.     int last_motion_y = 0;
  710.     int prior_last_motion_x = 0;
  711.     int prior_last_motion_y = 0;
  712.     int current_macroblock;
  713.     int current_fragment;
  714.     int frag;
  715.  
  716.     if (s->keyframe)
  717.         return 0;
  718.  
  719.     /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */
  720.     coding_mode = get_bits1(gb);
  721.  
  722.     /* iterate through all of the macroblocks that contain 1 or more
  723.      * coded fragments */
  724.     for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {
  725.         for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {
  726.             if (get_bits_left(gb) <= 0)
  727.                 return -1;
  728.  
  729.             for (j = 0; j < 4; j++) {
  730.                 int mb_x = 2 * sb_x + (j >> 1);
  731.                 int mb_y = 2 * sb_y + (((j >> 1) + j) & 1);
  732.                 current_macroblock = mb_y * s->macroblock_width + mb_x;
  733.  
  734.                 if (mb_x >= s->macroblock_width  ||
  735.                     mb_y >= s->macroblock_height ||
  736.                     s->macroblock_coding[current_macroblock] == MODE_COPY)
  737.                     continue;
  738.  
  739.                 switch (s->macroblock_coding[current_macroblock]) {
  740.                 case MODE_INTER_PLUS_MV:
  741.                 case MODE_GOLDEN_MV:
  742.                     /* all 6 fragments use the same motion vector */
  743.                     if (coding_mode == 0) {
  744.                         motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
  745.                         motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
  746.                     } else {
  747.                         motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];
  748.                         motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];
  749.                     }
  750.  
  751.                     /* vector maintenance, only on MODE_INTER_PLUS_MV */
  752.                     if (s->macroblock_coding[current_macroblock] == MODE_INTER_PLUS_MV) {
  753.                         prior_last_motion_x = last_motion_x;
  754.                         prior_last_motion_y = last_motion_y;
  755.                         last_motion_x       = motion_x[0];
  756.                         last_motion_y       = motion_y[0];
  757.                     }
  758.                     break;
  759.  
  760.                 case MODE_INTER_FOURMV:
  761.                     /* vector maintenance */
  762.                     prior_last_motion_x = last_motion_x;
  763.                     prior_last_motion_y = last_motion_y;
  764.  
  765.                     /* fetch 4 vectors from the bitstream, one for each
  766.                      * Y fragment, then average for the C fragment vectors */
  767.                     for (k = 0; k < 4; k++) {
  768.                         current_fragment = BLOCK_Y * s->fragment_width[0] + BLOCK_X;
  769.                         if (s->all_fragments[current_fragment].coding_method != MODE_COPY) {
  770.                             if (coding_mode == 0) {
  771.                                 motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
  772.                                 motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];
  773.                             } else {
  774.                                 motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];
  775.                                 motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];
  776.                             }
  777.                             last_motion_x = motion_x[k];
  778.                             last_motion_y = motion_y[k];
  779.                         } else {
  780.                             motion_x[k] = 0;
  781.                             motion_y[k] = 0;
  782.                         }
  783.                     }
  784.                     break;
  785.  
  786.                 case MODE_INTER_LAST_MV:
  787.                     /* all 6 fragments use the last motion vector */
  788.                     motion_x[0] = last_motion_x;
  789.                     motion_y[0] = last_motion_y;
  790.  
  791.                     /* no vector maintenance (last vector remains the
  792.                      * last vector) */
  793.                     break;
  794.  
  795.                 case MODE_INTER_PRIOR_LAST:
  796.                     /* all 6 fragments use the motion vector prior to the
  797.                      * last motion vector */
  798.                     motion_x[0] = prior_last_motion_x;
  799.                     motion_y[0] = prior_last_motion_y;
  800.  
  801.                     /* vector maintenance */
  802.                     prior_last_motion_x = last_motion_x;
  803.                     prior_last_motion_y = last_motion_y;
  804.                     last_motion_x       = motion_x[0];
  805.                     last_motion_y       = motion_y[0];
  806.                     break;
  807.  
  808.                 default:
  809.                     /* covers intra, inter without MV, golden without MV */
  810.                     motion_x[0] = 0;
  811.                     motion_y[0] = 0;
  812.  
  813.                     /* no vector maintenance */
  814.                     break;
  815.                 }
  816.  
  817.                 /* assign the motion vectors to the correct fragments */
  818.                 for (k = 0; k < 4; k++) {
  819.                     current_fragment =
  820.                         BLOCK_Y * s->fragment_width[0] + BLOCK_X;
  821.                     if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
  822.                         s->motion_val[0][current_fragment][0] = motion_x[k];
  823.                         s->motion_val[0][current_fragment][1] = motion_y[k];
  824.                     } else {
  825.                         s->motion_val[0][current_fragment][0] = motion_x[0];
  826.                         s->motion_val[0][current_fragment][1] = motion_y[0];
  827.                     }
  828.                 }
  829.  
  830.                 if (s->chroma_y_shift) {
  831.                     if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
  832.                         motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] +
  833.                                              motion_x[2] + motion_x[3], 2);
  834.                         motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] +
  835.                                              motion_y[2] + motion_y[3], 2);
  836.                     }
  837.                     motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
  838.                     motion_y[0] = (motion_y[0] >> 1) | (motion_y[0] & 1);
  839.                     frag = mb_y * s->fragment_width[1] + mb_x;
  840.                     s->motion_val[1][frag][0] = motion_x[0];
  841.                     s->motion_val[1][frag][1] = motion_y[0];
  842.                 } else if (s->chroma_x_shift) {
  843.                     if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
  844.                         motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);
  845.                         motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);
  846.                         motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);
  847.                         motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);
  848.                     } else {
  849.                         motion_x[1] = motion_x[0];
  850.                         motion_y[1] = motion_y[0];
  851.                     }
  852.                     motion_x[0] = (motion_x[0] >> 1) | (motion_x[0] & 1);
  853.                     motion_x[1] = (motion_x[1] >> 1) | (motion_x[1] & 1);
  854.  
  855.                     frag = 2 * mb_y * s->fragment_width[1] + mb_x;
  856.                     for (k = 0; k < 2; k++) {
  857.                         s->motion_val[1][frag][0] = motion_x[k];
  858.                         s->motion_val[1][frag][1] = motion_y[k];
  859.                         frag += s->fragment_width[1];
  860.                     }
  861.                 } else {
  862.                     for (k = 0; k < 4; k++) {
  863.                         frag = BLOCK_Y * s->fragment_width[1] + BLOCK_X;
  864.                         if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {
  865.                             s->motion_val[1][frag][0] = motion_x[k];
  866.                             s->motion_val[1][frag][1] = motion_y[k];
  867.                         } else {
  868.                             s->motion_val[1][frag][0] = motion_x[0];
  869.                             s->motion_val[1][frag][1] = motion_y[0];
  870.                         }
  871.                     }
  872.                 }
  873.             }
  874.         }
  875.     }
  876.  
  877.     return 0;
  878. }
  879.  
  880. static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)
  881. {
  882.     int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;
  883.     int num_blocks = s->total_num_coded_frags;
  884.  
  885.     for (qpi = 0; qpi < s->nqps - 1 && num_blocks > 0; qpi++) {
  886.         i = blocks_decoded = num_blocks_at_qpi = 0;
  887.  
  888.         bit        = get_bits1(gb) ^ 1;
  889.         run_length = 0;
  890.  
  891.         do {
  892.             if (run_length == MAXIMUM_LONG_BIT_RUN)
  893.                 bit = get_bits1(gb);
  894.             else
  895.                 bit ^= 1;
  896.  
  897.             run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;
  898.             if (run_length == 34)
  899.                 run_length += get_bits(gb, 12);
  900.             blocks_decoded += run_length;
  901.  
  902.             if (!bit)
  903.                 num_blocks_at_qpi += run_length;
  904.  
  905.             for (j = 0; j < run_length; i++) {
  906.                 if (i >= s->total_num_coded_frags)
  907.                     return -1;
  908.  
  909.                 if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) {
  910.                     s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit;
  911.                     j++;
  912.                 }
  913.             }
  914.         } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);
  915.  
  916.         num_blocks -= num_blocks_at_qpi;
  917.     }
  918.  
  919.     return 0;
  920. }
  921.  
  922. /*
  923.  * This function is called by unpack_dct_coeffs() to extract the VLCs from
  924.  * the bitstream. The VLCs encode tokens which are used to unpack DCT
  925.  * data. This function unpacks all the VLCs for either the Y plane or both
  926.  * C planes, and is called for DC coefficients or different AC coefficient
  927.  * levels (since different coefficient types require different VLC tables.
  928.  *
  929.  * This function returns a residual eob run. E.g, if a particular token gave
  930.  * instructions to EOB the next 5 fragments and there were only 2 fragments
  931.  * left in the current fragment range, 3 would be returned so that it could
  932.  * be passed into the next call to this same function.
  933.  */
  934. static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,
  935.                        VLC *table, int coeff_index,
  936.                        int plane,
  937.                        int eob_run)
  938. {
  939.     int i, j = 0;
  940.     int token;
  941.     int zero_run  = 0;
  942.     int16_t coeff = 0;
  943.     int bits_to_get;
  944.     int blocks_ended;
  945.     int coeff_i = 0;
  946.     int num_coeffs      = s->num_coded_frags[plane][coeff_index];
  947.     int16_t *dct_tokens = s->dct_tokens[plane][coeff_index];
  948.  
  949.     /* local references to structure members to avoid repeated deferences */
  950.     int *coded_fragment_list   = s->coded_fragment_list[plane];
  951.     Vp3Fragment *all_fragments = s->all_fragments;
  952.     VLC_TYPE(*vlc_table)[2] = table->table;
  953.  
  954.     if (num_coeffs < 0)
  955.         av_log(s->avctx, AV_LOG_ERROR,
  956.                "Invalid number of coefficents at level %d\n", coeff_index);
  957.  
  958.     if (eob_run > num_coeffs) {
  959.         coeff_i      =
  960.         blocks_ended = num_coeffs;
  961.         eob_run     -= num_coeffs;
  962.     } else {
  963.         coeff_i      =
  964.         blocks_ended = eob_run;
  965.         eob_run      = 0;
  966.     }
  967.  
  968.     // insert fake EOB token to cover the split between planes or zzi
  969.     if (blocks_ended)
  970.         dct_tokens[j++] = blocks_ended << 2;
  971.  
  972.     while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {
  973.         /* decode a VLC into a token */
  974.         token = get_vlc2(gb, vlc_table, 11, 3);
  975.         /* use the token to get a zero run, a coefficient, and an eob run */
  976.         if ((unsigned) token <= 6U) {
  977.             eob_run = eob_run_base[token];
  978.             if (eob_run_get_bits[token])
  979.                 eob_run += get_bits(gb, eob_run_get_bits[token]);
  980.  
  981.             // record only the number of blocks ended in this plane,
  982.             // any spill will be recorded in the next plane.
  983.             if (eob_run > num_coeffs - coeff_i) {
  984.                 dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i);
  985.                 blocks_ended   += num_coeffs - coeff_i;
  986.                 eob_run        -= num_coeffs - coeff_i;
  987.                 coeff_i         = num_coeffs;
  988.             } else {
  989.                 dct_tokens[j++] = TOKEN_EOB(eob_run);
  990.                 blocks_ended   += eob_run;
  991.                 coeff_i        += eob_run;
  992.                 eob_run         = 0;
  993.             }
  994.         } else if (token >= 0) {
  995.             bits_to_get = coeff_get_bits[token];
  996.             if (bits_to_get)
  997.                 bits_to_get = get_bits(gb, bits_to_get);
  998.             coeff = coeff_tables[token][bits_to_get];
  999.  
  1000.             zero_run = zero_run_base[token];
  1001.             if (zero_run_get_bits[token])
  1002.                 zero_run += get_bits(gb, zero_run_get_bits[token]);
  1003.  
  1004.             if (zero_run) {
  1005.                 dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run);
  1006.             } else {
  1007.                 // Save DC into the fragment structure. DC prediction is
  1008.                 // done in raster order, so the actual DC can't be in with
  1009.                 // other tokens. We still need the token in dct_tokens[]
  1010.                 // however, or else the structure collapses on itself.
  1011.                 if (!coeff_index)
  1012.                     all_fragments[coded_fragment_list[coeff_i]].dc = coeff;
  1013.  
  1014.                 dct_tokens[j++] = TOKEN_COEFF(coeff);
  1015.             }
  1016.  
  1017.             if (coeff_index + zero_run > 64) {
  1018.                 av_log(s->avctx, AV_LOG_DEBUG,
  1019.                        "Invalid zero run of %d with %d coeffs left\n",
  1020.                        zero_run, 64 - coeff_index);
  1021.                 zero_run = 64 - coeff_index;
  1022.             }
  1023.  
  1024.             // zero runs code multiple coefficients,
  1025.             // so don't try to decode coeffs for those higher levels
  1026.             for (i = coeff_index + 1; i <= coeff_index + zero_run; i++)
  1027.                 s->num_coded_frags[plane][i]--;
  1028.             coeff_i++;
  1029.         } else {
  1030.             av_log(s->avctx, AV_LOG_ERROR, "Invalid token %d\n", token);
  1031.             return -1;
  1032.         }
  1033.     }
  1034.  
  1035.     if (blocks_ended > s->num_coded_frags[plane][coeff_index])
  1036.         av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n");
  1037.  
  1038.     // decrement the number of blocks that have higher coefficients for each
  1039.     // EOB run at this level
  1040.     if (blocks_ended)
  1041.         for (i = coeff_index + 1; i < 64; i++)
  1042.             s->num_coded_frags[plane][i] -= blocks_ended;
  1043.  
  1044.     // setup the next buffer
  1045.     if (plane < 2)
  1046.         s->dct_tokens[plane + 1][coeff_index] = dct_tokens + j;
  1047.     else if (coeff_index < 63)
  1048.         s->dct_tokens[0][coeff_index + 1] = dct_tokens + j;
  1049.  
  1050.     return eob_run;
  1051. }
  1052.  
  1053. static void reverse_dc_prediction(Vp3DecodeContext *s,
  1054.                                   int first_fragment,
  1055.                                   int fragment_width,
  1056.                                   int fragment_height);
  1057. /*
  1058.  * This function unpacks all of the DCT coefficient data from the
  1059.  * bitstream.
  1060.  */
  1061. static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)
  1062. {
  1063.     int i;
  1064.     int dc_y_table;
  1065.     int dc_c_table;
  1066.     int ac_y_table;
  1067.     int ac_c_table;
  1068.     int residual_eob_run = 0;
  1069.     VLC *y_tables[64];
  1070.     VLC *c_tables[64];
  1071.  
  1072.     s->dct_tokens[0][0] = s->dct_tokens_base;
  1073.  
  1074.     /* fetch the DC table indexes */
  1075.     dc_y_table = get_bits(gb, 4);
  1076.     dc_c_table = get_bits(gb, 4);
  1077.  
  1078.     /* unpack the Y plane DC coefficients */
  1079.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,
  1080.                                    0, residual_eob_run);
  1081.     if (residual_eob_run < 0)
  1082.         return residual_eob_run;
  1083.  
  1084.     /* reverse prediction of the Y-plane DC coefficients */
  1085.     reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]);
  1086.  
  1087.     /* unpack the C plane DC coefficients */
  1088.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
  1089.                                    1, residual_eob_run);
  1090.     if (residual_eob_run < 0)
  1091.         return residual_eob_run;
  1092.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,
  1093.                                    2, residual_eob_run);
  1094.     if (residual_eob_run < 0)
  1095.         return residual_eob_run;
  1096.  
  1097.     /* reverse prediction of the C-plane DC coefficients */
  1098.     if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
  1099.         reverse_dc_prediction(s, s->fragment_start[1],
  1100.                               s->fragment_width[1], s->fragment_height[1]);
  1101.         reverse_dc_prediction(s, s->fragment_start[2],
  1102.                               s->fragment_width[1], s->fragment_height[1]);
  1103.     }
  1104.  
  1105.     /* fetch the AC table indexes */
  1106.     ac_y_table = get_bits(gb, 4);
  1107.     ac_c_table = get_bits(gb, 4);
  1108.  
  1109.     /* build tables of AC VLC tables */
  1110.     for (i = 1; i <= 5; i++) {
  1111.         y_tables[i] = &s->ac_vlc_1[ac_y_table];
  1112.         c_tables[i] = &s->ac_vlc_1[ac_c_table];
  1113.     }
  1114.     for (i = 6; i <= 14; i++) {
  1115.         y_tables[i] = &s->ac_vlc_2[ac_y_table];
  1116.         c_tables[i] = &s->ac_vlc_2[ac_c_table];
  1117.     }
  1118.     for (i = 15; i <= 27; i++) {
  1119.         y_tables[i] = &s->ac_vlc_3[ac_y_table];
  1120.         c_tables[i] = &s->ac_vlc_3[ac_c_table];
  1121.     }
  1122.     for (i = 28; i <= 63; i++) {
  1123.         y_tables[i] = &s->ac_vlc_4[ac_y_table];
  1124.         c_tables[i] = &s->ac_vlc_4[ac_c_table];
  1125.     }
  1126.  
  1127.     /* decode all AC coefficents */
  1128.     for (i = 1; i <= 63; i++) {
  1129.         residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,
  1130.                                        0, residual_eob_run);
  1131.         if (residual_eob_run < 0)
  1132.             return residual_eob_run;
  1133.  
  1134.         residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
  1135.                                        1, residual_eob_run);
  1136.         if (residual_eob_run < 0)
  1137.             return residual_eob_run;
  1138.         residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,
  1139.                                        2, residual_eob_run);
  1140.         if (residual_eob_run < 0)
  1141.             return residual_eob_run;
  1142.     }
  1143.  
  1144.     return 0;
  1145. }
  1146.  
  1147. /*
  1148.  * This function reverses the DC prediction for each coded fragment in
  1149.  * the frame. Much of this function is adapted directly from the original
  1150.  * VP3 source code.
  1151.  */
  1152. #define COMPATIBLE_FRAME(x)                                                   \
  1153.     (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)
  1154. #define DC_COEFF(u) s->all_fragments[u].dc
  1155.  
  1156. static void reverse_dc_prediction(Vp3DecodeContext *s,
  1157.                                   int first_fragment,
  1158.                                   int fragment_width,
  1159.                                   int fragment_height)
  1160. {
  1161. #define PUL 8
  1162. #define PU 4
  1163. #define PUR 2
  1164. #define PL 1
  1165.  
  1166.     int x, y;
  1167.     int i = first_fragment;
  1168.  
  1169.     int predicted_dc;
  1170.  
  1171.     /* DC values for the left, up-left, up, and up-right fragments */
  1172.     int vl, vul, vu, vur;
  1173.  
  1174.     /* indexes for the left, up-left, up, and up-right fragments */
  1175.     int l, ul, u, ur;
  1176.  
  1177.     /*
  1178.      * The 6 fields mean:
  1179.      *   0: up-left multiplier
  1180.      *   1: up multiplier
  1181.      *   2: up-right multiplier
  1182.      *   3: left multiplier
  1183.      */
  1184.     static const int predictor_transform[16][4] = {
  1185.         {    0,   0,   0,   0 },
  1186.         {    0,   0,   0, 128 }, // PL
  1187.         {    0,   0, 128,   0 }, // PUR
  1188.         {    0,   0,  53,  75 }, // PUR|PL
  1189.         {    0, 128,   0,   0 }, // PU
  1190.         {    0,  64,   0,  64 }, // PU |PL
  1191.         {    0, 128,   0,   0 }, // PU |PUR
  1192.         {    0,   0,  53,  75 }, // PU |PUR|PL
  1193.         {  128,   0,   0,   0 }, // PUL
  1194.         {    0,   0,   0, 128 }, // PUL|PL
  1195.         {   64,   0,  64,   0 }, // PUL|PUR
  1196.         {    0,   0,  53,  75 }, // PUL|PUR|PL
  1197.         {    0, 128,   0,   0 }, // PUL|PU
  1198.         { -104, 116,   0, 116 }, // PUL|PU |PL
  1199.         {   24,  80,  24,   0 }, // PUL|PU |PUR
  1200.         { -104, 116,   0, 116 }  // PUL|PU |PUR|PL
  1201.     };
  1202.  
  1203.     /* This table shows which types of blocks can use other blocks for
  1204.      * prediction. For example, INTRA is the only mode in this table to
  1205.      * have a frame number of 0. That means INTRA blocks can only predict
  1206.      * from other INTRA blocks. There are 2 golden frame coding types;
  1207.      * blocks encoding in these modes can only predict from other blocks
  1208.      * that were encoded with these 1 of these 2 modes. */
  1209.     static const unsigned char compatible_frame[9] = {
  1210.         1,    /* MODE_INTER_NO_MV */
  1211.         0,    /* MODE_INTRA */
  1212.         1,    /* MODE_INTER_PLUS_MV */
  1213.         1,    /* MODE_INTER_LAST_MV */
  1214.         1,    /* MODE_INTER_PRIOR_MV */
  1215.         2,    /* MODE_USING_GOLDEN */
  1216.         2,    /* MODE_GOLDEN_MV */
  1217.         1,    /* MODE_INTER_FOUR_MV */
  1218.         3     /* MODE_COPY */
  1219.     };
  1220.     int current_frame_type;
  1221.  
  1222.     /* there is a last DC predictor for each of the 3 frame types */
  1223.     short last_dc[3];
  1224.  
  1225.     int transform = 0;
  1226.  
  1227.     vul =
  1228.     vu  =
  1229.     vur =
  1230.     vl  = 0;
  1231.     last_dc[0] =
  1232.     last_dc[1] =
  1233.     last_dc[2] = 0;
  1234.  
  1235.     /* for each fragment row... */
  1236.     for (y = 0; y < fragment_height; y++) {
  1237.         /* for each fragment in a row... */
  1238.         for (x = 0; x < fragment_width; x++, i++) {
  1239.  
  1240.             /* reverse prediction if this block was coded */
  1241.             if (s->all_fragments[i].coding_method != MODE_COPY) {
  1242.                 current_frame_type =
  1243.                     compatible_frame[s->all_fragments[i].coding_method];
  1244.  
  1245.                 transform = 0;
  1246.                 if (x) {
  1247.                     l  = i - 1;
  1248.                     vl = DC_COEFF(l);
  1249.                     if (COMPATIBLE_FRAME(l))
  1250.                         transform |= PL;
  1251.                 }
  1252.                 if (y) {
  1253.                     u  = i - fragment_width;
  1254.                     vu = DC_COEFF(u);
  1255.                     if (COMPATIBLE_FRAME(u))
  1256.                         transform |= PU;
  1257.                     if (x) {
  1258.                         ul  = i - fragment_width - 1;
  1259.                         vul = DC_COEFF(ul);
  1260.                         if (COMPATIBLE_FRAME(ul))
  1261.                             transform |= PUL;
  1262.                     }
  1263.                     if (x + 1 < fragment_width) {
  1264.                         ur  = i - fragment_width + 1;
  1265.                         vur = DC_COEFF(ur);
  1266.                         if (COMPATIBLE_FRAME(ur))
  1267.                             transform |= PUR;
  1268.                     }
  1269.                 }
  1270.  
  1271.                 if (transform == 0) {
  1272.                     /* if there were no fragments to predict from, use last
  1273.                      * DC saved */
  1274.                     predicted_dc = last_dc[current_frame_type];
  1275.                 } else {
  1276.                     /* apply the appropriate predictor transform */
  1277.                     predicted_dc =
  1278.                         (predictor_transform[transform][0] * vul) +
  1279.                         (predictor_transform[transform][1] * vu) +
  1280.                         (predictor_transform[transform][2] * vur) +
  1281.                         (predictor_transform[transform][3] * vl);
  1282.  
  1283.                     predicted_dc /= 128;
  1284.  
  1285.                     /* check for outranging on the [ul u l] and
  1286.                      * [ul u ur l] predictors */
  1287.                     if ((transform == 15) || (transform == 13)) {
  1288.                         if (FFABS(predicted_dc - vu) > 128)
  1289.                             predicted_dc = vu;
  1290.                         else if (FFABS(predicted_dc - vl) > 128)
  1291.                             predicted_dc = vl;
  1292.                         else if (FFABS(predicted_dc - vul) > 128)
  1293.                             predicted_dc = vul;
  1294.                     }
  1295.                 }
  1296.  
  1297.                 /* at long last, apply the predictor */
  1298.                 DC_COEFF(i) += predicted_dc;
  1299.                 /* save the DC */
  1300.                 last_dc[current_frame_type] = DC_COEFF(i);
  1301.             }
  1302.         }
  1303.     }
  1304. }
  1305.  
  1306. static void apply_loop_filter(Vp3DecodeContext *s, int plane,
  1307.                               int ystart, int yend)
  1308. {
  1309.     int x, y;
  1310.     int *bounding_values = s->bounding_values_array + 127;
  1311.  
  1312.     int width           = s->fragment_width[!!plane];
  1313.     int height          = s->fragment_height[!!plane];
  1314.     int fragment        = s->fragment_start[plane] + ystart * width;
  1315.     ptrdiff_t stride    = s->current_frame.f->linesize[plane];
  1316.     uint8_t *plane_data = s->current_frame.f->data[plane];
  1317.     if (!s->flipped_image)
  1318.         stride = -stride;
  1319.     plane_data += s->data_offset[plane] + 8 * ystart * stride;
  1320.  
  1321.     for (y = ystart; y < yend; y++) {
  1322.         for (x = 0; x < width; x++) {
  1323.             /* This code basically just deblocks on the edges of coded blocks.
  1324.              * However, it has to be much more complicated because of the
  1325.              * braindamaged deblock ordering used in VP3/Theora. Order matters
  1326.              * because some pixels get filtered twice. */
  1327.             if (s->all_fragments[fragment].coding_method != MODE_COPY) {
  1328.                 /* do not perform left edge filter for left columns frags */
  1329.                 if (x > 0) {
  1330.                     s->vp3dsp.h_loop_filter(
  1331.                         plane_data + 8 * x,
  1332.                         stride, bounding_values);
  1333.                 }
  1334.  
  1335.                 /* do not perform top edge filter for top row fragments */
  1336.                 if (y > 0) {
  1337.                     s->vp3dsp.v_loop_filter(
  1338.                         plane_data + 8 * x,
  1339.                         stride, bounding_values);
  1340.                 }
  1341.  
  1342.                 /* do not perform right edge filter for right column
  1343.                  * fragments or if right fragment neighbor is also coded
  1344.                  * in this frame (it will be filtered in next iteration) */
  1345.                 if ((x < width - 1) &&
  1346.                     (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {
  1347.                     s->vp3dsp.h_loop_filter(
  1348.                         plane_data + 8 * x + 8,
  1349.                         stride, bounding_values);
  1350.                 }
  1351.  
  1352.                 /* do not perform bottom edge filter for bottom row
  1353.                  * fragments or if bottom fragment neighbor is also coded
  1354.                  * in this frame (it will be filtered in the next row) */
  1355.                 if ((y < height - 1) &&
  1356.                     (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {
  1357.                     s->vp3dsp.v_loop_filter(
  1358.                         plane_data + 8 * x + 8 * stride,
  1359.                         stride, bounding_values);
  1360.                 }
  1361.             }
  1362.  
  1363.             fragment++;
  1364.         }
  1365.         plane_data += 8 * stride;
  1366.     }
  1367. }
  1368.  
  1369. /**
  1370.  * Pull DCT tokens from the 64 levels to decode and dequant the coefficients
  1371.  * for the next block in coding order
  1372.  */
  1373. static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,
  1374.                               int plane, int inter, int16_t block[64])
  1375. {
  1376.     int16_t *dequantizer = s->qmat[frag->qpi][inter][plane];
  1377.     uint8_t *perm = s->idct_scantable;
  1378.     int i = 0;
  1379.  
  1380.     do {
  1381.         int token = *s->dct_tokens[plane][i];
  1382.         switch (token & 3) {
  1383.         case 0: // EOB
  1384.             if (--token < 4) // 0-3 are token types so the EOB run must now be 0
  1385.                 s->dct_tokens[plane][i]++;
  1386.             else
  1387.                 *s->dct_tokens[plane][i] = token & ~3;
  1388.             goto end;
  1389.         case 1: // zero run
  1390.             s->dct_tokens[plane][i]++;
  1391.             i += (token >> 2) & 0x7f;
  1392.             if (i > 63) {
  1393.                 av_log(s->avctx, AV_LOG_ERROR, "Coefficient index overflow\n");
  1394.                 return i;
  1395.             }
  1396.             block[perm[i]] = (token >> 9) * dequantizer[perm[i]];
  1397.             i++;
  1398.             break;
  1399.         case 2: // coeff
  1400.             block[perm[i]] = (token >> 2) * dequantizer[perm[i]];
  1401.             s->dct_tokens[plane][i++]++;
  1402.             break;
  1403.         default: // shouldn't happen
  1404.             return i;
  1405.         }
  1406.     } while (i < 64);
  1407.     // return value is expected to be a valid level
  1408.     i--;
  1409. end:
  1410.     // the actual DC+prediction is in the fragment structure
  1411.     block[0] = frag->dc * s->qmat[0][inter][plane][0];
  1412.     return i;
  1413. }
  1414.  
  1415. /**
  1416.  * called when all pixels up to row y are complete
  1417.  */
  1418. static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)
  1419. {
  1420.     int h, cy, i;
  1421.     int offset[AV_NUM_DATA_POINTERS];
  1422.  
  1423.     if (HAVE_THREADS && s->avctx->active_thread_type & FF_THREAD_FRAME) {
  1424.         int y_flipped = s->flipped_image ? s->height - y : y;
  1425.  
  1426.         /* At the end of the frame, report INT_MAX instead of the height of
  1427.          * the frame. This makes the other threads' ff_thread_await_progress()
  1428.          * calls cheaper, because they don't have to clip their values. */
  1429.         ff_thread_report_progress(&s->current_frame,
  1430.                                   y_flipped == s->height ? INT_MAX
  1431.                                                          : y_flipped - 1,
  1432.                                   0);
  1433.     }
  1434.  
  1435.     if (!s->avctx->draw_horiz_band)
  1436.         return;
  1437.  
  1438.     h = y - s->last_slice_end;
  1439.     s->last_slice_end = y;
  1440.     y -= h;
  1441.  
  1442.     if (!s->flipped_image)
  1443.         y = s->height - y - h;
  1444.  
  1445.     cy        = y >> s->chroma_y_shift;
  1446.     offset[0] = s->current_frame.f->linesize[0] * y;
  1447.     offset[1] = s->current_frame.f->linesize[1] * cy;
  1448.     offset[2] = s->current_frame.f->linesize[2] * cy;
  1449.     for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
  1450.         offset[i] = 0;
  1451.  
  1452.     emms_c();
  1453.     s->avctx->draw_horiz_band(s->avctx, s->current_frame.f, offset, y, 3, h);
  1454. }
  1455.  
  1456. /**
  1457.  * Wait for the reference frame of the current fragment.
  1458.  * The progress value is in luma pixel rows.
  1459.  */
  1460. static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment,
  1461.                                 int motion_y, int y)
  1462. {
  1463.     ThreadFrame *ref_frame;
  1464.     int ref_row;
  1465.     int border = motion_y & 1;
  1466.  
  1467.     if (fragment->coding_method == MODE_USING_GOLDEN ||
  1468.         fragment->coding_method == MODE_GOLDEN_MV)
  1469.         ref_frame = &s->golden_frame;
  1470.     else
  1471.         ref_frame = &s->last_frame;
  1472.  
  1473.     ref_row = y + (motion_y >> 1);
  1474.     ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border);
  1475.  
  1476.     ff_thread_await_progress(ref_frame, ref_row, 0);
  1477. }
  1478.  
  1479. /*
  1480.  * Perform the final rendering for a particular slice of data.
  1481.  * The slice number ranges from 0..(c_superblock_height - 1).
  1482.  */
  1483. static void render_slice(Vp3DecodeContext *s, int slice)
  1484. {
  1485.     int x, y, i, j, fragment;
  1486.     int16_t *block = s->block;
  1487.     int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;
  1488.     int motion_halfpel_index;
  1489.     uint8_t *motion_source;
  1490.     int plane, first_pixel;
  1491.  
  1492.     if (slice >= s->c_superblock_height)
  1493.         return;
  1494.  
  1495.     for (plane = 0; plane < 3; plane++) {
  1496.         uint8_t *output_plane = s->current_frame.f->data[plane] +
  1497.                                 s->data_offset[plane];
  1498.         uint8_t *last_plane = s->last_frame.f->data[plane] +
  1499.                               s->data_offset[plane];
  1500.         uint8_t *golden_plane = s->golden_frame.f->data[plane] +
  1501.                                 s->data_offset[plane];
  1502.         ptrdiff_t stride = s->current_frame.f->linesize[plane];
  1503.         int plane_width  = s->width  >> (plane && s->chroma_x_shift);
  1504.         int plane_height = s->height >> (plane && s->chroma_y_shift);
  1505.         int8_t(*motion_val)[2] = s->motion_val[!!plane];
  1506.  
  1507.         int sb_x, sb_y = slice << (!plane && s->chroma_y_shift);
  1508.         int slice_height = sb_y + 1 + (!plane && s->chroma_y_shift);
  1509.         int slice_width  = plane ? s->c_superblock_width
  1510.                                  : s->y_superblock_width;
  1511.  
  1512.         int fragment_width  = s->fragment_width[!!plane];
  1513.         int fragment_height = s->fragment_height[!!plane];
  1514.         int fragment_start  = s->fragment_start[plane];
  1515.  
  1516.         int do_await = !plane && HAVE_THREADS &&
  1517.                        (s->avctx->active_thread_type & FF_THREAD_FRAME);
  1518.  
  1519.         if (!s->flipped_image)
  1520.             stride = -stride;
  1521.         if (CONFIG_GRAY && plane && (s->avctx->flags & AV_CODEC_FLAG_GRAY))
  1522.             continue;
  1523.  
  1524.         /* for each superblock row in the slice (both of them)... */
  1525.         for (; sb_y < slice_height; sb_y++) {
  1526.             /* for each superblock in a row... */
  1527.             for (sb_x = 0; sb_x < slice_width; sb_x++) {
  1528.                 /* for each block in a superblock... */
  1529.                 for (j = 0; j < 16; j++) {
  1530.                     x        = 4 * sb_x + hilbert_offset[j][0];
  1531.                     y        = 4 * sb_y + hilbert_offset[j][1];
  1532.                     fragment = y * fragment_width + x;
  1533.  
  1534.                     i = fragment_start + fragment;
  1535.  
  1536.                     // bounds check
  1537.                     if (x >= fragment_width || y >= fragment_height)
  1538.                         continue;
  1539.  
  1540.                     first_pixel = 8 * y * stride + 8 * x;
  1541.  
  1542.                     if (do_await &&
  1543.                         s->all_fragments[i].coding_method != MODE_INTRA)
  1544.                         await_reference_row(s, &s->all_fragments[i],
  1545.                                             motion_val[fragment][1],
  1546.                                             (16 * y) >> s->chroma_y_shift);
  1547.  
  1548.                     /* transform if this block was coded */
  1549.                     if (s->all_fragments[i].coding_method != MODE_COPY) {
  1550.                         if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||
  1551.                             (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))
  1552.                             motion_source = golden_plane;
  1553.                         else
  1554.                             motion_source = last_plane;
  1555.  
  1556.                         motion_source       += first_pixel;
  1557.                         motion_halfpel_index = 0;
  1558.  
  1559.                         /* sort out the motion vector if this fragment is coded
  1560.                          * using a motion vector method */
  1561.                         if ((s->all_fragments[i].coding_method > MODE_INTRA) &&
  1562.                             (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {
  1563.                             int src_x, src_y;
  1564.                             motion_x = motion_val[fragment][0];
  1565.                             motion_y = motion_val[fragment][1];
  1566.  
  1567.                             src_x = (motion_x >> 1) + 8 * x;
  1568.                             src_y = (motion_y >> 1) + 8 * y;
  1569.  
  1570.                             motion_halfpel_index = motion_x & 0x01;
  1571.                             motion_source       += (motion_x >> 1);
  1572.  
  1573.                             motion_halfpel_index |= (motion_y & 0x01) << 1;
  1574.                             motion_source        += ((motion_y >> 1) * stride);
  1575.  
  1576.                             if (src_x < 0 || src_y < 0 ||
  1577.                                 src_x + 9 >= plane_width ||
  1578.                                 src_y + 9 >= plane_height) {
  1579.                                 uint8_t *temp = s->edge_emu_buffer;
  1580.                                 if (stride < 0)
  1581.                                     temp -= 8 * stride;
  1582.  
  1583.                                 s->vdsp.emulated_edge_mc(temp, motion_source,
  1584.                                                          stride, stride,
  1585.                                                          9, 9, src_x, src_y,
  1586.                                                          plane_width,
  1587.                                                          plane_height);
  1588.                                 motion_source = temp;
  1589.                             }
  1590.                         }
  1591.  
  1592.                         /* first, take care of copying a block from either the
  1593.                          * previous or the golden frame */
  1594.                         if (s->all_fragments[i].coding_method != MODE_INTRA) {
  1595.                             /* Note, it is possible to implement all MC cases
  1596.                              * with put_no_rnd_pixels_l2 which would look more
  1597.                              * like the VP3 source but this would be slower as
  1598.                              * put_no_rnd_pixels_tab is better optimzed */
  1599.                             if (motion_halfpel_index != 3) {
  1600.                                 s->hdsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](
  1601.                                     output_plane + first_pixel,
  1602.                                     motion_source, stride, 8);
  1603.                             } else {
  1604.                                 /* d is 0 if motion_x and _y have the same sign,
  1605.                                  * else -1 */
  1606.                                 int d = (motion_x ^ motion_y) >> 31;
  1607.                                 s->vp3dsp.put_no_rnd_pixels_l2(output_plane + first_pixel,
  1608.                                                                motion_source - d,
  1609.                                                                motion_source + stride + 1 + d,
  1610.                                                                stride, 8);
  1611.                             }
  1612.                         }
  1613.  
  1614.                         /* invert DCT and place (or add) in final output */
  1615.  
  1616.                         if (s->all_fragments[i].coding_method == MODE_INTRA) {
  1617.                             vp3_dequant(s, s->all_fragments + i,
  1618.                                         plane, 0, block);
  1619.                             s->vp3dsp.idct_put(output_plane + first_pixel,
  1620.                                                stride,
  1621.                                                block);
  1622.                         } else {
  1623.                             if (vp3_dequant(s, s->all_fragments + i,
  1624.                                             plane, 1, block)) {
  1625.                                 s->vp3dsp.idct_add(output_plane + first_pixel,
  1626.                                                    stride,
  1627.                                                    block);
  1628.                             } else {
  1629.                                 s->vp3dsp.idct_dc_add(output_plane + first_pixel,
  1630.                                                       stride, block);
  1631.                             }
  1632.                         }
  1633.                     } else {
  1634.                         /* copy directly from the previous frame */
  1635.                         s->hdsp.put_pixels_tab[1][0](
  1636.                             output_plane + first_pixel,
  1637.                             last_plane + first_pixel,
  1638.                             stride, 8);
  1639.                     }
  1640.                 }
  1641.             }
  1642.  
  1643.             // Filter up to the last row in the superblock row
  1644.             if (!s->skip_loop_filter)
  1645.                 apply_loop_filter(s, plane, 4 * sb_y - !!sb_y,
  1646.                                   FFMIN(4 * sb_y + 3, fragment_height - 1));
  1647.         }
  1648.     }
  1649.  
  1650.     /* this looks like a good place for slice dispatch... */
  1651.     /* algorithm:
  1652.      *   if (slice == s->macroblock_height - 1)
  1653.      *     dispatch (both last slice & 2nd-to-last slice);
  1654.      *   else if (slice > 0)
  1655.      *     dispatch (slice - 1);
  1656.      */
  1657.  
  1658.     vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) - 16,
  1659.                                  s->height - 16));
  1660. }
  1661.  
  1662. /// Allocate tables for per-frame data in Vp3DecodeContext
  1663. static av_cold int allocate_tables(AVCodecContext *avctx)
  1664. {
  1665.     Vp3DecodeContext *s = avctx->priv_data;
  1666.     int y_fragment_count, c_fragment_count;
  1667.  
  1668.     free_tables(avctx);
  1669.  
  1670.     y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
  1671.     c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
  1672.  
  1673.     s->superblock_coding = av_mallocz(s->superblock_count);
  1674.     s->all_fragments     = av_mallocz_array(s->fragment_count, sizeof(Vp3Fragment));
  1675.  
  1676.     s->coded_fragment_list[0] = av_mallocz_array(s->fragment_count, sizeof(int));
  1677.  
  1678.     s->dct_tokens_base = av_mallocz_array(s->fragment_count,
  1679.                                           64 * sizeof(*s->dct_tokens_base));
  1680.     s->motion_val[0] = av_mallocz_array(y_fragment_count, sizeof(*s->motion_val[0]));
  1681.     s->motion_val[1] = av_mallocz_array(c_fragment_count, sizeof(*s->motion_val[1]));
  1682.  
  1683.     /* work out the block mapping tables */
  1684.     s->superblock_fragments = av_mallocz_array(s->superblock_count, 16 * sizeof(int));
  1685.     s->macroblock_coding    = av_mallocz(s->macroblock_count + 1);
  1686.  
  1687.     if (!s->superblock_coding    || !s->all_fragments          ||
  1688.         !s->dct_tokens_base      || !s->coded_fragment_list[0] ||
  1689.         !s->superblock_fragments || !s->macroblock_coding      ||
  1690.         !s->motion_val[0]        || !s->motion_val[1]) {
  1691.         vp3_decode_end(avctx);
  1692.         return -1;
  1693.     }
  1694.  
  1695.     init_block_mapping(s);
  1696.  
  1697.     return 0;
  1698. }
  1699.  
  1700. static av_cold int init_frames(Vp3DecodeContext *s)
  1701. {
  1702.     s->current_frame.f = av_frame_alloc();
  1703.     s->last_frame.f    = av_frame_alloc();
  1704.     s->golden_frame.f  = av_frame_alloc();
  1705.  
  1706.     if (!s->current_frame.f || !s->last_frame.f || !s->golden_frame.f) {
  1707.         av_frame_free(&s->current_frame.f);
  1708.         av_frame_free(&s->last_frame.f);
  1709.         av_frame_free(&s->golden_frame.f);
  1710.         return AVERROR(ENOMEM);
  1711.     }
  1712.  
  1713.     return 0;
  1714. }
  1715.  
  1716. static av_cold int vp3_decode_init(AVCodecContext *avctx)
  1717. {
  1718.     Vp3DecodeContext *s = avctx->priv_data;
  1719.     int i, inter, plane, ret;
  1720.     int c_width;
  1721.     int c_height;
  1722.     int y_fragment_count, c_fragment_count;
  1723.  
  1724.     ret = init_frames(s);
  1725.     if (ret < 0)
  1726.         return ret;
  1727.  
  1728.     avctx->internal->allocate_progress = 1;
  1729.  
  1730.     if (avctx->codec_tag == MKTAG('V', 'P', '3', '0'))
  1731.         s->version = 0;
  1732.     else
  1733.         s->version = 1;
  1734.  
  1735.     s->avctx  = avctx;
  1736.     s->width  = FFALIGN(avctx->coded_width, 16);
  1737.     s->height = FFALIGN(avctx->coded_height, 16);
  1738.     if (avctx->codec_id != AV_CODEC_ID_THEORA)
  1739.         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  1740.     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
  1741.     ff_hpeldsp_init(&s->hdsp, avctx->flags | AV_CODEC_FLAG_BITEXACT);
  1742.     ff_videodsp_init(&s->vdsp, 8);
  1743.     ff_vp3dsp_init(&s->vp3dsp, avctx->flags);
  1744.  
  1745.     for (i = 0; i < 64; i++) {
  1746. #define TRANSPOSE(x) (((x) >> 3) | (((x) & 7) << 3))
  1747.         s->idct_permutation[i] = TRANSPOSE(i);
  1748.         s->idct_scantable[i]   = TRANSPOSE(ff_zigzag_direct[i]);
  1749. #undef TRANSPOSE
  1750.     }
  1751.  
  1752.     /* initialize to an impossible value which will force a recalculation
  1753.      * in the first frame decode */
  1754.     for (i = 0; i < 3; i++)
  1755.         s->qps[i] = -1;
  1756.  
  1757.     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
  1758.  
  1759.     s->y_superblock_width  = (s->width  + 31) / 32;
  1760.     s->y_superblock_height = (s->height + 31) / 32;
  1761.     s->y_superblock_count  = s->y_superblock_width * s->y_superblock_height;
  1762.  
  1763.     /* work out the dimensions for the C planes */
  1764.     c_width                = s->width >> s->chroma_x_shift;
  1765.     c_height               = s->height >> s->chroma_y_shift;
  1766.     s->c_superblock_width  = (c_width  + 31) / 32;
  1767.     s->c_superblock_height = (c_height + 31) / 32;
  1768.     s->c_superblock_count  = s->c_superblock_width * s->c_superblock_height;
  1769.  
  1770.     s->superblock_count   = s->y_superblock_count + (s->c_superblock_count * 2);
  1771.     s->u_superblock_start = s->y_superblock_count;
  1772.     s->v_superblock_start = s->u_superblock_start + s->c_superblock_count;
  1773.  
  1774.     s->macroblock_width  = (s->width  + 15) / 16;
  1775.     s->macroblock_height = (s->height + 15) / 16;
  1776.     s->macroblock_count  = s->macroblock_width * s->macroblock_height;
  1777.  
  1778.     s->fragment_width[0]  = s->width / FRAGMENT_PIXELS;
  1779.     s->fragment_height[0] = s->height / FRAGMENT_PIXELS;
  1780.     s->fragment_width[1]  = s->fragment_width[0] >> s->chroma_x_shift;
  1781.     s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;
  1782.  
  1783.     /* fragment count covers all 8x8 blocks for all 3 planes */
  1784.     y_fragment_count     = s->fragment_width[0] * s->fragment_height[0];
  1785.     c_fragment_count     = s->fragment_width[1] * s->fragment_height[1];
  1786.     s->fragment_count    = y_fragment_count + 2 * c_fragment_count;
  1787.     s->fragment_start[1] = y_fragment_count;
  1788.     s->fragment_start[2] = y_fragment_count + c_fragment_count;
  1789.  
  1790.     if (!s->theora_tables) {
  1791.         for (i = 0; i < 64; i++) {
  1792.             s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];
  1793.             s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];
  1794.             s->base_matrix[0][i]        = vp31_intra_y_dequant[i];
  1795.             s->base_matrix[1][i]        = vp31_intra_c_dequant[i];
  1796.             s->base_matrix[2][i]        = vp31_inter_dequant[i];
  1797.             s->filter_limit_values[i]   = vp31_filter_limit_values[i];
  1798.         }
  1799.  
  1800.         for (inter = 0; inter < 2; inter++) {
  1801.             for (plane = 0; plane < 3; plane++) {
  1802.                 s->qr_count[inter][plane]   = 1;
  1803.                 s->qr_size[inter][plane][0] = 63;
  1804.                 s->qr_base[inter][plane][0] =
  1805.                 s->qr_base[inter][plane][1] = 2 * inter + (!!plane) * !inter;
  1806.             }
  1807.         }
  1808.  
  1809.         /* init VLC tables */
  1810.         for (i = 0; i < 16; i++) {
  1811.             /* DC histograms */
  1812.             init_vlc(&s->dc_vlc[i], 11, 32,
  1813.                      &dc_bias[i][0][1], 4, 2,
  1814.                      &dc_bias[i][0][0], 4, 2, 0);
  1815.  
  1816.             /* group 1 AC histograms */
  1817.             init_vlc(&s->ac_vlc_1[i], 11, 32,
  1818.                      &ac_bias_0[i][0][1], 4, 2,
  1819.                      &ac_bias_0[i][0][0], 4, 2, 0);
  1820.  
  1821.             /* group 2 AC histograms */
  1822.             init_vlc(&s->ac_vlc_2[i], 11, 32,
  1823.                      &ac_bias_1[i][0][1], 4, 2,
  1824.                      &ac_bias_1[i][0][0], 4, 2, 0);
  1825.  
  1826.             /* group 3 AC histograms */
  1827.             init_vlc(&s->ac_vlc_3[i], 11, 32,
  1828.                      &ac_bias_2[i][0][1], 4, 2,
  1829.                      &ac_bias_2[i][0][0], 4, 2, 0);
  1830.  
  1831.             /* group 4 AC histograms */
  1832.             init_vlc(&s->ac_vlc_4[i], 11, 32,
  1833.                      &ac_bias_3[i][0][1], 4, 2,
  1834.                      &ac_bias_3[i][0][0], 4, 2, 0);
  1835.         }
  1836.     } else {
  1837.         for (i = 0; i < 16; i++) {
  1838.             /* DC histograms */
  1839.             if (init_vlc(&s->dc_vlc[i], 11, 32,
  1840.                          &s->huffman_table[i][0][1], 8, 4,
  1841.                          &s->huffman_table[i][0][0], 8, 4, 0) < 0)
  1842.                 goto vlc_fail;
  1843.  
  1844.             /* group 1 AC histograms */
  1845.             if (init_vlc(&s->ac_vlc_1[i], 11, 32,
  1846.                          &s->huffman_table[i + 16][0][1], 8, 4,
  1847.                          &s->huffman_table[i + 16][0][0], 8, 4, 0) < 0)
  1848.                 goto vlc_fail;
  1849.  
  1850.             /* group 2 AC histograms */
  1851.             if (init_vlc(&s->ac_vlc_2[i], 11, 32,
  1852.                          &s->huffman_table[i + 16 * 2][0][1], 8, 4,
  1853.                          &s->huffman_table[i + 16 * 2][0][0], 8, 4, 0) < 0)
  1854.                 goto vlc_fail;
  1855.  
  1856.             /* group 3 AC histograms */
  1857.             if (init_vlc(&s->ac_vlc_3[i], 11, 32,
  1858.                          &s->huffman_table[i + 16 * 3][0][1], 8, 4,
  1859.                          &s->huffman_table[i + 16 * 3][0][0], 8, 4, 0) < 0)
  1860.                 goto vlc_fail;
  1861.  
  1862.             /* group 4 AC histograms */
  1863.             if (init_vlc(&s->ac_vlc_4[i], 11, 32,
  1864.                          &s->huffman_table[i + 16 * 4][0][1], 8, 4,
  1865.                          &s->huffman_table[i + 16 * 4][0][0], 8, 4, 0) < 0)
  1866.                 goto vlc_fail;
  1867.         }
  1868.     }
  1869.  
  1870.     init_vlc(&s->superblock_run_length_vlc, 6, 34,
  1871.              &superblock_run_length_vlc_table[0][1], 4, 2,
  1872.              &superblock_run_length_vlc_table[0][0], 4, 2, 0);
  1873.  
  1874.     init_vlc(&s->fragment_run_length_vlc, 5, 30,
  1875.              &fragment_run_length_vlc_table[0][1], 4, 2,
  1876.              &fragment_run_length_vlc_table[0][0], 4, 2, 0);
  1877.  
  1878.     init_vlc(&s->mode_code_vlc, 3, 8,
  1879.              &mode_code_vlc_table[0][1], 2, 1,
  1880.              &mode_code_vlc_table[0][0], 2, 1, 0);
  1881.  
  1882.     init_vlc(&s->motion_vector_vlc, 6, 63,
  1883.              &motion_vector_vlc_table[0][1], 2, 1,
  1884.              &motion_vector_vlc_table[0][0], 2, 1, 0);
  1885.  
  1886.     return allocate_tables(avctx);
  1887.  
  1888. vlc_fail:
  1889.     av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");
  1890.     return -1;
  1891. }
  1892.  
  1893. /// Release and shuffle frames after decode finishes
  1894. static int update_frames(AVCodecContext *avctx)
  1895. {
  1896.     Vp3DecodeContext *s = avctx->priv_data;
  1897.     int ret = 0;
  1898.  
  1899.     /* shuffle frames (last = current) */
  1900.     ff_thread_release_buffer(avctx, &s->last_frame);
  1901.     ret = ff_thread_ref_frame(&s->last_frame, &s->current_frame);
  1902.     if (ret < 0)
  1903.         goto fail;
  1904.  
  1905.     if (s->keyframe) {
  1906.         ff_thread_release_buffer(avctx, &s->golden_frame);
  1907.         ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame);
  1908.     }
  1909.  
  1910. fail:
  1911.     ff_thread_release_buffer(avctx, &s->current_frame);
  1912.     return ret;
  1913. }
  1914.  
  1915. static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
  1916. {
  1917.     ff_thread_release_buffer(s->avctx, dst);
  1918.     if (src->f->data[0])
  1919.         return ff_thread_ref_frame(dst, src);
  1920.     return 0;
  1921. }
  1922.  
  1923. static int ref_frames(Vp3DecodeContext *dst, Vp3DecodeContext *src)
  1924. {
  1925.     int ret;
  1926.     if ((ret = ref_frame(dst, &dst->current_frame, &src->current_frame)) < 0 ||
  1927.         (ret = ref_frame(dst, &dst->golden_frame,  &src->golden_frame)) < 0  ||
  1928.         (ret = ref_frame(dst, &dst->last_frame,    &src->last_frame)) < 0)
  1929.         return ret;
  1930.     return 0;
  1931. }
  1932.  
  1933. static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
  1934. {
  1935.     Vp3DecodeContext *s = dst->priv_data, *s1 = src->priv_data;
  1936.     int qps_changed = 0, i, err;
  1937.  
  1938. #define copy_fields(to, from, start_field, end_field)                         \
  1939.     memcpy(&to->start_field, &from->start_field,                              \
  1940.            (char *) &to->end_field - (char *) &to->start_field)
  1941.  
  1942.     if (!s1->current_frame.f->data[0] ||
  1943.         s->width != s1->width || s->height != s1->height) {
  1944.         if (s != s1)
  1945.             ref_frames(s, s1);
  1946.         return -1;
  1947.     }
  1948.  
  1949.     if (s != s1) {
  1950.         if (!s->current_frame.f)
  1951.             return AVERROR(ENOMEM);
  1952.         // init tables if the first frame hasn't been decoded
  1953.         if (!s->current_frame.f->data[0]) {
  1954.             int y_fragment_count, c_fragment_count;
  1955.             s->avctx = dst;
  1956.             err = allocate_tables(dst);
  1957.             if (err)
  1958.                 return err;
  1959.             y_fragment_count = s->fragment_width[0] * s->fragment_height[0];
  1960.             c_fragment_count = s->fragment_width[1] * s->fragment_height[1];
  1961.             memcpy(s->motion_val[0], s1->motion_val[0],
  1962.                    y_fragment_count * sizeof(*s->motion_val[0]));
  1963.             memcpy(s->motion_val[1], s1->motion_val[1],
  1964.                    c_fragment_count * sizeof(*s->motion_val[1]));
  1965.         }
  1966.  
  1967.         // copy previous frame data
  1968.         if ((err = ref_frames(s, s1)) < 0)
  1969.             return err;
  1970.  
  1971.         s->keyframe = s1->keyframe;
  1972.  
  1973.         // copy qscale data if necessary
  1974.         for (i = 0; i < 3; i++) {
  1975.             if (s->qps[i] != s1->qps[1]) {
  1976.                 qps_changed = 1;
  1977.                 memcpy(&s->qmat[i], &s1->qmat[i], sizeof(s->qmat[i]));
  1978.             }
  1979.         }
  1980.  
  1981.         if (s->qps[0] != s1->qps[0])
  1982.             memcpy(&s->bounding_values_array, &s1->bounding_values_array,
  1983.                    sizeof(s->bounding_values_array));
  1984.  
  1985.         if (qps_changed)
  1986.             copy_fields(s, s1, qps, superblock_count);
  1987. #undef copy_fields
  1988.     }
  1989.  
  1990.     return update_frames(dst);
  1991. }
  1992.  
  1993. static int vp3_decode_frame(AVCodecContext *avctx,
  1994.                             void *data, int *got_frame,
  1995.                             AVPacket *avpkt)
  1996. {
  1997.     const uint8_t *buf  = avpkt->data;
  1998.     int buf_size        = avpkt->size;
  1999.     Vp3DecodeContext *s = avctx->priv_data;
  2000.     GetBitContext gb;
  2001.     int i, ret;
  2002.  
  2003.     if ((ret = init_get_bits8(&gb, buf, buf_size)) < 0)
  2004.         return ret;
  2005.  
  2006. #if CONFIG_THEORA_DECODER
  2007.     if (s->theora && get_bits1(&gb)) {
  2008.         int type = get_bits(&gb, 7);
  2009.         skip_bits_long(&gb, 6*8); /* "theora" */
  2010.  
  2011.         if (s->avctx->active_thread_type&FF_THREAD_FRAME) {
  2012.             av_log(avctx, AV_LOG_ERROR, "midstream reconfiguration with multithreading is unsupported, try -threads 1\n");
  2013.             return AVERROR_PATCHWELCOME;
  2014.         }
  2015.         if (type == 0) {
  2016.             vp3_decode_end(avctx);
  2017.             ret = theora_decode_header(avctx, &gb);
  2018.  
  2019.             if (ret >= 0)
  2020.                 ret = vp3_decode_init(avctx);
  2021.             if (ret < 0) {
  2022.                 vp3_decode_end(avctx);
  2023.             }
  2024.             return ret;
  2025.         } else if (type == 2) {
  2026.             ret = theora_decode_tables(avctx, &gb);
  2027.             if (ret >= 0)
  2028.                 ret = vp3_decode_init(avctx);
  2029.             if (ret < 0) {
  2030.                 vp3_decode_end(avctx);
  2031.             }
  2032.             return ret;
  2033.         }
  2034.  
  2035.         av_log(avctx, AV_LOG_ERROR,
  2036.                "Header packet passed to frame decoder, skipping\n");
  2037.         return -1;
  2038.     }
  2039. #endif
  2040.  
  2041.     s->keyframe = !get_bits1(&gb);
  2042.     if (!s->all_fragments) {
  2043.         av_log(avctx, AV_LOG_ERROR, "Data packet without prior valid headers\n");
  2044.         return -1;
  2045.     }
  2046.     if (!s->theora)
  2047.         skip_bits(&gb, 1);
  2048.     for (i = 0; i < 3; i++)
  2049.         s->last_qps[i] = s->qps[i];
  2050.  
  2051.     s->nqps = 0;
  2052.     do {
  2053.         s->qps[s->nqps++] = get_bits(&gb, 6);
  2054.     } while (s->theora >= 0x030200 && s->nqps < 3 && get_bits1(&gb));
  2055.     for (i = s->nqps; i < 3; i++)
  2056.         s->qps[i] = -1;
  2057.  
  2058.     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
  2059.         av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",
  2060.                s->keyframe ? "key" : "", avctx->frame_number + 1, s->qps[0]);
  2061.  
  2062.     s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||
  2063.                           avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL
  2064.                                                                   : AVDISCARD_NONKEY);
  2065.  
  2066.     if (s->qps[0] != s->last_qps[0])
  2067.         init_loop_filter(s);
  2068.  
  2069.     for (i = 0; i < s->nqps; i++)
  2070.         // reinit all dequantizers if the first one changed, because
  2071.         // the DC of the first quantizer must be used for all matrices
  2072.         if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])
  2073.             init_dequantizer(s, i);
  2074.  
  2075.     if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)
  2076.         return buf_size;
  2077.  
  2078.     s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
  2079.                                                 : AV_PICTURE_TYPE_P;
  2080.     s->current_frame.f->key_frame = s->keyframe;
  2081.     if (ff_thread_get_buffer(avctx, &s->current_frame, AV_GET_BUFFER_FLAG_REF) < 0)
  2082.         goto error;
  2083.  
  2084.     if (!s->edge_emu_buffer)
  2085.         s->edge_emu_buffer = av_malloc(9 * FFABS(s->current_frame.f->linesize[0]));
  2086.  
  2087.     if (s->keyframe) {
  2088.         if (!s->theora) {
  2089.             skip_bits(&gb, 4); /* width code */
  2090.             skip_bits(&gb, 4); /* height code */
  2091.             if (s->version) {
  2092.                 s->version = get_bits(&gb, 5);
  2093.                 if (avctx->frame_number == 0)
  2094.                     av_log(s->avctx, AV_LOG_DEBUG,
  2095.                            "VP version: %d\n", s->version);
  2096.             }
  2097.         }
  2098.         if (s->version || s->theora) {
  2099.             if (get_bits1(&gb))
  2100.                 av_log(s->avctx, AV_LOG_ERROR,
  2101.                        "Warning, unsupported keyframe coding type?!\n");
  2102.             skip_bits(&gb, 2); /* reserved? */
  2103.         }
  2104.     } else {
  2105.         if (!s->golden_frame.f->data[0]) {
  2106.             av_log(s->avctx, AV_LOG_WARNING,
  2107.                    "vp3: first frame not a keyframe\n");
  2108.  
  2109.             s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I;
  2110.             if (ff_thread_get_buffer(avctx, &s->golden_frame,
  2111.                                      AV_GET_BUFFER_FLAG_REF) < 0)
  2112.                 goto error;
  2113.             ff_thread_release_buffer(avctx, &s->last_frame);
  2114.             if ((ret = ff_thread_ref_frame(&s->last_frame,
  2115.                                            &s->golden_frame)) < 0)
  2116.                 goto error;
  2117.             ff_thread_report_progress(&s->last_frame, INT_MAX, 0);
  2118.         }
  2119.     }
  2120.  
  2121.     memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment));
  2122.     ff_thread_finish_setup(avctx);
  2123.  
  2124.     if (unpack_superblocks(s, &gb)) {
  2125.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");
  2126.         goto error;
  2127.     }
  2128.     if (unpack_modes(s, &gb)) {
  2129.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");
  2130.         goto error;
  2131.     }
  2132.     if (unpack_vectors(s, &gb)) {
  2133.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");
  2134.         goto error;
  2135.     }
  2136.     if (unpack_block_qpis(s, &gb)) {
  2137.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");
  2138.         goto error;
  2139.     }
  2140.     if (unpack_dct_coeffs(s, &gb)) {
  2141.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");
  2142.         goto error;
  2143.     }
  2144.  
  2145.     for (i = 0; i < 3; i++) {
  2146.         int height = s->height >> (i && s->chroma_y_shift);
  2147.         if (s->flipped_image)
  2148.             s->data_offset[i] = 0;
  2149.         else
  2150.             s->data_offset[i] = (height - 1) * s->current_frame.f->linesize[i];
  2151.     }
  2152.  
  2153.     s->last_slice_end = 0;
  2154.     for (i = 0; i < s->c_superblock_height; i++)
  2155.         render_slice(s, i);
  2156.  
  2157.     // filter the last row
  2158.     for (i = 0; i < 3; i++) {
  2159.         int row = (s->height >> (3 + (i && s->chroma_y_shift))) - 1;
  2160.         apply_loop_filter(s, i, row, row + 1);
  2161.     }
  2162.     vp3_draw_horiz_band(s, s->height);
  2163.  
  2164.     /* output frame, offset as needed */
  2165.     if ((ret = av_frame_ref(data, s->current_frame.f)) < 0)
  2166.         return ret;
  2167.     for (i = 0; i < 3; i++) {
  2168.         AVFrame *dst = data;
  2169.         int off = (s->offset_x >> (i && s->chroma_y_shift)) +
  2170.                   (s->offset_y >> (i && s->chroma_y_shift)) * dst->linesize[i];
  2171.         dst->data[i] += off;
  2172.     }
  2173.     *got_frame = 1;
  2174.  
  2175.     if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME)) {
  2176.         ret = update_frames(avctx);
  2177.         if (ret < 0)
  2178.             return ret;
  2179.     }
  2180.  
  2181.     return buf_size;
  2182.  
  2183. error:
  2184.     ff_thread_report_progress(&s->current_frame, INT_MAX, 0);
  2185.  
  2186.     if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_FRAME))
  2187.         av_frame_unref(s->current_frame.f);
  2188.  
  2189.     return -1;
  2190. }
  2191.  
  2192. static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)
  2193. {
  2194.     Vp3DecodeContext *s = avctx->priv_data;
  2195.  
  2196.     if (get_bits1(gb)) {
  2197.         int token;
  2198.         if (s->entries >= 32) { /* overflow */
  2199.             av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
  2200.             return -1;
  2201.         }
  2202.         token = get_bits(gb, 5);
  2203.         ff_dlog(avctx, "hti %d hbits %x token %d entry : %d size %d\n",
  2204.                 s->hti, s->hbits, token, s->entries, s->huff_code_size);
  2205.         s->huffman_table[s->hti][token][0] = s->hbits;
  2206.         s->huffman_table[s->hti][token][1] = s->huff_code_size;
  2207.         s->entries++;
  2208.     } else {
  2209.         if (s->huff_code_size >= 32) { /* overflow */
  2210.             av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");
  2211.             return -1;
  2212.         }
  2213.         s->huff_code_size++;
  2214.         s->hbits <<= 1;
  2215.         if (read_huffman_tree(avctx, gb))
  2216.             return -1;
  2217.         s->hbits |= 1;
  2218.         if (read_huffman_tree(avctx, gb))
  2219.             return -1;
  2220.         s->hbits >>= 1;
  2221.         s->huff_code_size--;
  2222.     }
  2223.     return 0;
  2224. }
  2225.  
  2226. static int vp3_init_thread_copy(AVCodecContext *avctx)
  2227. {
  2228.     Vp3DecodeContext *s = avctx->priv_data;
  2229.  
  2230.     s->superblock_coding      = NULL;
  2231.     s->all_fragments          = NULL;
  2232.     s->coded_fragment_list[0] = NULL;
  2233.     s->dct_tokens_base        = NULL;
  2234.     s->superblock_fragments   = NULL;
  2235.     s->macroblock_coding      = NULL;
  2236.     s->motion_val[0]          = NULL;
  2237.     s->motion_val[1]          = NULL;
  2238.     s->edge_emu_buffer        = NULL;
  2239.  
  2240.     return init_frames(s);
  2241. }
  2242.  
  2243. #if CONFIG_THEORA_DECODER
  2244. static const enum AVPixelFormat theora_pix_fmts[4] = {
  2245.     AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P
  2246. };
  2247.  
  2248. static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)
  2249. {
  2250.     Vp3DecodeContext *s = avctx->priv_data;
  2251.     int visible_width, visible_height, colorspace;
  2252.     uint8_t offset_x = 0, offset_y = 0;
  2253.     int ret;
  2254.     AVRational fps, aspect;
  2255.  
  2256.     s->theora_header = 0;
  2257.     s->theora = get_bits_long(gb, 24);
  2258.     av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);
  2259.  
  2260.     /* 3.2.0 aka alpha3 has the same frame orientation as original vp3
  2261.      * but previous versions have the image flipped relative to vp3 */
  2262.     if (s->theora < 0x030200) {
  2263.         s->flipped_image = 1;
  2264.         av_log(avctx, AV_LOG_DEBUG,
  2265.                "Old (<alpha3) Theora bitstream, flipped image\n");
  2266.     }
  2267.  
  2268.     visible_width  =
  2269.     s->width       = get_bits(gb, 16) << 4;
  2270.     visible_height =
  2271.     s->height      = get_bits(gb, 16) << 4;
  2272.  
  2273.     if (s->theora >= 0x030200) {
  2274.         visible_width  = get_bits_long(gb, 24);
  2275.         visible_height = get_bits_long(gb, 24);
  2276.  
  2277.         offset_x = get_bits(gb, 8); /* offset x */
  2278.         offset_y = get_bits(gb, 8); /* offset y, from bottom */
  2279.     }
  2280.  
  2281.     /* sanity check */
  2282.     if (av_image_check_size(visible_width, visible_height, 0, avctx) < 0 ||
  2283.         visible_width  + offset_x > s->width ||
  2284.         visible_height + offset_y > s->height) {
  2285.         av_log(avctx, AV_LOG_ERROR,
  2286.                "Invalid frame dimensions - w:%d h:%d x:%d y:%d (%dx%d).\n",
  2287.                visible_width, visible_height, offset_x, offset_y,
  2288.                s->width, s->height);
  2289.         return AVERROR_INVALIDDATA;
  2290.     }
  2291.  
  2292.     fps.num = get_bits_long(gb, 32);
  2293.     fps.den = get_bits_long(gb, 32);
  2294.     if (fps.num && fps.den) {
  2295.         if (fps.num < 0 || fps.den < 0) {
  2296.             av_log(avctx, AV_LOG_ERROR, "Invalid framerate\n");
  2297.             return AVERROR_INVALIDDATA;
  2298.         }
  2299.         av_reduce(&avctx->framerate.den, &avctx->framerate.num,
  2300.                   fps.den, fps.num, 1 << 30);
  2301.     }
  2302.  
  2303.     aspect.num = get_bits_long(gb, 24);
  2304.     aspect.den = get_bits_long(gb, 24);
  2305.     if (aspect.num && aspect.den) {
  2306.         av_reduce(&avctx->sample_aspect_ratio.num,
  2307.                   &avctx->sample_aspect_ratio.den,
  2308.                   aspect.num, aspect.den, 1 << 30);
  2309.         ff_set_sar(avctx, avctx->sample_aspect_ratio);
  2310.     }
  2311.  
  2312.     if (s->theora < 0x030200)
  2313.         skip_bits(gb, 5); /* keyframe frequency force */
  2314.     colorspace = get_bits(gb, 8);
  2315.     skip_bits(gb, 24); /* bitrate */
  2316.  
  2317.     skip_bits(gb, 6); /* quality hint */
  2318.  
  2319.     if (s->theora >= 0x030200) {
  2320.         skip_bits(gb, 5); /* keyframe frequency force */
  2321.         avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];
  2322.         if (avctx->pix_fmt == AV_PIX_FMT_NONE) {
  2323.             av_log(avctx, AV_LOG_ERROR, "Invalid pixel format\n");
  2324.             return AVERROR_INVALIDDATA;
  2325.         }
  2326.         skip_bits(gb, 3); /* reserved */
  2327.     } else
  2328.         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  2329.  
  2330.     ret = ff_set_dimensions(avctx, s->width, s->height);
  2331.     if (ret < 0)
  2332.         return ret;
  2333.     if (!(avctx->flags2 & AV_CODEC_FLAG2_IGNORE_CROP)) {
  2334.         avctx->width  = visible_width;
  2335.         avctx->height = visible_height;
  2336.         // translate offsets from theora axis ([0,0] lower left)
  2337.         // to normal axis ([0,0] upper left)
  2338.         s->offset_x = offset_x;
  2339.         s->offset_y = s->height - visible_height - offset_y;
  2340.  
  2341.         if ((s->offset_x & 0x1F) && !(avctx->flags & AV_CODEC_FLAG_UNALIGNED)) {
  2342.             s->offset_x &= ~0x1F;
  2343.             if (!s->offset_x_warned) {
  2344.                 s->offset_x_warned = 1;
  2345.                 av_log(avctx, AV_LOG_WARNING, "Reducing offset_x from %d to %d"
  2346.                     "chroma samples to preserve alignment.\n",
  2347.                     offset_x, s->offset_x);
  2348.             }
  2349.         }
  2350.     }
  2351.  
  2352.     if (colorspace == 1)
  2353.         avctx->color_primaries = AVCOL_PRI_BT470M;
  2354.     else if (colorspace == 2)
  2355.         avctx->color_primaries = AVCOL_PRI_BT470BG;
  2356.  
  2357.     if (colorspace == 1 || colorspace == 2) {
  2358.         avctx->colorspace = AVCOL_SPC_BT470BG;
  2359.         avctx->color_trc  = AVCOL_TRC_BT709;
  2360.     }
  2361.  
  2362.     s->theora_header = 1;
  2363.     return 0;
  2364. }
  2365.  
  2366. static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)
  2367. {
  2368.     Vp3DecodeContext *s = avctx->priv_data;
  2369.     int i, n, matrices, inter, plane;
  2370.  
  2371.     if (!s->theora_header)
  2372.         return AVERROR_INVALIDDATA;
  2373.  
  2374.     if (s->theora >= 0x030200) {
  2375.         n = get_bits(gb, 3);
  2376.         /* loop filter limit values table */
  2377.         if (n)
  2378.             for (i = 0; i < 64; i++)
  2379.                 s->filter_limit_values[i] = get_bits(gb, n);
  2380.     }
  2381.  
  2382.     if (s->theora >= 0x030200)
  2383.         n = get_bits(gb, 4) + 1;
  2384.     else
  2385.         n = 16;
  2386.     /* quality threshold table */
  2387.     for (i = 0; i < 64; i++)
  2388.         s->coded_ac_scale_factor[i] = get_bits(gb, n);
  2389.  
  2390.     if (s->theora >= 0x030200)
  2391.         n = get_bits(gb, 4) + 1;
  2392.     else
  2393.         n = 16;
  2394.     /* dc scale factor table */
  2395.     for (i = 0; i < 64; i++)
  2396.         s->coded_dc_scale_factor[i] = get_bits(gb, n);
  2397.  
  2398.     if (s->theora >= 0x030200)
  2399.         matrices = get_bits(gb, 9) + 1;
  2400.     else
  2401.         matrices = 3;
  2402.  
  2403.     if (matrices > 384) {
  2404.         av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");
  2405.         return -1;
  2406.     }
  2407.  
  2408.     for (n = 0; n < matrices; n++)
  2409.         for (i = 0; i < 64; i++)
  2410.             s->base_matrix[n][i] = get_bits(gb, 8);
  2411.  
  2412.     for (inter = 0; inter <= 1; inter++) {
  2413.         for (plane = 0; plane <= 2; plane++) {
  2414.             int newqr = 1;
  2415.             if (inter || plane > 0)
  2416.                 newqr = get_bits1(gb);
  2417.             if (!newqr) {
  2418.                 int qtj, plj;
  2419.                 if (inter && get_bits1(gb)) {
  2420.                     qtj = 0;
  2421.                     plj = plane;
  2422.                 } else {
  2423.                     qtj = (3 * inter + plane - 1) / 3;
  2424.                     plj = (plane + 2) % 3;
  2425.                 }
  2426.                 s->qr_count[inter][plane] = s->qr_count[qtj][plj];
  2427.                 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj],
  2428.                        sizeof(s->qr_size[0][0]));
  2429.                 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj],
  2430.                        sizeof(s->qr_base[0][0]));
  2431.             } else {
  2432.                 int qri = 0;
  2433.                 int qi  = 0;
  2434.  
  2435.                 for (;;) {
  2436.                     i = get_bits(gb, av_log2(matrices - 1) + 1);
  2437.                     if (i >= matrices) {
  2438.                         av_log(avctx, AV_LOG_ERROR,
  2439.                                "invalid base matrix index\n");
  2440.                         return -1;
  2441.                     }
  2442.                     s->qr_base[inter][plane][qri] = i;
  2443.                     if (qi >= 63)
  2444.                         break;
  2445.                     i = get_bits(gb, av_log2(63 - qi) + 1) + 1;
  2446.                     s->qr_size[inter][plane][qri++] = i;
  2447.                     qi += i;
  2448.                 }
  2449.  
  2450.                 if (qi > 63) {
  2451.                     av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);
  2452.                     return -1;
  2453.                 }
  2454.                 s->qr_count[inter][plane] = qri;
  2455.             }
  2456.         }
  2457.     }
  2458.  
  2459.     /* Huffman tables */
  2460.     for (s->hti = 0; s->hti < 80; s->hti++) {
  2461.         s->entries        = 0;
  2462.         s->huff_code_size = 1;
  2463.         if (!get_bits1(gb)) {
  2464.             s->hbits = 0;
  2465.             if (read_huffman_tree(avctx, gb))
  2466.                 return -1;
  2467.             s->hbits = 1;
  2468.             if (read_huffman_tree(avctx, gb))
  2469.                 return -1;
  2470.         }
  2471.     }
  2472.  
  2473.     s->theora_tables = 1;
  2474.  
  2475.     return 0;
  2476. }
  2477.  
  2478. static av_cold int theora_decode_init(AVCodecContext *avctx)
  2479. {
  2480.     Vp3DecodeContext *s = avctx->priv_data;
  2481.     GetBitContext gb;
  2482.     int ptype;
  2483.     const uint8_t *header_start[3];
  2484.     int header_len[3];
  2485.     int i;
  2486.     int ret;
  2487.  
  2488.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
  2489.  
  2490.     s->theora = 1;
  2491.  
  2492.     if (!avctx->extradata_size) {
  2493.         av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");
  2494.         return -1;
  2495.     }
  2496.  
  2497.     if (avpriv_split_xiph_headers(avctx->extradata, avctx->extradata_size,
  2498.                                   42, header_start, header_len) < 0) {
  2499.         av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");
  2500.         return -1;
  2501.     }
  2502.  
  2503.     for (i = 0; i < 3; i++) {
  2504.         if (header_len[i] <= 0)
  2505.             continue;
  2506.         ret = init_get_bits8(&gb, header_start[i], header_len[i]);
  2507.         if (ret < 0)
  2508.             return ret;
  2509.  
  2510.         ptype = get_bits(&gb, 8);
  2511.  
  2512.         if (!(ptype & 0x80)) {
  2513.             av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");
  2514. //          return -1;
  2515.         }
  2516.  
  2517.         // FIXME: Check for this as well.
  2518.         skip_bits_long(&gb, 6 * 8); /* "theora" */
  2519.  
  2520.         switch (ptype) {
  2521.         case 0x80:
  2522.             if (theora_decode_header(avctx, &gb) < 0)
  2523.                 return -1;
  2524.             break;
  2525.         case 0x81:
  2526. // FIXME: is this needed? it breaks sometimes
  2527. //            theora_decode_comments(avctx, gb);
  2528.             break;
  2529.         case 0x82:
  2530.             if (theora_decode_tables(avctx, &gb))
  2531.                 return -1;
  2532.             break;
  2533.         default:
  2534.             av_log(avctx, AV_LOG_ERROR,
  2535.                    "Unknown Theora config packet: %d\n", ptype & ~0x80);
  2536.             break;
  2537.         }
  2538.         if (ptype != 0x81 && 8 * header_len[i] != get_bits_count(&gb))
  2539.             av_log(avctx, AV_LOG_WARNING,
  2540.                    "%d bits left in packet %X\n",
  2541.                    8 * header_len[i] - get_bits_count(&gb), ptype);
  2542.         if (s->theora < 0x030200)
  2543.             break;
  2544.     }
  2545.  
  2546.     return vp3_decode_init(avctx);
  2547. }
  2548.  
  2549. AVCodec ff_theora_decoder = {
  2550.     .name                  = "theora",
  2551.     .long_name             = NULL_IF_CONFIG_SMALL("Theora"),
  2552.     .type                  = AVMEDIA_TYPE_VIDEO,
  2553.     .id                    = AV_CODEC_ID_THEORA,
  2554.     .priv_data_size        = sizeof(Vp3DecodeContext),
  2555.     .init                  = theora_decode_init,
  2556.     .close                 = vp3_decode_end,
  2557.     .decode                = vp3_decode_frame,
  2558.     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
  2559.                              AV_CODEC_CAP_FRAME_THREADS,
  2560.     .flush                 = vp3_decode_flush,
  2561.     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),
  2562.     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)
  2563. };
  2564. #endif
  2565.  
  2566. AVCodec ff_vp3_decoder = {
  2567.     .name                  = "vp3",
  2568.     .long_name             = NULL_IF_CONFIG_SMALL("On2 VP3"),
  2569.     .type                  = AVMEDIA_TYPE_VIDEO,
  2570.     .id                    = AV_CODEC_ID_VP3,
  2571.     .priv_data_size        = sizeof(Vp3DecodeContext),
  2572.     .init                  = vp3_decode_init,
  2573.     .close                 = vp3_decode_end,
  2574.     .decode                = vp3_decode_frame,
  2575.     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
  2576.                              AV_CODEC_CAP_FRAME_THREADS,
  2577.     .flush                 = vp3_decode_flush,
  2578.     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),
  2579.     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context),
  2580. };
  2581.