• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

libavcodec/h264_cavlc.c

Go to the documentation of this file.
00001 /*
00002  * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
00003  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00028 #define CABAC 0
00029 
00030 #include "internal.h"
00031 #include "avcodec.h"
00032 #include "mpegvideo.h"
00033 #include "h264.h"
00034 #include "h264data.h" // FIXME FIXME FIXME
00035 #include "h264_mvpred.h"
00036 #include "golomb.h"
00037 
00038 //#undef NDEBUG
00039 #include <assert.h>
00040 
00041 static const uint8_t golomb_to_inter_cbp_gray[16]={
00042  0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
00043 };
00044 
00045 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
00046 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
00047 };
00048 
00049 static const uint8_t chroma_dc_coeff_token_len[4*5]={
00050  2, 0, 0, 0,
00051  6, 1, 0, 0,
00052  6, 6, 3, 0,
00053  6, 7, 7, 6,
00054  6, 8, 8, 7,
00055 };
00056 
00057 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
00058  1, 0, 0, 0,
00059  7, 1, 0, 0,
00060  4, 6, 1, 0,
00061  3, 3, 2, 5,
00062  2, 3, 2, 0,
00063 };
00064 
00065 static const uint8_t coeff_token_len[4][4*17]={
00066 {
00067      1, 0, 0, 0,
00068      6, 2, 0, 0,     8, 6, 3, 0,     9, 8, 7, 5,    10, 9, 8, 6,
00069     11,10, 9, 7,    13,11,10, 8,    13,13,11, 9,    13,13,13,10,
00070     14,14,13,11,    14,14,14,13,    15,15,14,14,    15,15,15,14,
00071     16,15,15,15,    16,16,16,15,    16,16,16,16,    16,16,16,16,
00072 },
00073 {
00074      2, 0, 0, 0,
00075      6, 2, 0, 0,     6, 5, 3, 0,     7, 6, 6, 4,     8, 6, 6, 4,
00076      8, 7, 7, 5,     9, 8, 8, 6,    11, 9, 9, 6,    11,11,11, 7,
00077     12,11,11, 9,    12,12,12,11,    12,12,12,11,    13,13,13,12,
00078     13,13,13,13,    13,14,13,13,    14,14,14,13,    14,14,14,14,
00079 },
00080 {
00081      4, 0, 0, 0,
00082      6, 4, 0, 0,     6, 5, 4, 0,     6, 5, 5, 4,     7, 5, 5, 4,
00083      7, 5, 5, 4,     7, 6, 6, 4,     7, 6, 6, 4,     8, 7, 7, 5,
00084      8, 8, 7, 6,     9, 8, 8, 7,     9, 9, 8, 8,     9, 9, 9, 8,
00085     10, 9, 9, 9,    10,10,10,10,    10,10,10,10,    10,10,10,10,
00086 },
00087 {
00088      6, 0, 0, 0,
00089      6, 6, 0, 0,     6, 6, 6, 0,     6, 6, 6, 6,     6, 6, 6, 6,
00090      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
00091      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
00092      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
00093 }
00094 };
00095 
00096 static const uint8_t coeff_token_bits[4][4*17]={
00097 {
00098      1, 0, 0, 0,
00099      5, 1, 0, 0,     7, 4, 1, 0,     7, 6, 5, 3,     7, 6, 5, 3,
00100      7, 6, 5, 4,    15, 6, 5, 4,    11,14, 5, 4,     8,10,13, 4,
00101     15,14, 9, 4,    11,10,13,12,    15,14, 9,12,    11,10,13, 8,
00102     15, 1, 9,12,    11,14,13, 8,     7,10, 9,12,     4, 6, 5, 8,
00103 },
00104 {
00105      3, 0, 0, 0,
00106     11, 2, 0, 0,     7, 7, 3, 0,     7,10, 9, 5,     7, 6, 5, 4,
00107      4, 6, 5, 6,     7, 6, 5, 8,    15, 6, 5, 4,    11,14,13, 4,
00108     15,10, 9, 4,    11,14,13,12,     8,10, 9, 8,    15,14,13,12,
00109     11,10, 9,12,     7,11, 6, 8,     9, 8,10, 1,     7, 6, 5, 4,
00110 },
00111 {
00112     15, 0, 0, 0,
00113     15,14, 0, 0,    11,15,13, 0,     8,12,14,12,    15,10,11,11,
00114     11, 8, 9,10,     9,14,13, 9,     8,10, 9, 8,    15,14,13,13,
00115     11,14,10,12,    15,10,13,12,    11,14, 9,12,     8,10,13, 8,
00116     13, 7, 9,12,     9,12,11,10,     5, 8, 7, 6,     1, 4, 3, 2,
00117 },
00118 {
00119      3, 0, 0, 0,
00120      0, 1, 0, 0,     4, 5, 6, 0,     8, 9,10,11,    12,13,14,15,
00121     16,17,18,19,    20,21,22,23,    24,25,26,27,    28,29,30,31,
00122     32,33,34,35,    36,37,38,39,    40,41,42,43,    44,45,46,47,
00123     48,49,50,51,    52,53,54,55,    56,57,58,59,    60,61,62,63,
00124 }
00125 };
00126 
00127 static const uint8_t total_zeros_len[16][16]= {
00128     {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
00129     {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
00130     {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
00131     {5,3,4,4,3,3,3,4,3,4,5,5,5},
00132     {4,4,4,3,3,3,3,3,4,5,4,5},
00133     {6,5,3,3,3,3,3,3,4,3,6},
00134     {6,5,3,3,3,2,3,4,3,6},
00135     {6,4,5,3,2,2,3,3,6},
00136     {6,6,4,2,2,3,2,5},
00137     {5,5,3,2,2,2,4},
00138     {4,4,3,3,1,3},
00139     {4,4,2,1,3},
00140     {3,3,1,2},
00141     {2,2,1},
00142     {1,1},
00143 };
00144 
00145 static const uint8_t total_zeros_bits[16][16]= {
00146     {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
00147     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
00148     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
00149     {3,7,5,4,6,5,4,3,3,2,2,1,0},
00150     {5,4,3,7,6,5,4,3,2,1,1,0},
00151     {1,1,7,6,5,4,3,2,1,1,0},
00152     {1,1,5,4,3,3,2,1,1,0},
00153     {1,1,1,3,3,2,2,1,0},
00154     {1,0,1,3,2,1,1,1},
00155     {1,0,1,3,2,1,1},
00156     {0,1,1,2,1,3},
00157     {0,1,1,1,1},
00158     {0,1,1,1},
00159     {0,1,1},
00160     {0,1},
00161 };
00162 
00163 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
00164     { 1, 2, 3, 3,},
00165     { 1, 2, 2, 0,},
00166     { 1, 1, 0, 0,},
00167 };
00168 
00169 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
00170     { 1, 1, 1, 0,},
00171     { 1, 1, 0, 0,},
00172     { 1, 0, 0, 0,},
00173 };
00174 
00175 static const uint8_t run_len[7][16]={
00176     {1,1},
00177     {1,2,2},
00178     {2,2,2,2},
00179     {2,2,2,3,3},
00180     {2,2,3,3,3,3},
00181     {2,3,3,3,3,3,3},
00182     {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
00183 };
00184 
00185 static const uint8_t run_bits[7][16]={
00186     {1,0},
00187     {1,1,0},
00188     {3,2,1,0},
00189     {3,2,1,1,0},
00190     {3,2,3,2,1,0},
00191     {3,0,1,3,2,5,4},
00192     {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
00193 };
00194 
00195 static VLC coeff_token_vlc[4];
00196 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
00197 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
00198 
00199 static VLC chroma_dc_coeff_token_vlc;
00200 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
00201 static const int chroma_dc_coeff_token_vlc_table_size = 256;
00202 
00203 static VLC total_zeros_vlc[15];
00204 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
00205 static const int total_zeros_vlc_tables_size = 512;
00206 
00207 static VLC chroma_dc_total_zeros_vlc[3];
00208 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
00209 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
00210 
00211 static VLC run_vlc[6];
00212 static VLC_TYPE run_vlc_tables[6][8][2];
00213 static const int run_vlc_tables_size = 8;
00214 
00215 static VLC run7_vlc;
00216 static VLC_TYPE run7_vlc_table[96][2];
00217 static const int run7_vlc_table_size = 96;
00218 
00219 #define LEVEL_TAB_BITS 8
00220 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
00221 
00222 
00227 static inline int pred_non_zero_count(H264Context *h, int n){
00228     const int index8= scan8[n];
00229     const int left= h->non_zero_count_cache[index8 - 1];
00230     const int top = h->non_zero_count_cache[index8 - 8];
00231     int i= left + top;
00232 
00233     if(i<64) i= (i+1)>>1;
00234 
00235     tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
00236 
00237     return i&31;
00238 }
00239 
00240 static av_cold void init_cavlc_level_tab(void){
00241     int suffix_length, mask;
00242     unsigned int i;
00243 
00244     for(suffix_length=0; suffix_length<7; suffix_length++){
00245         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
00246             int prefix= LEVEL_TAB_BITS - av_log2(2*i);
00247             int level_code= (prefix<<suffix_length) + (i>>(LEVEL_TAB_BITS-prefix-1-suffix_length)) - (1<<suffix_length);
00248 
00249             mask= -(level_code&1);
00250             level_code= (((2+level_code)>>1) ^ mask) - mask;
00251             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
00252                 cavlc_level_tab[suffix_length][i][0]= level_code;
00253                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
00254             }else if(prefix + 1 <= LEVEL_TAB_BITS){
00255                 cavlc_level_tab[suffix_length][i][0]= prefix+100;
00256                 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
00257             }else{
00258                 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
00259                 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
00260             }
00261         }
00262     }
00263 }
00264 
00265 av_cold void ff_h264_decode_init_vlc(void){
00266     static int done = 0;
00267 
00268     if (!done) {
00269         int i;
00270         int offset;
00271         done = 1;
00272 
00273         chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
00274         chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
00275         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
00276                  &chroma_dc_coeff_token_len [0], 1, 1,
00277                  &chroma_dc_coeff_token_bits[0], 1, 1,
00278                  INIT_VLC_USE_NEW_STATIC);
00279 
00280         offset = 0;
00281         for(i=0; i<4; i++){
00282             coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
00283             coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
00284             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
00285                      &coeff_token_len [i][0], 1, 1,
00286                      &coeff_token_bits[i][0], 1, 1,
00287                      INIT_VLC_USE_NEW_STATIC);
00288             offset += coeff_token_vlc_tables_size[i];
00289         }
00290         /*
00291          * This is a one time safety check to make sure that
00292          * the packed static coeff_token_vlc table sizes
00293          * were initialized correctly.
00294          */
00295         assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
00296 
00297         for(i=0; i<3; i++){
00298             chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
00299             chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
00300             init_vlc(&chroma_dc_total_zeros_vlc[i],
00301                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
00302                      &chroma_dc_total_zeros_len [i][0], 1, 1,
00303                      &chroma_dc_total_zeros_bits[i][0], 1, 1,
00304                      INIT_VLC_USE_NEW_STATIC);
00305         }
00306         for(i=0; i<15; i++){
00307             total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
00308             total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
00309             init_vlc(&total_zeros_vlc[i],
00310                      TOTAL_ZEROS_VLC_BITS, 16,
00311                      &total_zeros_len [i][0], 1, 1,
00312                      &total_zeros_bits[i][0], 1, 1,
00313                      INIT_VLC_USE_NEW_STATIC);
00314         }
00315 
00316         for(i=0; i<6; i++){
00317             run_vlc[i].table = run_vlc_tables[i];
00318             run_vlc[i].table_allocated = run_vlc_tables_size;
00319             init_vlc(&run_vlc[i],
00320                      RUN_VLC_BITS, 7,
00321                      &run_len [i][0], 1, 1,
00322                      &run_bits[i][0], 1, 1,
00323                      INIT_VLC_USE_NEW_STATIC);
00324         }
00325         run7_vlc.table = run7_vlc_table,
00326         run7_vlc.table_allocated = run7_vlc_table_size;
00327         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
00328                  &run_len [6][0], 1, 1,
00329                  &run_bits[6][0], 1, 1,
00330                  INIT_VLC_USE_NEW_STATIC);
00331 
00332         init_cavlc_level_tab();
00333     }
00334 }
00335 
00339 static inline int get_level_prefix(GetBitContext *gb){
00340     unsigned int buf;
00341     int log;
00342 
00343     OPEN_READER(re, gb);
00344     UPDATE_CACHE(re, gb);
00345     buf=GET_CACHE(re, gb);
00346 
00347     log= 32 - av_log2(buf);
00348 #ifdef TRACE
00349     print_bin(buf>>(32-log), log);
00350     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d lpr @%5d in %s get_level_prefix\n", buf>>(32-log), log, log-1, get_bits_count(gb), __FILE__);
00351 #endif
00352 
00353     LAST_SKIP_BITS(re, gb, log);
00354     CLOSE_READER(re, gb);
00355 
00356     return log-1;
00357 }
00358 
00366 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
00367     MpegEncContext * const s = &h->s;
00368     static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3};
00369     int level[16];
00370     int zeros_left, coeff_num, coeff_token, total_coeff, i, j, trailing_ones, run_before;
00371 
00372     //FIXME put trailing_onex into the context
00373 
00374     if(n == CHROMA_DC_BLOCK_INDEX){
00375         coeff_token= get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
00376         total_coeff= coeff_token>>2;
00377     }else{
00378         if(n == LUMA_DC_BLOCK_INDEX){
00379             total_coeff= pred_non_zero_count(h, 0);
00380             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00381             total_coeff= coeff_token>>2;
00382         }else{
00383             total_coeff= pred_non_zero_count(h, n);
00384             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00385             total_coeff= coeff_token>>2;
00386             h->non_zero_count_cache[ scan8[n] ]= total_coeff;
00387         }
00388     }
00389 
00390     //FIXME set last_non_zero?
00391 
00392     if(total_coeff==0)
00393         return 0;
00394     if(total_coeff > (unsigned)max_coeff) {
00395         av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
00396         return -1;
00397     }
00398 
00399     trailing_ones= coeff_token&3;
00400     tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
00401     assert(total_coeff<=16);
00402 
00403     i = show_bits(gb, 3);
00404     skip_bits(gb, trailing_ones);
00405     level[0] = 1-((i&4)>>1);
00406     level[1] = 1-((i&2)   );
00407     level[2] = 1-((i&1)<<1);
00408 
00409     if(trailing_ones<total_coeff) {
00410         int mask, prefix;
00411         int suffix_length = total_coeff > 10 & trailing_ones < 3;
00412         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00413         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
00414 
00415         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00416         if(level_code >= 100){
00417             prefix= level_code - 100;
00418             if(prefix == LEVEL_TAB_BITS)
00419                 prefix += get_level_prefix(gb);
00420 
00421             //first coefficient has suffix_length equal to 0 or 1
00422             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
00423                 if(suffix_length)
00424                     level_code= (prefix<<1) + get_bits1(gb); //part
00425                 else
00426                     level_code= prefix; //part
00427             }else if(prefix==14){
00428                 if(suffix_length)
00429                     level_code= (prefix<<1) + get_bits1(gb); //part
00430                 else
00431                     level_code= prefix + get_bits(gb, 4); //part
00432             }else{
00433                 level_code= 30 + get_bits(gb, prefix-3); //part
00434                 if(prefix>=16){
00435                     if(prefix > 25+3){
00436                         av_log(h->s.avctx, AV_LOG_ERROR, "Invalid level prefix\n");
00437                         return -1;
00438                     }
00439                     level_code += (1<<(prefix-3))-4096;
00440                 }
00441             }
00442 
00443             if(trailing_ones < 3) level_code += 2;
00444 
00445             suffix_length = 2;
00446             mask= -(level_code&1);
00447             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
00448         }else{
00449             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
00450 
00451             suffix_length = 1 + (level_code + 3U > 6U);
00452             level[trailing_ones]= level_code;
00453         }
00454 
00455         //remaining coefficients have suffix_length > 0
00456         for(i=trailing_ones+1;i<total_coeff;i++) {
00457             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
00458             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00459             level_code= cavlc_level_tab[suffix_length][bitsi][0];
00460 
00461             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00462             if(level_code >= 100){
00463                 prefix= level_code - 100;
00464                 if(prefix == LEVEL_TAB_BITS){
00465                     prefix += get_level_prefix(gb);
00466                 }
00467                 if(prefix<15){
00468                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
00469                 }else{
00470                     level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
00471                     if(prefix>=16)
00472                         level_code += (1<<(prefix-3))-4096;
00473                 }
00474                 mask= -(level_code&1);
00475                 level_code= (((2+level_code)>>1) ^ mask) - mask;
00476             }
00477             level[i]= level_code;
00478             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
00479         }
00480     }
00481 
00482     if(total_coeff == max_coeff)
00483         zeros_left=0;
00484     else{
00485         if(n == CHROMA_DC_BLOCK_INDEX)
00486             zeros_left= get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[ total_coeff ].table, CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
00487         else
00488             zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
00489     }
00490 
00491     coeff_num = zeros_left + total_coeff - 1;
00492     j = scantable[coeff_num];
00493     if(n > 24){
00494         block[j] = level[0];
00495         for(i=1;i<total_coeff;i++) {
00496             if(zeros_left <= 0)
00497                 run_before = 0;
00498             else if(zeros_left < 7){
00499                 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
00500             }else{
00501                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
00502             }
00503             zeros_left -= run_before;
00504             coeff_num -= 1 + run_before;
00505             j= scantable[ coeff_num ];
00506 
00507             block[j]= level[i];
00508         }
00509     }else{
00510         block[j] = (level[0] * qmul[j] + 32)>>6;
00511         for(i=1;i<total_coeff;i++) {
00512             if(zeros_left <= 0)
00513                 run_before = 0;
00514             else if(zeros_left < 7){
00515                 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1);
00516             }else{
00517                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2);
00518             }
00519             zeros_left -= run_before;
00520             coeff_num -= 1 + run_before;
00521             j= scantable[ coeff_num ];
00522 
00523             block[j]= (level[i] * qmul[j] + 32)>>6;
00524         }
00525     }
00526 
00527     if(zeros_left<0){
00528         av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
00529         return -1;
00530     }
00531 
00532     return 0;
00533 }
00534 
00535 int ff_h264_decode_mb_cavlc(H264Context *h){
00536     MpegEncContext * const s = &h->s;
00537     int mb_xy;
00538     int partition_count;
00539     unsigned int mb_type, cbp;
00540     int dct8x8_allowed= h->pps.transform_8x8_mode;
00541 
00542     mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00543 
00544     tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
00545     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
00546                 down the code */
00547     if(h->slice_type_nos != FF_I_TYPE){
00548         if(s->mb_skip_run==-1)
00549             s->mb_skip_run= get_ue_golomb(&s->gb);
00550 
00551         if (s->mb_skip_run--) {
00552             if(FRAME_MBAFF && (s->mb_y&1) == 0){
00553                 if(s->mb_skip_run==0)
00554                     h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00555             }
00556             decode_mb_skip(h);
00557             return 0;
00558         }
00559     }
00560     if(FRAME_MBAFF){
00561         if( (s->mb_y&1) == 0 )
00562             h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00563     }
00564 
00565     h->prev_mb_skipped= 0;
00566 
00567     mb_type= get_ue_golomb(&s->gb);
00568     if(h->slice_type_nos == FF_B_TYPE){
00569         if(mb_type < 23){
00570             partition_count= b_mb_type_info[mb_type].partition_count;
00571             mb_type=         b_mb_type_info[mb_type].type;
00572         }else{
00573             mb_type -= 23;
00574             goto decode_intra_mb;
00575         }
00576     }else if(h->slice_type_nos == FF_P_TYPE){
00577         if(mb_type < 5){
00578             partition_count= p_mb_type_info[mb_type].partition_count;
00579             mb_type=         p_mb_type_info[mb_type].type;
00580         }else{
00581             mb_type -= 5;
00582             goto decode_intra_mb;
00583         }
00584     }else{
00585        assert(h->slice_type_nos == FF_I_TYPE);
00586         if(h->slice_type == FF_SI_TYPE && mb_type)
00587             mb_type--;
00588 decode_intra_mb:
00589         if(mb_type > 25){
00590             av_log(h->s.avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_pict_type_char(h->slice_type), s->mb_x, s->mb_y);
00591             return -1;
00592         }
00593         partition_count=0;
00594         cbp= i_mb_type_info[mb_type].cbp;
00595         h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
00596         mb_type= i_mb_type_info[mb_type].type;
00597     }
00598 
00599     if(MB_FIELD)
00600         mb_type |= MB_TYPE_INTERLACED;
00601 
00602     h->slice_table[ mb_xy ]= h->slice_num;
00603 
00604     if(IS_INTRA_PCM(mb_type)){
00605         unsigned int x;
00606 
00607         // We assume these blocks are very rare so we do not optimize it.
00608         align_get_bits(&s->gb);
00609 
00610         // The pixels are stored in the same order as levels in h->mb array.
00611         for(x=0; x < (CHROMA ? 384 : 256); x++){
00612             ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00613         }
00614 
00615         // In deblocking, the quantizer is 0
00616         s->current_picture.qscale_table[mb_xy]= 0;
00617         // All coeffs are present
00618         memset(h->non_zero_count[mb_xy], 16, 32);
00619 
00620         s->current_picture.mb_type[mb_xy]= mb_type;
00621         return 0;
00622     }
00623 
00624     if(MB_MBAFF){
00625         h->ref_count[0] <<= 1;
00626         h->ref_count[1] <<= 1;
00627     }
00628 
00629     fill_decode_neighbors(h, mb_type);
00630     fill_decode_caches(h, mb_type);
00631 
00632     //mb_pred
00633     if(IS_INTRA(mb_type)){
00634         int pred_mode;
00635 //            init_top_left_availability(h);
00636         if(IS_INTRA4x4(mb_type)){
00637             int i;
00638             int di = 1;
00639             if(dct8x8_allowed && get_bits1(&s->gb)){
00640                 mb_type |= MB_TYPE_8x8DCT;
00641                 di = 4;
00642             }
00643 
00644 //                fill_intra4x4_pred_table(h);
00645             for(i=0; i<16; i+=di){
00646                 int mode= pred_intra_mode(h, i);
00647 
00648                 if(!get_bits1(&s->gb)){
00649                     const int rem_mode= get_bits(&s->gb, 3);
00650                     mode = rem_mode + (rem_mode >= mode);
00651                 }
00652 
00653                 if(di==4)
00654                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
00655                 else
00656                     h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
00657             }
00658             ff_h264_write_back_intra_pred_mode(h);
00659             if( ff_h264_check_intra4x4_pred_mode(h) < 0)
00660                 return -1;
00661         }else{
00662             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode);
00663             if(h->intra16x16_pred_mode < 0)
00664                 return -1;
00665         }
00666         if(CHROMA){
00667             pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb));
00668             if(pred_mode < 0)
00669                 return -1;
00670             h->chroma_pred_mode= pred_mode;
00671         }
00672     }else if(partition_count==4){
00673         int i, j, sub_partition_count[4], list, ref[2][4];
00674 
00675         if(h->slice_type_nos == FF_B_TYPE){
00676             for(i=0; i<4; i++){
00677                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00678                 if(h->sub_mb_type[i] >=13){
00679                     av_log(h->s.avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
00680                     return -1;
00681                 }
00682                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00683                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00684             }
00685             if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
00686                 ff_h264_pred_direct_motion(h, &mb_type);
00687                 h->ref_cache[0][scan8[4]] =
00688                 h->ref_cache[1][scan8[4]] =
00689                 h->ref_cache[0][scan8[12]] =
00690                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
00691             }
00692         }else{
00693             assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ?
00694             for(i=0; i<4; i++){
00695                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00696                 if(h->sub_mb_type[i] >=4){
00697                     av_log(h->s.avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", h->sub_mb_type[i], s->mb_x, s->mb_y);
00698                     return -1;
00699                 }
00700                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00701                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00702             }
00703         }
00704 
00705         for(list=0; list<h->list_count; list++){
00706             int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
00707             for(i=0; i<4; i++){
00708                 if(IS_DIRECT(h->sub_mb_type[i])) continue;
00709                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00710                     unsigned int tmp;
00711                     if(ref_count == 1){
00712                         tmp= 0;
00713                     }else if(ref_count == 2){
00714                         tmp= get_bits1(&s->gb)^1;
00715                     }else{
00716                         tmp= get_ue_golomb_31(&s->gb);
00717                         if(tmp>=ref_count){
00718                             av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
00719                             return -1;
00720                         }
00721                     }
00722                     ref[list][i]= tmp;
00723                 }else{
00724                  //FIXME
00725                     ref[list][i] = -1;
00726                 }
00727             }
00728         }
00729 
00730         if(dct8x8_allowed)
00731             dct8x8_allowed = get_dct8x8_allowed(h);
00732 
00733         for(list=0; list<h->list_count; list++){
00734             for(i=0; i<4; i++){
00735                 if(IS_DIRECT(h->sub_mb_type[i])) {
00736                     h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
00737                     continue;
00738                 }
00739                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
00740                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
00741 
00742                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00743                     const int sub_mb_type= h->sub_mb_type[i];
00744                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
00745                     for(j=0; j<sub_partition_count[i]; j++){
00746                         int mx, my;
00747                         const int index= 4*i + block_width*j;
00748                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
00749                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
00750                         mx += get_se_golomb(&s->gb);
00751                         my += get_se_golomb(&s->gb);
00752                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00753 
00754                         if(IS_SUB_8X8(sub_mb_type)){
00755                             mv_cache[ 1 ][0]=
00756                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
00757                             mv_cache[ 1 ][1]=
00758                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
00759                         }else if(IS_SUB_8X4(sub_mb_type)){
00760                             mv_cache[ 1 ][0]= mx;
00761                             mv_cache[ 1 ][1]= my;
00762                         }else if(IS_SUB_4X8(sub_mb_type)){
00763                             mv_cache[ 8 ][0]= mx;
00764                             mv_cache[ 8 ][1]= my;
00765                         }
00766                         mv_cache[ 0 ][0]= mx;
00767                         mv_cache[ 0 ][1]= my;
00768                     }
00769                 }else{
00770                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
00771                     p[0] = p[1]=
00772                     p[8] = p[9]= 0;
00773                 }
00774             }
00775         }
00776     }else if(IS_DIRECT(mb_type)){
00777         ff_h264_pred_direct_motion(h, &mb_type);
00778         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
00779     }else{
00780         int list, mx, my, i;
00781          //FIXME we should set ref_idx_l? to 0 if we use that later ...
00782         if(IS_16X16(mb_type)){
00783             for(list=0; list<h->list_count; list++){
00784                     unsigned int val;
00785                     if(IS_DIR(mb_type, 0, list)){
00786                         if(h->ref_count[list]==1){
00787                             val= 0;
00788                         }else if(h->ref_count[list]==2){
00789                             val= get_bits1(&s->gb)^1;
00790                         }else{
00791                             val= get_ue_golomb_31(&s->gb);
00792                             if(val >= h->ref_count[list]){
00793                                 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00794                                 return -1;
00795                             }
00796                         }
00797                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
00798                     }
00799             }
00800             for(list=0; list<h->list_count; list++){
00801                 if(IS_DIR(mb_type, 0, list)){
00802                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
00803                     mx += get_se_golomb(&s->gb);
00804                     my += get_se_golomb(&s->gb);
00805                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00806 
00807                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
00808                 }
00809             }
00810         }
00811         else if(IS_16X8(mb_type)){
00812             for(list=0; list<h->list_count; list++){
00813                     for(i=0; i<2; i++){
00814                         unsigned int val;
00815                         if(IS_DIR(mb_type, i, list)){
00816                             if(h->ref_count[list] == 1){
00817                                 val= 0;
00818                             }else if(h->ref_count[list] == 2){
00819                                 val= get_bits1(&s->gb)^1;
00820                             }else{
00821                                 val= get_ue_golomb_31(&s->gb);
00822                                 if(val >= h->ref_count[list]){
00823                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00824                                     return -1;
00825                                 }
00826                             }
00827                         }else
00828                             val= LIST_NOT_USED&0xFF;
00829                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
00830                     }
00831             }
00832             for(list=0; list<h->list_count; list++){
00833                 for(i=0; i<2; i++){
00834                     unsigned int val;
00835                     if(IS_DIR(mb_type, i, list)){
00836                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
00837                         mx += get_se_golomb(&s->gb);
00838                         my += get_se_golomb(&s->gb);
00839                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00840 
00841                         val= pack16to32(mx,my);
00842                     }else
00843                         val=0;
00844                     fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
00845                 }
00846             }
00847         }else{
00848             assert(IS_8X16(mb_type));
00849             for(list=0; list<h->list_count; list++){
00850                     for(i=0; i<2; i++){
00851                         unsigned int val;
00852                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
00853                             if(h->ref_count[list]==1){
00854                                 val= 0;
00855                             }else if(h->ref_count[list]==2){
00856                                 val= get_bits1(&s->gb)^1;
00857                             }else{
00858                                 val= get_ue_golomb_31(&s->gb);
00859                                 if(val >= h->ref_count[list]){
00860                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00861                                     return -1;
00862                                 }
00863                             }
00864                         }else
00865                             val= LIST_NOT_USED&0xFF;
00866                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
00867                     }
00868             }
00869             for(list=0; list<h->list_count; list++){
00870                 for(i=0; i<2; i++){
00871                     unsigned int val;
00872                     if(IS_DIR(mb_type, i, list)){
00873                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
00874                         mx += get_se_golomb(&s->gb);
00875                         my += get_se_golomb(&s->gb);
00876                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00877 
00878                         val= pack16to32(mx,my);
00879                     }else
00880                         val=0;
00881                     fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
00882                 }
00883             }
00884         }
00885     }
00886 
00887     if(IS_INTER(mb_type))
00888         write_back_motion(h, mb_type);
00889 
00890     if(!IS_INTRA16x16(mb_type)){
00891         cbp= get_ue_golomb(&s->gb);
00892         if(cbp > 47){
00893             av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
00894             return -1;
00895         }
00896 
00897         if(CHROMA){
00898             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
00899             else                     cbp= golomb_to_inter_cbp   [cbp];
00900         }else{
00901             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
00902             else                     cbp= golomb_to_inter_cbp_gray[cbp];
00903         }
00904     }
00905 
00906     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
00907         mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
00908     }
00909     h->cbp=
00910     h->cbp_table[mb_xy]= cbp;
00911     s->current_picture.mb_type[mb_xy]= mb_type;
00912 
00913     if(cbp || IS_INTRA16x16(mb_type)){
00914         int i8x8, i4x4, chroma_idx;
00915         int dquant;
00916         GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
00917         const uint8_t *scan, *scan8x8, *dc_scan;
00918 
00919         if(IS_INTERLACED(mb_type)){
00920             scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
00921             scan= s->qscale ? h->field_scan : h->field_scan_q0;
00922             dc_scan= luma_dc_field_scan;
00923         }else{
00924             scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
00925             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
00926             dc_scan= luma_dc_zigzag_scan;
00927         }
00928 
00929         dquant= get_se_golomb(&s->gb);
00930 
00931         s->qscale += dquant;
00932 
00933         if(((unsigned)s->qscale) > 51){
00934             if(s->qscale<0) s->qscale+= 52;
00935             else            s->qscale-= 52;
00936             if(((unsigned)s->qscale) > 51){
00937                 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
00938                 return -1;
00939             }
00940         }
00941 
00942         h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
00943         h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
00944         if(IS_INTRA16x16(mb_type)){
00945             if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){
00946                 return -1; //FIXME continue if partitioned and other return -1 too
00947             }
00948 
00949             assert((cbp&15) == 0 || (cbp&15) == 15);
00950 
00951             if(cbp&15){
00952                 for(i8x8=0; i8x8<4; i8x8++){
00953                     for(i4x4=0; i4x4<4; i4x4++){
00954                         const int index= i4x4 + 4*i8x8;
00955                         if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){
00956                             return -1;
00957                         }
00958                     }
00959                 }
00960             }else{
00961                 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1);
00962             }
00963         }else{
00964             for(i8x8=0; i8x8<4; i8x8++){
00965                 if(cbp & (1<<i8x8)){
00966                     if(IS_8x8DCT(mb_type)){
00967                         DCTELEM *buf = &h->mb[64*i8x8];
00968                         uint8_t *nnz;
00969                         for(i4x4=0; i4x4<4; i4x4++){
00970                             if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4,
00971                                                 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 )
00972                                 return -1;
00973                         }
00974                         nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
00975                         nnz[0] += nnz[1] + nnz[8] + nnz[9];
00976                     }else{
00977                         for(i4x4=0; i4x4<4; i4x4++){
00978                             const int index= i4x4 + 4*i8x8;
00979 
00980                             if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){
00981                                 return -1;
00982                             }
00983                         }
00984                     }
00985                 }else{
00986                     uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ];
00987                     nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
00988                 }
00989             }
00990         }
00991 
00992         if(cbp&0x30){
00993             for(chroma_idx=0; chroma_idx<2; chroma_idx++)
00994                 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){
00995                     return -1;
00996                 }
00997         }
00998 
00999         if(cbp&0x20){
01000             for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01001                 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01002                 for(i4x4=0; i4x4<4; i4x4++){
01003                     const int index= 16 + 4*chroma_idx + i4x4;
01004                     if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){
01005                         return -1;
01006                     }
01007                 }
01008             }
01009         }else{
01010             uint8_t * const nnz= &h->non_zero_count_cache[0];
01011             nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01012             nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01013         }
01014     }else{
01015         uint8_t * const nnz= &h->non_zero_count_cache[0];
01016         fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1);
01017         nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] =
01018         nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0;
01019     }
01020     s->current_picture.qscale_table[mb_xy]= s->qscale;
01021     write_back_non_zero_count(h);
01022 
01023     if(MB_MBAFF){
01024         h->ref_count[0] >>= 1;
01025         h->ref_count[1] >>= 1;
01026     }
01027 
01028     return 0;
01029 }
01030 

Generated on Fri Sep 16 2011 17:17:37 for FFmpeg by  doxygen 1.7.1