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