LCOV - code coverage report
Current view: top level - libavcodec - rv34.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 937 1064 88.1 %
Date: 2017-12-10 21:22:29 Functions: 42 46 91.3 %

          Line data    Source code
       1             : /*
       2             :  * RV30/40 decoder common data
       3             :  * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * RV30/40 decoder common data
      25             :  */
      26             : 
      27             : #include "libavutil/imgutils.h"
      28             : #include "libavutil/internal.h"
      29             : 
      30             : #include "avcodec.h"
      31             : #include "error_resilience.h"
      32             : #include "mpegutils.h"
      33             : #include "mpegvideo.h"
      34             : #include "golomb.h"
      35             : #include "internal.h"
      36             : #include "mathops.h"
      37             : #include "mpeg_er.h"
      38             : #include "qpeldsp.h"
      39             : #include "rectangle.h"
      40             : #include "thread.h"
      41             : 
      42             : #include "rv34vlc.h"
      43             : #include "rv34data.h"
      44             : #include "rv34.h"
      45             : 
      46      454602 : static inline void ZERO8x2(void* dst, int stride)
      47             : {
      48      454602 :     fill_rectangle(dst,                 1, 2, stride, 0, 4);
      49      454602 :     fill_rectangle(((uint8_t*)(dst))+4, 1, 2, stride, 0, 4);
      50      454602 : }
      51             : 
      52             : /** translation of RV30/40 macroblock types to lavc ones */
      53             : static const int rv34_mb_type_to_lavc[12] = {
      54             :     MB_TYPE_INTRA,
      55             :     MB_TYPE_INTRA16x16              | MB_TYPE_SEPARATE_DC,
      56             :     MB_TYPE_16x16   | MB_TYPE_L0,
      57             :     MB_TYPE_8x8     | MB_TYPE_L0,
      58             :     MB_TYPE_16x16   | MB_TYPE_L0,
      59             :     MB_TYPE_16x16   | MB_TYPE_L1,
      60             :     MB_TYPE_SKIP,
      61             :     MB_TYPE_DIRECT2 | MB_TYPE_16x16,
      62             :     MB_TYPE_16x8    | MB_TYPE_L0,
      63             :     MB_TYPE_8x16    | MB_TYPE_L0,
      64             :     MB_TYPE_16x16   | MB_TYPE_L0L1,
      65             :     MB_TYPE_16x16   | MB_TYPE_L0    | MB_TYPE_SEPARATE_DC
      66             : };
      67             : 
      68             : 
      69             : static RV34VLC intra_vlcs[NUM_INTRA_TABLES], inter_vlcs[NUM_INTER_TABLES];
      70             : 
      71             : static int rv34_decode_mv(RV34DecContext *r, int block_type);
      72             : 
      73             : /**
      74             :  * @name RV30/40 VLC generating functions
      75             :  * @{
      76             :  */
      77             : 
      78             : static const int table_offs[] = {
      79             :       0,   1818,   3622,   4144,   4698,   5234,   5804,   5868,   5900,   5932,
      80             :    5996,   6252,   6316,   6348,   6380,   7674,   8944,  10274,  11668,  12250,
      81             :   14060,  15846,  16372,  16962,  17512,  18148,  18180,  18212,  18244,  18308,
      82             :   18564,  18628,  18660,  18692,  20036,  21314,  22648,  23968,  24614,  26384,
      83             :   28190,  28736,  29366,  29938,  30608,  30640,  30672,  30704,  30768,  31024,
      84             :   31088,  31120,  31184,  32570,  33898,  35236,  36644,  37286,  39020,  40802,
      85             :   41368,  42052,  42692,  43348,  43380,  43412,  43444,  43476,  43604,  43668,
      86             :   43700,  43732,  45100,  46430,  47778,  49160,  49802,  51550,  53340,  53972,
      87             :   54648,  55348,  55994,  56122,  56154,  56186,  56218,  56346,  56410,  56442,
      88             :   56474,  57878,  59290,  60636,  62036,  62682,  64460,  64524,  64588,  64716,
      89             :   64844,  66076,  67466,  67978,  68542,  69064,  69648,  70296,  72010,  72074,
      90             :   72138,  72202,  72330,  73572,  74936,  75454,  76030,  76566,  77176,  77822,
      91             :   79582,  79646,  79678,  79742,  79870,  81180,  82536,  83064,  83672,  84242,
      92             :   84934,  85576,  87384,  87448,  87480,  87544,  87672,  88982,  90340,  90902,
      93             :   91598,  92182,  92846,  93488,  95246,  95278,  95310,  95374,  95502,  96878,
      94             :   98266,  98848,  99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416,
      95             :  103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398,
      96             :  111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592
      97             : };
      98             : 
      99             : static VLC_TYPE table_data[117592][2];
     100             : 
     101             : /**
     102             :  * Generate VLC from codeword lengths.
     103             :  * @param bits   codeword lengths (zeroes are accepted)
     104             :  * @param size   length of input data
     105             :  * @param vlc    output VLC
     106             :  * @param insyms symbols for input codes (NULL for default ones)
     107             :  * @param num    VLC table number (for static initialization)
     108             :  */
     109         895 : static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *insyms,
     110             :                          const int num)
     111             : {
     112             :     int i;
     113         895 :     int counts[17] = {0}, codes[17];
     114             :     uint16_t cw[MAX_VLC_SIZE], syms[MAX_VLC_SIZE];
     115             :     uint8_t bits2[MAX_VLC_SIZE];
     116         895 :     int maxbits = 0, realsize = 0;
     117             : 
     118      291215 :     for(i = 0; i < size; i++){
     119      290320 :         if(bits[i]){
     120      289595 :             bits2[realsize] = bits[i];
     121      289595 :             syms[realsize] = insyms ? insyms[i] : i;
     122      289595 :             realsize++;
     123      289595 :             maxbits = FFMAX(maxbits, bits[i]);
     124      289595 :             counts[bits[i]]++;
     125             :         }
     126             :     }
     127             : 
     128         895 :     codes[0] = 0;
     129       15215 :     for(i = 0; i < 16; i++)
     130       14320 :         codes[i+1] = (codes[i] + counts[i]) << 1;
     131      290490 :     for(i = 0; i < realsize; i++)
     132      289595 :         cw[i] = codes[bits2[i]]++;
     133             : 
     134         895 :     vlc->table = &table_data[table_offs[num]];
     135         895 :     vlc->table_allocated = table_offs[num + 1] - table_offs[num];
     136         895 :     ff_init_vlc_sparse(vlc, FFMIN(maxbits, 9), realsize,
     137             :                        bits2, 1, 1,
     138             :                        cw,    2, 2,
     139             :                        syms,  2, 2, INIT_VLC_USE_NEW_STATIC);
     140         895 : }
     141             : 
     142             : /**
     143             :  * Initialize all tables.
     144             :  */
     145           5 : static av_cold void rv34_init_tables(void)
     146             : {
     147             :     int i, j, k;
     148             : 
     149          30 :     for(i = 0; i < NUM_INTRA_TABLES; i++){
     150          75 :         for(j = 0; j < 2; j++){
     151          50 :             rv34_gen_vlc(rv34_table_intra_cbppat   [i][j], CBPPAT_VLC_SIZE,   &intra_vlcs[i].cbppattern[j],     NULL, 19*i + 0 + j);
     152          50 :             rv34_gen_vlc(rv34_table_intra_secondpat[i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].second_pattern[j], NULL, 19*i + 2 + j);
     153          50 :             rv34_gen_vlc(rv34_table_intra_thirdpat [i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].third_pattern[j],  NULL, 19*i + 4 + j);
     154         250 :             for(k = 0; k < 4; k++){
     155         200 :                 rv34_gen_vlc(rv34_table_intra_cbp[i][j+k*2],  CBP_VLC_SIZE,   &intra_vlcs[i].cbp[j][k],         rv34_cbp_code, 19*i + 6 + j*4 + k);
     156             :             }
     157             :         }
     158         125 :         for(j = 0; j < 4; j++){
     159         100 :             rv34_gen_vlc(rv34_table_intra_firstpat[i][j], FIRSTBLK_VLC_SIZE, &intra_vlcs[i].first_pattern[j], NULL, 19*i + 14 + j);
     160             :         }
     161          25 :         rv34_gen_vlc(rv34_intra_coeff[i], COEFF_VLC_SIZE, &intra_vlcs[i].coefficient, NULL, 19*i + 18);
     162             :     }
     163             : 
     164          40 :     for(i = 0; i < NUM_INTER_TABLES; i++){
     165          35 :         rv34_gen_vlc(rv34_inter_cbppat[i], CBPPAT_VLC_SIZE, &inter_vlcs[i].cbppattern[0], NULL, i*12 + 95);
     166         175 :         for(j = 0; j < 4; j++){
     167         140 :             rv34_gen_vlc(rv34_inter_cbp[i][j], CBP_VLC_SIZE, &inter_vlcs[i].cbp[0][j], rv34_cbp_code, i*12 + 96 + j);
     168             :         }
     169         105 :         for(j = 0; j < 2; j++){
     170          70 :             rv34_gen_vlc(rv34_table_inter_firstpat [i][j], FIRSTBLK_VLC_SIZE, &inter_vlcs[i].first_pattern[j],  NULL, i*12 + 100 + j);
     171          70 :             rv34_gen_vlc(rv34_table_inter_secondpat[i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].second_pattern[j], NULL, i*12 + 102 + j);
     172          70 :             rv34_gen_vlc(rv34_table_inter_thirdpat [i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].third_pattern[j],  NULL, i*12 + 104 + j);
     173             :         }
     174          35 :         rv34_gen_vlc(rv34_inter_coeff[i], COEFF_VLC_SIZE, &inter_vlcs[i].coefficient, NULL, i*12 + 106);
     175             :     }
     176           5 : }
     177             : 
     178             : /** @} */ // vlc group
     179             : 
     180             : /**
     181             :  * @name RV30/40 4x4 block decoding functions
     182             :  * @{
     183             :  */
     184             : 
     185             : /**
     186             :  * Decode coded block pattern.
     187             :  */
     188      129189 : static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table)
     189             : {
     190      129189 :     int pattern, code, cbp=0;
     191             :     int ones;
     192             :     static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000};
     193             :     static const int shifts[4] = { 0, 2, 8, 10 };
     194      129189 :     const int *curshift = shifts;
     195             :     int i, t, mask;
     196             : 
     197      129189 :     code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2);
     198      129189 :     pattern = code & 0xF;
     199      129189 :     code >>= 4;
     200             : 
     201      129189 :     ones = rv34_count_ones[pattern];
     202             : 
     203      645945 :     for(mask = 8; mask; mask >>= 1, curshift++){
     204      516756 :         if(pattern & mask)
     205      181416 :             cbp |= get_vlc2(gb, vlc->cbp[table][ones].table, vlc->cbp[table][ones].bits, 1) << curshift[0];
     206             :     }
     207             : 
     208      645945 :     for(i = 0; i < 4; i++){
     209      516756 :         t = (modulo_three_table[code] >> (6 - 2*i)) & 3;
     210      516756 :         if(t == 1)
     211      121158 :             cbp |= cbp_masks[get_bits1(gb)] << i;
     212      516756 :         if(t == 2)
     213       59165 :             cbp |= cbp_masks[2] << i;
     214             :     }
     215      129189 :     return cbp;
     216             : }
     217             : 
     218             : /**
     219             :  * Get one coefficient value from the bitstream and store it.
     220             :  */
     221     2269770 : static inline void decode_coeff(int16_t *dst, int coef, int esc, GetBitContext *gb, VLC* vlc, int q)
     222             : {
     223     2269770 :     if(coef){
     224     1158695 :         if(coef == esc){
     225      158483 :             coef = get_vlc2(gb, vlc->table, 9, 2);
     226      158483 :             if(coef > 23){
     227         139 :                 coef -= 23;
     228         139 :                 coef = 22 + ((1 << coef) | get_bits(gb, coef));
     229             :             }
     230      158483 :             coef += esc;
     231             :         }
     232     1158695 :         if(get_bits1(gb))
     233      572454 :             coef = -coef;
     234     1158695 :         *dst = (coef*q + 8) >> 4;
     235             :     }
     236     2269770 : }
     237             : 
     238             : /**
     239             :  * Decode 2x2 subblock of coefficients.
     240             :  */
     241      134059 : static inline void decode_subblock(int16_t *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc, int q)
     242             : {
     243      134059 :     int flags = modulo_three_table[code];
     244             : 
     245      134059 :     decode_coeff(    dst+0*4+0, (flags >> 6)    , 3, gb, vlc, q);
     246      134059 :     if(is_block2){
     247       83261 :         decode_coeff(dst+1*4+0, (flags >> 4) & 3, 2, gb, vlc, q);
     248       83261 :         decode_coeff(dst+0*4+1, (flags >> 2) & 3, 2, gb, vlc, q);
     249             :     }else{
     250       50798 :         decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q);
     251       50798 :         decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q);
     252             :     }
     253      134059 :     decode_coeff(    dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q);
     254      134059 : }
     255             : 
     256             : /**
     257             :  * Decode a single coefficient.
     258             :  */
     259      404286 : static inline void decode_subblock1(int16_t *dst, int code, GetBitContext *gb, VLC *vlc, int q)
     260             : {
     261      404286 :     int coeff = modulo_three_table[code] >> 6;
     262      404286 :     decode_coeff(dst, coeff, 3, gb, vlc, q);
     263      404286 : }
     264             : 
     265      332312 : static inline void decode_subblock3(int16_t *dst, int code, GetBitContext *gb, VLC *vlc,
     266             :                                     int q_dc, int q_ac1, int q_ac2)
     267             : {
     268      332312 :     int flags = modulo_three_table[code];
     269             : 
     270      332312 :     decode_coeff(dst+0*4+0, (flags >> 6)    , 3, gb, vlc, q_dc);
     271      332312 :     decode_coeff(dst+0*4+1, (flags >> 4) & 3, 2, gb, vlc, q_ac1);
     272      332312 :     decode_coeff(dst+1*4+0, (flags >> 2) & 3, 2, gb, vlc, q_ac1);
     273      332312 :     decode_coeff(dst+1*4+1, (flags >> 0) & 3, 2, gb, vlc, q_ac2);
     274      332312 : }
     275             : 
     276             : /**
     277             :  * Decode coefficients for 4x4 block.
     278             :  *
     279             :  * This is done by filling 2x2 subblocks with decoded coefficients
     280             :  * in this order (the same for subblocks and subblock coefficients):
     281             :  *  o--o
     282             :  *    /
     283             :  *   /
     284             :  *  o--o
     285             :  */
     286             : 
     287      736598 : static int rv34_decode_block(int16_t *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc, int q_dc, int q_ac1, int q_ac2)
     288             : {
     289      736598 :     int code, pattern, has_ac = 1;
     290             : 
     291      736598 :     code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2);
     292             : 
     293      736598 :     pattern = code & 0x7;
     294             : 
     295      736598 :     code >>= 3;
     296             : 
     297      736598 :     if (modulo_three_table[code] & 0x3F) {
     298      332312 :         decode_subblock3(dst, code, gb, &rvlc->coefficient, q_dc, q_ac1, q_ac2);
     299             :     } else {
     300      404286 :         decode_subblock1(dst, code, gb, &rvlc->coefficient, q_dc);
     301      404286 :         if (!pattern)
     302      363407 :             return 0;
     303       40879 :         has_ac = 0;
     304             :     }
     305             : 
     306      373191 :     if(pattern & 4){
     307       44632 :         code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
     308       44632 :         decode_subblock(dst + 4*0+2, code, 0, gb, &rvlc->coefficient, q_ac2);
     309             :     }
     310      373191 :     if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this block
     311       83261 :         code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2);
     312       83261 :         decode_subblock(dst + 4*2+0, code, 1, gb, &rvlc->coefficient, q_ac2);
     313             :     }
     314      373191 :     if(pattern & 1){
     315        6166 :         code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2);
     316        6166 :         decode_subblock(dst + 4*2+2, code, 0, gb, &rvlc->coefficient, q_ac2);
     317             :     }
     318      373191 :     return has_ac | pattern;
     319             : }
     320             : 
     321             : /**
     322             :  * @name RV30/40 bitstream parsing
     323             :  * @{
     324             :  */
     325             : 
     326             : /**
     327             :  * Decode starting slice position.
     328             :  * @todo Maybe replace with ff_h263_decode_mba() ?
     329             :  */
     330        2770 : int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
     331             : {
     332             :     int i;
     333       10368 :     for(i = 0; i < 5; i++)
     334       10368 :         if(rv34_mb_max_sizes[i] >= mb_size - 1)
     335        2770 :             break;
     336        2770 :     return rv34_mb_bits_sizes[i];
     337             : }
     338             : 
     339             : /**
     340             :  * Select VLC set for decoding from current quantizer, modifier and frame type.
     341             :  */
     342      130283 : static inline RV34VLC* choose_vlc_set(int quant, int mod, int type)
     343             : {
     344      130283 :     if(mod == 2 && quant < 19) quant += 10;
     345       70216 :     else if(mod && quant < 26) quant += 5;
     346       97819 :     return type ? &inter_vlcs[rv34_quant_to_vlc_set[1][av_clip(quant, 0, 30)]]
     347      228102 :                 : &intra_vlcs[rv34_quant_to_vlc_set[0][av_clip(quant, 0, 30)]];
     348             : }
     349             : 
     350             : /**
     351             :  * Decode intra macroblock header and return CBP in case of success, -1 otherwise.
     352             :  */
     353        7640 : static int rv34_decode_intra_mb_header(RV34DecContext *r, int8_t *intra_types)
     354             : {
     355        7640 :     MpegEncContext *s = &r->s;
     356        7640 :     GetBitContext *gb = &s->gb;
     357        7640 :     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     358             :     int t;
     359             : 
     360        7640 :     r->is16 = get_bits1(gb);
     361        7640 :     if(r->is16){
     362        5830 :         s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA16x16;
     363        5830 :         r->block_type = RV34_MB_TYPE_INTRA16x16;
     364        5830 :         t = get_bits(gb, 2);
     365        5830 :         fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
     366        5830 :         r->luma_vlc   = 2;
     367             :     }else{
     368        1810 :         if(!r->rv30){
     369         467 :             if(!get_bits1(gb))
     370           0 :                 av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n");
     371             :         }
     372        1810 :         s->current_picture_ptr->mb_type[mb_pos] = MB_TYPE_INTRA;
     373        1810 :         r->block_type = RV34_MB_TYPE_INTRA;
     374        1810 :         if(r->decode_intra_types(r, gb, intra_types) < 0)
     375           0 :             return -1;
     376        1810 :         r->luma_vlc   = 1;
     377             :     }
     378             : 
     379        7640 :     r->chroma_vlc = 0;
     380        7640 :     r->cur_vlcs   = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
     381             : 
     382        7640 :     return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
     383             : }
     384             : 
     385             : /**
     386             :  * Decode inter macroblock header and return CBP in case of success, -1 otherwise.
     387             :  */
     388      284640 : static int rv34_decode_inter_mb_header(RV34DecContext *r, int8_t *intra_types)
     389             : {
     390      284640 :     MpegEncContext *s = &r->s;
     391      284640 :     GetBitContext *gb = &s->gb;
     392      284640 :     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     393             :     int i, t;
     394             : 
     395      284640 :     r->block_type = r->decode_mb_info(r);
     396      284640 :     if(r->block_type == -1)
     397           0 :         return -1;
     398      284640 :     s->current_picture_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type];
     399      284640 :     r->mb_type[mb_pos] = r->block_type;
     400      284640 :     if(r->block_type == RV34_MB_SKIP){
     401      163091 :         if(s->pict_type == AV_PICTURE_TYPE_P)
     402       31305 :             r->mb_type[mb_pos] = RV34_MB_P_16x16;
     403      163091 :         if(s->pict_type == AV_PICTURE_TYPE_B)
     404      131786 :             r->mb_type[mb_pos] = RV34_MB_B_DIRECT;
     405             :     }
     406      284640 :     r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]);
     407      284640 :     if (rv34_decode_mv(r, r->block_type) < 0)
     408           0 :         return -1;
     409      284640 :     if(r->block_type == RV34_MB_SKIP){
     410      163091 :         fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0]));
     411      163091 :         return 0;
     412             :     }
     413      121549 :     r->chroma_vlc = 1;
     414      121549 :     r->luma_vlc   = 0;
     415             : 
     416      121549 :     if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){
     417       24277 :         if(r->is16){
     418       10976 :             t = get_bits(gb, 2);
     419       10976 :             fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0]));
     420       10976 :             r->luma_vlc   = 2;
     421             :         }else{
     422       13301 :             if(r->decode_intra_types(r, gb, intra_types) < 0)
     423           0 :                 return -1;
     424       13301 :             r->luma_vlc   = 1;
     425             :         }
     426       24277 :         r->chroma_vlc = 0;
     427       24277 :         r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
     428             :     }else{
     429     1653624 :         for(i = 0; i < 16; i++)
     430     1556352 :             intra_types[(i & 3) + (i>>2) * r->intra_types_stride] = 0;
     431       97272 :         r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
     432       97272 :         if(r->mb_type[mb_pos] == RV34_MB_P_MIX16x16){
     433         547 :             r->is16 = 1;
     434         547 :             r->chroma_vlc = 1;
     435         547 :             r->luma_vlc   = 2;
     436         547 :             r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0);
     437             :         }
     438             :     }
     439             : 
     440      121549 :     return rv34_decode_cbp(gb, r->cur_vlcs, r->is16);
     441             : }
     442             : 
     443             : /** @} */ //bitstream functions
     444             : 
     445             : /**
     446             :  * @name motion vector related code (prediction, reconstruction, motion compensation)
     447             :  * @{
     448             :  */
     449             : 
     450             : /** macroblock partition width in 8x8 blocks */
     451             : static const uint8_t part_sizes_w[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 };
     452             : 
     453             : /** macroblock partition height in 8x8 blocks */
     454             : static const uint8_t part_sizes_h[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 };
     455             : 
     456             : /** availability index for subblocks */
     457             : static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 };
     458             : 
     459             : /**
     460             :  * motion vector prediction
     461             :  *
     462             :  * Motion prediction performed for the block by using median prediction of
     463             :  * motion vectors from the left, top and right top blocks but in corner cases
     464             :  * some other vectors may be used instead.
     465             :  */
     466       42620 : static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no)
     467             : {
     468       42620 :     MpegEncContext *s = &r->s;
     469       42620 :     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     470       42620 :     int A[2] = {0}, B[2], C[2];
     471             :     int i, j;
     472             :     int mx, my;
     473       42620 :     int* avail = r->avail_cache + avail_indexes[subblock_no];
     474       42620 :     int c_off = part_sizes_w[block_type];
     475             : 
     476       42620 :     mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->b8_stride;
     477       42620 :     if(subblock_no == 3)
     478        4526 :         c_off = -1;
     479             : 
     480       42620 :     if(avail[-1]){
     481       41140 :         A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0];
     482       41140 :         A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1];
     483             :     }
     484       42620 :     if(avail[-4]){
     485       30363 :         B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0];
     486       30363 :         B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1];
     487             :     }else{
     488       12257 :         B[0] = A[0];
     489       12257 :         B[1] = A[1];
     490             :     }
     491       42620 :     if(!avail[c_off-4]){
     492       13924 :         if(avail[-4] && (avail[-1] || r->rv30)){
     493        1813 :             C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0];
     494        1813 :             C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1];
     495             :         }else{
     496       12111 :             C[0] = A[0];
     497       12111 :             C[1] = A[1];
     498             :         }
     499             :     }else{
     500       28696 :         C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0];
     501       28696 :         C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1];
     502             :     }
     503       42620 :     mx = mid_pred(A[0], B[0], C[0]);
     504       42620 :     my = mid_pred(A[1], B[1], C[1]);
     505       42620 :     mx += r->dmv[dmv_no][0];
     506       42620 :     my += r->dmv[dmv_no][1];
     507      107064 :     for(j = 0; j < part_sizes_h[block_type]; j++){
     508      165336 :         for(i = 0; i < part_sizes_w[block_type]; i++){
     509      100892 :             s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx;
     510      100892 :             s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my;
     511             :         }
     512             :     }
     513       42620 : }
     514             : 
     515             : #define GET_PTS_DIFF(a, b) (((a) - (b) + 8192) & 0x1FFF)
     516             : 
     517             : /**
     518             :  * Calculate motion vector component that should be added for direct blocks.
     519             :  */
     520      802736 : static int calc_add_mv(RV34DecContext *r, int dir, int val)
     521             : {
     522      802736 :     int mul = dir ? -r->mv_weight2 : r->mv_weight1;
     523             : 
     524      802736 :     return (int)(val * (SUINT)mul + 0x2000) >> 14;
     525             : }
     526             : 
     527             : /**
     528             :  * Predict motion vector for B-frame macroblock.
     529             :  */
     530       47002 : static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2],
     531             :                                       int A_avail, int B_avail, int C_avail,
     532             :                                       int *mx, int *my)
     533             : {
     534       47002 :     if(A_avail + B_avail + C_avail != 3){
     535       34307 :         *mx = A[0] + B[0] + C[0];
     536       34307 :         *my = A[1] + B[1] + C[1];
     537       34307 :         if(A_avail + B_avail + C_avail == 2){
     538       11581 :             *mx /= 2;
     539       11581 :             *my /= 2;
     540             :         }
     541             :     }else{
     542       12695 :         *mx = mid_pred(A[0], B[0], C[0]);
     543       12695 :         *my = mid_pred(A[1], B[1], C[1]);
     544             :     }
     545       47002 : }
     546             : 
     547             : /**
     548             :  * motion vector prediction for B-frames
     549             :  */
     550       47002 : static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir)
     551             : {
     552       47002 :     MpegEncContext *s = &r->s;
     553       47002 :     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
     554       47002 :     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     555       47002 :     int A[2] = { 0 }, B[2] = { 0 }, C[2] = { 0 };
     556       47002 :     int has_A = 0, has_B = 0, has_C = 0;
     557             :     int mx, my;
     558             :     int i, j;
     559       47002 :     Picture *cur_pic = s->current_picture_ptr;
     560       47002 :     const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0;
     561       47002 :     int type = cur_pic->mb_type[mb_pos];
     562             : 
     563       47002 :     if((r->avail_cache[6-1] & type) & mask){
     564       29561 :         A[0] = cur_pic->motion_val[dir][mv_pos - 1][0];
     565       29561 :         A[1] = cur_pic->motion_val[dir][mv_pos - 1][1];
     566       29561 :         has_A = 1;
     567             :     }
     568       47002 :     if((r->avail_cache[6-4] & type) & mask){
     569       24041 :         B[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][0];
     570       24041 :         B[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][1];
     571       24041 :         has_B = 1;
     572             :     }
     573       47002 :     if(r->avail_cache[6-4] && (r->avail_cache[6-2] & type) & mask){
     574       21963 :         C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][0];
     575       21963 :         C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][1];
     576       21963 :         has_C = 1;
     577       25039 :     }else if((s->mb_x+1) == s->mb_width && (r->avail_cache[6-5] & type) & mask){
     578         386 :         C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][0];
     579         386 :         C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][1];
     580         386 :         has_C = 1;
     581             :     }
     582             : 
     583       47002 :     rv34_pred_b_vector(A, B, C, has_A, has_B, has_C, &mx, &my);
     584             : 
     585       47002 :     mx += r->dmv[dir][0];
     586       47002 :     my += r->dmv[dir][1];
     587             : 
     588      141006 :     for(j = 0; j < 2; j++){
     589      282012 :         for(i = 0; i < 2; i++){
     590      188008 :             cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][0] = mx;
     591      188008 :             cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][1] = my;
     592             :         }
     593             :     }
     594       47002 :     if(block_type == RV34_MB_B_BACKWARD || block_type == RV34_MB_B_FORWARD){
     595       28476 :         ZERO8x2(cur_pic->motion_val[!dir][mv_pos], s->b8_stride);
     596             :     }
     597       47002 : }
     598             : 
     599             : /**
     600             :  * motion vector prediction - RV3 version
     601             :  */
     602        9134 : static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir)
     603             : {
     604        9134 :     MpegEncContext *s = &r->s;
     605        9134 :     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     606        9134 :     int A[2] = {0}, B[2], C[2];
     607             :     int i, j, k;
     608             :     int mx, my;
     609        9134 :     int* avail = r->avail_cache + avail_indexes[0];
     610             : 
     611        9134 :     if(avail[-1]){
     612        8666 :         A[0] = s->current_picture_ptr->motion_val[0][mv_pos - 1][0];
     613        8666 :         A[1] = s->current_picture_ptr->motion_val[0][mv_pos - 1][1];
     614             :     }
     615        9134 :     if(avail[-4]){
     616        8618 :         B[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][0];
     617        8618 :         B[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride][1];
     618             :     }else{
     619         516 :         B[0] = A[0];
     620         516 :         B[1] = A[1];
     621             :     }
     622        9134 :     if(!avail[-4 + 2]){
     623         950 :         if(avail[-4] && (avail[-1])){
     624         434 :             C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][0];
     625         434 :             C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride - 1][1];
     626             :         }else{
     627         516 :             C[0] = A[0];
     628         516 :             C[1] = A[1];
     629             :         }
     630             :     }else{
     631        8184 :         C[0] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][0];
     632        8184 :         C[1] = s->current_picture_ptr->motion_val[0][mv_pos - s->b8_stride + 2][1];
     633             :     }
     634        9134 :     mx = mid_pred(A[0], B[0], C[0]);
     635        9134 :     my = mid_pred(A[1], B[1], C[1]);
     636        9134 :     mx += r->dmv[0][0];
     637        9134 :     my += r->dmv[0][1];
     638       27402 :     for(j = 0; j < 2; j++){
     639       54804 :         for(i = 0; i < 2; i++){
     640      109608 :             for(k = 0; k < 2; k++){
     641       73072 :                 s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx;
     642       73072 :                 s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my;
     643             :             }
     644             :         }
     645             :     }
     646        9134 : }
     647             : 
     648             : static const int chroma_coeffs[3] = { 0, 3, 5 };
     649             : 
     650             : /**
     651             :  * generic motion compensation function
     652             :  *
     653             :  * @param r decoder context
     654             :  * @param block_type type of the current block
     655             :  * @param xoff horizontal offset from the start of the current block
     656             :  * @param yoff vertical offset from the start of the current block
     657             :  * @param mv_off offset to the motion vector information
     658             :  * @param width width of the current partition in 8x8 blocks
     659             :  * @param height height of the current partition in 8x8 blocks
     660             :  * @param dir motion compensation direction (i.e. from the last or the next reference frame)
     661             :  * @param thirdpel motion vectors are specified in 1/3 of pixel
     662             :  * @param qpel_mc a set of functions used to perform luma motion compensation
     663             :  * @param chroma_mc a set of functions used to perform chroma motion compensation
     664             :  */
     665      511743 : static inline void rv34_mc(RV34DecContext *r, const int block_type,
     666             :                           const int xoff, const int yoff, int mv_off,
     667             :                           const int width, const int height, int dir,
     668             :                           const int thirdpel, int weighted,
     669             :                           qpel_mc_func (*qpel_mc)[16],
     670             :                           h264_chroma_mc_func (*chroma_mc))
     671             : {
     672      511743 :     MpegEncContext *s = &r->s;
     673             :     uint8_t *Y, *U, *V, *srcY, *srcU, *srcV;
     674             :     int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y;
     675      511743 :     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off;
     676      511743 :     int is16x16 = 1;
     677      511743 :     int emu = 0;
     678             : 
     679      511743 :     if(thirdpel){
     680             :         int chroma_mx, chroma_my;
     681      127708 :         mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24);
     682      127708 :         my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24);
     683      127708 :         lx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3;
     684      127708 :         ly = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3;
     685      127708 :         chroma_mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
     686      127708 :         chroma_my = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
     687      127708 :         umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24);
     688      127708 :         umy = (chroma_my + (3 << 24)) / 3 - (1 << 24);
     689      127708 :         uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3];
     690      127708 :         uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3];
     691             :     }else{
     692             :         int cx, cy;
     693      384035 :         mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2;
     694      384035 :         my = s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2;
     695      384035 :         lx = s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3;
     696      384035 :         ly = s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3;
     697      384035 :         cx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2;
     698      384035 :         cy = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2;
     699      384035 :         umx = cx >> 2;
     700      384035 :         umy = cy >> 2;
     701      384035 :         uvmx = (cx & 3) << 1;
     702      384035 :         uvmy = (cy & 3) << 1;
     703             :         //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3
     704      384035 :         if(uvmx == 6 && uvmy == 6)
     705        7377 :             uvmx = uvmy = 4;
     706             :     }
     707             : 
     708      511743 :     if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
     709             :         /* wait for the referenced mb row to be finished */
     710           0 :         int mb_row = s->mb_y + ((yoff + my + 5 + 8 * height) >> 4);
     711           0 :         ThreadFrame *f = dir ? &s->next_picture_ptr->tf : &s->last_picture_ptr->tf;
     712           0 :         ff_thread_await_progress(f, mb_row, 0);
     713             :     }
     714             : 
     715      511743 :     dxy = ly*4 + lx;
     716      511743 :     srcY = dir ? s->next_picture_ptr->f->data[0] : s->last_picture_ptr->f->data[0];
     717      511743 :     srcU = dir ? s->next_picture_ptr->f->data[1] : s->last_picture_ptr->f->data[1];
     718      511743 :     srcV = dir ? s->next_picture_ptr->f->data[2] : s->last_picture_ptr->f->data[2];
     719      511743 :     src_x = s->mb_x * 16 + xoff + mx;
     720      511743 :     src_y = s->mb_y * 16 + yoff + my;
     721      511743 :     uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx;
     722      511743 :     uvsrc_y = s->mb_y * 8 + (yoff >> 1) + umy;
     723      511743 :     srcY += src_y * s->linesize + src_x;
     724      511743 :     srcU += uvsrc_y * s->uvlinesize + uvsrc_x;
     725      511743 :     srcV += uvsrc_y * s->uvlinesize + uvsrc_x;
     726     1023486 :     if(s->h_edge_pos - (width << 3) < 6 || s->v_edge_pos - (height << 3) < 6 ||
     727     1007421 :        (unsigned)(src_x - !!lx*2) > s->h_edge_pos - !!lx*2 - (width <<3) - 4 ||
     728      495678 :        (unsigned)(src_y - !!ly*2) > s->v_edge_pos - !!ly*2 - (height<<3) - 4) {
     729       43652 :         srcY -= 2 + 2*s->linesize;
     730      130956 :         s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, srcY,
     731             :                                  s->linesize, s->linesize,
     732       87304 :                                  (width << 3) + 6, (height << 3) + 6,
     733             :                                  src_x - 2, src_y - 2,
     734             :                                  s->h_edge_pos, s->v_edge_pos);
     735       43652 :         srcY = s->sc.edge_emu_buffer + 2 + 2*s->linesize;
     736       43652 :         emu = 1;
     737             :     }
     738      511743 :     if(!weighted){
     739      230597 :         Y = s->dest[0] + xoff      + yoff     *s->linesize;
     740      230597 :         U = s->dest[1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
     741      230597 :         V = s->dest[2] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
     742             :     }else{
     743      281146 :         Y = r->tmp_b_block_y [dir]     +  xoff     +  yoff    *s->linesize;
     744      281146 :         U = r->tmp_b_block_uv[dir*2]   + (xoff>>1) + (yoff>>1)*s->uvlinesize;
     745      281146 :         V = r->tmp_b_block_uv[dir*2+1] + (xoff>>1) + (yoff>>1)*s->uvlinesize;
     746             :     }
     747             : 
     748      511743 :     if(block_type == RV34_MB_P_16x8){
     749        2692 :         qpel_mc[1][dxy](Y, srcY, s->linesize);
     750        2692 :         Y    += 8;
     751        2692 :         srcY += 8;
     752      509051 :     }else if(block_type == RV34_MB_P_8x16){
     753        4946 :         qpel_mc[1][dxy](Y, srcY, s->linesize);
     754        4946 :         Y    += 8 * s->linesize;
     755        4946 :         srcY += 8 * s->linesize;
     756             :     }
     757      511743 :     is16x16 = (block_type != RV34_MB_P_8x8) && (block_type != RV34_MB_P_16x8) && (block_type != RV34_MB_P_8x16);
     758      511743 :     qpel_mc[!is16x16][dxy](Y, srcY, s->linesize);
     759      511743 :     if (emu) {
     760       43652 :         uint8_t *uvbuf = s->sc.edge_emu_buffer;
     761             : 
     762      218260 :         s->vdsp.emulated_edge_mc(uvbuf, srcU,
     763             :                                  s->uvlinesize, s->uvlinesize,
     764       87304 :                                  (width << 2) + 1, (height << 2) + 1,
     765             :                                  uvsrc_x, uvsrc_y,
     766       87304 :                                  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
     767       43652 :         srcU = uvbuf;
     768       43652 :         uvbuf += 9*s->uvlinesize;
     769             : 
     770      218260 :         s->vdsp.emulated_edge_mc(uvbuf, srcV,
     771             :                                  s->uvlinesize, s->uvlinesize,
     772       87304 :                                  (width << 2) + 1, (height << 2) + 1,
     773             :                                  uvsrc_x, uvsrc_y,
     774       87304 :                                  s->h_edge_pos >> 1, s->v_edge_pos >> 1);
     775       43652 :         srcV = uvbuf;
     776             :     }
     777      511743 :     chroma_mc[2-width]   (U, srcU, s->uvlinesize, height*4, uvmx, uvmy);
     778      511743 :     chroma_mc[2-width]   (V, srcV, s->uvlinesize, height*4, uvmx, uvmy);
     779      511743 : }
     780             : 
     781      111535 : static void rv34_mc_1mv(RV34DecContext *r, const int block_type,
     782             :                         const int xoff, const int yoff, int mv_off,
     783             :                         const int width, const int height, int dir)
     784             : {
     785      111535 :     rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->rv30, 0,
     786      111535 :             r->rdsp.put_pixels_tab,
     787      111535 :             r->rdsp.put_chroma_pixels_tab);
     788      111535 : }
     789             : 
     790      115964 : static void rv4_weight(RV34DecContext *r)
     791             : {
     792      115964 :     r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][0](r->s.dest[0],
     793             :                                                         r->tmp_b_block_y[0],
     794             :                                                         r->tmp_b_block_y[1],
     795             :                                                         r->weight1,
     796             :                                                         r->weight2,
     797             :                                                         r->s.linesize);
     798      115964 :     r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[1],
     799             :                                                         r->tmp_b_block_uv[0],
     800             :                                                         r->tmp_b_block_uv[2],
     801             :                                                         r->weight1,
     802             :                                                         r->weight2,
     803             :                                                         r->s.uvlinesize);
     804      115964 :     r->rdsp.rv40_weight_pixels_tab[r->scaled_weight][1](r->s.dest[2],
     805             :                                                         r->tmp_b_block_uv[1],
     806             :                                                         r->tmp_b_block_uv[3],
     807             :                                                         r->weight1,
     808             :                                                         r->weight2,
     809             :                                                         r->s.uvlinesize);
     810      115964 : }
     811             : 
     812      154932 : static void rv34_mc_2mv(RV34DecContext *r, const int block_type)
     813             : {
     814      154932 :     int weighted = !r->rv30 && block_type != RV34_MB_B_BIDIR && r->weight1 != 8192;
     815             : 
     816      154932 :     rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->rv30, weighted,
     817      154932 :             r->rdsp.put_pixels_tab,
     818      154932 :             r->rdsp.put_chroma_pixels_tab);
     819      154932 :     if(!weighted){
     820       47171 :         rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 0,
     821       47171 :                 r->rdsp.avg_pixels_tab,
     822       47171 :                 r->rdsp.avg_chroma_pixels_tab);
     823             :     }else{
     824      107761 :         rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, 1,
     825      107761 :                 r->rdsp.put_pixels_tab,
     826      107761 :                 r->rdsp.put_chroma_pixels_tab);
     827      107761 :         rv4_weight(r);
     828             :     }
     829      154932 : }
     830             : 
     831       11293 : static void rv34_mc_2mv_skip(RV34DecContext *r)
     832             : {
     833             :     int i, j;
     834       11293 :     int weighted = !r->rv30 && r->weight1 != 8192;
     835             : 
     836       33879 :     for(j = 0; j < 2; j++)
     837       67758 :         for(i = 0; i < 2; i++){
     838       45172 :              rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 0, r->rv30,
     839             :                      weighted,
     840       45172 :                      r->rdsp.put_pixels_tab,
     841       45172 :                      r->rdsp.put_chroma_pixels_tab);
     842       45172 :              rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 1, r->rv30,
     843             :                      weighted,
     844             :                      weighted ? r->rdsp.put_pixels_tab : r->rdsp.avg_pixels_tab,
     845             :                      weighted ? r->rdsp.put_chroma_pixels_tab : r->rdsp.avg_chroma_pixels_tab);
     846             :         }
     847       11293 :     if(weighted)
     848        8203 :         rv4_weight(r);
     849       11293 : }
     850             : 
     851             : /** number of motion vectors in each macroblock type */
     852             : static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 };
     853             : 
     854             : /**
     855             :  * Decode motion vector differences
     856             :  * and perform motion vector reconstruction and motion compensation.
     857             :  */
     858      284640 : static int rv34_decode_mv(RV34DecContext *r, int block_type)
     859             : {
     860      284640 :     MpegEncContext *s = &r->s;
     861      284640 :     GetBitContext *gb = &s->gb;
     862             :     int i, j, k, l;
     863      284640 :     int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
     864             :     int next_bt;
     865             : 
     866      284640 :     memset(r->dmv, 0, sizeof(r->dmv));
     867      383396 :     for(i = 0; i < num_mvs[block_type]; i++){
     868       98756 :         r->dmv[i][0] = get_interleaved_se_golomb(gb);
     869       98756 :         r->dmv[i][1] = get_interleaved_se_golomb(gb);
     870      197512 :         if (r->dmv[i][0] == INVALID_VLC ||
     871       98756 :             r->dmv[i][1] == INVALID_VLC) {
     872           0 :             r->dmv[i][0] = r->dmv[i][1] = 0;
     873           0 :             return AVERROR_INVALIDDATA;
     874             :         }
     875             :     }
     876      284640 :     switch(block_type){
     877       24277 :     case RV34_MB_TYPE_INTRA:
     878             :     case RV34_MB_TYPE_INTRA16x16:
     879       24277 :         ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
     880       24277 :         return 0;
     881      163091 :     case RV34_MB_SKIP:
     882      163091 :         if(s->pict_type == AV_PICTURE_TYPE_P){
     883       31305 :             ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
     884       31305 :             rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
     885       31305 :             break;
     886             :         }
     887             :     case RV34_MB_B_DIRECT:
     888             :         //surprisingly, it uses motion scheme from next reference frame
     889             :         /* wait for the current mb row to be finished */
     890      156962 :         if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
     891           0 :             ff_thread_await_progress(&s->next_picture_ptr->tf, FFMAX(0, s->mb_y-1), 0);
     892             : 
     893      156962 :         next_bt = s->next_picture_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride];
     894      156962 :         if(IS_INTRA(next_bt) || IS_SKIP(next_bt)){
     895      106791 :             ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
     896      106791 :             ZERO8x2(s->current_picture_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
     897             :         }else
     898      150513 :             for(j = 0; j < 2; j++)
     899      301026 :                 for(i = 0; i < 2; i++)
     900      602052 :                     for(k = 0; k < 2; k++)
     901     1204104 :                         for(l = 0; l < 2; l++)
     902      802736 :                             s->current_picture_ptr->motion_val[l][mv_pos + i + j*s->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][k]);
     903      156962 :         if(!(IS_16X8(next_bt) || IS_8X16(next_bt) || IS_8X8(next_bt))) //we can use whole macroblock MC
     904      145669 :             rv34_mc_2mv(r, block_type);
     905             :         else
     906       11293 :             rv34_mc_2mv_skip(r);
     907      156962 :         ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride);
     908      156962 :         break;
     909       16878 :     case RV34_MB_P_16x16:
     910             :     case RV34_MB_P_MIX16x16:
     911       16878 :         rv34_pred_mv(r, block_type, 0, 0);
     912       16878 :         rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0);
     913       16878 :         break;
     914       37610 :     case RV34_MB_B_FORWARD:
     915             :     case RV34_MB_B_BACKWARD:
     916       37610 :         r->dmv[1][0] = r->dmv[0][0];
     917       37610 :         r->dmv[1][1] = r->dmv[0][1];
     918       37610 :         if(r->rv30)
     919        9134 :             rv34_pred_mv_rv3(r, block_type, block_type == RV34_MB_B_BACKWARD);
     920             :         else
     921       28476 :             rv34_pred_mv_b  (r, block_type, block_type == RV34_MB_B_BACKWARD);
     922       37610 :         rv34_mc_1mv     (r, block_type, 0, 0, 0, 2, 2, block_type == RV34_MB_B_BACKWARD);
     923       37610 :         break;
     924        3819 :     case RV34_MB_P_16x8:
     925             :     case RV34_MB_P_8x16:
     926        3819 :         rv34_pred_mv(r, block_type, 0, 0);
     927        3819 :         rv34_pred_mv(r, block_type, 1 + (block_type == RV34_MB_P_16x8), 1);
     928        3819 :         if(block_type == RV34_MB_P_16x8){
     929        1346 :             rv34_mc_1mv(r, block_type, 0, 0, 0,            2, 1, 0);
     930        1346 :             rv34_mc_1mv(r, block_type, 0, 8, s->b8_stride, 2, 1, 0);
     931             :         }
     932        3819 :         if(block_type == RV34_MB_P_8x16){
     933        2473 :             rv34_mc_1mv(r, block_type, 0, 0, 0, 1, 2, 0);
     934        2473 :             rv34_mc_1mv(r, block_type, 8, 0, 1, 1, 2, 0);
     935             :         }
     936        3819 :         break;
     937        9263 :     case RV34_MB_B_BIDIR:
     938        9263 :         rv34_pred_mv_b  (r, block_type, 0);
     939        9263 :         rv34_pred_mv_b  (r, block_type, 1);
     940        9263 :         rv34_mc_2mv     (r, block_type);
     941        9263 :         break;
     942        4526 :     case RV34_MB_P_8x8:
     943       22630 :         for(i=0;i< 4;i++){
     944       18104 :             rv34_pred_mv(r, block_type, i, i);
     945       18104 :             rv34_mc_1mv (r, block_type, (i&1)<<3, (i&2)<<2, (i&1)+(i>>1)*s->b8_stride, 1, 1, 0);
     946             :         }
     947        4526 :         break;
     948             :     }
     949             : 
     950      260363 :     return 0;
     951             : }
     952             : /** @} */ // mv group
     953             : 
     954             : /**
     955             :  * @name Macroblock reconstruction functions
     956             :  * @{
     957             :  */
     958             : /** mapping of RV30/40 intra prediction types to standard H.264 types */
     959             : static const int ittrans[9] = {
     960             :  DC_PRED, VERT_PRED, HOR_PRED, DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_LEFT_PRED,
     961             :  VERT_RIGHT_PRED, VERT_LEFT_PRED, HOR_UP_PRED, HOR_DOWN_PRED,
     962             : };
     963             : 
     964             : /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */
     965             : static const int ittrans16[4] = {
     966             :  DC_PRED8x8, VERT_PRED8x8, HOR_PRED8x8, PLANE_PRED8x8,
     967             : };
     968             : 
     969             : /**
     970             :  * Perform 4x4 intra prediction.
     971             :  */
     972      362664 : static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right)
     973             : {
     974      362664 :     uint8_t *prev = dst - stride + 4;
     975             :     uint32_t topleft;
     976             : 
     977      362664 :     if(!up && !left)
     978         906 :         itype = DC_128_PRED;
     979      361758 :     else if(!up){
     980       43702 :         if(itype == VERT_PRED) itype = HOR_PRED;
     981       43702 :         if(itype == DC_PRED)   itype = LEFT_DC_PRED;
     982      318056 :     }else if(!left){
     983        5318 :         if(itype == HOR_PRED)  itype = VERT_PRED;
     984        5318 :         if(itype == DC_PRED)   itype = TOP_DC_PRED;
     985        5318 :         if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN;
     986             :     }
     987      362664 :     if(!down){
     988      289443 :         if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN;
     989      289443 :         if(itype == HOR_UP_PRED) itype = HOR_UP_PRED_RV40_NODOWN;
     990      289443 :         if(itype == VERT_LEFT_PRED) itype = VERT_LEFT_PRED_RV40_NODOWN;
     991             :     }
     992      362664 :     if(!right && up){
     993       76047 :         topleft = dst[-stride + 3] * 0x01010101u;
     994       76047 :         prev = (uint8_t*)&topleft;
     995             :     }
     996      362664 :     r->h.pred4x4[itype](dst, prev, stride);
     997      362664 : }
     998             : 
     999       33612 : static inline int adjust_pred16(int itype, int up, int left)
    1000             : {
    1001       33612 :     if(!up && !left)
    1002          54 :         itype = DC_128_PRED8x8;
    1003       33558 :     else if(!up){
    1004        5754 :         if(itype == PLANE_PRED8x8)itype = HOR_PRED8x8;
    1005        5754 :         if(itype == VERT_PRED8x8) itype = HOR_PRED8x8;
    1006        5754 :         if(itype == DC_PRED8x8)   itype = LEFT_DC_PRED8x8;
    1007       27804 :     }else if(!left){
    1008         836 :         if(itype == PLANE_PRED8x8)itype = VERT_PRED8x8;
    1009         836 :         if(itype == HOR_PRED8x8)  itype = VERT_PRED8x8;
    1010         836 :         if(itype == DC_PRED8x8)   itype = TOP_DC_PRED8x8;
    1011             :     }
    1012       33612 :     return itype;
    1013             : }
    1014             : 
    1015      704977 : static inline void rv34_process_block(RV34DecContext *r,
    1016             :                                       uint8_t *pdst, int stride,
    1017             :                                       int fc, int sc, int q_dc, int q_ac)
    1018             : {
    1019      704977 :     MpegEncContext *s = &r->s;
    1020      704977 :     int16_t *ptr = s->block[0];
    1021      704977 :     int has_ac = rv34_decode_block(ptr, &s->gb, r->cur_vlcs,
    1022             :                                    fc, sc, q_dc, q_ac, q_ac);
    1023      704977 :     if(has_ac){
    1024      350745 :         r->rdsp.rv34_idct_add(pdst, stride, ptr);
    1025             :     }else{
    1026      354232 :         r->rdsp.rv34_idct_dc_add(pdst, stride, ptr[0]);
    1027      354232 :         ptr[0] = 0;
    1028             :     }
    1029      704977 : }
    1030             : 
    1031       16806 : static void rv34_output_i16x16(RV34DecContext *r, int8_t *intra_types, int cbp)
    1032             : {
    1033       16806 :     LOCAL_ALIGNED_16(int16_t, block16, [16]);
    1034       16806 :     MpegEncContext *s    = &r->s;
    1035       16806 :     GetBitContext  *gb   = &s->gb;
    1036       16806 :     int             q_dc = rv34_qscale_tab[ r->luma_dc_quant_i[s->qscale] ],
    1037       16806 :                     q_ac = rv34_qscale_tab[s->qscale];
    1038       16806 :     uint8_t        *dst  = s->dest[0];
    1039       16806 :     int16_t        *ptr  = s->block[0];
    1040             :     int i, j, itype, has_ac;
    1041             : 
    1042       16806 :     memset(block16, 0, 16 * sizeof(*block16));
    1043             : 
    1044       16806 :     has_ac = rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac);
    1045       16806 :     if(has_ac)
    1046        7912 :         r->rdsp.rv34_inv_transform(block16);
    1047             :     else
    1048        8894 :         r->rdsp.rv34_inv_transform_dc(block16);
    1049             : 
    1050       16806 :     itype = ittrans16[intra_types[0]];
    1051       16806 :     itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
    1052       16806 :     r->h.pred16x16[itype](dst, s->linesize);
    1053             : 
    1054       84030 :     for(j = 0; j < 4; j++){
    1055      336120 :         for(i = 0; i < 4; i++, cbp >>= 1){
    1056      268896 :             int dc = block16[i + j*4];
    1057             : 
    1058      268896 :             if(cbp & 1){
    1059       14262 :                 has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
    1060             :             }else
    1061      254634 :                 has_ac = 0;
    1062             : 
    1063      268896 :             if(has_ac){
    1064       14262 :                 ptr[0] = dc;
    1065       14262 :                 r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
    1066             :             }else
    1067      254634 :                 r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
    1068             :         }
    1069             : 
    1070       67224 :         dst += 4*s->linesize;
    1071             :     }
    1072             : 
    1073       16806 :     itype = ittrans16[intra_types[0]];
    1074       16806 :     if(itype == PLANE_PRED8x8) itype = DC_PRED8x8;
    1075       16806 :     itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]);
    1076             : 
    1077       16806 :     q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
    1078       16806 :     q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
    1079             : 
    1080       50418 :     for(j = 1; j < 3; j++){
    1081       33612 :         dst = s->dest[j];
    1082       33612 :         r->h.pred8x8[itype](dst, s->uvlinesize);
    1083      168060 :         for(i = 0; i < 4; i++, cbp >>= 1){
    1084             :             uint8_t *pdst;
    1085      134448 :             if(!(cbp & 1)) continue;
    1086       24665 :             pdst   = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
    1087             : 
    1088       24665 :             rv34_process_block(r, pdst, s->uvlinesize,
    1089             :                                r->chroma_vlc, 1, q_dc, q_ac);
    1090             :         }
    1091             :     }
    1092       16806 : }
    1093             : 
    1094       15111 : static void rv34_output_intra(RV34DecContext *r, int8_t *intra_types, int cbp)
    1095             : {
    1096       15111 :     MpegEncContext *s   = &r->s;
    1097       15111 :     uint8_t        *dst = s->dest[0];
    1098       15111 :     int      avail[6*8] = {0};
    1099             :     int i, j, k;
    1100             :     int idx, q_ac, q_dc;
    1101             : 
    1102             :     // Set neighbour information.
    1103       15111 :     if(r->avail_cache[1])
    1104        8914 :         avail[0] = 1;
    1105       15111 :     if(r->avail_cache[2])
    1106        9535 :         avail[1] = avail[2] = 1;
    1107       15111 :     if(r->avail_cache[3])
    1108        9535 :         avail[3] = avail[4] = 1;
    1109       15111 :     if(r->avail_cache[4])
    1110        9499 :         avail[5] = 1;
    1111       15111 :     if(r->avail_cache[5])
    1112       14333 :         avail[8] = avail[16] = 1;
    1113       15111 :     if(r->avail_cache[9])
    1114       14333 :         avail[24] = avail[32] = 1;
    1115             : 
    1116       15111 :     q_ac = rv34_qscale_tab[s->qscale];
    1117       75555 :     for(j = 0; j < 4; j++){
    1118       60444 :         idx = 9 + j*8;
    1119      302220 :         for(i = 0; i < 4; i++, cbp >>= 1, dst += 4, idx++){
    1120      241776 :             rv34_pred_4x4_block(r, dst, s->linesize, ittrans[intra_types[i]], avail[idx-8], avail[idx-1], avail[idx+7], avail[idx-7]);
    1121      241776 :             avail[idx] = 1;
    1122      241776 :             if(!(cbp & 1)) continue;
    1123             : 
    1124      148411 :             rv34_process_block(r, dst, s->linesize,
    1125             :                                r->luma_vlc, 0, q_ac, q_ac);
    1126             :         }
    1127       60444 :         dst += s->linesize * 4 - 4*4;
    1128       60444 :         intra_types += r->intra_types_stride;
    1129             :     }
    1130             : 
    1131       15111 :     intra_types -= r->intra_types_stride * 4;
    1132             : 
    1133       15111 :     q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
    1134       15111 :     q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
    1135             : 
    1136       45333 :     for(k = 0; k < 2; k++){
    1137       30222 :         dst = s->dest[1+k];
    1138       30222 :         fill_rectangle(r->avail_cache + 6, 2, 2, 4, 0, 4);
    1139             : 
    1140       90666 :         for(j = 0; j < 2; j++){
    1141       60444 :             int* acache = r->avail_cache + 6 + j*4;
    1142      181332 :             for(i = 0; i < 2; i++, cbp >>= 1, acache++){
    1143      120888 :                 int itype = ittrans[intra_types[i*2+j*2*r->intra_types_stride]];
    1144      120888 :                 rv34_pred_4x4_block(r, dst+4*i, s->uvlinesize, itype, acache[-4], acache[-1], !i && !j, acache[-3]);
    1145      120888 :                 acache[0] = 1;
    1146             : 
    1147      120888 :                 if(!(cbp&1)) continue;
    1148             : 
    1149       71067 :                 rv34_process_block(r, dst + 4*i, s->uvlinesize,
    1150             :                                    r->chroma_vlc, 1, q_dc, q_ac);
    1151             :             }
    1152             : 
    1153       60444 :             dst += 4*s->uvlinesize;
    1154             :         }
    1155             :     }
    1156       15111 : }
    1157             : 
    1158     2246368 : static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step)
    1159             : {
    1160             :     int d;
    1161     2246368 :     d = motion_val[0][0] - motion_val[-step][0];
    1162     2246368 :     if(d < -3 || d > 3)
    1163      188252 :         return 1;
    1164     2058116 :     d = motion_val[0][1] - motion_val[-step][1];
    1165     2058116 :     if(d < -3 || d > 3)
    1166       31852 :         return 1;
    1167     2026264 :     return 0;
    1168             : }
    1169             : 
    1170      284640 : static int rv34_set_deblock_coef(RV34DecContext *r)
    1171             : {
    1172      284640 :     MpegEncContext *s = &r->s;
    1173      284640 :     int hmvmask = 0, vmvmask = 0, i, j;
    1174      284640 :     int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride;
    1175      284640 :     int16_t (*motion_val)[2] = &s->current_picture_ptr->motion_val[0][midx];
    1176      853920 :     for(j = 0; j < 16; j += 8){
    1177     1707840 :         for(i = 0; i < 2; i++){
    1178     1138560 :             if(is_mv_diff_gt_3(motion_val + i, 1))
    1179      106472 :                 vmvmask |= 0x11 << (j + i*2);
    1180     1138560 :             if((j || s->mb_y) && is_mv_diff_gt_3(motion_val + i, s->b8_stride))
    1181      113632 :                 hmvmask |= 0x03 << (j + i*2);
    1182             :         }
    1183      569280 :         motion_val += s->b8_stride;
    1184             :     }
    1185      284640 :     if(s->first_slice_line)
    1186       42347 :         hmvmask &= ~0x000F;
    1187      284640 :     if(!s->mb_x)
    1188        9120 :         vmvmask &= ~0x1111;
    1189      284640 :     if(r->rv30){ //RV30 marks both subblocks on the edge for filtering
    1190       68640 :         vmvmask |= (vmvmask & 0x4444) >> 1;
    1191       68640 :         hmvmask |= (hmvmask & 0x0F00) >> 4;
    1192       68640 :         if(s->mb_x)
    1193       65520 :             r->deblock_coefs[s->mb_x - 1 + s->mb_y*s->mb_stride] |= (vmvmask & 0x1111) << 3;
    1194       68640 :         if(!s->first_slice_line)
    1195       61878 :             r->deblock_coefs[s->mb_x + (s->mb_y - 1)*s->mb_stride] |= (hmvmask & 0xF) << 12;
    1196             :     }
    1197      284640 :     return hmvmask | vmvmask;
    1198             : }
    1199             : 
    1200      284640 : static int rv34_decode_inter_macroblock(RV34DecContext *r, int8_t *intra_types)
    1201             : {
    1202      284640 :     MpegEncContext *s   = &r->s;
    1203      284640 :     GetBitContext  *gb  = &s->gb;
    1204      284640 :     uint8_t        *dst = s->dest[0];
    1205      284640 :     int16_t        *ptr = s->block[0];
    1206      284640 :     int          mb_pos = s->mb_x + s->mb_y * s->mb_stride;
    1207             :     int cbp, cbp2;
    1208             :     int q_dc, q_ac, has_ac;
    1209             :     int i, j;
    1210             :     int dist;
    1211             : 
    1212             :     // Calculate which neighbours are available. Maybe it's worth optimizing too.
    1213      284640 :     memset(r->avail_cache, 0, sizeof(r->avail_cache));
    1214      284640 :     fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
    1215      284640 :     dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
    1216      284640 :     if(s->mb_x && dist)
    1217      275017 :         r->avail_cache[5] =
    1218      275017 :         r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];
    1219      284640 :     if(dist >= s->mb_width)
    1220      242293 :         r->avail_cache[2] =
    1221      242293 :         r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];
    1222      284640 :     if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
    1223      234929 :         r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];
    1224      284640 :     if(s->mb_x && dist > s->mb_width)
    1225      234004 :         r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];
    1226             : 
    1227      284640 :     s->qscale = r->si.quant;
    1228      284640 :     cbp = cbp2 = rv34_decode_inter_mb_header(r, intra_types);
    1229      284640 :     r->cbp_luma  [mb_pos] = cbp;
    1230      284640 :     r->cbp_chroma[mb_pos] = cbp >> 16;
    1231      284640 :     r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) | r->cbp_luma[mb_pos];
    1232      284640 :     s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;
    1233             : 
    1234      284640 :     if(cbp == -1)
    1235           0 :         return -1;
    1236             : 
    1237      284640 :     if (IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){
    1238       24277 :         if(r->is16) rv34_output_i16x16(r, intra_types, cbp);
    1239       13301 :         else        rv34_output_intra(r, intra_types, cbp);
    1240       24277 :         return 0;
    1241             :     }
    1242             : 
    1243      260363 :     if(r->is16){
    1244             :         // Only for RV34_MB_P_MIX16x16
    1245         547 :         LOCAL_ALIGNED_16(int16_t, block16, [16]);
    1246         547 :         memset(block16, 0, 16 * sizeof(*block16));
    1247         547 :         q_dc = rv34_qscale_tab[ r->luma_dc_quant_p[s->qscale] ];
    1248         547 :         q_ac = rv34_qscale_tab[s->qscale];
    1249         547 :         if (rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0, q_dc, q_dc, q_ac))
    1250         266 :             r->rdsp.rv34_inv_transform(block16);
    1251             :         else
    1252         281 :             r->rdsp.rv34_inv_transform_dc(block16);
    1253             : 
    1254         547 :         q_ac = rv34_qscale_tab[s->qscale];
    1255             : 
    1256        2735 :         for(j = 0; j < 4; j++){
    1257       10940 :             for(i = 0; i < 4; i++, cbp >>= 1){
    1258        8752 :                 int      dc   = block16[i + j*4];
    1259             : 
    1260        8752 :                 if(cbp & 1){
    1261           6 :                     has_ac = rv34_decode_block(ptr, gb, r->cur_vlcs, r->luma_vlc, 0, q_ac, q_ac, q_ac);
    1262             :                 }else
    1263        8746 :                     has_ac = 0;
    1264             : 
    1265        8752 :                 if(has_ac){
    1266           6 :                     ptr[0] = dc;
    1267           6 :                     r->rdsp.rv34_idct_add(dst+4*i, s->linesize, ptr);
    1268             :                 }else
    1269        8746 :                     r->rdsp.rv34_idct_dc_add(dst+4*i, s->linesize, dc);
    1270             :             }
    1271             : 
    1272        2188 :             dst += 4*s->linesize;
    1273             :         }
    1274             : 
    1275         547 :         r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1);
    1276             :     }else{
    1277      259816 :         q_ac = rv34_qscale_tab[s->qscale];
    1278             : 
    1279     1299080 :         for(j = 0; j < 4; j++){
    1280     5196320 :             for(i = 0; i < 4; i++, cbp >>= 1){
    1281     4157056 :                 if(!(cbp & 1)) continue;
    1282             : 
    1283      317078 :                 rv34_process_block(r, dst + 4*i, s->linesize,
    1284             :                                    r->luma_vlc, 0, q_ac, q_ac);
    1285             :             }
    1286     1039264 :             dst += 4*s->linesize;
    1287             :         }
    1288             :     }
    1289             : 
    1290      260363 :     q_dc = rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]];
    1291      260363 :     q_ac = rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]];
    1292             : 
    1293      781089 :     for(j = 1; j < 3; j++){
    1294      520726 :         dst = s->dest[j];
    1295     2603630 :         for(i = 0; i < 4; i++, cbp >>= 1){
    1296             :             uint8_t *pdst;
    1297     2082904 :             if(!(cbp & 1)) continue;
    1298      143756 :             pdst = dst + (i&1)*4 + (i&2)*2*s->uvlinesize;
    1299             : 
    1300      143756 :             rv34_process_block(r, pdst, s->uvlinesize,
    1301             :                                r->chroma_vlc, 1, q_dc, q_ac);
    1302             :         }
    1303             :     }
    1304             : 
    1305      260363 :     return 0;
    1306             : }
    1307             : 
    1308        7640 : static int rv34_decode_intra_macroblock(RV34DecContext *r, int8_t *intra_types)
    1309             : {
    1310        7640 :     MpegEncContext *s = &r->s;
    1311             :     int cbp, dist;
    1312        7640 :     int mb_pos = s->mb_x + s->mb_y * s->mb_stride;
    1313             : 
    1314             :     // Calculate which neighbours are available. Maybe it's worth optimizing too.
    1315        7640 :     memset(r->avail_cache, 0, sizeof(r->avail_cache));
    1316        7640 :     fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4);
    1317        7640 :     dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width;
    1318        7640 :     if(s->mb_x && dist)
    1319        7325 :         r->avail_cache[5] =
    1320        7325 :         r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1];
    1321        7640 :     if(dist >= s->mb_width)
    1322        6133 :         r->avail_cache[2] =
    1323        6133 :         r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride];
    1324        7640 :     if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1)
    1325        5928 :         r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1];
    1326        7640 :     if(s->mb_x && dist > s->mb_width)
    1327        5878 :         r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1];
    1328             : 
    1329        7640 :     s->qscale = r->si.quant;
    1330        7640 :     cbp = rv34_decode_intra_mb_header(r, intra_types);
    1331        7640 :     r->cbp_luma  [mb_pos] = cbp;
    1332        7640 :     r->cbp_chroma[mb_pos] = cbp >> 16;
    1333        7640 :     r->deblock_coefs[mb_pos] = 0xFFFF;
    1334        7640 :     s->current_picture_ptr->qscale_table[mb_pos] = s->qscale;
    1335             : 
    1336        7640 :     if(cbp == -1)
    1337           0 :         return -1;
    1338             : 
    1339        7640 :     if(r->is16){
    1340        5830 :         rv34_output_i16x16(r, intra_types, cbp);
    1341        5830 :         return 0;
    1342             :     }
    1343             : 
    1344        1810 :     rv34_output_intra(r, intra_types, cbp);
    1345        1810 :     return 0;
    1346             : }
    1347             : 
    1348      293665 : static int check_slice_end(RV34DecContext *r, MpegEncContext *s)
    1349             : {
    1350             :     int bits;
    1351      293665 :     if(s->mb_y >= s->mb_height)
    1352         526 :         return 1;
    1353      293139 :     if(!s->mb_num_left)
    1354         859 :         return 1;
    1355      292280 :     if(r->s.mb_skip_run > 1)
    1356      128319 :         return 0;
    1357      163961 :     bits = get_bits_left(&s->gb);
    1358      163961 :     if(bits <= 0 || (bits < 8 && !show_bits(&s->gb, bits)))
    1359           0 :         return 1;
    1360      163961 :     return 0;
    1361             : }
    1362             : 
    1363             : 
    1364           9 : static void rv34_decoder_free(RV34DecContext *r)
    1365             : {
    1366           9 :     av_freep(&r->intra_types_hist);
    1367           9 :     r->intra_types = NULL;
    1368           9 :     av_freep(&r->tmp_b_block_base);
    1369           9 :     av_freep(&r->mb_type);
    1370           9 :     av_freep(&r->cbp_luma);
    1371           9 :     av_freep(&r->cbp_chroma);
    1372           9 :     av_freep(&r->deblock_coefs);
    1373           9 : }
    1374             : 
    1375             : 
    1376           9 : static int rv34_decoder_alloc(RV34DecContext *r)
    1377             : {
    1378           9 :     r->intra_types_stride = r->s.mb_width * 4 + 4;
    1379             : 
    1380           9 :     r->cbp_chroma       = av_mallocz(r->s.mb_stride * r->s.mb_height *
    1381             :                                     sizeof(*r->cbp_chroma));
    1382           9 :     r->cbp_luma         = av_mallocz(r->s.mb_stride * r->s.mb_height *
    1383             :                                     sizeof(*r->cbp_luma));
    1384           9 :     r->deblock_coefs    = av_mallocz(r->s.mb_stride * r->s.mb_height *
    1385             :                                     sizeof(*r->deblock_coefs));
    1386           9 :     r->intra_types_hist = av_malloc(r->intra_types_stride * 4 * 2 *
    1387             :                                     sizeof(*r->intra_types_hist));
    1388           9 :     r->mb_type          = av_mallocz(r->s.mb_stride * r->s.mb_height *
    1389             :                                      sizeof(*r->mb_type));
    1390             : 
    1391          27 :     if (!(r->cbp_chroma       && r->cbp_luma && r->deblock_coefs &&
    1392          18 :           r->intra_types_hist && r->mb_type)) {
    1393           0 :         rv34_decoder_free(r);
    1394           0 :         return AVERROR(ENOMEM);
    1395             :     }
    1396             : 
    1397           9 :     r->intra_types = r->intra_types_hist + r->intra_types_stride * 4;
    1398             : 
    1399           9 :     return 0;
    1400             : }
    1401             : 
    1402             : 
    1403           0 : static int rv34_decoder_realloc(RV34DecContext *r)
    1404             : {
    1405           0 :     rv34_decoder_free(r);
    1406           0 :     return rv34_decoder_alloc(r);
    1407             : }
    1408             : 
    1409             : 
    1410        1385 : static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size)
    1411             : {
    1412        1385 :     MpegEncContext *s = &r->s;
    1413        1385 :     GetBitContext *gb = &s->gb;
    1414             :     int mb_pos, slice_type;
    1415             :     int res;
    1416             : 
    1417        1385 :     init_get_bits(&r->s.gb, buf, buf_size*8);
    1418        1385 :     res = r->parse_slice_header(r, gb, &r->si);
    1419        1385 :     if(res < 0){
    1420           0 :         av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n");
    1421           0 :         return -1;
    1422             :     }
    1423             : 
    1424        1385 :     slice_type = r->si.type ? r->si.type : AV_PICTURE_TYPE_I;
    1425        1385 :     if (slice_type != s->pict_type) {
    1426           0 :         av_log(s->avctx, AV_LOG_ERROR, "Slice type mismatch\n");
    1427           0 :         return AVERROR_INVALIDDATA;
    1428             :     }
    1429        1385 :     if (s->width != r->si.width || s->height != r->si.height) {
    1430           0 :         av_log(s->avctx, AV_LOG_ERROR, "Size mismatch\n");
    1431           0 :         return AVERROR_INVALIDDATA;
    1432             :     }
    1433             : 
    1434        1385 :     r->si.end = end;
    1435        1385 :     s->qscale = r->si.quant;
    1436        1385 :     s->mb_num_left = r->si.end - r->si.start;
    1437        1385 :     r->s.mb_skip_run = 0;
    1438             : 
    1439        1385 :     mb_pos = s->mb_x + s->mb_y * s->mb_width;
    1440        1385 :     if(r->si.start != mb_pos){
    1441           0 :         av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos);
    1442           0 :         s->mb_x = r->si.start % s->mb_width;
    1443           0 :         s->mb_y = r->si.start / s->mb_width;
    1444             :     }
    1445        1385 :     memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist));
    1446        1385 :     s->first_slice_line = 1;
    1447        1385 :     s->resync_mb_x = s->mb_x;
    1448        1385 :     s->resync_mb_y = s->mb_y;
    1449             : 
    1450        1385 :     ff_init_block_index(s);
    1451      295050 :     while(!check_slice_end(r, s)) {
    1452      292280 :         ff_update_block_index(s);
    1453             : 
    1454      292280 :         if(r->si.type)
    1455      284640 :             res = rv34_decode_inter_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
    1456             :         else
    1457        7640 :             res = rv34_decode_intra_macroblock(r, r->intra_types + s->mb_x * 4 + 4);
    1458      292280 :         if(res < 0){
    1459           0 :             ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_ERROR);
    1460           0 :             return -1;
    1461             :         }
    1462      292280 :         if (++s->mb_x == s->mb_width) {
    1463        9408 :             s->mb_x = 0;
    1464        9408 :             s->mb_y++;
    1465        9408 :             ff_init_block_index(s);
    1466             : 
    1467        9408 :             memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
    1468        9408 :             memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist));
    1469             : 
    1470        9408 :             if(r->loop_filter && s->mb_y >= 2)
    1471        8882 :                 r->loop_filter(r, s->mb_y - 2);
    1472             : 
    1473        9408 :             if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
    1474           0 :                 ff_thread_report_progress(&s->current_picture_ptr->tf,
    1475           0 :                                           s->mb_y - 2, 0);
    1476             : 
    1477             :         }
    1478      292280 :         if(s->mb_x == s->resync_mb_x)
    1479        9031 :             s->first_slice_line=0;
    1480      292280 :         s->mb_num_left--;
    1481             :     }
    1482        1385 :     ff_er_add_slice(&s->er, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, ER_MB_END);
    1483             : 
    1484        1385 :     return s->mb_y == s->mb_height;
    1485             : }
    1486             : 
    1487             : /** @} */ // reconstruction group end
    1488             : 
    1489             : /**
    1490             :  * Initialize decoder.
    1491             :  */
    1492           9 : av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
    1493             : {
    1494           9 :     RV34DecContext *r = avctx->priv_data;
    1495           9 :     MpegEncContext *s = &r->s;
    1496             :     int ret;
    1497             : 
    1498           9 :     ff_mpv_decode_defaults(s);
    1499           9 :     ff_mpv_decode_init(s, avctx);
    1500           9 :     s->out_format = FMT_H263;
    1501             : 
    1502           9 :     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
    1503           9 :     avctx->has_b_frames = 1;
    1504           9 :     s->low_delay = 0;
    1505             : 
    1506           9 :     ff_mpv_idct_init(s);
    1507           9 :     if ((ret = ff_mpv_common_init(s)) < 0)
    1508           0 :         return ret;
    1509             : 
    1510           9 :     ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
    1511             : 
    1512             : #if CONFIG_RV30_DECODER
    1513           9 :     if (avctx->codec_id == AV_CODEC_ID_RV30)
    1514           5 :         ff_rv30dsp_init(&r->rdsp);
    1515             : #endif
    1516             : #if CONFIG_RV40_DECODER
    1517           9 :     if (avctx->codec_id == AV_CODEC_ID_RV40)
    1518           4 :         ff_rv40dsp_init(&r->rdsp);
    1519             : #endif
    1520             : 
    1521           9 :     if ((ret = rv34_decoder_alloc(r)) < 0) {
    1522           0 :         ff_mpv_common_end(&r->s);
    1523           0 :         return ret;
    1524             :     }
    1525             : 
    1526           9 :     if(!intra_vlcs[0].cbppattern[0].bits)
    1527           5 :         rv34_init_tables();
    1528             : 
    1529           9 :     avctx->internal->allocate_progress = 1;
    1530             : 
    1531           9 :     return 0;
    1532             : }
    1533             : 
    1534           0 : int ff_rv34_decode_init_thread_copy(AVCodecContext *avctx)
    1535             : {
    1536             :     int err;
    1537           0 :     RV34DecContext *r = avctx->priv_data;
    1538             : 
    1539           0 :     r->s.avctx = avctx;
    1540             : 
    1541           0 :     if (avctx->internal->is_copy) {
    1542           0 :         r->tmp_b_block_base = NULL;
    1543           0 :         r->cbp_chroma       = NULL;
    1544           0 :         r->cbp_luma         = NULL;
    1545           0 :         r->deblock_coefs    = NULL;
    1546           0 :         r->intra_types_hist = NULL;
    1547           0 :         r->mb_type          = NULL;
    1548             : 
    1549           0 :         ff_mpv_idct_init(&r->s);
    1550             : 
    1551           0 :         if ((err = ff_mpv_common_init(&r->s)) < 0)
    1552           0 :             return err;
    1553           0 :         if ((err = rv34_decoder_alloc(r)) < 0) {
    1554           0 :             ff_mpv_common_end(&r->s);
    1555           0 :             return err;
    1556             :         }
    1557             :     }
    1558             : 
    1559           0 :     return 0;
    1560             : }
    1561             : 
    1562           0 : int ff_rv34_decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
    1563             : {
    1564           0 :     RV34DecContext *r = dst->priv_data, *r1 = src->priv_data;
    1565           0 :     MpegEncContext * const s = &r->s, * const s1 = &r1->s;
    1566             :     int err;
    1567             : 
    1568           0 :     if (dst == src || !s1->context_initialized)
    1569           0 :         return 0;
    1570             : 
    1571           0 :     if (s->height != s1->height || s->width != s1->width) {
    1572           0 :         s->height = s1->height;
    1573           0 :         s->width  = s1->width;
    1574           0 :         if ((err = ff_mpv_common_frame_size_change(s)) < 0)
    1575           0 :             return err;
    1576           0 :         if ((err = rv34_decoder_realloc(r)) < 0)
    1577           0 :             return err;
    1578             :     }
    1579             : 
    1580           0 :     r->cur_pts  = r1->cur_pts;
    1581           0 :     r->last_pts = r1->last_pts;
    1582           0 :     r->next_pts = r1->next_pts;
    1583             : 
    1584           0 :     memset(&r->si, 0, sizeof(r->si));
    1585             : 
    1586             :     // Do no call ff_mpeg_update_thread_context on a partially initialized
    1587             :     // decoder context.
    1588           0 :     if (!s1->linesize)
    1589           0 :         return 0;
    1590             : 
    1591           0 :     return ff_mpeg_update_thread_context(dst, src);
    1592             : }
    1593             : 
    1594        4156 : static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n, int slice_count, int buf_size)
    1595             : {
    1596        4156 :     if (n < slice_count) {
    1597        3273 :         if(avctx->slice_count) return avctx->slice_offset[n];
    1598        3273 :         else                   return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) :  AV_RB32(buf + n*8);
    1599             :     } else
    1600         883 :         return buf_size;
    1601             : }
    1602             : 
    1603         526 : static int finish_frame(AVCodecContext *avctx, AVFrame *pict)
    1604             : {
    1605         526 :     RV34DecContext *r = avctx->priv_data;
    1606         526 :     MpegEncContext *s = &r->s;
    1607         526 :     int got_picture = 0, ret;
    1608             : 
    1609         526 :     ff_er_frame_end(&s->er);
    1610         526 :     ff_mpv_frame_end(s);
    1611         526 :     s->mb_num_left = 0;
    1612             : 
    1613         526 :     if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
    1614           0 :         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
    1615             : 
    1616         526 :     if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
    1617         387 :         if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
    1618           0 :             return ret;
    1619         387 :         ff_print_debug_info(s, s->current_picture_ptr, pict);
    1620         387 :         ff_mpv_export_qp_table(s, pict, s->current_picture_ptr, FF_QSCALE_TYPE_MPEG1);
    1621         387 :         got_picture = 1;
    1622         139 :     } else if (s->last_picture_ptr) {
    1623         130 :         if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
    1624           0 :             return ret;
    1625         130 :         ff_print_debug_info(s, s->last_picture_ptr, pict);
    1626         130 :         ff_mpv_export_qp_table(s, pict, s->last_picture_ptr, FF_QSCALE_TYPE_MPEG1);
    1627         130 :         got_picture = 1;
    1628             :     }
    1629             : 
    1630         526 :     return got_picture;
    1631             : }
    1632             : 
    1633           0 : static AVRational update_sar(int old_w, int old_h, AVRational sar, int new_w, int new_h)
    1634             : {
    1635             :     // attempt to keep aspect during typical resolution switches
    1636           0 :     if (!sar.num)
    1637           0 :         sar = (AVRational){1, 1};
    1638             : 
    1639           0 :     sar = av_mul_q(sar, av_mul_q((AVRational){new_h, new_w}, (AVRational){old_w, old_h}));
    1640           0 :     return sar;
    1641             : }
    1642             : 
    1643         532 : int ff_rv34_decode_frame(AVCodecContext *avctx,
    1644             :                             void *data, int *got_picture_ptr,
    1645             :                             AVPacket *avpkt)
    1646             : {
    1647         532 :     const uint8_t *buf = avpkt->data;
    1648         532 :     int buf_size = avpkt->size;
    1649         532 :     RV34DecContext *r = avctx->priv_data;
    1650         532 :     MpegEncContext *s = &r->s;
    1651         532 :     AVFrame *pict = data;
    1652             :     SliceInfo si;
    1653             :     int i, ret;
    1654             :     int slice_count;
    1655         532 :     const uint8_t *slices_hdr = NULL;
    1656         532 :     int last = 0;
    1657         532 :     int faulty_b = 0;
    1658             :     int offset;
    1659             : 
    1660             :     /* no supplementary picture */
    1661         532 :     if (buf_size == 0) {
    1662             :         /* special case for last picture */
    1663           6 :         if (s->low_delay==0 && s->next_picture_ptr) {
    1664           4 :             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
    1665           0 :                 return ret;
    1666           4 :             s->next_picture_ptr = NULL;
    1667             : 
    1668           4 :             *got_picture_ptr = 1;
    1669             :         }
    1670           6 :         return 0;
    1671             :     }
    1672             : 
    1673         526 :     if(!avctx->slice_count){
    1674         526 :         slice_count = (*buf++) + 1;
    1675         526 :         slices_hdr = buf + 4;
    1676         526 :         buf += 8 * slice_count;
    1677         526 :         buf_size -= 1 + 8 * slice_count;
    1678             :     }else
    1679           0 :         slice_count = avctx->slice_count;
    1680             : 
    1681         526 :     offset = get_slice_offset(avctx, slices_hdr, 0, slice_count, buf_size);
    1682             :     //parse first slice header to check whether this frame can be decoded
    1683         526 :     if(offset < 0 || offset > buf_size){
    1684           0 :         av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
    1685           0 :         return AVERROR_INVALIDDATA;
    1686             :     }
    1687         526 :     init_get_bits(&s->gb, buf+offset, (buf_size-offset)*8);
    1688         526 :     if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){
    1689           0 :         av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n");
    1690           0 :         return AVERROR_INVALIDDATA;
    1691             :     }
    1692         539 :     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->data[0]) &&
    1693          13 :         si.type == AV_PICTURE_TYPE_B) {
    1694           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid decoder state: B-frame without "
    1695             :                "reference data.\n");
    1696           0 :         faulty_b = 1;
    1697             :     }
    1698         526 :     if(   (avctx->skip_frame >= AVDISCARD_NONREF && si.type==AV_PICTURE_TYPE_B)
    1699         526 :        || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=AV_PICTURE_TYPE_I)
    1700         526 :        ||  avctx->skip_frame >= AVDISCARD_ALL)
    1701           0 :         return avpkt->size;
    1702             : 
    1703             :     /* first slice */
    1704         526 :     if (si.start == 0) {
    1705         526 :         if (s->mb_num_left > 0 && s->current_picture_ptr) {
    1706           0 :             av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
    1707             :                    s->mb_num_left);
    1708           0 :             ff_er_frame_end(&s->er);
    1709           0 :             ff_mpv_frame_end(s);
    1710             :         }
    1711             : 
    1712         526 :         if (s->width != si.width || s->height != si.height) {
    1713             :             int err;
    1714             : 
    1715           0 :             av_log(s->avctx, AV_LOG_WARNING, "Changing dimensions to %dx%d\n",
    1716             :                    si.width, si.height);
    1717             : 
    1718           0 :             if (av_image_check_size(si.width, si.height, 0, s->avctx))
    1719           0 :                 return AVERROR_INVALIDDATA;
    1720             : 
    1721           0 :             s->avctx->sample_aspect_ratio = update_sar(
    1722           0 :                 s->width, s->height, s->avctx->sample_aspect_ratio,
    1723             :                 si.width, si.height);
    1724           0 :             s->width  = si.width;
    1725           0 :             s->height = si.height;
    1726             : 
    1727           0 :             err = ff_set_dimensions(s->avctx, s->width, s->height);
    1728           0 :             if (err < 0)
    1729           0 :                 return err;
    1730             : 
    1731           0 :             if ((err = ff_mpv_common_frame_size_change(s)) < 0)
    1732           0 :                 return err;
    1733           0 :             if ((err = rv34_decoder_realloc(r)) < 0)
    1734           0 :                 return err;
    1735             :         }
    1736         526 :         s->pict_type = si.type ? si.type : AV_PICTURE_TYPE_I;
    1737         526 :         if (ff_mpv_frame_start(s, s->avctx) < 0)
    1738           0 :             return -1;
    1739         526 :         ff_mpeg_er_frame_start(s);
    1740         526 :         if (!r->tmp_b_block_base) {
    1741             :             int i;
    1742             : 
    1743           9 :             r->tmp_b_block_base = av_malloc(s->linesize * 48);
    1744          27 :             for (i = 0; i < 2; i++)
    1745          36 :                 r->tmp_b_block_y[i] = r->tmp_b_block_base
    1746          18 :                                       + i * 16 * s->linesize;
    1747          45 :             for (i = 0; i < 4; i++)
    1748          72 :                 r->tmp_b_block_uv[i] = r->tmp_b_block_base + 32 * s->linesize
    1749          36 :                                        + (i >> 1) * 8 * s->uvlinesize
    1750          36 :                                        + (i &  1) * 16;
    1751             :         }
    1752         526 :         r->cur_pts = si.pts;
    1753         526 :         if (s->pict_type != AV_PICTURE_TYPE_B) {
    1754         139 :             r->last_pts = r->next_pts;
    1755         139 :             r->next_pts = r->cur_pts;
    1756             :         } else {
    1757         387 :             int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts);
    1758         387 :             int dist0   = GET_PTS_DIFF(r->cur_pts,  r->last_pts);
    1759         387 :             int dist1   = GET_PTS_DIFF(r->next_pts, r->cur_pts);
    1760             : 
    1761         387 :             if(!refdist){
    1762           0 :                 r->mv_weight1 = r->mv_weight2 = r->weight1 = r->weight2 = 8192;
    1763           0 :                 r->scaled_weight = 0;
    1764             :             }else{
    1765         387 :                 if (FFMAX(dist0, dist1) > refdist)
    1766           0 :                     av_log(avctx, AV_LOG_TRACE, "distance overflow\n");
    1767             : 
    1768         387 :                 r->mv_weight1 = (dist0 << 14) / refdist;
    1769         387 :                 r->mv_weight2 = (dist1 << 14) / refdist;
    1770         387 :                 if((r->mv_weight1|r->mv_weight2) & 511){
    1771         349 :                     r->weight1 = r->mv_weight1;
    1772         349 :                     r->weight2 = r->mv_weight2;
    1773         349 :                     r->scaled_weight = 0;
    1774             :                 }else{
    1775          38 :                     r->weight1 = r->mv_weight1 >> 9;
    1776          38 :                     r->weight2 = r->mv_weight2 >> 9;
    1777          38 :                     r->scaled_weight = 1;
    1778             :                 }
    1779             :             }
    1780             :         }
    1781         526 :         s->mb_x = s->mb_y = 0;
    1782         526 :         ff_thread_finish_setup(s->avctx);
    1783           0 :     } else if (HAVE_THREADS &&
    1784           0 :                (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
    1785           0 :         av_log(s->avctx, AV_LOG_ERROR, "Decoder needs full frames in frame "
    1786             :                "multithreading mode (start MB is %d).\n", si.start);
    1787           0 :         return AVERROR_INVALIDDATA;
    1788             :     }
    1789         526 :     if (faulty_b)
    1790           0 :         return AVERROR_INVALIDDATA;
    1791             : 
    1792        1385 :     for(i = 0; i < slice_count; i++){
    1793        1385 :         int offset  = get_slice_offset(avctx, slices_hdr, i  , slice_count, buf_size);
    1794        1385 :         int offset1 = get_slice_offset(avctx, slices_hdr, i+1, slice_count, buf_size);
    1795             :         int size;
    1796             : 
    1797        1385 :         if(offset < 0 || offset > offset1 || offset1 > buf_size){
    1798           0 :             av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
    1799           0 :             break;
    1800             :         }
    1801        1385 :         size = offset1 - offset;
    1802             : 
    1803        1385 :         r->si.end = s->mb_width * s->mb_height;
    1804        1385 :         s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start;
    1805             : 
    1806        1385 :         if(i+1 < slice_count){
    1807         860 :             int offset2 = get_slice_offset(avctx, slices_hdr, i+2, slice_count, buf_size);
    1808         860 :             if (offset2 < offset1 || offset2 > buf_size) {
    1809           0 :                 av_log(avctx, AV_LOG_ERROR, "Slice offset is invalid\n");
    1810           0 :                 break;
    1811             :             }
    1812         860 :             init_get_bits(&s->gb, buf+offset1, (buf_size-offset1)*8);
    1813         860 :             if(r->parse_slice_header(r, &r->s.gb, &si) < 0){
    1814           1 :                 size = offset2 - offset;
    1815             :             }else
    1816         859 :                 r->si.end = si.start;
    1817             :         }
    1818        1385 :         av_assert0 (size >= 0 && size <= buf_size - offset);
    1819        1385 :         last = rv34_decode_slice(r, r->si.end, buf + offset, size);
    1820        1385 :         if(last)
    1821         526 :             break;
    1822             :     }
    1823             : 
    1824         526 :     if (s->current_picture_ptr) {
    1825         526 :         if (last) {
    1826         526 :             if(r->loop_filter)
    1827         526 :                 r->loop_filter(r, s->mb_height - 1);
    1828             : 
    1829         526 :             ret = finish_frame(avctx, pict);
    1830         526 :             if (ret < 0)
    1831           0 :                 return ret;
    1832         526 :             *got_picture_ptr = ret;
    1833           0 :         } else if (HAVE_THREADS &&
    1834           0 :                    (s->avctx->active_thread_type & FF_THREAD_FRAME)) {
    1835           0 :             av_log(avctx, AV_LOG_INFO, "marking unfished frame as finished\n");
    1836             :             /* always mark the current frame as finished, frame-mt supports
    1837             :              * only complete frames */
    1838           0 :             ff_er_frame_end(&s->er);
    1839           0 :             ff_mpv_frame_end(s);
    1840           0 :             s->mb_num_left = 0;
    1841           0 :             ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
    1842           0 :             return AVERROR_INVALIDDATA;
    1843             :         }
    1844             :     }
    1845             : 
    1846         526 :     return avpkt->size;
    1847             : }
    1848             : 
    1849           9 : av_cold int ff_rv34_decode_end(AVCodecContext *avctx)
    1850             : {
    1851           9 :     RV34DecContext *r = avctx->priv_data;
    1852             : 
    1853           9 :     ff_mpv_common_end(&r->s);
    1854           9 :     rv34_decoder_free(r);
    1855             : 
    1856           9 :     return 0;
    1857             : }

Generated by: LCOV version 1.13