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         if (get_bits_left(&s->gb) < mb_size) {
00773             av_log(s->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
00774             return AVERROR_INVALIDDATA;
00775         }
00776 
00777         // The pixels are stored in the same order as levels in h->mb array.
00778         for(x=0; x < mb_size; x++){
00779             ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00780         }
00781 
00782         // In deblocking, the quantizer is 0
00783         s->current_picture.f.qscale_table[mb_xy] = 0;
00784         // All coeffs are present
00785         memset(h->non_zero_count[mb_xy], 16, 48);
00786 
00787         s->current_picture.f.mb_type[mb_xy] = mb_type;
00788         return 0;
00789     }
00790 
00791     if(MB_MBAFF){
00792         h->ref_count[0] <<= 1;
00793         h->ref_count[1] <<= 1;
00794     }
00795 
00796     fill_decode_neighbors(h, mb_type);
00797     fill_decode_caches(h, mb_type);
00798 
00799     //mb_pred
00800     if(IS_INTRA(mb_type)){
00801         int pred_mode;
00802 //            init_top_left_availability(h);
00803         if(IS_INTRA4x4(mb_type)){
00804             int i;
00805             int di = 1;
00806             if(dct8x8_allowed && get_bits1(&s->gb)){
00807                 mb_type |= MB_TYPE_8x8DCT;
00808                 di = 4;
00809             }
00810 
00811 //                fill_intra4x4_pred_table(h);
00812             for(i=0; i<16; i+=di){
00813                 int mode= pred_intra_mode(h, i);
00814 
00815                 if(!get_bits1(&s->gb)){
00816                     const int rem_mode= get_bits(&s->gb, 3);
00817                     mode = rem_mode + (rem_mode >= mode);
00818                 }
00819 
00820                 if(di==4)
00821                     fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
00822                 else
00823                     h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
00824             }
00825             write_back_intra_pred_mode(h);
00826             if( ff_h264_check_intra4x4_pred_mode(h) < 0)
00827                 return -1;
00828         }else{
00829             h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
00830             if(h->intra16x16_pred_mode < 0)
00831                 return -1;
00832         }
00833         if(decode_chroma){
00834             pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb), 1);
00835             if(pred_mode < 0)
00836                 return -1;
00837             h->chroma_pred_mode= pred_mode;
00838         } else {
00839             h->chroma_pred_mode = DC_128_PRED8x8;
00840         }
00841     }else if(partition_count==4){
00842         int i, j, sub_partition_count[4], list, ref[2][4];
00843 
00844         if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00845             for(i=0; i<4; i++){
00846                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00847                 if(h->sub_mb_type[i] >=13){
00848                     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);
00849                     return -1;
00850                 }
00851                 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00852                 h->sub_mb_type[i]=      b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00853             }
00854             if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
00855                 ff_h264_pred_direct_motion(h, &mb_type);
00856                 h->ref_cache[0][scan8[4]] =
00857                 h->ref_cache[1][scan8[4]] =
00858                 h->ref_cache[0][scan8[12]] =
00859                 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
00860             }
00861         }else{
00862             assert(h->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
00863             for(i=0; i<4; i++){
00864                 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00865                 if(h->sub_mb_type[i] >=4){
00866                     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);
00867                     return -1;
00868                 }
00869                 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00870                 h->sub_mb_type[i]=      p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00871             }
00872         }
00873 
00874         for(list=0; list<h->list_count; list++){
00875             int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
00876             for(i=0; i<4; i++){
00877                 if(IS_DIRECT(h->sub_mb_type[i])) continue;
00878                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00879                     unsigned int tmp;
00880                     if(ref_count == 1){
00881                         tmp= 0;
00882                     }else if(ref_count == 2){
00883                         tmp= get_bits1(&s->gb)^1;
00884                     }else{
00885                         tmp= get_ue_golomb_31(&s->gb);
00886                         if(tmp>=ref_count){
00887                             av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
00888                             return -1;
00889                         }
00890                     }
00891                     ref[list][i]= tmp;
00892                 }else{
00893                  //FIXME
00894                     ref[list][i] = -1;
00895                 }
00896             }
00897         }
00898 
00899         if(dct8x8_allowed)
00900             dct8x8_allowed = get_dct8x8_allowed(h);
00901 
00902         for(list=0; list<h->list_count; list++){
00903             for(i=0; i<4; i++){
00904                 if(IS_DIRECT(h->sub_mb_type[i])) {
00905                     h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
00906                     continue;
00907                 }
00908                 h->ref_cache[list][ scan8[4*i]   ]=h->ref_cache[list][ scan8[4*i]+1 ]=
00909                 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
00910 
00911                 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00912                     const int sub_mb_type= h->sub_mb_type[i];
00913                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
00914                     for(j=0; j<sub_partition_count[i]; j++){
00915                         int mx, my;
00916                         const int index= 4*i + block_width*j;
00917                         int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
00918                         pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
00919                         mx += get_se_golomb(&s->gb);
00920                         my += get_se_golomb(&s->gb);
00921                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00922 
00923                         if(IS_SUB_8X8(sub_mb_type)){
00924                             mv_cache[ 1 ][0]=
00925                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
00926                             mv_cache[ 1 ][1]=
00927                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
00928                         }else if(IS_SUB_8X4(sub_mb_type)){
00929                             mv_cache[ 1 ][0]= mx;
00930                             mv_cache[ 1 ][1]= my;
00931                         }else if(IS_SUB_4X8(sub_mb_type)){
00932                             mv_cache[ 8 ][0]= mx;
00933                             mv_cache[ 8 ][1]= my;
00934                         }
00935                         mv_cache[ 0 ][0]= mx;
00936                         mv_cache[ 0 ][1]= my;
00937                     }
00938                 }else{
00939                     uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
00940                     p[0] = p[1]=
00941                     p[8] = p[9]= 0;
00942                 }
00943             }
00944         }
00945     }else if(IS_DIRECT(mb_type)){
00946         ff_h264_pred_direct_motion(h, &mb_type);
00947         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
00948     }else{
00949         int list, mx, my, i;
00950          //FIXME we should set ref_idx_l? to 0 if we use that later ...
00951         if(IS_16X16(mb_type)){
00952             for(list=0; list<h->list_count; list++){
00953                     unsigned int val;
00954                     if(IS_DIR(mb_type, 0, list)){
00955                         if(h->ref_count[list]==1){
00956                             val= 0;
00957                         }else if(h->ref_count[list]==2){
00958                             val= get_bits1(&s->gb)^1;
00959                         }else{
00960                             val= get_ue_golomb_31(&s->gb);
00961                             if(val >= h->ref_count[list]){
00962                                 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00963                                 return -1;
00964                             }
00965                         }
00966                     fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
00967                     }
00968             }
00969             for(list=0; list<h->list_count; list++){
00970                 if(IS_DIR(mb_type, 0, list)){
00971                     pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
00972                     mx += get_se_golomb(&s->gb);
00973                     my += get_se_golomb(&s->gb);
00974                     tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00975 
00976                     fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
00977                 }
00978             }
00979         }
00980         else if(IS_16X8(mb_type)){
00981             for(list=0; list<h->list_count; list++){
00982                     for(i=0; i<2; i++){
00983                         unsigned int val;
00984                         if(IS_DIR(mb_type, i, list)){
00985                             if(h->ref_count[list] == 1){
00986                                 val= 0;
00987                             }else if(h->ref_count[list] == 2){
00988                                 val= get_bits1(&s->gb)^1;
00989                             }else{
00990                                 val= get_ue_golomb_31(&s->gb);
00991                                 if(val >= h->ref_count[list]){
00992                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00993                                     return -1;
00994                                 }
00995                             }
00996                         }else
00997                             val= LIST_NOT_USED&0xFF;
00998                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
00999                     }
01000             }
01001             for(list=0; list<h->list_count; list++){
01002                 for(i=0; i<2; i++){
01003                     unsigned int val;
01004                     if(IS_DIR(mb_type, i, list)){
01005                         pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01006                         mx += get_se_golomb(&s->gb);
01007                         my += get_se_golomb(&s->gb);
01008                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01009 
01010                         val= pack16to32(mx,my);
01011                     }else
01012                         val=0;
01013                     fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
01014                 }
01015             }
01016         }else{
01017             assert(IS_8X16(mb_type));
01018             for(list=0; list<h->list_count; list++){
01019                     for(i=0; i<2; i++){
01020                         unsigned int val;
01021                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
01022                             if(h->ref_count[list]==1){
01023                                 val= 0;
01024                             }else if(h->ref_count[list]==2){
01025                                 val= get_bits1(&s->gb)^1;
01026                             }else{
01027                                 val= get_ue_golomb_31(&s->gb);
01028                                 if(val >= h->ref_count[list]){
01029                                     av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
01030                                     return -1;
01031                                 }
01032                             }
01033                         }else
01034                             val= LIST_NOT_USED&0xFF;
01035                         fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
01036                     }
01037             }
01038             for(list=0; list<h->list_count; list++){
01039                 for(i=0; i<2; i++){
01040                     unsigned int val;
01041                     if(IS_DIR(mb_type, i, list)){
01042                         pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01043                         mx += get_se_golomb(&s->gb);
01044                         my += get_se_golomb(&s->gb);
01045                         tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01046 
01047                         val= pack16to32(mx,my);
01048                     }else
01049                         val=0;
01050                     fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
01051                 }
01052             }
01053         }
01054     }
01055 
01056     if(IS_INTER(mb_type))
01057         write_back_motion(h, mb_type);
01058 
01059     if(!IS_INTRA16x16(mb_type)){
01060         cbp= get_ue_golomb(&s->gb);
01061 
01062         if(decode_chroma){
01063             if(cbp > 47){
01064                 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01065                 return -1;
01066             }
01067             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
01068             else                     cbp= golomb_to_inter_cbp   [cbp];
01069         }else{
01070             if(cbp > 15){
01071                 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01072                 return -1;
01073             }
01074             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
01075             else                     cbp= golomb_to_inter_cbp_gray[cbp];
01076         }
01077     }
01078 
01079     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
01080         mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
01081     }
01082     h->cbp=
01083     h->cbp_table[mb_xy]= cbp;
01084     s->current_picture.f.mb_type[mb_xy] = mb_type;
01085 
01086     if(cbp || IS_INTRA16x16(mb_type)){
01087         int i4x4, i8x8, chroma_idx;
01088         int dquant;
01089         int ret;
01090         GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
01091         const uint8_t *scan, *scan8x8;
01092         const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
01093 
01094         if(IS_INTERLACED(mb_type)){
01095             scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
01096             scan= s->qscale ? h->field_scan : h->field_scan_q0;
01097         }else{
01098             scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
01099             scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01100         }
01101 
01102         dquant= get_se_golomb(&s->gb);
01103 
01104         s->qscale += dquant;
01105 
01106         if(((unsigned)s->qscale) > max_qp){
01107             if(s->qscale<0) s->qscale+= max_qp+1;
01108             else            s->qscale-= max_qp+1;
01109             if(((unsigned)s->qscale) > max_qp){
01110                 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
01111                 return -1;
01112             }
01113         }
01114 
01115         h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
01116         h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
01117 
01118         if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
01119             return -1;
01120         }
01121         h->cbp_table[mb_xy] |= ret << 12;
01122         if(CHROMA444){
01123             if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
01124                 return -1;
01125             }
01126             if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
01127                 return -1;
01128             }
01129         } else if (CHROMA422) {
01130             if(cbp&0x30){
01131                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01132                     if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
01133                                         CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
01134                                         NULL, 8) < 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 < 2; 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         } else /* yuv420 */ {
01157             if(cbp&0x30){
01158                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01159                     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){
01160                         return -1;
01161                     }
01162             }
01163 
01164             if(cbp&0x20){
01165                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01166                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01167                     for(i4x4=0; i4x4<4; i4x4++){
01168                         const int index= 16 + 16*chroma_idx + i4x4;
01169                         if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
01170                             return -1;
01171                         }
01172                     }
01173                 }
01174             }else{
01175                 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01176                 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01177             }
01178         }
01179     }else{
01180         fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
01181         fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01182         fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01183     }
01184     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
01185     write_back_non_zero_count(h);
01186 
01187     if(MB_MBAFF){
01188         h->ref_count[0] >>= 1;
01189         h->ref_count[1] >>= 1;
01190     }
01191 
01192     return 0;
01193 }
01194