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