falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
30982 Commits
32 Branches
297MB
Tree: a7c31f1595
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a7c31f1595'
${ noResults }
FFmpeg/libavcodec/vp3.c

2396 lines
83KB
Raw Blame History 

  1. /*

  2.  * Copyright (C) 2003-2004 the ffmpeg project

  3.  *

  4.  * This file is part of Libav.

  5.  *

  6.  * Libav 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.  * Libav 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 Libav; 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. #include "avcodec.h"

  38. #include "internal.h"

  39. #include "dsputil.h"

  40. #include "get_bits.h"

  41. 

  42. #include "vp3data.h"

  43. #include "xiph.h"

  44. #include "thread.h"

  45. 

  46. #define FRAGMENT_PIXELS 8

  47. 

  48. static av_cold int vp3_decode_end(AVCodecContext *avctx);

  49. static void vp3_decode_flush(AVCodecContext *avctx);

  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. /* There are 6 preset schemes, plus a free-form scheme */

  81. static const int ModeAlphabet[6][CODING_MODE_COUNT] =

  82. {

  83.     /* scheme 1: Last motion vector dominates */

  84.     {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,

  85.          MODE_INTER_PLUS_MV,    MODE_INTER_NO_MV,

  86.          MODE_INTRA,            MODE_USING_GOLDEN,

  87.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  88. 

  89.     /* scheme 2 */

  90.     {    MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,

  91.          MODE_INTER_NO_MV,      MODE_INTER_PLUS_MV,

  92.          MODE_INTRA,            MODE_USING_GOLDEN,

  93.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  94. 

  95.     /* scheme 3 */

  96.     {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,

  97.          MODE_INTER_PRIOR_LAST, MODE_INTER_NO_MV,

  98.          MODE_INTRA,            MODE_USING_GOLDEN,

  99.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  100. 

  101.     /* scheme 4 */

  102.     {    MODE_INTER_LAST_MV,    MODE_INTER_PLUS_MV,

  103.          MODE_INTER_NO_MV,      MODE_INTER_PRIOR_LAST,

  104.          MODE_INTRA,            MODE_USING_GOLDEN,

  105.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  106. 

  107.     /* scheme 5: No motion vector dominates */

  108.     {    MODE_INTER_NO_MV,      MODE_INTER_LAST_MV,

  109.          MODE_INTER_PRIOR_LAST, MODE_INTER_PLUS_MV,

  110.          MODE_INTRA,            MODE_USING_GOLDEN,

  111.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  112. 

  113.     /* scheme 6 */

  114.     {    MODE_INTER_NO_MV,      MODE_USING_GOLDEN,

  115.          MODE_INTER_LAST_MV,    MODE_INTER_PRIOR_LAST,

  116.          MODE_INTER_PLUS_MV,    MODE_INTRA,

  117.          MODE_GOLDEN_MV,        MODE_INTER_FOURMV },

  118. 

  119. };

  120. 

  121. static const uint8_t hilbert_offset[16][2] = {

  122.     {0,0}, {1,0}, {1,1}, {0,1},

  123.     {0,2}, {0,3}, {1,3}, {1,2},

  124.     {2,2}, {2,3}, {3,3}, {3,2},

  125.     {3,1}, {2,1}, {2,0}, {3,0}

  126. };

  127. 

  128. #define MIN_DEQUANT_VAL 2

  129. 

  130. typedef struct Vp3DecodeContext {

  131.     AVCodecContext *avctx;

  132.     int theora, theora_tables;

  133.     int version;

  134.     int width, height;

  135.     int chroma_x_shift, chroma_y_shift;

  136.     AVFrame golden_frame;

  137.     AVFrame last_frame;

  138.     AVFrame current_frame;

  139.     int keyframe;

  140.     DSPContext dsp;

  141.     int flipped_image;

  142.     int last_slice_end;

  143.     int skip_loop_filter;

  144. 

  145.     int qps[3];

  146.     int nqps;

  147.     int last_qps[3];

  148. 

  149.     int superblock_count;

  150.     int y_superblock_width;

  151.     int y_superblock_height;

  152.     int y_superblock_count;

  153.     int c_superblock_width;

  154.     int c_superblock_height;

  155.     int c_superblock_count;

  156.     int u_superblock_start;

  157.     int v_superblock_start;

  158.     unsigned char *superblock_coding;

  159. 

  160.     int macroblock_count;

  161.     int macroblock_width;

  162.     int macroblock_height;

  163. 

  164.     int fragment_count;

  165.     int fragment_width[2];

  166.     int fragment_height[2];

  167. 

  168.     Vp3Fragment *all_fragments;

  169.     int fragment_start[3];

  170.     int data_offset[3];

  171. 

  172.     int8_t (*motion_val[2])[2];

  173. 

  174.     ScanTable scantable;

  175. 

  176.     /* tables */

  177.     uint16_t coded_dc_scale_factor[64];

  178.     uint32_t coded_ac_scale_factor[64];

  179.     uint8_t base_matrix[384][64];

  180.     uint8_t qr_count[2][3];

  181.     uint8_t qr_size [2][3][64];

  182.     uint16_t qr_base[2][3][64];

  183. 

  184.     /**

  185.      * This is a list of all tokens in bitstream order. Reordering takes place

  186.      * by pulling from each level during IDCT. As a consequence, IDCT must be

  187.      * in Hilbert order, making the minimum slice height 64 for 4:2:0 and 32

  188.      * otherwise. The 32 different tokens with up to 12 bits of extradata are

  189.      * collapsed into 3 types, packed as follows:

  190.      *   (from the low to high bits)

  191.      *

  192.      * 2 bits: type (0,1,2)

  193.      *   0: EOB run, 14 bits for run length (12 needed)

  194.      *   1: zero run, 7 bits for run length

  195.      *                7 bits for the next coefficient (3 needed)

  196.      *   2: coefficient, 14 bits (11 needed)

  197.      *

  198.      * Coefficients are signed, so are packed in the highest bits for automatic

  199.      * sign extension.

  200.      */

  201.     int16_t *dct_tokens[3][64];

  202.     int16_t *dct_tokens_base;

  203. #define TOKEN_EOB(eob_run)              ((eob_run) << 2)

  204. #define TOKEN_ZERO_RUN(coeff, zero_run) (((coeff) << 9) + ((zero_run) << 2) + 1)

  205. #define TOKEN_COEFF(coeff)              (((coeff) << 2) + 2)

  206. 

  207.     /**

  208.      * number of blocks that contain DCT coefficients at the given level or higher

  209.      */

  210.     int num_coded_frags[3][64];

  211.     int total_num_coded_frags;

  212. 

  213.     /* this is a list of indexes into the all_fragments array indicating

  214.      * which of the fragments are coded */

  215.     int *coded_fragment_list[3];

  216. 

  217.     VLC dc_vlc[16];

  218.     VLC ac_vlc_1[16];

  219.     VLC ac_vlc_2[16];

  220.     VLC ac_vlc_3[16];

  221.     VLC ac_vlc_4[16];

  222. 

  223.     VLC superblock_run_length_vlc;

  224.     VLC fragment_run_length_vlc;

  225.     VLC mode_code_vlc;

  226.     VLC motion_vector_vlc;

  227. 

  228.     /* these arrays need to be on 16-byte boundaries since SSE2 operations

  229.      * index into them */

  230.     DECLARE_ALIGNED(16, int16_t, qmat)[3][2][3][64];     ///< qmat[qpi][is_inter][plane]

  231. 

  232.     /* This table contains superblock_count * 16 entries. Each set of 16

  233.      * numbers corresponds to the fragment indexes 0..15 of the superblock.

  234.      * An entry will be -1 to indicate that no entry corresponds to that

  235.      * index. */

  236.     int *superblock_fragments;

  237. 

  238.     /* This is an array that indicates how a particular macroblock

  239.      * is coded. */

  240.     unsigned char *macroblock_coding;

  241. 

  242.     uint8_t *edge_emu_buffer;

  243. 

  244.     /* Huffman decode */

  245.     int hti;

  246.     unsigned int hbits;

  247.     int entries;

  248.     int huff_code_size;

  249.     uint32_t huffman_table[80][32][2];

  250. 

  251.     uint8_t filter_limit_values[64];

  252.     DECLARE_ALIGNED(8, int, bounding_values_array)[256+2];

  253. } Vp3DecodeContext;

  254. 

  255. /************************************************************************

  256.  * VP3 specific functions

  257.  ************************************************************************/

  258. 

  259. /*

  260.  * This function sets up all of the various blocks mappings:

  261.  * superblocks <-> fragments, macroblocks <-> fragments,

  262.  * superblocks <-> macroblocks

  263.  *

  264.  * @return 0 is successful; returns 1 if *anything* went wrong.

  265.  */

  266. static int init_block_mapping(Vp3DecodeContext *s)

  267. {

  268.     int sb_x, sb_y, plane;

  269.     int x, y, i, j = 0;

  270. 

  271.     for (plane = 0; plane < 3; plane++) {

  272.         int sb_width    = plane ? s->c_superblock_width  : s->y_superblock_width;

  273.         int sb_height   = plane ? s->c_superblock_height : s->y_superblock_height;

  274.         int frag_width  = s->fragment_width[!!plane];

  275.         int frag_height = s->fragment_height[!!plane];

  276. 

  277.         for (sb_y = 0; sb_y < sb_height; sb_y++)

  278.             for (sb_x = 0; sb_x < sb_width; sb_x++)

  279.                 for (i = 0; i < 16; i++) {

  280.                     x = 4*sb_x + hilbert_offset[i][0];

  281.                     y = 4*sb_y + hilbert_offset[i][1];

  282. 

  283.                     if (x < frag_width && y < frag_height)

  284.                         s->superblock_fragments[j++] = s->fragment_start[plane] + y*frag_width + x;

  285.                     else

  286.                         s->superblock_fragments[j++] = -1;

  287.                 }

  288.     }

  289. 

  290.     return 0;  /* successful path out */

  291. }

  292. 

  293. /*

  294.  * This function sets up the dequantization tables used for a particular

  295.  * frame.

  296.  */

  297. static void init_dequantizer(Vp3DecodeContext *s, int qpi)

  298. {

  299.     int ac_scale_factor = s->coded_ac_scale_factor[s->qps[qpi]];

  300.     int dc_scale_factor = s->coded_dc_scale_factor[s->qps[qpi]];

  301.     int i, plane, inter, qri, bmi, bmj, qistart;

  302. 

  303.     for(inter=0; inter<2; inter++){

  304.         for(plane=0; plane<3; plane++){

  305.             int sum=0;

  306.             for(qri=0; qri<s->qr_count[inter][plane]; qri++){

  307.                 sum+= s->qr_size[inter][plane][qri];

  308.                 if(s->qps[qpi] <= sum)

  309.                     break;

  310.             }

  311.             qistart= sum - s->qr_size[inter][plane][qri];

  312.             bmi= s->qr_base[inter][plane][qri  ];

  313.             bmj= s->qr_base[inter][plane][qri+1];

  314.             for(i=0; i<64; i++){

  315.                 int coeff= (  2*(sum    -s->qps[qpi])*s->base_matrix[bmi][i]

  316.                             - 2*(qistart-s->qps[qpi])*s->base_matrix[bmj][i]

  317.                             + s->qr_size[inter][plane][qri])

  318.                            / (2*s->qr_size[inter][plane][qri]);

  319. 

  320.                 int qmin= 8<<(inter + !i);

  321.                 int qscale= i ? ac_scale_factor : dc_scale_factor;

  322. 

  323.                 s->qmat[qpi][inter][plane][s->dsp.idct_permutation[i]]= av_clip((qscale * coeff)/100 * 4, qmin, 4096);

  324.             }

  325.             // all DC coefficients use the same quant so as not to interfere with DC prediction

  326.             s->qmat[qpi][inter][plane][0] = s->qmat[0][inter][plane][0];

  327.         }

  328.     }

  329. }

  330. 

  331. /*

  332.  * This function initializes the loop filter boundary limits if the frame's

  333.  * quality index is different from the previous frame's.

  334.  *

  335.  * The filter_limit_values may not be larger than 127.

  336.  */

  337. static void init_loop_filter(Vp3DecodeContext *s)

  338. {

  339.     int *bounding_values= s->bounding_values_array+127;

  340.     int filter_limit;

  341.     int x;

  342.     int value;

  343. 

  344.     filter_limit = s->filter_limit_values[s->qps[0]];

  345. 

  346.     /* set up the bounding values */

  347.     memset(s->bounding_values_array, 0, 256 * sizeof(int));

  348.     for (x = 0; x < filter_limit; x++) {

  349.         bounding_values[-x] = -x;

  350.         bounding_values[x] = x;

  351.     }

  352.     for (x = value = filter_limit; x < 128 && value; x++, value--) {

  353.         bounding_values[ x] =  value;

  354.         bounding_values[-x] = -value;

  355.     }

  356.     if (value)

  357.         bounding_values[128] = value;

  358.     bounding_values[129] = bounding_values[130] = filter_limit * 0x02020202;

  359. }

  360. 

  361. /*

  362.  * This function unpacks all of the superblock/macroblock/fragment coding

  363.  * information from the bitstream.

  364.  */

  365. static int unpack_superblocks(Vp3DecodeContext *s, GetBitContext *gb)

  366. {

  367.     int superblock_starts[3] = { 0, s->u_superblock_start, s->v_superblock_start };

  368.     int bit = 0;

  369.     int current_superblock = 0;

  370.     int current_run = 0;

  371.     int num_partial_superblocks = 0;

  372. 

  373.     int i, j;

  374.     int current_fragment;

  375.     int plane;

  376. 

  377.     if (s->keyframe) {

  378.         memset(s->superblock_coding, SB_FULLY_CODED, s->superblock_count);

  379. 

  380.     } else {

  381. 

  382.         /* unpack the list of partially-coded superblocks */

  383.         bit = get_bits1(gb) ^ 1;

  384.         current_run = 0;

  385. 

  386.         while (current_superblock < s->superblock_count && get_bits_left(gb) > 0) {

  387.             if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)

  388.                 bit = get_bits1(gb);

  389.             else

  390.                 bit ^= 1;

  391. 

  392.                 current_run = get_vlc2(gb,

  393.                     s->superblock_run_length_vlc.table, 6, 2) + 1;

  394.                 if (current_run == 34)

  395.                     current_run += get_bits(gb, 12);

  396. 

  397.             if (current_superblock + current_run > s->superblock_count) {

  398.                 av_log(s->avctx, AV_LOG_ERROR, "Invalid partially coded superblock run length\n");

  399.                 return -1;

  400.             }

  401. 

  402.             memset(s->superblock_coding + current_superblock, bit, current_run);

  403. 

  404.             current_superblock += current_run;

  405.             if (bit)

  406.                 num_partial_superblocks += current_run;

  407.         }

  408. 

  409.         /* unpack the list of fully coded superblocks if any of the blocks were

  410.          * not marked as partially coded in the previous step */

  411.         if (num_partial_superblocks < s->superblock_count) {

  412.             int superblocks_decoded = 0;

  413. 

  414.             current_superblock = 0;

  415.             bit = get_bits1(gb) ^ 1;

  416.             current_run = 0;

  417. 

  418.             while (superblocks_decoded < s->superblock_count - num_partial_superblocks

  419.                    && get_bits_left(gb) > 0) {

  420. 

  421.                 if (s->theora && current_run == MAXIMUM_LONG_BIT_RUN)

  422.                     bit = get_bits1(gb);

  423.                 else

  424.                     bit ^= 1;

  425. 

  426.                         current_run = get_vlc2(gb,

  427.                             s->superblock_run_length_vlc.table, 6, 2) + 1;

  428.                         if (current_run == 34)

  429.                             current_run += get_bits(gb, 12);

  430. 

  431.                 for (j = 0; j < current_run; current_superblock++) {

  432.                     if (current_superblock >= s->superblock_count) {

  433.                         av_log(s->avctx, AV_LOG_ERROR, "Invalid fully coded superblock run length\n");

  434.                         return -1;

  435.                     }

  436. 

  437.                 /* skip any superblocks already marked as partially coded */

  438.                 if (s->superblock_coding[current_superblock] == SB_NOT_CODED) {

  439.                     s->superblock_coding[current_superblock] = 2*bit;

  440.                     j++;

  441.                 }

  442.                 }

  443.                 superblocks_decoded += current_run;

  444.             }

  445.         }

  446. 

  447.         /* if there were partial blocks, initialize bitstream for

  448.          * unpacking fragment codings */

  449.         if (num_partial_superblocks) {

  450. 

  451.             current_run = 0;

  452.             bit = get_bits1(gb);

  453.             /* toggle the bit because as soon as the first run length is

  454.              * fetched the bit will be toggled again */

  455.             bit ^= 1;

  456.         }

  457.     }

  458. 

  459.     /* figure out which fragments are coded; iterate through each

  460.      * superblock (all planes) */

  461.     s->total_num_coded_frags = 0;

  462.     memset(s->macroblock_coding, MODE_COPY, s->macroblock_count);

  463. 

  464.     for (plane = 0; plane < 3; plane++) {

  465.         int sb_start = superblock_starts[plane];

  466.         int sb_end = sb_start + (plane ? s->c_superblock_count : s->y_superblock_count);

  467.         int num_coded_frags = 0;

  468. 

  469.     for (i = sb_start; i < sb_end && get_bits_left(gb) > 0; i++) {

  470. 

  471.         /* iterate through all 16 fragments in a superblock */

  472.         for (j = 0; j < 16; j++) {

  473. 

  474.             /* if the fragment is in bounds, check its coding status */

  475.             current_fragment = s->superblock_fragments[i * 16 + j];

  476.             if (current_fragment != -1) {

  477.                 int coded = s->superblock_coding[i];

  478. 

  479.                 if (s->superblock_coding[i] == SB_PARTIALLY_CODED) {

  480. 

  481.                     /* fragment may or may not be coded; this is the case

  482.                      * that cares about the fragment coding runs */

  483.                     if (current_run-- == 0) {

  484.                         bit ^= 1;

  485.                         current_run = get_vlc2(gb,

  486.                             s->fragment_run_length_vlc.table, 5, 2);

  487.                     }

  488.                     coded = bit;

  489.                 }

  490. 

  491.                     if (coded) {

  492.                         /* default mode; actual mode will be decoded in

  493.                          * the next phase */

  494.                         s->all_fragments[current_fragment].coding_method =

  495.                             MODE_INTER_NO_MV;

  496.                         s->coded_fragment_list[plane][num_coded_frags++] =

  497.                             current_fragment;

  498.                     } else {

  499.                         /* not coded; copy this fragment from the prior frame */

  500.                         s->all_fragments[current_fragment].coding_method =

  501.                             MODE_COPY;

  502.                     }

  503.             }

  504.         }

  505.     }

  506.         s->total_num_coded_frags += num_coded_frags;

  507.         for (i = 0; i < 64; i++)

  508.             s->num_coded_frags[plane][i] = num_coded_frags;

  509.         if (plane < 2)

  510.             s->coded_fragment_list[plane+1] = s->coded_fragment_list[plane] + num_coded_frags;

  511.     }

  512.     return 0;

  513. }

  514. 

  515. /*

  516.  * This function unpacks all the coding mode data for individual macroblocks

  517.  * from the bitstream.

  518.  */

  519. static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)

  520. {

  521.     int i, j, k, sb_x, sb_y;

  522.     int scheme;

  523.     int current_macroblock;

  524.     int current_fragment;

  525.     int coding_mode;

  526.     int custom_mode_alphabet[CODING_MODE_COUNT];

  527.     const int *alphabet;

  528.     Vp3Fragment *frag;

  529. 

  530.     if (s->keyframe) {

  531.         for (i = 0; i < s->fragment_count; i++)

  532.             s->all_fragments[i].coding_method = MODE_INTRA;

  533. 

  534.     } else {

  535. 

  536.         /* fetch the mode coding scheme for this frame */

  537.         scheme = get_bits(gb, 3);

  538. 

  539.         /* is it a custom coding scheme? */

  540.         if (scheme == 0) {

  541.             for (i = 0; i < 8; i++)

  542.                 custom_mode_alphabet[i] = MODE_INTER_NO_MV;

  543.             for (i = 0; i < 8; i++)

  544.                 custom_mode_alphabet[get_bits(gb, 3)] = i;

  545.             alphabet = custom_mode_alphabet;

  546.         } else

  547.             alphabet = ModeAlphabet[scheme-1];

  548. 

  549.         /* iterate through all of the macroblocks that contain 1 or more

  550.          * coded fragments */

  551.         for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {

  552.             for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {

  553.                 if (get_bits_left(gb) <= 0)

  554.                     return -1;

  555. 

  556.             for (j = 0; j < 4; j++) {

  557.                 int mb_x = 2*sb_x +   (j>>1);

  558.                 int mb_y = 2*sb_y + (((j>>1)+j)&1);

  559.                 current_macroblock = mb_y * s->macroblock_width + mb_x;

  560. 

  561.                 if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height)

  562.                     continue;

  563. 

  564. #define BLOCK_X (2*mb_x + (k&1))

  565. #define BLOCK_Y (2*mb_y + (k>>1))

  566.                 /* coding modes are only stored if the macroblock has at least one

  567.                  * luma block coded, otherwise it must be INTER_NO_MV */

  568.                 for (k = 0; k < 4; k++) {

  569.                     current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X;

  570.                     if (s->all_fragments[current_fragment].coding_method != MODE_COPY)

  571.                         break;

  572.                 }

  573.                 if (k == 4) {

  574.                     s->macroblock_coding[current_macroblock] = MODE_INTER_NO_MV;

  575.                     continue;

  576.                 }

  577. 

  578.                 /* mode 7 means get 3 bits for each coding mode */

  579.                 if (scheme == 7)

  580.                     coding_mode = get_bits(gb, 3);

  581.                 else

  582.                     coding_mode = alphabet

  583.                         [get_vlc2(gb, s->mode_code_vlc.table, 3, 3)];

  584. 

  585.                 s->macroblock_coding[current_macroblock] = coding_mode;

  586.                 for (k = 0; k < 4; k++) {

  587.                     frag = s->all_fragments + BLOCK_Y*s->fragment_width[0] + BLOCK_X;

  588.                     if (frag->coding_method != MODE_COPY)

  589.                         frag->coding_method = coding_mode;

  590.                 }

  591. 

  592. #define SET_CHROMA_MODES \

  593.     if (frag[s->fragment_start[1]].coding_method != MODE_COPY) \

  594.         frag[s->fragment_start[1]].coding_method = coding_mode;\

  595.     if (frag[s->fragment_start[2]].coding_method != MODE_COPY) \

  596.         frag[s->fragment_start[2]].coding_method = coding_mode;

  597. 

  598.                 if (s->chroma_y_shift) {

  599.                     frag = s->all_fragments + mb_y*s->fragment_width[1] + mb_x;

  600.                     SET_CHROMA_MODES

  601.                 } else if (s->chroma_x_shift) {

  602.                     frag = s->all_fragments + 2*mb_y*s->fragment_width[1] + mb_x;

  603.                     for (k = 0; k < 2; k++) {

  604.                         SET_CHROMA_MODES

  605.                         frag += s->fragment_width[1];

  606.                     }

  607.                 } else {

  608.                     for (k = 0; k < 4; k++) {

  609.                         frag = s->all_fragments + BLOCK_Y*s->fragment_width[1] + BLOCK_X;

  610.                         SET_CHROMA_MODES

  611.                     }

  612.                 }

  613.             }

  614.             }

  615.         }

  616.     }

  617. 

  618.     return 0;

  619. }

  620. 

  621. /*

  622.  * This function unpacks all the motion vectors for the individual

  623.  * macroblocks from the bitstream.

  624.  */

  625. static int unpack_vectors(Vp3DecodeContext *s, GetBitContext *gb)

  626. {

  627.     int j, k, sb_x, sb_y;

  628.     int coding_mode;

  629.     int motion_x[4];

  630.     int motion_y[4];

  631.     int last_motion_x = 0;

  632.     int last_motion_y = 0;

  633.     int prior_last_motion_x = 0;

  634.     int prior_last_motion_y = 0;

  635.     int current_macroblock;

  636.     int current_fragment;

  637.     int frag;

  638. 

  639.     if (s->keyframe)

  640.         return 0;

  641. 

  642.     /* coding mode 0 is the VLC scheme; 1 is the fixed code scheme */

  643.     coding_mode = get_bits1(gb);

  644. 

  645.     /* iterate through all of the macroblocks that contain 1 or more

  646.      * coded fragments */

  647.     for (sb_y = 0; sb_y < s->y_superblock_height; sb_y++) {

  648.         for (sb_x = 0; sb_x < s->y_superblock_width; sb_x++) {

  649.             if (get_bits_left(gb) <= 0)

  650.                 return -1;

  651. 

  652.         for (j = 0; j < 4; j++) {

  653.             int mb_x = 2*sb_x +   (j>>1);

  654.             int mb_y = 2*sb_y + (((j>>1)+j)&1);

  655.             current_macroblock = mb_y * s->macroblock_width + mb_x;

  656. 

  657.             if (mb_x >= s->macroblock_width || mb_y >= s->macroblock_height ||

  658.                 (s->macroblock_coding[current_macroblock] == MODE_COPY))

  659.                 continue;

  660. 

  661.             switch (s->macroblock_coding[current_macroblock]) {

  662. 

  663.             case MODE_INTER_PLUS_MV:

  664.             case MODE_GOLDEN_MV:

  665.                 /* all 6 fragments use the same motion vector */

  666.                 if (coding_mode == 0) {

  667.                     motion_x[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

  668.                     motion_y[0] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

  669.                 } else {

  670.                     motion_x[0] = fixed_motion_vector_table[get_bits(gb, 6)];

  671.                     motion_y[0] = fixed_motion_vector_table[get_bits(gb, 6)];

  672.                 }

  673. 

  674.                 /* vector maintenance, only on MODE_INTER_PLUS_MV */

  675.                 if (s->macroblock_coding[current_macroblock] ==

  676.                     MODE_INTER_PLUS_MV) {

  677.                     prior_last_motion_x = last_motion_x;

  678.                     prior_last_motion_y = last_motion_y;

  679.                     last_motion_x = motion_x[0];

  680.                     last_motion_y = motion_y[0];

  681.                 }

  682.                 break;

  683. 

  684.             case MODE_INTER_FOURMV:

  685.                 /* vector maintenance */

  686.                 prior_last_motion_x = last_motion_x;

  687.                 prior_last_motion_y = last_motion_y;

  688. 

  689.                 /* fetch 4 vectors from the bitstream, one for each

  690.                  * Y fragment, then average for the C fragment vectors */

  691.                 for (k = 0; k < 4; k++) {

  692.                     current_fragment = BLOCK_Y*s->fragment_width[0] + BLOCK_X;

  693.                     if (s->all_fragments[current_fragment].coding_method != MODE_COPY) {

  694.                         if (coding_mode == 0) {

  695.                             motion_x[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

  696.                             motion_y[k] = motion_vector_table[get_vlc2(gb, s->motion_vector_vlc.table, 6, 2)];

  697.                         } else {

  698.                             motion_x[k] = fixed_motion_vector_table[get_bits(gb, 6)];

  699.                             motion_y[k] = fixed_motion_vector_table[get_bits(gb, 6)];

  700.                         }

  701.                         last_motion_x = motion_x[k];

  702.                         last_motion_y = motion_y[k];

  703.                     } else {

  704.                         motion_x[k] = 0;

  705.                         motion_y[k] = 0;

  706.                     }

  707.                 }

  708.                 break;

  709. 

  710.             case MODE_INTER_LAST_MV:

  711.                 /* all 6 fragments use the last motion vector */

  712.                 motion_x[0] = last_motion_x;

  713.                 motion_y[0] = last_motion_y;

  714. 

  715.                 /* no vector maintenance (last vector remains the

  716.                  * last vector) */

  717.                 break;

  718. 

  719.             case MODE_INTER_PRIOR_LAST:

  720.                 /* all 6 fragments use the motion vector prior to the

  721.                  * last motion vector */

  722.                 motion_x[0] = prior_last_motion_x;

  723.                 motion_y[0] = prior_last_motion_y;

  724. 

  725.                 /* vector maintenance */

  726.                 prior_last_motion_x = last_motion_x;

  727.                 prior_last_motion_y = last_motion_y;

  728.                 last_motion_x = motion_x[0];

  729.                 last_motion_y = motion_y[0];

  730.                 break;

  731. 

  732.             default:

  733.                 /* covers intra, inter without MV, golden without MV */

  734.                 motion_x[0] = 0;

  735.                 motion_y[0] = 0;

  736. 

  737.                 /* no vector maintenance */

  738.                 break;

  739.             }

  740. 

  741.             /* assign the motion vectors to the correct fragments */

  742.             for (k = 0; k < 4; k++) {

  743.                 current_fragment =

  744.                     BLOCK_Y*s->fragment_width[0] + BLOCK_X;

  745.                 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

  746.                     s->motion_val[0][current_fragment][0] = motion_x[k];

  747.                     s->motion_val[0][current_fragment][1] = motion_y[k];

  748.                 } else {

  749.                     s->motion_val[0][current_fragment][0] = motion_x[0];

  750.                     s->motion_val[0][current_fragment][1] = motion_y[0];

  751.                 }

  752.             }

  753. 

  754.             if (s->chroma_y_shift) {

  755.                 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

  756.                     motion_x[0] = RSHIFT(motion_x[0] + motion_x[1] + motion_x[2] + motion_x[3], 2);

  757.                     motion_y[0] = RSHIFT(motion_y[0] + motion_y[1] + motion_y[2] + motion_y[3], 2);

  758.                 }

  759.                 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);

  760.                 motion_y[0] = (motion_y[0]>>1) | (motion_y[0]&1);

  761.                 frag = mb_y*s->fragment_width[1] + mb_x;

  762.                 s->motion_val[1][frag][0] = motion_x[0];

  763.                 s->motion_val[1][frag][1] = motion_y[0];

  764.             } else if (s->chroma_x_shift) {

  765.                 if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

  766.                     motion_x[0] = RSHIFT(motion_x[0] + motion_x[1], 1);

  767.                     motion_y[0] = RSHIFT(motion_y[0] + motion_y[1], 1);

  768.                     motion_x[1] = RSHIFT(motion_x[2] + motion_x[3], 1);

  769.                     motion_y[1] = RSHIFT(motion_y[2] + motion_y[3], 1);

  770.                 } else {

  771.                     motion_x[1] = motion_x[0];

  772.                     motion_y[1] = motion_y[0];

  773.                 }

  774.                 motion_x[0] = (motion_x[0]>>1) | (motion_x[0]&1);

  775.                 motion_x[1] = (motion_x[1]>>1) | (motion_x[1]&1);

  776. 

  777.                 frag = 2*mb_y*s->fragment_width[1] + mb_x;

  778.                 for (k = 0; k < 2; k++) {

  779.                     s->motion_val[1][frag][0] = motion_x[k];

  780.                     s->motion_val[1][frag][1] = motion_y[k];

  781.                     frag += s->fragment_width[1];

  782.                 }

  783.             } else {

  784.                 for (k = 0; k < 4; k++) {

  785.                     frag = BLOCK_Y*s->fragment_width[1] + BLOCK_X;

  786.                     if (s->macroblock_coding[current_macroblock] == MODE_INTER_FOURMV) {

  787.                         s->motion_val[1][frag][0] = motion_x[k];

  788.                         s->motion_val[1][frag][1] = motion_y[k];

  789.                     } else {

  790.                         s->motion_val[1][frag][0] = motion_x[0];

  791.                         s->motion_val[1][frag][1] = motion_y[0];

  792.                     }

  793.                 }

  794.             }

  795.         }

  796.         }

  797.     }

  798. 

  799.     return 0;

  800. }

  801. 

  802. static int unpack_block_qpis(Vp3DecodeContext *s, GetBitContext *gb)

  803. {

  804.     int qpi, i, j, bit, run_length, blocks_decoded, num_blocks_at_qpi;

  805.     int num_blocks = s->total_num_coded_frags;

  806. 

  807.     for (qpi = 0; qpi < s->nqps-1 && num_blocks > 0; qpi++) {

  808.         i = blocks_decoded = num_blocks_at_qpi = 0;

  809. 

  810.         bit = get_bits1(gb) ^ 1;

  811.         run_length = 0;

  812. 

  813.         do {

  814.             if (run_length == MAXIMUM_LONG_BIT_RUN)

  815.                 bit = get_bits1(gb);

  816.             else

  817.                 bit ^= 1;

  818. 

  819.             run_length = get_vlc2(gb, s->superblock_run_length_vlc.table, 6, 2) + 1;

  820.             if (run_length == 34)

  821.                 run_length += get_bits(gb, 12);

  822.             blocks_decoded += run_length;

  823. 

  824.             if (!bit)

  825.                 num_blocks_at_qpi += run_length;

  826. 

  827.             for (j = 0; j < run_length; i++) {

  828.                 if (i >= s->total_num_coded_frags)

  829.                     return -1;

  830. 

  831.                 if (s->all_fragments[s->coded_fragment_list[0][i]].qpi == qpi) {

  832.                     s->all_fragments[s->coded_fragment_list[0][i]].qpi += bit;

  833.                     j++;

  834.                 }

  835.             }

  836.         } while (blocks_decoded < num_blocks && get_bits_left(gb) > 0);

  837. 

  838.         num_blocks -= num_blocks_at_qpi;

  839.     }

  840. 

  841.     return 0;

  842. }

  843. 

  844. /*

  845.  * This function is called by unpack_dct_coeffs() to extract the VLCs from

  846.  * the bitstream. The VLCs encode tokens which are used to unpack DCT

  847.  * data. This function unpacks all the VLCs for either the Y plane or both

  848.  * C planes, and is called for DC coefficients or different AC coefficient

  849.  * levels (since different coefficient types require different VLC tables.

  850.  *

  851.  * This function returns a residual eob run. E.g, if a particular token gave

  852.  * instructions to EOB the next 5 fragments and there were only 2 fragments

  853.  * left in the current fragment range, 3 would be returned so that it could

  854.  * be passed into the next call to this same function.

  855.  */

  856. static int unpack_vlcs(Vp3DecodeContext *s, GetBitContext *gb,

  857.                         VLC *table, int coeff_index,

  858.                         int plane,

  859.                         int eob_run)

  860. {

  861.     int i, j = 0;

  862.     int token;

  863.     int zero_run = 0;

  864.     DCTELEM coeff = 0;

  865.     int bits_to_get;

  866.     int blocks_ended;

  867.     int coeff_i = 0;

  868.     int num_coeffs = s->num_coded_frags[plane][coeff_index];

  869.     int16_t *dct_tokens = s->dct_tokens[plane][coeff_index];

  870. 

  871.     /* local references to structure members to avoid repeated deferences */

  872.     int *coded_fragment_list = s->coded_fragment_list[plane];

  873.     Vp3Fragment *all_fragments = s->all_fragments;

  874.     VLC_TYPE (*vlc_table)[2] = table->table;

  875. 

  876.     if (num_coeffs < 0)

  877.         av_log(s->avctx, AV_LOG_ERROR, "Invalid number of coefficents at level %d\n", coeff_index);

  878. 

  879.     if (eob_run > num_coeffs) {

  880.         coeff_i = blocks_ended = num_coeffs;

  881.         eob_run -= num_coeffs;

  882.     } else {

  883.         coeff_i = blocks_ended = eob_run;

  884.         eob_run = 0;

  885.     }

  886. 

  887.     // insert fake EOB token to cover the split between planes or zzi

  888.     if (blocks_ended)

  889.         dct_tokens[j++] = blocks_ended << 2;

  890. 

  891.     while (coeff_i < num_coeffs && get_bits_left(gb) > 0) {

  892.             /* decode a VLC into a token */

  893.             token = get_vlc2(gb, vlc_table, 11, 3);

  894.             /* use the token to get a zero run, a coefficient, and an eob run */

  895.             if ((unsigned) token <= 6U) {

  896.                 eob_run = eob_run_base[token];

  897.                 if (eob_run_get_bits[token])

  898.                     eob_run += get_bits(gb, eob_run_get_bits[token]);

  899. 

  900.                 // record only the number of blocks ended in this plane,

  901.                 // any spill will be recorded in the next plane.

  902.                 if (eob_run > num_coeffs - coeff_i) {

  903.                     dct_tokens[j++] = TOKEN_EOB(num_coeffs - coeff_i);

  904.                     blocks_ended   += num_coeffs - coeff_i;

  905.                     eob_run        -= num_coeffs - coeff_i;

  906.                     coeff_i         = num_coeffs;

  907.                 } else {

  908.                     dct_tokens[j++] = TOKEN_EOB(eob_run);

  909.                     blocks_ended   += eob_run;

  910.                     coeff_i        += eob_run;

  911.                     eob_run = 0;

  912.                 }

  913.             } else if (token >= 0) {

  914.                 bits_to_get = coeff_get_bits[token];

  915.                 if (bits_to_get)

  916.                     bits_to_get = get_bits(gb, bits_to_get);

  917.                 coeff = coeff_tables[token][bits_to_get];

  918. 

  919.                 zero_run = zero_run_base[token];

  920.                 if (zero_run_get_bits[token])

  921.                     zero_run += get_bits(gb, zero_run_get_bits[token]);

  922. 

  923.                 if (zero_run) {

  924.                     dct_tokens[j++] = TOKEN_ZERO_RUN(coeff, zero_run);

  925.                 } else {

  926.                     // Save DC into the fragment structure. DC prediction is

  927.                     // done in raster order, so the actual DC can't be in with

  928.                     // other tokens. We still need the token in dct_tokens[]

  929.                     // however, or else the structure collapses on itself.

  930.                     if (!coeff_index)

  931.                         all_fragments[coded_fragment_list[coeff_i]].dc = coeff;

  932. 

  933.                     dct_tokens[j++] = TOKEN_COEFF(coeff);

  934.                 }

  935. 

  936.                 if (coeff_index + zero_run > 64) {

  937.                     av_log(s->avctx, AV_LOG_DEBUG, "Invalid zero run of %d with"

  938.                            " %d coeffs left\n", zero_run, 64-coeff_index);

  939.                     zero_run = 64 - coeff_index;

  940.                 }

  941. 

  942.                 // zero runs code multiple coefficients,

  943.                 // so don't try to decode coeffs for those higher levels

  944.                 for (i = coeff_index+1; i <= coeff_index+zero_run; i++)

  945.                     s->num_coded_frags[plane][i]--;

  946.                 coeff_i++;

  947.             } else {

  948.                 av_log(s->avctx, AV_LOG_ERROR,

  949.                        "Invalid token %d\n", token);

  950.                 return -1;

  951.             }

  952.     }

  953. 

  954.     if (blocks_ended > s->num_coded_frags[plane][coeff_index])

  955.         av_log(s->avctx, AV_LOG_ERROR, "More blocks ended than coded!\n");

  956. 

  957.     // decrement the number of blocks that have higher coeffecients for each

  958.     // EOB run at this level

  959.     if (blocks_ended)

  960.         for (i = coeff_index+1; i < 64; i++)

  961.             s->num_coded_frags[plane][i] -= blocks_ended;

  962. 

  963.     // setup the next buffer

  964.     if (plane < 2)

  965.         s->dct_tokens[plane+1][coeff_index] = dct_tokens + j;

  966.     else if (coeff_index < 63)

  967.         s->dct_tokens[0][coeff_index+1] = dct_tokens + j;

  968. 

  969.     return eob_run;

  970. }

  971. 

  972. static void reverse_dc_prediction(Vp3DecodeContext *s,

  973.                                   int first_fragment,

  974.                                   int fragment_width,

  975.                                   int fragment_height);

  976. /*

  977.  * This function unpacks all of the DCT coefficient data from the

  978.  * bitstream.

  979.  */

  980. static int unpack_dct_coeffs(Vp3DecodeContext *s, GetBitContext *gb)

  981. {

  982.     int i;

  983.     int dc_y_table;

  984.     int dc_c_table;

  985.     int ac_y_table;

  986.     int ac_c_table;

  987.     int residual_eob_run = 0;

  988.     VLC *y_tables[64];

  989.     VLC *c_tables[64];

  990. 

  991.     s->dct_tokens[0][0] = s->dct_tokens_base;

  992. 

  993.     /* fetch the DC table indexes */

  994.     dc_y_table = get_bits(gb, 4);

  995.     dc_c_table = get_bits(gb, 4);

  996. 

  997.     /* unpack the Y plane DC coefficients */

  998.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_y_table], 0,

  999.         0, residual_eob_run);

  1000.     if (residual_eob_run < 0)

  1001.         return residual_eob_run;

  1002. 

  1003.     /* reverse prediction of the Y-plane DC coefficients */

  1004.     reverse_dc_prediction(s, 0, s->fragment_width[0], s->fragment_height[0]);

  1005. 

  1006.     /* unpack the C plane DC coefficients */

  1007.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,

  1008.         1, residual_eob_run);

  1009.     if (residual_eob_run < 0)

  1010.         return residual_eob_run;

  1011.     residual_eob_run = unpack_vlcs(s, gb, &s->dc_vlc[dc_c_table], 0,

  1012.         2, residual_eob_run);

  1013.     if (residual_eob_run < 0)

  1014.         return residual_eob_run;

  1015. 

  1016.     /* reverse prediction of the C-plane DC coefficients */

  1017.     if (!(s->avctx->flags & CODEC_FLAG_GRAY))

  1018.     {

  1019.         reverse_dc_prediction(s, s->fragment_start[1],

  1020.             s->fragment_width[1], s->fragment_height[1]);

  1021.         reverse_dc_prediction(s, s->fragment_start[2],

  1022.             s->fragment_width[1], s->fragment_height[1]);

  1023.     }

  1024. 

  1025.     /* fetch the AC table indexes */

  1026.     ac_y_table = get_bits(gb, 4);

  1027.     ac_c_table = get_bits(gb, 4);

  1028. 

  1029.     /* build tables of AC VLC tables */

  1030.     for (i = 1; i <= 5; i++) {

  1031.         y_tables[i] = &s->ac_vlc_1[ac_y_table];

  1032.         c_tables[i] = &s->ac_vlc_1[ac_c_table];

  1033.     }

  1034.     for (i = 6; i <= 14; i++) {

  1035.         y_tables[i] = &s->ac_vlc_2[ac_y_table];

  1036.         c_tables[i] = &s->ac_vlc_2[ac_c_table];

  1037.     }

  1038.     for (i = 15; i <= 27; i++) {

  1039.         y_tables[i] = &s->ac_vlc_3[ac_y_table];

  1040.         c_tables[i] = &s->ac_vlc_3[ac_c_table];

  1041.     }

  1042.     for (i = 28; i <= 63; i++) {

  1043.         y_tables[i] = &s->ac_vlc_4[ac_y_table];

  1044.         c_tables[i] = &s->ac_vlc_4[ac_c_table];

  1045.     }

  1046. 

  1047.     /* decode all AC coefficents */

  1048.     for (i = 1; i <= 63; i++) {

  1049.             residual_eob_run = unpack_vlcs(s, gb, y_tables[i], i,

  1050.                 0, residual_eob_run);

  1051.             if (residual_eob_run < 0)

  1052.                 return residual_eob_run;

  1053. 

  1054.             residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,

  1055.                 1, residual_eob_run);

  1056.             if (residual_eob_run < 0)

  1057.                 return residual_eob_run;

  1058.             residual_eob_run = unpack_vlcs(s, gb, c_tables[i], i,

  1059.                 2, residual_eob_run);

  1060.             if (residual_eob_run < 0)

  1061.                 return residual_eob_run;

  1062.     }

  1063. 

  1064.     return 0;

  1065. }

  1066. 

  1067. /*

  1068.  * This function reverses the DC prediction for each coded fragment in

  1069.  * the frame. Much of this function is adapted directly from the original

  1070.  * VP3 source code.

  1071.  */

  1072. #define COMPATIBLE_FRAME(x) \

  1073.   (compatible_frame[s->all_fragments[x].coding_method] == current_frame_type)

  1074. #define DC_COEFF(u) s->all_fragments[u].dc

  1075. 

  1076. static void reverse_dc_prediction(Vp3DecodeContext *s,

  1077.                                   int first_fragment,

  1078.                                   int fragment_width,

  1079.                                   int fragment_height)

  1080. {

  1081. 

  1082. #define PUL 8

  1083. #define PU 4

  1084. #define PUR 2

  1085. #define PL 1

  1086. 

  1087.     int x, y;

  1088.     int i = first_fragment;

  1089. 

  1090.     int predicted_dc;

  1091. 

  1092.     /* DC values for the left, up-left, up, and up-right fragments */

  1093.     int vl, vul, vu, vur;

  1094. 

  1095.     /* indexes for the left, up-left, up, and up-right fragments */

  1096.     int l, ul, u, ur;

  1097. 

  1098.     /*

  1099.      * The 6 fields mean:

  1100.      *   0: up-left multiplier

  1101.      *   1: up multiplier

  1102.      *   2: up-right multiplier

  1103.      *   3: left multiplier

  1104.      */

  1105.     static const int predictor_transform[16][4] = {

  1106.         {  0,  0,  0,  0},

  1107.         {  0,  0,  0,128},        // PL

  1108.         {  0,  0,128,  0},        // PUR

  1109.         {  0,  0, 53, 75},        // PUR|PL

  1110.         {  0,128,  0,  0},        // PU

  1111.         {  0, 64,  0, 64},        // PU|PL

  1112.         {  0,128,  0,  0},        // PU|PUR

  1113.         {  0,  0, 53, 75},        // PU|PUR|PL

  1114.         {128,  0,  0,  0},        // PUL

  1115.         {  0,  0,  0,128},        // PUL|PL

  1116.         { 64,  0, 64,  0},        // PUL|PUR

  1117.         {  0,  0, 53, 75},        // PUL|PUR|PL

  1118.         {  0,128,  0,  0},        // PUL|PU

  1119.        {-104,116,  0,116},        // PUL|PU|PL

  1120.         { 24, 80, 24,  0},        // PUL|PU|PUR

  1121.        {-104,116,  0,116}         // PUL|PU|PUR|PL

  1122.     };

  1123. 

  1124.     /* This table shows which types of blocks can use other blocks for

  1125.      * prediction. For example, INTRA is the only mode in this table to

  1126.      * have a frame number of 0. That means INTRA blocks can only predict

  1127.      * from other INTRA blocks. There are 2 golden frame coding types;

  1128.      * blocks encoding in these modes can only predict from other blocks

  1129.      * that were encoded with these 1 of these 2 modes. */

  1130.     static const unsigned char compatible_frame[9] = {

  1131.         1,    /* MODE_INTER_NO_MV */

  1132.         0,    /* MODE_INTRA */

  1133.         1,    /* MODE_INTER_PLUS_MV */

  1134.         1,    /* MODE_INTER_LAST_MV */

  1135.         1,    /* MODE_INTER_PRIOR_MV */

  1136.         2,    /* MODE_USING_GOLDEN */

  1137.         2,    /* MODE_GOLDEN_MV */

  1138.         1,    /* MODE_INTER_FOUR_MV */

  1139.         3     /* MODE_COPY */

  1140.     };

  1141.     int current_frame_type;

  1142. 

  1143.     /* there is a last DC predictor for each of the 3 frame types */

  1144.     short last_dc[3];

  1145. 

  1146.     int transform = 0;

  1147. 

  1148.     vul = vu = vur = vl = 0;

  1149.     last_dc[0] = last_dc[1] = last_dc[2] = 0;

  1150. 

  1151.     /* for each fragment row... */

  1152.     for (y = 0; y < fragment_height; y++) {

  1153. 

  1154.         /* for each fragment in a row... */

  1155.         for (x = 0; x < fragment_width; x++, i++) {

  1156. 

  1157.             /* reverse prediction if this block was coded */

  1158.             if (s->all_fragments[i].coding_method != MODE_COPY) {

  1159. 

  1160.                 current_frame_type =

  1161.                     compatible_frame[s->all_fragments[i].coding_method];

  1162. 

  1163.                 transform= 0;

  1164.                 if(x){

  1165.                     l= i-1;

  1166.                     vl = DC_COEFF(l);

  1167.                     if(COMPATIBLE_FRAME(l))

  1168.                         transform |= PL;

  1169.                 }

  1170.                 if(y){

  1171.                     u= i-fragment_width;

  1172.                     vu = DC_COEFF(u);

  1173.                     if(COMPATIBLE_FRAME(u))

  1174.                         transform |= PU;

  1175.                     if(x){

  1176.                         ul= i-fragment_width-1;

  1177.                         vul = DC_COEFF(ul);

  1178.                         if(COMPATIBLE_FRAME(ul))

  1179.                             transform |= PUL;

  1180.                     }

  1181.                     if(x + 1 < fragment_width){

  1182.                         ur= i-fragment_width+1;

  1183.                         vur = DC_COEFF(ur);

  1184.                         if(COMPATIBLE_FRAME(ur))

  1185.                             transform |= PUR;

  1186.                     }

  1187.                 }

  1188. 

  1189.                 if (transform == 0) {

  1190. 

  1191.                     /* if there were no fragments to predict from, use last

  1192.                      * DC saved */

  1193.                     predicted_dc = last_dc[current_frame_type];

  1194.                 } else {

  1195. 

  1196.                     /* apply the appropriate predictor transform */

  1197.                     predicted_dc =

  1198.                         (predictor_transform[transform][0] * vul) +

  1199.                         (predictor_transform[transform][1] * vu) +

  1200.                         (predictor_transform[transform][2] * vur) +

  1201.                         (predictor_transform[transform][3] * vl);

  1202. 

  1203.                     predicted_dc /= 128;

  1204. 

  1205.                     /* check for outranging on the [ul u l] and

  1206.                      * [ul u ur l] predictors */

  1207.                     if ((transform == 15) || (transform == 13)) {

  1208.                         if (FFABS(predicted_dc - vu) > 128)

  1209.                             predicted_dc = vu;

  1210.                         else if (FFABS(predicted_dc - vl) > 128)

  1211.                             predicted_dc = vl;

  1212.                         else if (FFABS(predicted_dc - vul) > 128)

  1213.                             predicted_dc = vul;

  1214.                     }

  1215.                 }

  1216. 

  1217.                 /* at long last, apply the predictor */

  1218.                 DC_COEFF(i) += predicted_dc;

  1219.                 /* save the DC */

  1220.                 last_dc[current_frame_type] = DC_COEFF(i);

  1221.             }

  1222.         }

  1223.     }

  1224. }

  1225. 

  1226. static void apply_loop_filter(Vp3DecodeContext *s, int plane, int ystart, int yend)

  1227. {

  1228.     int x, y;

  1229.     int *bounding_values= s->bounding_values_array+127;

  1230. 

  1231.     int width           = s->fragment_width[!!plane];

  1232.     int height          = s->fragment_height[!!plane];

  1233.     int fragment        = s->fragment_start        [plane] + ystart * width;

  1234.     int stride          = s->current_frame.linesize[plane];

  1235.     uint8_t *plane_data = s->current_frame.data    [plane];

  1236.     if (!s->flipped_image) stride = -stride;

  1237.     plane_data += s->data_offset[plane] + 8*ystart*stride;

  1238. 

  1239.     for (y = ystart; y < yend; y++) {

  1240. 

  1241.         for (x = 0; x < width; x++) {

  1242.             /* This code basically just deblocks on the edges of coded blocks.

  1243.              * However, it has to be much more complicated because of the

  1244.              * braindamaged deblock ordering used in VP3/Theora. Order matters

  1245.              * because some pixels get filtered twice. */

  1246.             if( s->all_fragments[fragment].coding_method != MODE_COPY )

  1247.             {

  1248.                 /* do not perform left edge filter for left columns frags */

  1249.                 if (x > 0) {

  1250.                     s->dsp.vp3_h_loop_filter(

  1251.                         plane_data + 8*x,

  1252.                         stride, bounding_values);

  1253.                 }

  1254. 

  1255.                 /* do not perform top edge filter for top row fragments */

  1256.                 if (y > 0) {

  1257.                     s->dsp.vp3_v_loop_filter(

  1258.                         plane_data + 8*x,

  1259.                         stride, bounding_values);

  1260.                 }

  1261. 

  1262.                 /* do not perform right edge filter for right column

  1263.                  * fragments or if right fragment neighbor is also coded

  1264.                  * in this frame (it will be filtered in next iteration) */

  1265.                 if ((x < width - 1) &&

  1266.                     (s->all_fragments[fragment + 1].coding_method == MODE_COPY)) {

  1267.                     s->dsp.vp3_h_loop_filter(

  1268.                         plane_data + 8*x + 8,

  1269.                         stride, bounding_values);

  1270.                 }

  1271. 

  1272.                 /* do not perform bottom edge filter for bottom row

  1273.                  * fragments or if bottom fragment neighbor is also coded

  1274.                  * in this frame (it will be filtered in the next row) */

  1275.                 if ((y < height - 1) &&

  1276.                     (s->all_fragments[fragment + width].coding_method == MODE_COPY)) {

  1277.                     s->dsp.vp3_v_loop_filter(

  1278.                         plane_data + 8*x + 8*stride,

  1279.                         stride, bounding_values);

  1280.                 }

  1281.             }

  1282. 

  1283.             fragment++;

  1284.         }

  1285.         plane_data += 8*stride;

  1286.     }

  1287. }

  1288. 

  1289. /**

  1290.  * Pull DCT tokens from the 64 levels to decode and dequant the coefficients

  1291.  * for the next block in coding order

  1292.  */

  1293. static inline int vp3_dequant(Vp3DecodeContext *s, Vp3Fragment *frag,

  1294.                               int plane, int inter, DCTELEM block[64])

  1295. {

  1296.     int16_t *dequantizer = s->qmat[frag->qpi][inter][plane];

  1297.     uint8_t *perm = s->scantable.permutated;

  1298.     int i = 0;

  1299. 

  1300.     do {

  1301.         int token = *s->dct_tokens[plane][i];

  1302.         switch (token & 3) {

  1303.         case 0: // EOB

  1304.             if (--token < 4) // 0-3 are token types, so the EOB run must now be 0

  1305.                 s->dct_tokens[plane][i]++;

  1306.             else

  1307.                 *s->dct_tokens[plane][i] = token & ~3;

  1308.             goto end;

  1309.         case 1: // zero run

  1310.             s->dct_tokens[plane][i]++;

  1311.             i += (token >> 2) & 0x7f;

  1312.             block[perm[i]] = (token >> 9) * dequantizer[perm[i]];

  1313.             i++;

  1314.             break;

  1315.         case 2: // coeff

  1316.             block[perm[i]] = (token >> 2) * dequantizer[perm[i]];

  1317.             s->dct_tokens[plane][i++]++;

  1318.             break;

  1319.         default: // shouldn't happen

  1320.             return i;

  1321.         }

  1322.     } while (i < 64);

  1323. end:

  1324.     // the actual DC+prediction is in the fragment structure

  1325.     block[0] = frag->dc * s->qmat[0][inter][plane][0];

  1326.     return i;

  1327. }

  1328. 

  1329. /**

  1330.  * called when all pixels up to row y are complete

  1331.  */

  1332. static void vp3_draw_horiz_band(Vp3DecodeContext *s, int y)

  1333. {

  1334.     int h, cy;

  1335.     int offset[4];

  1336. 

  1337.     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {

  1338.         int y_flipped = s->flipped_image ? s->avctx->height-y : y;

  1339. 

  1340.         // At the end of the frame, report INT_MAX instead of the height of the frame.

  1341.         // This makes the other threads' ff_thread_await_progress() calls cheaper, because

  1342.         // they don't have to clip their values.

  1343.         ff_thread_report_progress(&s->current_frame, y_flipped==s->avctx->height ? INT_MAX : y_flipped-1, 0);

  1344.     }

  1345. 

  1346.     if(s->avctx->draw_horiz_band==NULL)

  1347.         return;

  1348. 

  1349.     h= y - s->last_slice_end;

  1350.     s->last_slice_end= y;

  1351.     y -= h;

  1352. 

  1353.     if (!s->flipped_image) {

  1354.         y = s->avctx->height - y - h;

  1355.     }

  1356. 

  1357.     cy = y >> s->chroma_y_shift;

  1358.     offset[0] = s->current_frame.linesize[0]*y;

  1359.     offset[1] = s->current_frame.linesize[1]*cy;

  1360.     offset[2] = s->current_frame.linesize[2]*cy;

  1361.     offset[3] = 0;

  1362. 

  1363.     emms_c();

  1364.     s->avctx->draw_horiz_band(s->avctx, &s->current_frame, offset, y, 3, h);

  1365. }

  1366. 

  1367. /**

  1368.  * Wait for the reference frame of the current fragment.

  1369.  * The progress value is in luma pixel rows.

  1370.  */

  1371. static void await_reference_row(Vp3DecodeContext *s, Vp3Fragment *fragment, int motion_y, int y)

  1372. {

  1373.     AVFrame *ref_frame;

  1374.     int ref_row;

  1375.     int border = motion_y&1;

  1376. 

  1377.     if (fragment->coding_method == MODE_USING_GOLDEN ||

  1378.         fragment->coding_method == MODE_GOLDEN_MV)

  1379.         ref_frame = &s->golden_frame;

  1380.     else

  1381.         ref_frame = &s->last_frame;

  1382. 

  1383.     ref_row = y + (motion_y>>1);

  1384.     ref_row = FFMAX(FFABS(ref_row), ref_row + 8 + border);

  1385. 

  1386.     ff_thread_await_progress(ref_frame, ref_row, 0);

  1387. }

  1388. 

  1389. /*

  1390.  * Perform the final rendering for a particular slice of data.

  1391.  * The slice number ranges from 0..(c_superblock_height - 1).

  1392.  */

  1393. static void render_slice(Vp3DecodeContext *s, int slice)

  1394. {

  1395.     int x, y, i, j, fragment;

  1396.     LOCAL_ALIGNED_16(DCTELEM, block, [64]);

  1397.     int motion_x = 0xdeadbeef, motion_y = 0xdeadbeef;

  1398.     int motion_halfpel_index;

  1399.     uint8_t *motion_source;

  1400.     int plane, first_pixel;

  1401. 

  1402.     if (slice >= s->c_superblock_height)

  1403.         return;

  1404. 

  1405.     for (plane = 0; plane < 3; plane++) {

  1406.         uint8_t *output_plane = s->current_frame.data    [plane] + s->data_offset[plane];

  1407.         uint8_t *  last_plane = s->   last_frame.data    [plane] + s->data_offset[plane];

  1408.         uint8_t *golden_plane = s-> golden_frame.data    [plane] + s->data_offset[plane];

  1409.         int stride            = s->current_frame.linesize[plane];

  1410.         int plane_width       = s->width  >> (plane && s->chroma_x_shift);

  1411.         int plane_height      = s->height >> (plane && s->chroma_y_shift);

  1412.         int8_t (*motion_val)[2] = s->motion_val[!!plane];

  1413. 

  1414.         int sb_x, sb_y        = slice << (!plane && s->chroma_y_shift);

  1415.         int slice_height      = sb_y + 1 + (!plane && s->chroma_y_shift);

  1416.         int slice_width       = plane ? s->c_superblock_width : s->y_superblock_width;

  1417. 

  1418.         int fragment_width    = s->fragment_width[!!plane];

  1419.         int fragment_height   = s->fragment_height[!!plane];

  1420.         int fragment_start    = s->fragment_start[plane];

  1421.         int do_await          = !plane && HAVE_THREADS && (s->avctx->active_thread_type&FF_THREAD_FRAME);

  1422. 

  1423.         if (!s->flipped_image) stride = -stride;

  1424.         if (CONFIG_GRAY && plane && (s->avctx->flags & CODEC_FLAG_GRAY))

  1425.             continue;

  1426. 

  1427.         /* for each superblock row in the slice (both of them)... */

  1428.         for (; sb_y < slice_height; sb_y++) {

  1429. 

  1430.             /* for each superblock in a row... */

  1431.             for (sb_x = 0; sb_x < slice_width; sb_x++) {

  1432. 

  1433.                 /* for each block in a superblock... */

  1434.                 for (j = 0; j < 16; j++) {

  1435.                     x = 4*sb_x + hilbert_offset[j][0];

  1436.                     y = 4*sb_y + hilbert_offset[j][1];

  1437.                     fragment = y*fragment_width + x;

  1438. 

  1439.                     i = fragment_start + fragment;

  1440. 

  1441.                     // bounds check

  1442.                     if (x >= fragment_width || y >= fragment_height)

  1443.                         continue;

  1444. 

  1445.                 first_pixel = 8*y*stride + 8*x;

  1446. 

  1447.                 if (do_await && s->all_fragments[i].coding_method != MODE_INTRA)

  1448.                     await_reference_row(s, &s->all_fragments[i], motion_val[fragment][1], (16*y) >> s->chroma_y_shift);

  1449. 

  1450.                 /* transform if this block was coded */

  1451.                 if (s->all_fragments[i].coding_method != MODE_COPY) {

  1452.                     if ((s->all_fragments[i].coding_method == MODE_USING_GOLDEN) ||

  1453.                         (s->all_fragments[i].coding_method == MODE_GOLDEN_MV))

  1454.                         motion_source= golden_plane;

  1455.                     else

  1456.                         motion_source= last_plane;

  1457. 

  1458.                     motion_source += first_pixel;

  1459.                     motion_halfpel_index = 0;

  1460. 

  1461.                     /* sort out the motion vector if this fragment is coded

  1462.                      * using a motion vector method */

  1463.                     if ((s->all_fragments[i].coding_method > MODE_INTRA) &&

  1464.                         (s->all_fragments[i].coding_method != MODE_USING_GOLDEN)) {

  1465.                         int src_x, src_y;

  1466.                         motion_x = motion_val[fragment][0];

  1467.                         motion_y = motion_val[fragment][1];

  1468. 

  1469.                         src_x= (motion_x>>1) + 8*x;

  1470.                         src_y= (motion_y>>1) + 8*y;

  1471. 

  1472.                         motion_halfpel_index = motion_x & 0x01;

  1473.                         motion_source += (motion_x >> 1);

  1474. 

  1475.                         motion_halfpel_index |= (motion_y & 0x01) << 1;

  1476.                         motion_source += ((motion_y >> 1) * stride);

  1477. 

  1478.                         if(src_x<0 || src_y<0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height){

  1479.                             uint8_t *temp= s->edge_emu_buffer;

  1480.                             if(stride<0) temp -= 8*stride;

  1481. 

  1482.                             s->dsp.emulated_edge_mc(temp, motion_source, stride, 9, 9, src_x, src_y, plane_width, plane_height);

  1483.                             motion_source= temp;

  1484.                         }

  1485.                     }

  1486. 

  1487. 

  1488.                     /* first, take care of copying a block from either the

  1489.                      * previous or the golden frame */

  1490.                     if (s->all_fragments[i].coding_method != MODE_INTRA) {

  1491.                         /* Note, it is possible to implement all MC cases with

  1492.                            put_no_rnd_pixels_l2 which would look more like the

  1493.                            VP3 source but this would be slower as

  1494.                            put_no_rnd_pixels_tab is better optimzed */

  1495.                         if(motion_halfpel_index != 3){

  1496.                             s->dsp.put_no_rnd_pixels_tab[1][motion_halfpel_index](

  1497.                                 output_plane + first_pixel,

  1498.                                 motion_source, stride, 8);

  1499.                         }else{

  1500.                             int d= (motion_x ^ motion_y)>>31; // d is 0 if motion_x and _y have the same sign, else -1

  1501.                             s->dsp.put_no_rnd_pixels_l2[1](

  1502.                                 output_plane + first_pixel,

  1503.                                 motion_source - d,

  1504.                                 motion_source + stride + 1 + d,

  1505.                                 stride, 8);

  1506.                         }

  1507.                     }

  1508. 

  1509.                         s->dsp.clear_block(block);

  1510. 

  1511.                     /* invert DCT and place (or add) in final output */

  1512. 

  1513.                     if (s->all_fragments[i].coding_method == MODE_INTRA) {

  1514.                         vp3_dequant(s, s->all_fragments + i, plane, 0, block);

  1515.                         if(s->avctx->idct_algo!=FF_IDCT_VP3)

  1516.                             block[0] += 128<<3;

  1517.                         s->dsp.idct_put(

  1518.                             output_plane + first_pixel,

  1519.                             stride,

  1520.                             block);

  1521.                     } else {

  1522.                         if (vp3_dequant(s, s->all_fragments + i, plane, 1, block)) {

  1523.                         s->dsp.idct_add(

  1524.                             output_plane + first_pixel,

  1525.                             stride,

  1526.                             block);

  1527.                         } else {

  1528.                             s->dsp.vp3_idct_dc_add(output_plane + first_pixel, stride, block);

  1529.                         }

  1530.                     }

  1531.                 } else {

  1532. 

  1533.                     /* copy directly from the previous frame */

  1534.                     s->dsp.put_pixels_tab[1][0](

  1535.                         output_plane + first_pixel,

  1536.                         last_plane + first_pixel,

  1537.                         stride, 8);

  1538. 

  1539.                 }

  1540.                 }

  1541.             }

  1542. 

  1543.             // Filter up to the last row in the superblock row

  1544.             if (!s->skip_loop_filter)

  1545.                 apply_loop_filter(s, plane, 4*sb_y - !!sb_y, FFMIN(4*sb_y+3, fragment_height-1));

  1546.         }

  1547.     }

  1548. 

  1549.      /* this looks like a good place for slice dispatch... */

  1550.      /* algorithm:

  1551.       *   if (slice == s->macroblock_height - 1)

  1552.       *     dispatch (both last slice & 2nd-to-last slice);

  1553.       *   else if (slice > 0)

  1554.       *     dispatch (slice - 1);

  1555.       */

  1556. 

  1557.     vp3_draw_horiz_band(s, FFMIN((32 << s->chroma_y_shift) * (slice + 1) -16, s->height-16));

  1558. }

  1559. 

  1560. /// Allocate tables for per-frame data in Vp3DecodeContext

  1561. static av_cold int allocate_tables(AVCodecContext *avctx)

  1562. {

  1563.     Vp3DecodeContext *s = avctx->priv_data;

  1564.     int y_fragment_count, c_fragment_count;

  1565. 

  1566.     y_fragment_count = s->fragment_width[0] * s->fragment_height[0];

  1567.     c_fragment_count = s->fragment_width[1] * s->fragment_height[1];

  1568. 

  1569.     s->superblock_coding = av_malloc(s->superblock_count);

  1570.     s->all_fragments = av_malloc(s->fragment_count * sizeof(Vp3Fragment));

  1571.     s->coded_fragment_list[0] = av_malloc(s->fragment_count * sizeof(int));

  1572.     s->dct_tokens_base = av_malloc(64*s->fragment_count * sizeof(*s->dct_tokens_base));

  1573.     s->motion_val[0] = av_malloc(y_fragment_count * sizeof(*s->motion_val[0]));

  1574.     s->motion_val[1] = av_malloc(c_fragment_count * sizeof(*s->motion_val[1]));

  1575. 

  1576.     /* work out the block mapping tables */

  1577.     s->superblock_fragments = av_malloc(s->superblock_count * 16 * sizeof(int));

  1578.     s->macroblock_coding = av_malloc(s->macroblock_count + 1);

  1579. 

  1580.     if (!s->superblock_coding || !s->all_fragments || !s->dct_tokens_base ||

  1581.         !s->coded_fragment_list[0] || !s->superblock_fragments || !s->macroblock_coding ||

  1582.         !s->motion_val[0] || !s->motion_val[1]) {

  1583.         vp3_decode_end(avctx);

  1584.         return -1;

  1585.     }

  1586. 

  1587.     init_block_mapping(s);

  1588. 

  1589.     return 0;

  1590. }

  1591. 

  1592. static av_cold int vp3_decode_init(AVCodecContext *avctx)

  1593. {

  1594.     Vp3DecodeContext *s = avctx->priv_data;

  1595.     int i, inter, plane;

  1596.     int c_width;

  1597.     int c_height;

  1598.     int y_fragment_count, c_fragment_count;

  1599. 

  1600.     if (avctx->codec_tag == MKTAG('V','P','3','0'))

  1601.         s->version = 0;

  1602.     else

  1603.         s->version = 1;

  1604. 

  1605.     s->avctx = avctx;

  1606.     s->width = FFALIGN(avctx->width, 16);

  1607.     s->height = FFALIGN(avctx->height, 16);

  1608.     if (avctx->pix_fmt == PIX_FMT_NONE)

  1609.         avctx->pix_fmt = PIX_FMT_YUV420P;

  1610.     avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;

  1611.     if(avctx->idct_algo==FF_IDCT_AUTO)

  1612.         avctx->idct_algo=FF_IDCT_VP3;

  1613.     dsputil_init(&s->dsp, avctx);

  1614. 

  1615.     ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);

  1616. 

  1617.     /* initialize to an impossible value which will force a recalculation

  1618.      * in the first frame decode */

  1619.     for (i = 0; i < 3; i++)

  1620.         s->qps[i] = -1;

  1621. 

  1622.     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);

  1623. 

  1624.     s->y_superblock_width = (s->width + 31) / 32;

  1625.     s->y_superblock_height = (s->height + 31) / 32;

  1626.     s->y_superblock_count = s->y_superblock_width * s->y_superblock_height;

  1627. 

  1628.     /* work out the dimensions for the C planes */

  1629.     c_width = s->width >> s->chroma_x_shift;

  1630.     c_height = s->height >> s->chroma_y_shift;

  1631.     s->c_superblock_width = (c_width + 31) / 32;

  1632.     s->c_superblock_height = (c_height + 31) / 32;

  1633.     s->c_superblock_count = s->c_superblock_width * s->c_superblock_height;

  1634. 

  1635.     s->superblock_count = s->y_superblock_count + (s->c_superblock_count * 2);

  1636.     s->u_superblock_start = s->y_superblock_count;

  1637.     s->v_superblock_start = s->u_superblock_start + s->c_superblock_count;

  1638. 

  1639.     s->macroblock_width = (s->width + 15) / 16;

  1640.     s->macroblock_height = (s->height + 15) / 16;

  1641.     s->macroblock_count = s->macroblock_width * s->macroblock_height;

  1642. 

  1643.     s->fragment_width[0] = s->width / FRAGMENT_PIXELS;

  1644.     s->fragment_height[0] = s->height / FRAGMENT_PIXELS;

  1645.     s->fragment_width[1]  = s->fragment_width[0]  >> s->chroma_x_shift;

  1646.     s->fragment_height[1] = s->fragment_height[0] >> s->chroma_y_shift;

  1647. 

  1648.     /* fragment count covers all 8x8 blocks for all 3 planes */

  1649.     y_fragment_count     = s->fragment_width[0] * s->fragment_height[0];

  1650.     c_fragment_count     = s->fragment_width[1] * s->fragment_height[1];

  1651.     s->fragment_count    = y_fragment_count + 2*c_fragment_count;

  1652.     s->fragment_start[1] = y_fragment_count;

  1653.     s->fragment_start[2] = y_fragment_count + c_fragment_count;

  1654. 

  1655.     if (!s->theora_tables)

  1656.     {

  1657.         for (i = 0; i < 64; i++) {

  1658.             s->coded_dc_scale_factor[i] = vp31_dc_scale_factor[i];

  1659.             s->coded_ac_scale_factor[i] = vp31_ac_scale_factor[i];

  1660.             s->base_matrix[0][i] = vp31_intra_y_dequant[i];

  1661.             s->base_matrix[1][i] = vp31_intra_c_dequant[i];

  1662.             s->base_matrix[2][i] = vp31_inter_dequant[i];

  1663.             s->filter_limit_values[i] = vp31_filter_limit_values[i];

  1664.         }

  1665. 

  1666.         for(inter=0; inter<2; inter++){

  1667.             for(plane=0; plane<3; plane++){

  1668.                 s->qr_count[inter][plane]= 1;

  1669.                 s->qr_size [inter][plane][0]= 63;

  1670.                 s->qr_base [inter][plane][0]=

  1671.                 s->qr_base [inter][plane][1]= 2*inter + (!!plane)*!inter;

  1672.             }

  1673.         }

  1674. 

  1675.         /* init VLC tables */

  1676.         for (i = 0; i < 16; i++) {

  1677. 

  1678.             /* DC histograms */

  1679.             init_vlc(&s->dc_vlc[i], 11, 32,

  1680.                 &dc_bias[i][0][1], 4, 2,

  1681.                 &dc_bias[i][0][0], 4, 2, 0);

  1682. 

  1683.             /* group 1 AC histograms */

  1684.             init_vlc(&s->ac_vlc_1[i], 11, 32,

  1685.                 &ac_bias_0[i][0][1], 4, 2,

  1686.                 &ac_bias_0[i][0][0], 4, 2, 0);

  1687. 

  1688.             /* group 2 AC histograms */

  1689.             init_vlc(&s->ac_vlc_2[i], 11, 32,

  1690.                 &ac_bias_1[i][0][1], 4, 2,

  1691.                 &ac_bias_1[i][0][0], 4, 2, 0);

  1692. 

  1693.             /* group 3 AC histograms */

  1694.             init_vlc(&s->ac_vlc_3[i], 11, 32,

  1695.                 &ac_bias_2[i][0][1], 4, 2,

  1696.                 &ac_bias_2[i][0][0], 4, 2, 0);

  1697. 

  1698.             /* group 4 AC histograms */

  1699.             init_vlc(&s->ac_vlc_4[i], 11, 32,

  1700.                 &ac_bias_3[i][0][1], 4, 2,

  1701.                 &ac_bias_3[i][0][0], 4, 2, 0);

  1702.         }

  1703.     } else {

  1704. 

  1705.         for (i = 0; i < 16; i++) {

  1706.             /* DC histograms */

  1707.             if (init_vlc(&s->dc_vlc[i], 11, 32,

  1708.                 &s->huffman_table[i][0][1], 8, 4,

  1709.                 &s->huffman_table[i][0][0], 8, 4, 0) < 0)

  1710.                 goto vlc_fail;

  1711. 

  1712.             /* group 1 AC histograms */

  1713.             if (init_vlc(&s->ac_vlc_1[i], 11, 32,

  1714.                 &s->huffman_table[i+16][0][1], 8, 4,

  1715.                 &s->huffman_table[i+16][0][0], 8, 4, 0) < 0)

  1716.                 goto vlc_fail;

  1717. 

  1718.             /* group 2 AC histograms */

  1719.             if (init_vlc(&s->ac_vlc_2[i], 11, 32,

  1720.                 &s->huffman_table[i+16*2][0][1], 8, 4,

  1721.                 &s->huffman_table[i+16*2][0][0], 8, 4, 0) < 0)

  1722.                 goto vlc_fail;

  1723. 

  1724.             /* group 3 AC histograms */

  1725.             if (init_vlc(&s->ac_vlc_3[i], 11, 32,

  1726.                 &s->huffman_table[i+16*3][0][1], 8, 4,

  1727.                 &s->huffman_table[i+16*3][0][0], 8, 4, 0) < 0)

  1728.                 goto vlc_fail;

  1729. 

  1730.             /* group 4 AC histograms */

  1731.             if (init_vlc(&s->ac_vlc_4[i], 11, 32,

  1732.                 &s->huffman_table[i+16*4][0][1], 8, 4,

  1733.                 &s->huffman_table[i+16*4][0][0], 8, 4, 0) < 0)

  1734.                 goto vlc_fail;

  1735.         }

  1736.     }

  1737. 

  1738.     init_vlc(&s->superblock_run_length_vlc, 6, 34,

  1739.         &superblock_run_length_vlc_table[0][1], 4, 2,

  1740.         &superblock_run_length_vlc_table[0][0], 4, 2, 0);

  1741. 

  1742.     init_vlc(&s->fragment_run_length_vlc, 5, 30,

  1743.         &fragment_run_length_vlc_table[0][1], 4, 2,

  1744.         &fragment_run_length_vlc_table[0][0], 4, 2, 0);

  1745. 

  1746.     init_vlc(&s->mode_code_vlc, 3, 8,

  1747.         &mode_code_vlc_table[0][1], 2, 1,

  1748.         &mode_code_vlc_table[0][0], 2, 1, 0);

  1749. 

  1750.     init_vlc(&s->motion_vector_vlc, 6, 63,

  1751.         &motion_vector_vlc_table[0][1], 2, 1,

  1752.         &motion_vector_vlc_table[0][0], 2, 1, 0);

  1753. 

  1754.     for (i = 0; i < 3; i++) {

  1755.         s->current_frame.data[i] = NULL;

  1756.         s->last_frame.data[i] = NULL;

  1757.         s->golden_frame.data[i] = NULL;

  1758.     }

  1759. 

  1760.     return allocate_tables(avctx);

  1761. 

  1762. vlc_fail:

  1763.     av_log(avctx, AV_LOG_FATAL, "Invalid huffman table\n");

  1764.     return -1;

  1765. }

  1766. 

  1767. /// Release and shuffle frames after decode finishes

  1768. static void update_frames(AVCodecContext *avctx)

  1769. {

  1770.     Vp3DecodeContext *s = avctx->priv_data;

  1771. 

  1772.     /* release the last frame, if it is allocated and if it is not the

  1773.      * golden frame */

  1774.     if (s->last_frame.data[0] && s->last_frame.type != FF_BUFFER_TYPE_COPY)

  1775.         ff_thread_release_buffer(avctx, &s->last_frame);

  1776. 

  1777.     /* shuffle frames (last = current) */

  1778.     s->last_frame= s->current_frame;

  1779. 

  1780.     if (s->keyframe) {

  1781.         if (s->golden_frame.data[0])

  1782.             ff_thread_release_buffer(avctx, &s->golden_frame);

  1783.         s->golden_frame = s->current_frame;

  1784.         s->last_frame.type = FF_BUFFER_TYPE_COPY;

  1785.     }

  1786. 

  1787.     s->current_frame.data[0]= NULL; /* ensure that we catch any access to this released frame */

  1788. }

  1789. 

  1790. static int vp3_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)

  1791. {

  1792.     Vp3DecodeContext *s = dst->priv_data, *s1 = src->priv_data;

  1793.     int qps_changed = 0, i, err;

  1794. 

  1795. #define copy_fields(to, from, start_field, end_field) memcpy(&to->start_field, &from->start_field, (char*)&to->end_field - (char*)&to->start_field)

  1796. 

  1797.     if (!s1->current_frame.data[0]

  1798.         ||s->width != s1->width

  1799.         ||s->height!= s1->height) {

  1800.         if (s != s1)

  1801.             copy_fields(s, s1, golden_frame, current_frame);

  1802.         return -1;

  1803.     }

  1804. 

  1805.     if (s != s1) {

  1806.         // init tables if the first frame hasn't been decoded

  1807.         if (!s->current_frame.data[0]) {

  1808.             int y_fragment_count, c_fragment_count;

  1809.             s->avctx = dst;

  1810.             err = allocate_tables(dst);

  1811.             if (err)

  1812.                 return err;

  1813.             y_fragment_count = s->fragment_width[0] * s->fragment_height[0];

  1814.             c_fragment_count = s->fragment_width[1] * s->fragment_height[1];

  1815.             memcpy(s->motion_val[0], s1->motion_val[0], y_fragment_count * sizeof(*s->motion_val[0]));

  1816.             memcpy(s->motion_val[1], s1->motion_val[1], c_fragment_count * sizeof(*s->motion_val[1]));

  1817.         }

  1818. 

  1819.         // copy previous frame data

  1820.         copy_fields(s, s1, golden_frame, dsp);

  1821. 

  1822.         // copy qscale data if necessary

  1823.         for (i = 0; i < 3; i++) {

  1824.             if (s->qps[i] != s1->qps[1]) {

  1825.                 qps_changed = 1;

  1826.                 memcpy(&s->qmat[i], &s1->qmat[i], sizeof(s->qmat[i]));

  1827.             }

  1828.         }

  1829. 

  1830.         if (s->qps[0] != s1->qps[0])

  1831.             memcpy(&s->bounding_values_array, &s1->bounding_values_array, sizeof(s->bounding_values_array));

  1832. 

  1833.         if (qps_changed)

  1834.             copy_fields(s, s1, qps, superblock_count);

  1835. #undef copy_fields

  1836.     }

  1837. 

  1838.     update_frames(dst);

  1839. 

  1840.     return 0;

  1841. }

  1842. 

  1843. static int vp3_decode_frame(AVCodecContext *avctx,

  1844.                             void *data, int *data_size,

  1845.                             AVPacket *avpkt)

  1846. {

  1847.     const uint8_t *buf = avpkt->data;

  1848.     int buf_size = avpkt->size;

  1849.     Vp3DecodeContext *s = avctx->priv_data;

  1850.     GetBitContext gb;

  1851.     int i;

  1852. 

  1853.     init_get_bits(&gb, buf, buf_size * 8);

  1854. 

  1855.     if (s->theora && get_bits1(&gb))

  1856.     {

  1857.         av_log(avctx, AV_LOG_ERROR, "Header packet passed to frame decoder, skipping\n");

  1858.         return -1;

  1859.     }

  1860. 

  1861.     s->keyframe = !get_bits1(&gb);

  1862.     if (!s->theora)

  1863.         skip_bits(&gb, 1);

  1864.     for (i = 0; i < 3; i++)

  1865.         s->last_qps[i] = s->qps[i];

  1866. 

  1867.     s->nqps=0;

  1868.     do{

  1869.         s->qps[s->nqps++]= get_bits(&gb, 6);

  1870.     } while(s->theora >= 0x030200 && s->nqps<3 && get_bits1(&gb));

  1871.     for (i = s->nqps; i < 3; i++)

  1872.         s->qps[i] = -1;

  1873. 

  1874.     if (s->avctx->debug & FF_DEBUG_PICT_INFO)

  1875.         av_log(s->avctx, AV_LOG_INFO, " VP3 %sframe #%d: Q index = %d\n",

  1876.             s->keyframe?"key":"", avctx->frame_number+1, s->qps[0]);

  1877. 

  1878.     s->skip_loop_filter = !s->filter_limit_values[s->qps[0]] ||

  1879.         avctx->skip_loop_filter >= (s->keyframe ? AVDISCARD_ALL : AVDISCARD_NONKEY);

  1880. 

  1881.     if (s->qps[0] != s->last_qps[0])

  1882.         init_loop_filter(s);

  1883. 

  1884.     for (i = 0; i < s->nqps; i++)

  1885.         // reinit all dequantizers if the first one changed, because

  1886.         // the DC of the first quantizer must be used for all matrices

  1887.         if (s->qps[i] != s->last_qps[i] || s->qps[0] != s->last_qps[0])

  1888.             init_dequantizer(s, i);

  1889. 

  1890.     if (avctx->skip_frame >= AVDISCARD_NONKEY && !s->keyframe)

  1891.         return buf_size;

  1892. 

  1893.     s->current_frame.reference = 3;

  1894.     s->current_frame.pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

  1895.     if (ff_thread_get_buffer(avctx, &s->current_frame) < 0) {

  1896.         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1897.         goto error;

  1898.     }

  1899. 

  1900.     if (!s->edge_emu_buffer)

  1901.         s->edge_emu_buffer = av_malloc(9*FFABS(s->current_frame.linesize[0]));

  1902. 

  1903.     if (s->keyframe) {

  1904.         if (!s->theora)

  1905.         {

  1906.             skip_bits(&gb, 4); /* width code */

  1907.             skip_bits(&gb, 4); /* height code */

  1908.             if (s->version)

  1909.             {

  1910.                 s->version = get_bits(&gb, 5);

  1911.                 if (avctx->frame_number == 0)

  1912.                     av_log(s->avctx, AV_LOG_DEBUG, "VP version: %d\n", s->version);

  1913.             }

  1914.         }

  1915.         if (s->version || s->theora)

  1916.         {

  1917.                 if (get_bits1(&gb))

  1918.                     av_log(s->avctx, AV_LOG_ERROR, "Warning, unsupported keyframe coding type?!\n");

  1919.             skip_bits(&gb, 2); /* reserved? */

  1920.         }

  1921.     } else {

  1922.         if (!s->golden_frame.data[0]) {

  1923.             av_log(s->avctx, AV_LOG_WARNING, "vp3: first frame not a keyframe\n");

  1924. 

  1925.             s->golden_frame.reference = 3;

  1926.             s->golden_frame.pict_type = AV_PICTURE_TYPE_I;

  1927.             if (ff_thread_get_buffer(avctx, &s->golden_frame) < 0) {

  1928.                 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");

  1929.                 goto error;

  1930.             }

  1931.             s->last_frame = s->golden_frame;

  1932.             s->last_frame.type = FF_BUFFER_TYPE_COPY;

  1933.             ff_thread_report_progress(&s->last_frame, INT_MAX, 0);

  1934.         }

  1935.     }

  1936. 

  1937.     memset(s->all_fragments, 0, s->fragment_count * sizeof(Vp3Fragment));

  1938.     ff_thread_finish_setup(avctx);

  1939. 

  1940.     if (unpack_superblocks(s, &gb)){

  1941.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_superblocks\n");

  1942.         goto error;

  1943.     }

  1944.     if (unpack_modes(s, &gb)){

  1945.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_modes\n");

  1946.         goto error;

  1947.     }

  1948.     if (unpack_vectors(s, &gb)){

  1949.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_vectors\n");

  1950.         goto error;

  1951.     }

  1952.     if (unpack_block_qpis(s, &gb)){

  1953.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_block_qpis\n");

  1954.         goto error;

  1955.     }

  1956.     if (unpack_dct_coeffs(s, &gb)){

  1957.         av_log(s->avctx, AV_LOG_ERROR, "error in unpack_dct_coeffs\n");

  1958.         goto error;

  1959.     }

  1960. 

  1961.     for (i = 0; i < 3; i++) {

  1962.         int height = s->height >> (i && s->chroma_y_shift);

  1963.         if (s->flipped_image)

  1964.             s->data_offset[i] = 0;

  1965.         else

  1966.             s->data_offset[i] = (height-1) * s->current_frame.linesize[i];

  1967.     }

  1968. 

  1969.     s->last_slice_end = 0;

  1970.     for (i = 0; i < s->c_superblock_height; i++)

  1971.         render_slice(s, i);

  1972. 

  1973.     // filter the last row

  1974.     for (i = 0; i < 3; i++) {

  1975.         int row = (s->height >> (3+(i && s->chroma_y_shift))) - 1;

  1976.         apply_loop_filter(s, i, row, row+1);

  1977.     }

  1978.     vp3_draw_horiz_band(s, s->avctx->height);

  1979. 

  1980.     *data_size=sizeof(AVFrame);

  1981.     *(AVFrame*)data= s->current_frame;

  1982. 

  1983.     if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_FRAME))

  1984.         update_frames(avctx);

  1985. 

  1986.     return buf_size;

  1987. 

  1988. error:

  1989.     ff_thread_report_progress(&s->current_frame, INT_MAX, 0);

  1990. 

  1991.     if (!HAVE_THREADS || !(s->avctx->active_thread_type&FF_THREAD_FRAME))

  1992.         avctx->release_buffer(avctx, &s->current_frame);

  1993. 

  1994.     return -1;

  1995. }

  1996. 

  1997. static av_cold int vp3_decode_end(AVCodecContext *avctx)

  1998. {

  1999.     Vp3DecodeContext *s = avctx->priv_data;

  2000.     int i;

  2001. 

  2002.     av_free(s->superblock_coding);

  2003.     av_free(s->all_fragments);

  2004.     av_free(s->coded_fragment_list[0]);

  2005.     av_free(s->dct_tokens_base);

  2006.     av_free(s->superblock_fragments);

  2007.     av_free(s->macroblock_coding);

  2008.     av_free(s->motion_val[0]);

  2009.     av_free(s->motion_val[1]);

  2010.     av_free(s->edge_emu_buffer);

  2011. 

  2012.     if (avctx->internal->is_copy)

  2013.         return 0;

  2014. 

  2015.     for (i = 0; i < 16; i++) {

  2016.         free_vlc(&s->dc_vlc[i]);

  2017.         free_vlc(&s->ac_vlc_1[i]);

  2018.         free_vlc(&s->ac_vlc_2[i]);

  2019.         free_vlc(&s->ac_vlc_3[i]);

  2020.         free_vlc(&s->ac_vlc_4[i]);

  2021.     }

  2022. 

  2023.     free_vlc(&s->superblock_run_length_vlc);

  2024.     free_vlc(&s->fragment_run_length_vlc);

  2025.     free_vlc(&s->mode_code_vlc);

  2026.     free_vlc(&s->motion_vector_vlc);

  2027. 

  2028.     /* release all frames */

  2029.     vp3_decode_flush(avctx);

  2030. 

  2031.     return 0;

  2032. }

  2033. 

  2034. static int read_huffman_tree(AVCodecContext *avctx, GetBitContext *gb)

  2035. {

  2036.     Vp3DecodeContext *s = avctx->priv_data;

  2037. 

  2038.     if (get_bits1(gb)) {

  2039.         int token;

  2040.         if (s->entries >= 32) { /* overflow */

  2041.             av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");

  2042.             return -1;

  2043.         }

  2044.         token = get_bits(gb, 5);

  2045.         //av_log(avctx, AV_LOG_DEBUG, "hti %d hbits %x token %d entry : %d size %d\n", s->hti, s->hbits, token, s->entries, s->huff_code_size);

  2046.         s->huffman_table[s->hti][token][0] = s->hbits;

  2047.         s->huffman_table[s->hti][token][1] = s->huff_code_size;

  2048.         s->entries++;

  2049.     }

  2050.     else {

  2051.         if (s->huff_code_size >= 32) {/* overflow */

  2052.             av_log(avctx, AV_LOG_ERROR, "huffman tree overflow\n");

  2053.             return -1;

  2054.         }

  2055.         s->huff_code_size++;

  2056.         s->hbits <<= 1;

  2057.         if (read_huffman_tree(avctx, gb))

  2058.             return -1;

  2059.         s->hbits |= 1;

  2060.         if (read_huffman_tree(avctx, gb))

  2061.             return -1;

  2062.         s->hbits >>= 1;

  2063.         s->huff_code_size--;

  2064.     }

  2065.     return 0;

  2066. }

  2067. 

  2068. #if CONFIG_THEORA_DECODER

  2069. static const enum PixelFormat theora_pix_fmts[4] = {

  2070.     PIX_FMT_YUV420P, PIX_FMT_NONE, PIX_FMT_YUV422P, PIX_FMT_YUV444P

  2071. };

  2072. 

  2073. static int theora_decode_header(AVCodecContext *avctx, GetBitContext *gb)

  2074. {

  2075.     Vp3DecodeContext *s = avctx->priv_data;

  2076.     int visible_width, visible_height, colorspace;

  2077.     int offset_x = 0, offset_y = 0;

  2078.     AVRational fps, aspect;

  2079. 

  2080.     s->theora = get_bits_long(gb, 24);

  2081.     av_log(avctx, AV_LOG_DEBUG, "Theora bitstream version %X\n", s->theora);

  2082. 

  2083.     /* 3.2.0 aka alpha3 has the same frame orientation as original vp3 */

  2084.     /* but previous versions have the image flipped relative to vp3 */

  2085.     if (s->theora < 0x030200)

  2086.     {

  2087.         s->flipped_image = 1;

  2088.         av_log(avctx, AV_LOG_DEBUG, "Old (<alpha3) Theora bitstream, flipped image\n");

  2089.     }

  2090. 

  2091.     visible_width  = s->width  = get_bits(gb, 16) << 4;

  2092.     visible_height = s->height = get_bits(gb, 16) << 4;

  2093. 

  2094.     if(av_image_check_size(s->width, s->height, 0, avctx)){

  2095.         av_log(avctx, AV_LOG_ERROR, "Invalid dimensions (%dx%d)\n", s->width, s->height);

  2096.         s->width= s->height= 0;

  2097.         return -1;

  2098.     }

  2099. 

  2100.     if (s->theora >= 0x030200) {

  2101.         visible_width  = get_bits_long(gb, 24);

  2102.         visible_height = get_bits_long(gb, 24);

  2103. 

  2104.         offset_x = get_bits(gb, 8); /* offset x */

  2105.         offset_y = get_bits(gb, 8); /* offset y, from bottom */

  2106.     }

  2107. 

  2108.     fps.num = get_bits_long(gb, 32);

  2109.     fps.den = get_bits_long(gb, 32);

  2110.     if (fps.num && fps.den) {

  2111.         av_reduce(&avctx->time_base.num, &avctx->time_base.den,

  2112.                   fps.den, fps.num, 1<<30);

  2113.     }

  2114. 

  2115.     aspect.num = get_bits_long(gb, 24);

  2116.     aspect.den = get_bits_long(gb, 24);

  2117.     if (aspect.num && aspect.den) {

  2118.         av_reduce(&avctx->sample_aspect_ratio.num,

  2119.                   &avctx->sample_aspect_ratio.den,

  2120.                   aspect.num, aspect.den, 1<<30);

  2121.     }

  2122. 

  2123.     if (s->theora < 0x030200)

  2124.         skip_bits(gb, 5); /* keyframe frequency force */

  2125.     colorspace = get_bits(gb, 8);

  2126.     skip_bits(gb, 24); /* bitrate */

  2127. 

  2128.     skip_bits(gb, 6); /* quality hint */

  2129. 

  2130.     if (s->theora >= 0x030200)

  2131.     {

  2132.         skip_bits(gb, 5); /* keyframe frequency force */

  2133.         avctx->pix_fmt = theora_pix_fmts[get_bits(gb, 2)];

  2134.         skip_bits(gb, 3); /* reserved */

  2135.     }

  2136. 

  2137. //    align_get_bits(gb);

  2138. 

  2139.     if (   visible_width  <= s->width  && visible_width  > s->width-16

  2140.         && visible_height <= s->height && visible_height > s->height-16

  2141.         && !offset_x && (offset_y == s->height - visible_height))

  2142.         avcodec_set_dimensions(avctx, visible_width, visible_height);

  2143.     else

  2144.         avcodec_set_dimensions(avctx, s->width, s->height);

  2145. 

  2146.     if (colorspace == 1) {

  2147.         avctx->color_primaries = AVCOL_PRI_BT470M;

  2148.     } else if (colorspace == 2) {

  2149.         avctx->color_primaries = AVCOL_PRI_BT470BG;

  2150.     }

  2151.     if (colorspace == 1 || colorspace == 2) {

  2152.         avctx->colorspace = AVCOL_SPC_BT470BG;

  2153.         avctx->color_trc  = AVCOL_TRC_BT709;

  2154.     }

  2155. 

  2156.     return 0;

  2157. }

  2158. 

  2159. static int theora_decode_tables(AVCodecContext *avctx, GetBitContext *gb)

  2160. {

  2161.     Vp3DecodeContext *s = avctx->priv_data;

  2162.     int i, n, matrices, inter, plane;

  2163. 

  2164.     if (s->theora >= 0x030200) {

  2165.         n = get_bits(gb, 3);

  2166.         /* loop filter limit values table */

  2167.         if (n)

  2168.             for (i = 0; i < 64; i++)

  2169.                 s->filter_limit_values[i] = get_bits(gb, n);

  2170.     }

  2171. 

  2172.     if (s->theora >= 0x030200)

  2173.         n = get_bits(gb, 4) + 1;

  2174.     else

  2175.         n = 16;

  2176.     /* quality threshold table */

  2177.     for (i = 0; i < 64; i++)

  2178.         s->coded_ac_scale_factor[i] = get_bits(gb, n);

  2179. 

  2180.     if (s->theora >= 0x030200)

  2181.         n = get_bits(gb, 4) + 1;

  2182.     else

  2183.         n = 16;

  2184.     /* dc scale factor table */

  2185.     for (i = 0; i < 64; i++)

  2186.         s->coded_dc_scale_factor[i] = get_bits(gb, n);

  2187. 

  2188.     if (s->theora >= 0x030200)

  2189.         matrices = get_bits(gb, 9) + 1;

  2190.     else

  2191.         matrices = 3;

  2192. 

  2193.     if(matrices > 384){

  2194.         av_log(avctx, AV_LOG_ERROR, "invalid number of base matrixes\n");

  2195.         return -1;

  2196.     }

  2197. 

  2198.     for(n=0; n<matrices; n++){

  2199.         for (i = 0; i < 64; i++)

  2200.             s->base_matrix[n][i]= get_bits(gb, 8);

  2201.     }

  2202. 

  2203.     for (inter = 0; inter <= 1; inter++) {

  2204.         for (plane = 0; plane <= 2; plane++) {

  2205.             int newqr= 1;

  2206.             if (inter || plane > 0)

  2207.                 newqr = get_bits1(gb);

  2208.             if (!newqr) {

  2209.                 int qtj, plj;

  2210.                 if(inter && get_bits1(gb)){

  2211.                     qtj = 0;

  2212.                     plj = plane;

  2213.                 }else{

  2214.                     qtj= (3*inter + plane - 1) / 3;

  2215.                     plj= (plane + 2) % 3;

  2216.                 }

  2217.                 s->qr_count[inter][plane]= s->qr_count[qtj][plj];

  2218.                 memcpy(s->qr_size[inter][plane], s->qr_size[qtj][plj], sizeof(s->qr_size[0][0]));

  2219.                 memcpy(s->qr_base[inter][plane], s->qr_base[qtj][plj], sizeof(s->qr_base[0][0]));

  2220.             } else {

  2221.                 int qri= 0;

  2222.                 int qi = 0;

  2223. 

  2224.                 for(;;){

  2225.                     i= get_bits(gb, av_log2(matrices-1)+1);

  2226.                     if(i>= matrices){

  2227.                         av_log(avctx, AV_LOG_ERROR, "invalid base matrix index\n");

  2228.                         return -1;

  2229.                     }

  2230.                     s->qr_base[inter][plane][qri]= i;

  2231.                     if(qi >= 63)

  2232.                         break;

  2233.                     i = get_bits(gb, av_log2(63-qi)+1) + 1;

  2234.                     s->qr_size[inter][plane][qri++]= i;

  2235.                     qi += i;

  2236.                 }

  2237. 

  2238.                 if (qi > 63) {

  2239.                     av_log(avctx, AV_LOG_ERROR, "invalid qi %d > 63\n", qi);

  2240.                     return -1;

  2241.                 }

  2242.                 s->qr_count[inter][plane]= qri;

  2243.             }

  2244.         }

  2245.     }

  2246. 

  2247.     /* Huffman tables */

  2248.     for (s->hti = 0; s->hti < 80; s->hti++) {

  2249.         s->entries = 0;

  2250.         s->huff_code_size = 1;

  2251.         if (!get_bits1(gb)) {

  2252.             s->hbits = 0;

  2253.             if(read_huffman_tree(avctx, gb))

  2254.                 return -1;

  2255.             s->hbits = 1;

  2256.             if(read_huffman_tree(avctx, gb))

  2257.                 return -1;

  2258.         }

  2259.     }

  2260. 

  2261.     s->theora_tables = 1;

  2262. 

  2263.     return 0;

  2264. }

  2265. 

  2266. static av_cold int theora_decode_init(AVCodecContext *avctx)

  2267. {

  2268.     Vp3DecodeContext *s = avctx->priv_data;

  2269.     GetBitContext gb;

  2270.     int ptype;

  2271.     uint8_t *header_start[3];

  2272.     int header_len[3];

  2273.     int i;

  2274. 

  2275.     s->theora = 1;

  2276. 

  2277.     if (!avctx->extradata_size)

  2278.     {

  2279.         av_log(avctx, AV_LOG_ERROR, "Missing extradata!\n");

  2280.         return -1;

  2281.     }

  2282. 

  2283.     if (avpriv_split_xiph_headers(avctx->extradata, avctx->extradata_size,

  2284.                               42, header_start, header_len) < 0) {

  2285.         av_log(avctx, AV_LOG_ERROR, "Corrupt extradata\n");

  2286.         return -1;

  2287.     }

  2288. 

  2289.   for(i=0;i<3;i++) {

  2290.     init_get_bits(&gb, header_start[i], header_len[i] * 8);

  2291. 

  2292.     ptype = get_bits(&gb, 8);

  2293. 

  2294.      if (!(ptype & 0x80))

  2295.      {

  2296.         av_log(avctx, AV_LOG_ERROR, "Invalid extradata!\n");

  2297. //        return -1;

  2298.      }

  2299. 

  2300.     // FIXME: Check for this as well.

  2301.     skip_bits_long(&gb, 6*8); /* "theora" */

  2302. 

  2303.     switch(ptype)

  2304.     {

  2305.         case 0x80:

  2306.             theora_decode_header(avctx, &gb);

  2307.                 break;

  2308.         case 0x81:

  2309. // FIXME: is this needed? it breaks sometimes

  2310. //            theora_decode_comments(avctx, gb);

  2311.             break;

  2312.         case 0x82:

  2313.             if (theora_decode_tables(avctx, &gb))

  2314.                 return -1;

  2315.             break;

  2316.         default:

  2317.             av_log(avctx, AV_LOG_ERROR, "Unknown Theora config packet: %d\n", ptype&~0x80);

  2318.             break;

  2319.     }

  2320.     if(ptype != 0x81 && 8*header_len[i] != get_bits_count(&gb))

  2321.         av_log(avctx, AV_LOG_WARNING, "%d bits left in packet %X\n", 8*header_len[i] - get_bits_count(&gb), ptype);

  2322.     if (s->theora < 0x030200)

  2323.         break;

  2324.   }

  2325. 

  2326.     return vp3_decode_init(avctx);

  2327. }

  2328. 

  2329. static void vp3_decode_flush(AVCodecContext *avctx)

  2330. {

  2331.     Vp3DecodeContext *s = avctx->priv_data;

  2332. 

  2333.     if (s->golden_frame.data[0]) {

  2334.         if (s->golden_frame.data[0] == s->last_frame.data[0])

  2335.             memset(&s->last_frame, 0, sizeof(AVFrame));

  2336.         if (s->current_frame.data[0] == s->golden_frame.data[0])

  2337.             memset(&s->current_frame, 0, sizeof(AVFrame));

  2338.         ff_thread_release_buffer(avctx, &s->golden_frame);

  2339.     }

  2340.     if (s->last_frame.data[0]) {

  2341.         if (s->current_frame.data[0] == s->last_frame.data[0])

  2342.             memset(&s->current_frame, 0, sizeof(AVFrame));

  2343.         ff_thread_release_buffer(avctx, &s->last_frame);

  2344.     }

  2345.     if (s->current_frame.data[0])

  2346.         ff_thread_release_buffer(avctx, &s->current_frame);

  2347. }

  2348. 

  2349. static int vp3_init_thread_copy(AVCodecContext *avctx)

  2350. {

  2351.     Vp3DecodeContext *s = avctx->priv_data;

  2352. 

  2353.     s->superblock_coding      = NULL;

  2354.     s->all_fragments          = NULL;

  2355.     s->coded_fragment_list[0] = NULL;

  2356.     s->dct_tokens_base        = NULL;

  2357.     s->superblock_fragments   = NULL;

  2358.     s->macroblock_coding      = NULL;

  2359.     s->motion_val[0]          = NULL;

  2360.     s->motion_val[1]          = NULL;

  2361.     s->edge_emu_buffer        = NULL;

  2362. 

  2363.     return 0;

  2364. }

  2365. 

  2366. AVCodec ff_theora_decoder = {

  2367.     .name           = "theora",

  2368.     .type           = AVMEDIA_TYPE_VIDEO,

  2369.     .id             = CODEC_ID_THEORA,

  2370.     .priv_data_size = sizeof(Vp3DecodeContext),

  2371.     .init           = theora_decode_init,

  2372.     .close          = vp3_decode_end,

  2373.     .decode         = vp3_decode_frame,

  2374.     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,

  2375.     .flush = vp3_decode_flush,

  2376.     .long_name = NULL_IF_CONFIG_SMALL("Theora"),

  2377.     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),

  2378.     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)

  2379. };

  2380. #endif

  2381. 

  2382. AVCodec ff_vp3_decoder = {

  2383.     .name           = "vp3",

  2384.     .type           = AVMEDIA_TYPE_VIDEO,

  2385.     .id             = CODEC_ID_VP3,

  2386.     .priv_data_size = sizeof(Vp3DecodeContext),

  2387.     .init           = vp3_decode_init,

  2388.     .close          = vp3_decode_end,

  2389.     .decode         = vp3_decode_frame,

  2390.     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_FRAME_THREADS,

  2391.     .flush = vp3_decode_flush,

  2392.     .long_name = NULL_IF_CONFIG_SMALL("On2 VP3"),

  2393.     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(vp3_init_thread_copy),

  2394.     .update_thread_context = ONLY_IF_THREADS_ENABLED(vp3_update_thread_context)

  2395. };