git.sesse.net Git - ffmpeg/blob - libavcodec/h264_cavlc.c

   1 /*
   2  * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding
   3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * Libav is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * H.264 / AVC / MPEG-4 part10 cavlc bitstream decoding.
  25  * @author Michael Niedermayer <michaelni@gmx.at>
  26  */
  27
  28 #define CABAC(h) 0
  29
  30 #include "internal.h"
  31 #include "avcodec.h"
  32 #include "h264dec.h"
  33 #include "h264_mvpred.h"
  34 #include "h264data.h"
  35 #include "golomb_legacy.h"
  36 #include "mpegutils.h"
  37
  38 #include <assert.h>
  39
  40 static const uint8_t golomb_to_inter_cbp_gray[16]={
  41  0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
  42 };
  43
  44 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
  45 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
  46 };
  47
  48 static const uint8_t chroma_dc_coeff_token_len[4*5]={
  49  2, 0, 0, 0,
  50  6, 1, 0, 0,
  51  6, 6, 3, 0,
  52  6, 7, 7, 6,
  53  6, 8, 8, 7,
  54 };
  55
  56 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
  57  1, 0, 0, 0,
  58  7, 1, 0, 0,
  59  4, 6, 1, 0,
  60  3, 3, 2, 5,
  61  2, 3, 2, 0,
  62 };
  63
  64 static const uint8_t chroma422_dc_coeff_token_len[4*9]={
  65   1,  0,  0,  0,
  66   7,  2,  0,  0,
  67   7,  7,  3,  0,
  68   9,  7,  7,  5,
  69   9,  9,  7,  6,
  70  10, 10,  9,  7,
  71  11, 11, 10,  7,
  72  12, 12, 11, 10,
  73  13, 12, 12, 11,
  74 };
  75
  76 static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
  77   1,   0,  0, 0,
  78  15,   1,  0, 0,
  79  14,  13,  1, 0,
  80   7,  12, 11, 1,
  81   6,   5, 10, 1,
  82   7,   6,  4, 9,
  83   7,   6,  5, 8,
  84   7,   6,  5, 4,
  85   7,   5,  4, 4,
  86 };
  87
  88 static const uint8_t coeff_token_len[4][4*17]={
  89 {
  90      1, 0, 0, 0,
  91      6, 2, 0, 0,     8, 6, 3, 0,     9, 8, 7, 5,    10, 9, 8, 6,
  92     11,10, 9, 7,    13,11,10, 8,    13,13,11, 9,    13,13,13,10,
  93     14,14,13,11,    14,14,14,13,    15,15,14,14,    15,15,15,14,
  94     16,15,15,15,    16,16,16,15,    16,16,16,16,    16,16,16,16,
  95 },
  96 {
  97      2, 0, 0, 0,
  98      6, 2, 0, 0,     6, 5, 3, 0,     7, 6, 6, 4,     8, 6, 6, 4,
  99      8, 7, 7, 5,     9, 8, 8, 6,    11, 9, 9, 6,    11,11,11, 7,
 100     12,11,11, 9,    12,12,12,11,    12,12,12,11,    13,13,13,12,
 101     13,13,13,13,    13,14,13,13,    14,14,14,13,    14,14,14,14,
 102 },
 103 {
 104      4, 0, 0, 0,
 105      6, 4, 0, 0,     6, 5, 4, 0,     6, 5, 5, 4,     7, 5, 5, 4,
 106      7, 5, 5, 4,     7, 6, 6, 4,     7, 6, 6, 4,     8, 7, 7, 5,
 107      8, 8, 7, 6,     9, 8, 8, 7,     9, 9, 8, 8,     9, 9, 9, 8,
 108     10, 9, 9, 9,    10,10,10,10,    10,10,10,10,    10,10,10,10,
 109 },
 110 {
 111      6, 0, 0, 0,
 112      6, 6, 0, 0,     6, 6, 6, 0,     6, 6, 6, 6,     6, 6, 6, 6,
 113      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
 114      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
 115      6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,     6, 6, 6, 6,
 116 }
 117 };
 118
 119 static const uint8_t coeff_token_bits[4][4*17]={
 120 {
 121      1, 0, 0, 0,
 122      5, 1, 0, 0,     7, 4, 1, 0,     7, 6, 5, 3,     7, 6, 5, 3,
 123      7, 6, 5, 4,    15, 6, 5, 4,    11,14, 5, 4,     8,10,13, 4,
 124     15,14, 9, 4,    11,10,13,12,    15,14, 9,12,    11,10,13, 8,
 125     15, 1, 9,12,    11,14,13, 8,     7,10, 9,12,     4, 6, 5, 8,
 126 },
 127 {
 128      3, 0, 0, 0,
 129     11, 2, 0, 0,     7, 7, 3, 0,     7,10, 9, 5,     7, 6, 5, 4,
 130      4, 6, 5, 6,     7, 6, 5, 8,    15, 6, 5, 4,    11,14,13, 4,
 131     15,10, 9, 4,    11,14,13,12,     8,10, 9, 8,    15,14,13,12,
 132     11,10, 9,12,     7,11, 6, 8,     9, 8,10, 1,     7, 6, 5, 4,
 133 },
 134 {
 135     15, 0, 0, 0,
 136     15,14, 0, 0,    11,15,13, 0,     8,12,14,12,    15,10,11,11,
 137     11, 8, 9,10,     9,14,13, 9,     8,10, 9, 8,    15,14,13,13,
 138     11,14,10,12,    15,10,13,12,    11,14, 9,12,     8,10,13, 8,
 139     13, 7, 9,12,     9,12,11,10,     5, 8, 7, 6,     1, 4, 3, 2,
 140 },
 141 {
 142      3, 0, 0, 0,
 143      0, 1, 0, 0,     4, 5, 6, 0,     8, 9,10,11,    12,13,14,15,
 144     16,17,18,19,    20,21,22,23,    24,25,26,27,    28,29,30,31,
 145     32,33,34,35,    36,37,38,39,    40,41,42,43,    44,45,46,47,
 146     48,49,50,51,    52,53,54,55,    56,57,58,59,    60,61,62,63,
 147 }
 148 };
 149
 150 static const uint8_t total_zeros_len[16][16]= {
 151     {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
 152     {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
 153     {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
 154     {5,3,4,4,3,3,3,4,3,4,5,5,5},
 155     {4,4,4,3,3,3,3,3,4,5,4,5},
 156     {6,5,3,3,3,3,3,3,4,3,6},
 157     {6,5,3,3,3,2,3,4,3,6},
 158     {6,4,5,3,2,2,3,3,6},
 159     {6,6,4,2,2,3,2,5},
 160     {5,5,3,2,2,2,4},
 161     {4,4,3,3,1,3},
 162     {4,4,2,1,3},
 163     {3,3,1,2},
 164     {2,2,1},
 165     {1,1},
 166 };
 167
 168 static const uint8_t total_zeros_bits[16][16]= {
 169     {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
 170     {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
 171     {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
 172     {3,7,5,4,6,5,4,3,3,2,2,1,0},
 173     {5,4,3,7,6,5,4,3,2,1,1,0},
 174     {1,1,7,6,5,4,3,2,1,1,0},
 175     {1,1,5,4,3,3,2,1,1,0},
 176     {1,1,1,3,3,2,2,1,0},
 177     {1,0,1,3,2,1,1,1},
 178     {1,0,1,3,2,1,1},
 179     {0,1,1,2,1,3},
 180     {0,1,1,1,1},
 181     {0,1,1,1},
 182     {0,1,1},
 183     {0,1},
 184 };
 185
 186 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
 187     { 1, 2, 3, 3,},
 188     { 1, 2, 2, 0,},
 189     { 1, 1, 0, 0,},
 190 };
 191
 192 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
 193     { 1, 1, 1, 0,},
 194     { 1, 1, 0, 0,},
 195     { 1, 0, 0, 0,},
 196 };
 197
 198 static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
 199     { 1, 3, 3, 4, 4, 4, 5, 5 },
 200     { 3, 2, 3, 3, 3, 3, 3 },
 201     { 3, 3, 2, 2, 3, 3 },
 202     { 3, 2, 2, 2, 3 },
 203     { 2, 2, 2, 2 },
 204     { 2, 2, 1 },
 205     { 1, 1 },
 206 };
 207
 208 static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
 209     { 1, 2, 3, 2, 3, 1, 1, 0 },
 210     { 0, 1, 1, 4, 5, 6, 7 },
 211     { 0, 1, 1, 2, 6, 7 },
 212     { 6, 0, 1, 2, 7 },
 213     { 0, 1, 2, 3 },
 214     { 0, 1, 1 },
 215     { 0, 1 },
 216 };
 217
 218 static const uint8_t run_len[7][16]={
 219     {1,1},
 220     {1,2,2},
 221     {2,2,2,2},
 222     {2,2,2,3,3},
 223     {2,2,3,3,3,3},
 224     {2,3,3,3,3,3,3},
 225     {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
 226 };
 227
 228 static const uint8_t run_bits[7][16]={
 229     {1,0},
 230     {1,1,0},
 231     {3,2,1,0},
 232     {3,2,1,1,0},
 233     {3,2,3,2,1,0},
 234     {3,0,1,3,2,5,4},
 235     {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
 236 };
 237
 238 static VLC coeff_token_vlc[4];
 239 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
 240 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
 241
 242 static VLC chroma_dc_coeff_token_vlc;
 243 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
 244 static const int chroma_dc_coeff_token_vlc_table_size = 256;
 245
 246 static VLC chroma422_dc_coeff_token_vlc;
 247 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
 248 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
 249
 250 static VLC total_zeros_vlc[15];
 251 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
 252 static const int total_zeros_vlc_tables_size = 512;
 253
 254 static VLC chroma_dc_total_zeros_vlc[3];
 255 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
 256 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
 257
 258 static VLC chroma422_dc_total_zeros_vlc[7];
 259 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
 260 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
 261
 262 static VLC run_vlc[6];
 263 static VLC_TYPE run_vlc_tables[6][8][2];
 264 static const int run_vlc_tables_size = 8;
 265
 266 static VLC run7_vlc;
 267 static VLC_TYPE run7_vlc_table[96][2];
 268 static const int run7_vlc_table_size = 96;
 269
 270 #define LEVEL_TAB_BITS 8
 271 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
 272
 273 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
 274 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
 275 #define COEFF_TOKEN_VLC_BITS           8
 276 #define TOTAL_ZEROS_VLC_BITS           9
 277 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
 278 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
 279 #define RUN_VLC_BITS                   3
 280 #define RUN7_VLC_BITS                  6
 281
 282 /**
 283  * Get the predicted number of non-zero coefficients.
 284  * @param n block index
 285  */
 286 static inline int pred_non_zero_count(const H264Context *h, H264SliceContext *sl, int n)
 287 {
 288     const int index8= scan8[n];
 289     const int left = sl->non_zero_count_cache[index8 - 1];
 290     const int top  = sl->non_zero_count_cache[index8 - 8];
 291     int i= left + top;
 292
 293     if(i<64) i= (i+1)>>1;
 294
 295     ff_tlog(h->avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
 296
 297     return i&31;
 298 }
 299
 300 static av_cold void init_cavlc_level_tab(void){
 301     int suffix_length;
 302     unsigned int i;
 303
 304     for(suffix_length=0; suffix_length<7; suffix_length++){
 305         for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
 306             int prefix= LEVEL_TAB_BITS - av_log2(2*i);
 307
 308             if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
 309                 int level_code = (prefix << suffix_length) +
 310                     (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
 311                 int mask = -(level_code&1);
 312                 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
 313                 cavlc_level_tab[suffix_length][i][0]= level_code;
 314                 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
 315             }else if(prefix + 1 <= LEVEL_TAB_BITS){
 316                 cavlc_level_tab[suffix_length][i][0]= prefix+100;
 317                 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
 318             }else{
 319                 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
 320                 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
 321             }
 322         }
 323     }
 324 }
 325
 326 av_cold void ff_h264_decode_init_vlc(void){
 327     static int done = 0;
 328
 329     if (!done) {
 330         int i;
 331         int offset;
 332         done = 1;
 333
 334         chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
 335         chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
 336         init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
 337                  &chroma_dc_coeff_token_len [0], 1, 1,
 338                  &chroma_dc_coeff_token_bits[0], 1, 1,
 339                  INIT_VLC_USE_NEW_STATIC);
 340
 341         chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
 342         chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
 343         init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
 344                  &chroma422_dc_coeff_token_len [0], 1, 1,
 345                  &chroma422_dc_coeff_token_bits[0], 1, 1,
 346                  INIT_VLC_USE_NEW_STATIC);
 347
 348         offset = 0;
 349         for(i=0; i<4; i++){
 350             coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
 351             coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
 352             init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
 353                      &coeff_token_len [i][0], 1, 1,
 354                      &coeff_token_bits[i][0], 1, 1,
 355                      INIT_VLC_USE_NEW_STATIC);
 356             offset += coeff_token_vlc_tables_size[i];
 357         }
 358         /*
 359          * This is a one time safety check to make sure that
 360          * the packed static coeff_token_vlc table sizes
 361          * were initialized correctly.
 362          */
 363         assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
 364
 365         for(i=0; i<3; i++){
 366             chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
 367             chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
 368             init_vlc(&chroma_dc_total_zeros_vlc[i],
 369                      CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
 370                      &chroma_dc_total_zeros_len [i][0], 1, 1,
 371                      &chroma_dc_total_zeros_bits[i][0], 1, 1,
 372                      INIT_VLC_USE_NEW_STATIC);
 373         }
 374
 375         for(i=0; i<7; i++){
 376             chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
 377             chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
 378             init_vlc(&chroma422_dc_total_zeros_vlc[i],
 379                      CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
 380                      &chroma422_dc_total_zeros_len [i][0], 1, 1,
 381                      &chroma422_dc_total_zeros_bits[i][0], 1, 1,
 382                      INIT_VLC_USE_NEW_STATIC);
 383         }
 384
 385         for(i=0; i<15; i++){
 386             total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
 387             total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
 388             init_vlc(&total_zeros_vlc[i],
 389                      TOTAL_ZEROS_VLC_BITS, 16,
 390                      &total_zeros_len [i][0], 1, 1,
 391                      &total_zeros_bits[i][0], 1, 1,
 392                      INIT_VLC_USE_NEW_STATIC);
 393         }
 394
 395         for(i=0; i<6; i++){
 396             run_vlc[i].table = run_vlc_tables[i];
 397             run_vlc[i].table_allocated = run_vlc_tables_size;
 398             init_vlc(&run_vlc[i],
 399                      RUN_VLC_BITS, 7,
 400                      &run_len [i][0], 1, 1,
 401                      &run_bits[i][0], 1, 1,
 402                      INIT_VLC_USE_NEW_STATIC);
 403         }
 404         run7_vlc.table = run7_vlc_table,
 405         run7_vlc.table_allocated = run7_vlc_table_size;
 406         init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
 407                  &run_len [6][0], 1, 1,
 408                  &run_bits[6][0], 1, 1,
 409                  INIT_VLC_USE_NEW_STATIC);
 410
 411         init_cavlc_level_tab();
 412     }
 413 }
 414
 415 static inline int get_level_prefix(GetBitContext *gb){
 416     unsigned int buf;
 417     int log;
 418
 419     OPEN_READER(re, gb);
 420     UPDATE_CACHE(re, gb);
 421     buf=GET_CACHE(re, gb);
 422
 423     log= 32 - av_log2(buf);
 424
 425     LAST_SKIP_BITS(re, gb, log);
 426     CLOSE_READER(re, gb);
 427
 428     return log-1;
 429 }
 430
 431 /**
 432  * Decode a residual block.
 433  * @param n block index
 434  * @param scantable scantable
 435  * @param max_coeff number of coefficients in the block
 436  * @return <0 if an error occurred
 437  */
 438 static int decode_residual(const H264Context *h, H264SliceContext *sl,
 439                            GetBitContext *gb, int16_t *block, int n,
 440                            const uint8_t *scantable, const uint32_t *qmul,
 441                            int max_coeff)
 442 {
 443     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};
 444     int level[16];
 445     int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
 446
 447     //FIXME put trailing_onex into the context
 448
 449     if(max_coeff <= 8){
 450         if (max_coeff == 4)
 451             coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
 452         else
 453             coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
 454         total_coeff= coeff_token>>2;
 455     }else{
 456         if(n >= LUMA_DC_BLOCK_INDEX){
 457             total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
 458             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
 459             total_coeff= coeff_token>>2;
 460         }else{
 461             total_coeff= pred_non_zero_count(h, sl, n);
 462             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
 463             total_coeff= coeff_token>>2;
 464         }
 465     }
 466     sl->non_zero_count_cache[scan8[n]] = total_coeff;
 467
 468     //FIXME set last_non_zero?
 469
 470     if(total_coeff==0)
 471         return 0;
 472     if(total_coeff > (unsigned)max_coeff) {
 473         av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
 474         return -1;
 475     }
 476
 477     trailing_ones= coeff_token&3;
 478     ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
 479     assert(total_coeff<=16);
 480
 481     i = show_bits(gb, 3);
 482     skip_bits(gb, trailing_ones);
 483     level[0] = 1-((i&4)>>1);
 484     level[1] = 1-((i&2)   );
 485     level[2] = 1-((i&1)<<1);
 486
 487     if(trailing_ones<total_coeff) {
 488         int mask, prefix;
 489         int suffix_length = total_coeff > 10 & trailing_ones < 3;
 490         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 491         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
 492
 493         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 494         if(level_code >= 100){
 495             prefix= level_code - 100;
 496             if(prefix == LEVEL_TAB_BITS)
 497                 prefix += get_level_prefix(gb);
 498
 499             //first coefficient has suffix_length equal to 0 or 1
 500             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
 501                 if(suffix_length)
 502                     level_code= (prefix<<1) + get_bits1(gb); //part
 503                 else
 504                     level_code= prefix; //part
 505             }else if(prefix==14){
 506                 if(suffix_length)
 507                     level_code= (prefix<<1) + get_bits1(gb); //part
 508                 else
 509                     level_code= prefix + get_bits(gb, 4); //part
 510             }else{
 511                 level_code= 30 + get_bits(gb, prefix-3); //part
 512                 if(prefix>=16){
 513                     if(prefix > 25+3){
 514                         av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
 515                         return -1;
 516                     }
 517                     level_code += (1<<(prefix-3))-4096;
 518                 }
 519             }
 520
 521             if(trailing_ones < 3) level_code += 2;
 522
 523             suffix_length = 2;
 524             mask= -(level_code&1);
 525             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
 526         }else{
 527             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
 528
 529             suffix_length = 1 + (level_code + 3U > 6U);
 530             level[trailing_ones]= level_code;
 531         }
 532
 533         //remaining coefficients have suffix_length > 0
 534         for(i=trailing_ones+1;i<total_coeff;i++) {
 535             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
 536             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 537             level_code= cavlc_level_tab[suffix_length][bitsi][0];
 538
 539             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 540             if(level_code >= 100){
 541                 prefix= level_code - 100;
 542                 if(prefix == LEVEL_TAB_BITS){
 543                     prefix += get_level_prefix(gb);
 544                 }
 545                 if(prefix<15){
 546                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
 547                 }else{
 548                     level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
 549                     if(prefix>=16)
 550                         level_code += (1<<(prefix-3))-4096;
 551                 }
 552                 mask= -(level_code&1);
 553                 level_code= (((2+level_code)>>1) ^ mask) - mask;
 554             }
 555             level[i]= level_code;
 556             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
 557         }
 558     }
 559
 560     if(total_coeff == max_coeff)
 561         zeros_left=0;
 562     else{
 563         if (max_coeff <= 8) {
 564             if (max_coeff == 4)
 565                 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
 566                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
 567             else
 568                 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
 569                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
 570         } else {
 571             zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
 572         }
 573     }
 574
 575 #define STORE_BLOCK(type) \
 576     scantable += zeros_left + total_coeff - 1; \
 577     if(n >= LUMA_DC_BLOCK_INDEX){ \
 578         ((type*)block)[*scantable] = level[0]; \
 579         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 580             if(zeros_left < 7) \
 581                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 582             else {\
 583                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 584                 run_before = FFMIN(zeros_left, run_before);\
 585             }\
 586             zeros_left -= run_before; \
 587             scantable -= 1 + run_before; \
 588             ((type*)block)[*scantable]= level[i]; \
 589         } \
 590         for(;i<total_coeff;i++) { \
 591             scantable--; \
 592             ((type*)block)[*scantable]= level[i]; \
 593         } \
 594     }else{ \
 595         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
 596         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 597             if(zeros_left < 7) \
 598                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 599             else {\
 600                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 601                 run_before = FFMIN(zeros_left, run_before);\
 602             }\
 603             zeros_left -= run_before; \
 604             scantable -= 1 + run_before; \
 605             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
 606         } \
 607         for(;i<total_coeff;i++) { \
 608             scantable--; \
 609             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
 610         } \
 611     }
 612
 613     if (zeros_left < 0) {
 614         av_log(h->avctx, AV_LOG_ERROR,
 615                "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
 616         return AVERROR_INVALIDDATA;
 617     }
 618
 619     if (h->pixel_shift) {
 620         STORE_BLOCK(int32_t)
 621     } else {
 622         STORE_BLOCK(int16_t)
 623     }
 624
 625     return 0;
 626 }
 627
 628 static av_always_inline
 629 int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
 630                          GetBitContext *gb, const uint8_t *scan,
 631                          const uint8_t *scan8x8, int pixel_shift,
 632                          int mb_type, int cbp, int p)
 633 {
 634     int i4x4, i8x8;
 635     int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
 636     if(IS_INTRA16x16(mb_type)){
 637         AV_ZERO128(sl->mb_luma_dc[p]+0);
 638         AV_ZERO128(sl->mb_luma_dc[p]+8);
 639         AV_ZERO128(sl->mb_luma_dc[p]+16);
 640         AV_ZERO128(sl->mb_luma_dc[p]+24);
 641         if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
 642             return -1; //FIXME continue if partitioned and other return -1 too
 643         }
 644
 645         assert((cbp&15) == 0 || (cbp&15) == 15);
 646
 647         if(cbp&15){
 648             for(i8x8=0; i8x8<4; i8x8++){
 649                 for(i4x4=0; i4x4<4; i4x4++){
 650                     const int index= i4x4 + 4*i8x8 + p*16;
 651                     if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
 652                         index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
 653                         return -1;
 654                     }
 655                 }
 656             }
 657             return 0xf;
 658         }else{
 659             fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
 660             return 0;
 661         }
 662     }else{
 663         int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
 664         /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
 665         int new_cbp = 0;
 666         for(i8x8=0; i8x8<4; i8x8++){
 667             if(cbp & (1<<i8x8)){
 668                 if(IS_8x8DCT(mb_type)){
 669                     int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
 670                     uint8_t *nnz;
 671                     for(i4x4=0; i4x4<4; i4x4++){
 672                         const int index= i4x4 + 4*i8x8 + p*16;
 673                         if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
 674                                             h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
 675                             return -1;
 676                     }
 677                     nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
 678                     nnz[0] += nnz[1] + nnz[8] + nnz[9];
 679                     new_cbp |= !!nnz[0] << i8x8;
 680                 }else{
 681                     for(i4x4=0; i4x4<4; i4x4++){
 682                         const int index= i4x4 + 4*i8x8 + p*16;
 683                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
 684                                             scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
 685                             return -1;
 686                         }
 687                         new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
 688                     }
 689                 }
 690             }else{
 691                 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
 692                 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
 693             }
 694         }
 695         return new_cbp;
 696     }
 697 }
 698
 699 int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
 700 {
 701     int mb_xy;
 702     int partition_count;
 703     unsigned int mb_type, cbp;
 704     int dct8x8_allowed= h->ps.pps->transform_8x8_mode;
 705     int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
 706     const int pixel_shift = h->pixel_shift;
 707
 708     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
 709
 710     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
 711                 down the code */
 712     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
 713         if (sl->mb_skip_run == -1)
 714             sl->mb_skip_run = get_ue_golomb(&sl->gb);
 715
 716         if (sl->mb_skip_run--) {
 717             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
 718                 if (sl->mb_skip_run == 0)
 719                     sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 720             }
 721             decode_mb_skip(h, sl);
 722             return 0;
 723         }
 724     }
 725     if (FRAME_MBAFF(h)) {
 726         if ((sl->mb_y & 1) == 0)
 727             sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 728     }
 729
 730     sl->prev_mb_skipped = 0;
 731
 732     mb_type= get_ue_golomb(&sl->gb);
 733     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 734         if(mb_type < 23){
 735             partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
 736             mb_type         = ff_h264_b_mb_type_info[mb_type].type;
 737         }else{
 738             mb_type -= 23;
 739             goto decode_intra_mb;
 740         }
 741     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
 742         if(mb_type < 5){
 743             partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
 744             mb_type         = ff_h264_p_mb_type_info[mb_type].type;
 745         }else{
 746             mb_type -= 5;
 747             goto decode_intra_mb;
 748         }
 749     }else{
 750        assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 751         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
 752             mb_type--;
 753 decode_intra_mb:
 754         if(mb_type > 25){
 755             av_log(h->avctx, AV_LOG_ERROR, "mb_type %d in %c slice too large at %d %d\n", mb_type, av_get_picture_type_char(sl->slice_type), sl->mb_x, sl->mb_y);
 756             return -1;
 757         }
 758         partition_count=0;
 759         cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
 760         sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
 761         mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
 762     }
 763
 764     if (MB_FIELD(sl))
 765         mb_type |= MB_TYPE_INTERLACED;
 766
 767     h->slice_table[mb_xy] = sl->slice_num;
 768
 769     if(IS_INTRA_PCM(mb_type)){
 770         const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
 771                             h->ps.sps->bit_depth_luma;
 772
 773         // We assume these blocks are very rare so we do not optimize it.
 774         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
 775         if (get_bits_left(&sl->gb) < mb_size) {
 776             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
 777             return AVERROR_INVALIDDATA;
 778         }
 779         skip_bits_long(&sl->gb, mb_size);
 780
 781         // In deblocking, the quantizer is 0
 782         h->cur_pic.qscale_table[mb_xy] = 0;
 783         // All coeffs are present
 784         memset(h->non_zero_count[mb_xy], 16, 48);
 785
 786         h->cur_pic.mb_type[mb_xy] = mb_type;
 787         return 0;
 788     }
 789
 790     fill_decode_neighbors(h, sl, mb_type);
 791     fill_decode_caches(h, sl, mb_type);
 792
 793     //mb_pred
 794     if(IS_INTRA(mb_type)){
 795         int pred_mode;
 796 //            init_top_left_availability(h);
 797         if(IS_INTRA4x4(mb_type)){
 798             int i;
 799             int di = 1;
 800             if(dct8x8_allowed && get_bits1(&sl->gb)){
 801                 mb_type |= MB_TYPE_8x8DCT;
 802                 di = 4;
 803             }
 804
 805 //                fill_intra4x4_pred_table(h);
 806             for(i=0; i<16; i+=di){
 807                 int mode = pred_intra_mode(h, sl, i);
 808
 809                 if(!get_bits1(&sl->gb)){
 810                     const int rem_mode= get_bits(&sl->gb, 3);
 811                     mode = rem_mode + (rem_mode >= mode);
 812                 }
 813
 814                 if(di==4)
 815                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
 816                 else
 817                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
 818             }
 819             write_back_intra_pred_mode(h, sl);
 820             if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
 821                                                  sl->top_samples_available, sl->left_samples_available) < 0)
 822                 return -1;
 823         }else{
 824             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 825                                                                      sl->left_samples_available, sl->intra16x16_pred_mode, 0);
 826             if (sl->intra16x16_pred_mode < 0)
 827                 return -1;
 828         }
 829         if(decode_chroma){
 830             pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 831                                                      sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
 832             if(pred_mode < 0)
 833                 return -1;
 834             sl->chroma_pred_mode = pred_mode;
 835         } else {
 836             sl->chroma_pred_mode = DC_128_PRED8x8;
 837         }
 838     }else if(partition_count==4){
 839         int i, j, sub_partition_count[4], list, ref[2][4];
 840
 841         if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 842             for(i=0; i<4; i++){
 843                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
 844                 if(sl->sub_mb_type[i] >=13){
 845                     av_log(h->avctx, AV_LOG_ERROR, "B sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
 846                     return -1;
 847                 }
 848                 sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 849                 sl->sub_mb_type[i]     = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
 850             }
 851             if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
 852                 ff_h264_pred_direct_motion(h, sl, &mb_type);
 853                 sl->ref_cache[0][scan8[4]] =
 854                 sl->ref_cache[1][scan8[4]] =
 855                 sl->ref_cache[0][scan8[12]] =
 856                 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
 857             }
 858         }else{
 859             assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
 860             for(i=0; i<4; i++){
 861                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
 862                 if(sl->sub_mb_type[i] >=4){
 863                     av_log(h->avctx, AV_LOG_ERROR, "P sub_mb_type %u out of range at %d %d\n", sl->sub_mb_type[i], sl->mb_x, sl->mb_y);
 864                     return -1;
 865                 }
 866                 sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 867                 sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
 868             }
 869         }
 870
 871         for (list = 0; list < sl->list_count; list++) {
 872             int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
 873             for(i=0; i<4; i++){
 874                 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
 875                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
 876                     unsigned int tmp;
 877                     if(ref_count == 1){
 878                         tmp= 0;
 879                     }else if(ref_count == 2){
 880                         tmp= get_bits1(&sl->gb)^1;
 881                     }else{
 882                         tmp= get_ue_golomb_31(&sl->gb);
 883                         if(tmp>=ref_count){
 884                             av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
 885                             return -1;
 886                         }
 887                     }
 888                     ref[list][i]= tmp;
 889                 }else{
 890                  //FIXME
 891                     ref[list][i] = -1;
 892                 }
 893             }
 894         }
 895
 896         if(dct8x8_allowed)
 897             dct8x8_allowed = get_dct8x8_allowed(h, sl);
 898
 899         for (list = 0; list < sl->list_count; list++) {
 900             for(i=0; i<4; i++){
 901                 if(IS_DIRECT(sl->sub_mb_type[i])) {
 902                     sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
 903                     continue;
 904                 }
 905                 sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
 906                 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
 907
 908                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
 909                     const int sub_mb_type= sl->sub_mb_type[i];
 910                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
 911                     for(j=0; j<sub_partition_count[i]; j++){
 912                         int mx, my;
 913                         const int index= 4*i + block_width*j;
 914                         int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
 915                         pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
 916                         mx += get_se_golomb(&sl->gb);
 917                         my += get_se_golomb(&sl->gb);
 918                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
 919
 920                         if(IS_SUB_8X8(sub_mb_type)){
 921                             mv_cache[ 1 ][0]=
 922                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
 923                             mv_cache[ 1 ][1]=
 924                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
 925                         }else if(IS_SUB_8X4(sub_mb_type)){
 926                             mv_cache[ 1 ][0]= mx;
 927                             mv_cache[ 1 ][1]= my;
 928                         }else if(IS_SUB_4X8(sub_mb_type)){
 929                             mv_cache[ 8 ][0]= mx;
 930                             mv_cache[ 8 ][1]= my;
 931                         }
 932                         mv_cache[ 0 ][0]= mx;
 933                         mv_cache[ 0 ][1]= my;
 934                     }
 935                 }else{
 936                     uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
 937                     p[0] = p[1]=
 938                     p[8] = p[9]= 0;
 939                 }
 940             }
 941         }
 942     }else if(IS_DIRECT(mb_type)){
 943         ff_h264_pred_direct_motion(h, sl, &mb_type);
 944         dct8x8_allowed &= h->ps.sps->direct_8x8_inference_flag;
 945     }else{
 946         int list, mx, my, i;
 947          //FIXME we should set ref_idx_l? to 0 if we use that later ...
 948         if(IS_16X16(mb_type)){
 949             for (list = 0; list < sl->list_count; list++) {
 950                     unsigned int val;
 951                     if(IS_DIR(mb_type, 0, list)){
 952                         int rc = sl->ref_count[list] << MB_MBAFF(sl);
 953                         if (rc == 1) {
 954                             val= 0;
 955                         } else if (rc == 2) {
 956                             val= get_bits1(&sl->gb)^1;
 957                         }else{
 958                             val= get_ue_golomb_31(&sl->gb);
 959                             if (val >= rc) {
 960                                 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
 961                                 return -1;
 962                             }
 963                         }
 964                     fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
 965                     }
 966             }
 967             for (list = 0; list < sl->list_count; list++) {
 968                 if(IS_DIR(mb_type, 0, list)){
 969                     pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
 970                     mx += get_se_golomb(&sl->gb);
 971                     my += get_se_golomb(&sl->gb);
 972                     ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
 973
 974                     fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
 975                 }
 976             }
 977         }
 978         else if(IS_16X8(mb_type)){
 979             for (list = 0; list < sl->list_count; list++) {
 980                     for(i=0; i<2; i++){
 981                         unsigned int val;
 982                         if(IS_DIR(mb_type, i, list)){
 983                             int rc = sl->ref_count[list] << MB_MBAFF(sl);
 984                             if (rc == 1) {
 985                                 val= 0;
 986                             } else if (rc == 2) {
 987                                 val= get_bits1(&sl->gb)^1;
 988                             }else{
 989                                 val= get_ue_golomb_31(&sl->gb);
 990                                 if (val >= rc) {
 991                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
 992                                     return -1;
 993                                 }
 994                             }
 995                         }else
 996                             val= LIST_NOT_USED&0xFF;
 997                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
 998                     }
 999             }
1000             for (list = 0; list < sl->list_count; list++) {
1001                 for(i=0; i<2; i++){
1002                     unsigned int val;
1003                     if(IS_DIR(mb_type, i, list)){
1004                         pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1005                         mx += get_se_golomb(&sl->gb);
1006                         my += get_se_golomb(&sl->gb);
1007                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1008
1009                         val= pack16to32(mx,my);
1010                     }else
1011                         val=0;
1012                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1013                 }
1014             }
1015         }else{
1016             assert(IS_8X16(mb_type));
1017             for (list = 0; list < sl->list_count; list++) {
1018                     for(i=0; i<2; i++){
1019                         unsigned int val;
1020                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1021                             int rc = sl->ref_count[list] << MB_MBAFF(sl);
1022                             if (rc == 1) {
1023                                 val= 0;
1024                             } else if (rc == 2) {
1025                                 val= get_bits1(&sl->gb)^1;
1026                             }else{
1027                                 val= get_ue_golomb_31(&sl->gb);
1028                                 if (val >= rc) {
1029                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1030                                     return -1;
1031                                 }
1032                             }
1033                         }else
1034                             val= LIST_NOT_USED&0xFF;
1035                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1036                     }
1037             }
1038             for (list = 0; list < sl->list_count; list++) {
1039                 for(i=0; i<2; i++){
1040                     unsigned int val;
1041                     if(IS_DIR(mb_type, i, list)){
1042                         pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1043                         mx += get_se_golomb(&sl->gb);
1044                         my += get_se_golomb(&sl->gb);
1045                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1046
1047                         val= pack16to32(mx,my);
1048                     }else
1049                         val=0;
1050                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1051                 }
1052             }
1053         }
1054     }
1055
1056     if(IS_INTER(mb_type))
1057         write_back_motion(h, sl, mb_type);
1058
1059     if(!IS_INTRA16x16(mb_type)){
1060         cbp= get_ue_golomb(&sl->gb);
1061
1062         if(decode_chroma){
1063             if(cbp > 47){
1064                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1065                 return -1;
1066             }
1067             if (IS_INTRA4x4(mb_type))
1068                 cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1069             else
1070                 cbp = ff_h264_golomb_to_inter_cbp[cbp];
1071         }else{
1072             if(cbp > 15){
1073                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1074                 return -1;
1075             }
1076             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1077             else                     cbp= golomb_to_inter_cbp_gray[cbp];
1078         }
1079     }
1080
1081     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1082         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1083     }
1084     sl->cbp=
1085     h->cbp_table[mb_xy]= cbp;
1086     h->cur_pic.mb_type[mb_xy] = mb_type;
1087
1088     if(cbp || IS_INTRA16x16(mb_type)){
1089         int i4x4, i8x8, chroma_idx;
1090         int dquant;
1091         int ret;
1092         GetBitContext *gb = &sl->gb;
1093         const uint8_t *scan, *scan8x8;
1094         const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1095
1096         if(IS_INTERLACED(mb_type)){
1097             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1098             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1099         }else{
1100             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1101             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1102         }
1103
1104         dquant= get_se_golomb(&sl->gb);
1105
1106         sl->qscale += dquant;
1107
1108         if (((unsigned)sl->qscale) > max_qp){
1109             if (sl->qscale < 0) sl->qscale += max_qp + 1;
1110             else                sl->qscale -= max_qp+1;
1111             if (((unsigned)sl->qscale) > max_qp){
1112                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1113                 return -1;
1114             }
1115         }
1116
1117         sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1118         sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1119
1120         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1121             return -1;
1122         }
1123         h->cbp_table[mb_xy] |= ret << 12;
1124         if (CHROMA444(h)) {
1125             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1126                 return -1;
1127             }
1128             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1129                 return -1;
1130             }
1131         } else if (CHROMA422(h)) {
1132             if(cbp&0x30){
1133                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1134                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1135                                         CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_chroma422_dc_scan,
1136                                         NULL, 8) < 0) {
1137                         return -1;
1138                     }
1139             }
1140
1141             if(cbp&0x20){
1142                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1143                     const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1144                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1145                     for (i8x8 = 0; i8x8 < 2; i8x8++) {
1146                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
1147                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1148                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1149                                 return -1;
1150                             mb += 16 << pixel_shift;
1151                         }
1152                     }
1153                 }
1154             }else{
1155                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1156                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1157             }
1158         } else /* yuv420 */ {
1159             if(cbp&0x30){
1160                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1161                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16 * 16 * chroma_idx) << pixel_shift),
1162                                         CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_chroma_dc_scan, NULL, 4) < 0) {
1163                         return -1;
1164                     }
1165             }
1166
1167             if(cbp&0x20){
1168                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1169                     const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1170                     for(i4x4=0; i4x4<4; i4x4++){
1171                         const int index= 16 + 16*chroma_idx + i4x4;
1172                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1173                             return -1;
1174                         }
1175                     }
1176                 }
1177             }else{
1178                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1179                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1180             }
1181         }
1182     }else{
1183         fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1184         fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1185         fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1186     }
1187     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1188     write_back_non_zero_count(h, sl);
1189
1190     return 0;
1191 }