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 / MPEG4 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 "h264.h"
  33 #include "h264_mvpred.h"
  34 #include "h264data.h"
  35 #include "golomb.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 #ifdef TRACE
 425     print_bin(buf>>(32-log), log);
 426     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__);
 427 #endif
 428
 429     LAST_SKIP_BITS(re, gb, log);
 430     CLOSE_READER(re, gb);
 431
 432     return log-1;
 433 }
 434
 435 /**
 436  * Decode a residual block.
 437  * @param n block index
 438  * @param scantable scantable
 439  * @param max_coeff number of coefficients in the block
 440  * @return <0 if an error occurred
 441  */
 442 static int decode_residual(const H264Context *h, H264SliceContext *sl,
 443                            GetBitContext *gb, int16_t *block, int n,
 444                            const uint8_t *scantable, const uint32_t *qmul,
 445                            int max_coeff)
 446 {
 447     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};
 448     int level[16];
 449     int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
 450
 451     //FIXME put trailing_onex into the context
 452
 453     if(max_coeff <= 8){
 454         if (max_coeff == 4)
 455             coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
 456         else
 457             coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
 458         total_coeff= coeff_token>>2;
 459     }else{
 460         if(n >= LUMA_DC_BLOCK_INDEX){
 461             total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
 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         }else{
 465             total_coeff= pred_non_zero_count(h, sl, n);
 466             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
 467             total_coeff= coeff_token>>2;
 468         }
 469     }
 470     sl->non_zero_count_cache[scan8[n]] = total_coeff;
 471
 472     //FIXME set last_non_zero?
 473
 474     if(total_coeff==0)
 475         return 0;
 476     if(total_coeff > (unsigned)max_coeff) {
 477         av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
 478         return -1;
 479     }
 480
 481     trailing_ones= coeff_token&3;
 482     ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
 483     assert(total_coeff<=16);
 484
 485     i = show_bits(gb, 3);
 486     skip_bits(gb, trailing_ones);
 487     level[0] = 1-((i&4)>>1);
 488     level[1] = 1-((i&2)   );
 489     level[2] = 1-((i&1)<<1);
 490
 491     if(trailing_ones<total_coeff) {
 492         int mask, prefix;
 493         int suffix_length = total_coeff > 10 & trailing_ones < 3;
 494         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 495         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
 496
 497         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 498         if(level_code >= 100){
 499             prefix= level_code - 100;
 500             if(prefix == LEVEL_TAB_BITS)
 501                 prefix += get_level_prefix(gb);
 502
 503             //first coefficient has suffix_length equal to 0 or 1
 504             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
 505                 if(suffix_length)
 506                     level_code= (prefix<<1) + get_bits1(gb); //part
 507                 else
 508                     level_code= prefix; //part
 509             }else if(prefix==14){
 510                 if(suffix_length)
 511                     level_code= (prefix<<1) + get_bits1(gb); //part
 512                 else
 513                     level_code= prefix + get_bits(gb, 4); //part
 514             }else{
 515                 level_code= 30 + get_bits(gb, prefix-3); //part
 516                 if(prefix>=16){
 517                     if(prefix > 25+3){
 518                         av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
 519                         return -1;
 520                     }
 521                     level_code += (1<<(prefix-3))-4096;
 522                 }
 523             }
 524
 525             if(trailing_ones < 3) level_code += 2;
 526
 527             suffix_length = 2;
 528             mask= -(level_code&1);
 529             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
 530         }else{
 531             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
 532
 533             suffix_length = 1 + (level_code + 3U > 6U);
 534             level[trailing_ones]= level_code;
 535         }
 536
 537         //remaining coefficients have suffix_length > 0
 538         for(i=trailing_ones+1;i<total_coeff;i++) {
 539             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
 540             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 541             level_code= cavlc_level_tab[suffix_length][bitsi][0];
 542
 543             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 544             if(level_code >= 100){
 545                 prefix= level_code - 100;
 546                 if(prefix == LEVEL_TAB_BITS){
 547                     prefix += get_level_prefix(gb);
 548                 }
 549                 if(prefix<15){
 550                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
 551                 }else{
 552                     level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
 553                     if(prefix>=16)
 554                         level_code += (1<<(prefix-3))-4096;
 555                 }
 556                 mask= -(level_code&1);
 557                 level_code= (((2+level_code)>>1) ^ mask) - mask;
 558             }
 559             level[i]= level_code;
 560             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
 561         }
 562     }
 563
 564     if(total_coeff == max_coeff)
 565         zeros_left=0;
 566     else{
 567         if (max_coeff <= 8) {
 568             if (max_coeff == 4)
 569                 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff - 1].table,
 570                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
 571             else
 572                 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff - 1].table,
 573                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
 574         } else {
 575             zeros_left= get_vlc2(gb, total_zeros_vlc[total_coeff - 1].table, TOTAL_ZEROS_VLC_BITS, 1);
 576         }
 577     }
 578
 579 #define STORE_BLOCK(type) \
 580     scantable += zeros_left + total_coeff - 1; \
 581     if(n >= LUMA_DC_BLOCK_INDEX){ \
 582         ((type*)block)[*scantable] = level[0]; \
 583         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 584             if(zeros_left < 7) \
 585                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 586             else \
 587                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 588             zeros_left -= run_before; \
 589             scantable -= 1 + run_before; \
 590             ((type*)block)[*scantable]= level[i]; \
 591         } \
 592         for(;i<total_coeff;i++) { \
 593             scantable--; \
 594             ((type*)block)[*scantable]= level[i]; \
 595         } \
 596     }else{ \
 597         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
 598         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 599             if(zeros_left < 7) \
 600                 run_before= get_vlc2(gb, run_vlc[zeros_left - 1].table, RUN_VLC_BITS, 1); \
 601             else \
 602                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 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->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->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->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->pps.transform_8x8_mode;
 705     int decode_chroma = h->sps.chroma_format_idc == 1 || h->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     ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->frame_num, sl->mb_x, sl->mb_y);
 711     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
 712                 down the code */
 713     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
 714         if (sl->mb_skip_run == -1)
 715             sl->mb_skip_run = get_ue_golomb(&sl->gb);
 716
 717         if (sl->mb_skip_run--) {
 718             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
 719                 if (sl->mb_skip_run == 0)
 720                     sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 721             }
 722             decode_mb_skip(h, sl);
 723             return 0;
 724         }
 725     }
 726     if (FRAME_MBAFF(h)) {
 727         if ((sl->mb_y & 1) == 0)
 728             sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 729     }
 730
 731     sl->prev_mb_skipped = 0;
 732
 733     mb_type= get_ue_golomb(&sl->gb);
 734     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 735         if(mb_type < 23){
 736             partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
 737             mb_type         = ff_h264_b_mb_type_info[mb_type].type;
 738         }else{
 739             mb_type -= 23;
 740             goto decode_intra_mb;
 741         }
 742     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
 743         if(mb_type < 5){
 744             partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
 745             mb_type         = ff_h264_p_mb_type_info[mb_type].type;
 746         }else{
 747             mb_type -= 5;
 748             goto decode_intra_mb;
 749         }
 750     }else{
 751        assert(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 752         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
 753             mb_type--;
 754 decode_intra_mb:
 755         if(mb_type > 25){
 756             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);
 757             return -1;
 758         }
 759         partition_count=0;
 760         cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
 761         sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
 762         mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
 763     }
 764
 765     if (MB_FIELD(sl))
 766         mb_type |= MB_TYPE_INTERLACED;
 767
 768     h->slice_table[mb_xy] = sl->slice_num;
 769
 770     if(IS_INTRA_PCM(mb_type)){
 771         const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
 772                             h->sps.bit_depth_luma;
 773
 774         // We assume these blocks are very rare so we do not optimize it.
 775         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
 776         if (get_bits_left(&sl->gb) < mb_size) {
 777             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
 778             return AVERROR_INVALIDDATA;
 779         }
 780         skip_bits_long(&sl->gb, mb_size);
 781
 782         // In deblocking, the quantizer is 0
 783         h->cur_pic.qscale_table[mb_xy] = 0;
 784         // All coeffs are present
 785         memset(h->non_zero_count[mb_xy], 16, 48);
 786
 787         h->cur_pic.mb_type[mb_xy] = mb_type;
 788         return 0;
 789     }
 790
 791     fill_decode_neighbors(h, sl, mb_type);
 792     fill_decode_caches(h, sl, mb_type);
 793
 794     //mb_pred
 795     if(IS_INTRA(mb_type)){
 796         int pred_mode;
 797 //            init_top_left_availability(h);
 798         if(IS_INTRA4x4(mb_type)){
 799             int i;
 800             int di = 1;
 801             if(dct8x8_allowed && get_bits1(&sl->gb)){
 802                 mb_type |= MB_TYPE_8x8DCT;
 803                 di = 4;
 804             }
 805
 806 //                fill_intra4x4_pred_table(h);
 807             for(i=0; i<16; i+=di){
 808                 int mode = pred_intra_mode(h, sl, i);
 809
 810                 if(!get_bits1(&sl->gb)){
 811                     const int rem_mode= get_bits(&sl->gb, 3);
 812                     mode = rem_mode + (rem_mode >= mode);
 813                 }
 814
 815                 if(di==4)
 816                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
 817                 else
 818                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
 819             }
 820             write_back_intra_pred_mode(h, sl);
 821             if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
 822                                                  sl->top_samples_available, sl->left_samples_available) < 0)
 823                 return -1;
 824         }else{
 825             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 826                                                                      sl->left_samples_available, sl->intra16x16_pred_mode, 0);
 827             if (sl->intra16x16_pred_mode < 0)
 828                 return -1;
 829         }
 830         if(decode_chroma){
 831             pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 832                                                      sl->left_samples_available, get_ue_golomb_31(&sl->gb), 1);
 833             if(pred_mode < 0)
 834                 return -1;
 835             sl->chroma_pred_mode = pred_mode;
 836         } else {
 837             sl->chroma_pred_mode = DC_128_PRED8x8;
 838         }
 839     }else if(partition_count==4){
 840         int i, j, sub_partition_count[4], list, ref[2][4];
 841
 842         if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 843             for(i=0; i<4; i++){
 844                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
 845                 if(sl->sub_mb_type[i] >=13){
 846                     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);
 847                     return -1;
 848                 }
 849                 sub_partition_count[i] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 850                 sl->sub_mb_type[i]     = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].type;
 851             }
 852             if( IS_DIRECT(sl->sub_mb_type[0]|sl->sub_mb_type[1]|sl->sub_mb_type[2]|sl->sub_mb_type[3])) {
 853                 ff_h264_pred_direct_motion(h, sl, &mb_type);
 854                 sl->ref_cache[0][scan8[4]] =
 855                 sl->ref_cache[1][scan8[4]] =
 856                 sl->ref_cache[0][scan8[12]] =
 857                 sl->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
 858             }
 859         }else{
 860             assert(sl->slice_type_nos == AV_PICTURE_TYPE_P); //FIXME SP correct ?
 861             for(i=0; i<4; i++){
 862                 sl->sub_mb_type[i]= get_ue_golomb_31(&sl->gb);
 863                 if(sl->sub_mb_type[i] >=4){
 864                     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);
 865                     return -1;
 866                 }
 867                 sub_partition_count[i] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 868                 sl->sub_mb_type[i]     = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].type;
 869             }
 870         }
 871
 872         for (list = 0; list < sl->list_count; list++) {
 873             int ref_count = IS_REF0(mb_type) ? 1 : sl->ref_count[list] << MB_MBAFF(sl);
 874             for(i=0; i<4; i++){
 875                 if(IS_DIRECT(sl->sub_mb_type[i])) continue;
 876                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
 877                     unsigned int tmp;
 878                     if(ref_count == 1){
 879                         tmp= 0;
 880                     }else if(ref_count == 2){
 881                         tmp= get_bits1(&sl->gb)^1;
 882                     }else{
 883                         tmp= get_ue_golomb_31(&sl->gb);
 884                         if(tmp>=ref_count){
 885                             av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
 886                             return -1;
 887                         }
 888                     }
 889                     ref[list][i]= tmp;
 890                 }else{
 891                  //FIXME
 892                     ref[list][i] = -1;
 893                 }
 894             }
 895         }
 896
 897         if(dct8x8_allowed)
 898             dct8x8_allowed = get_dct8x8_allowed(h, sl);
 899
 900         for (list = 0; list < sl->list_count; list++) {
 901             for(i=0; i<4; i++){
 902                 if(IS_DIRECT(sl->sub_mb_type[i])) {
 903                     sl->ref_cache[list][ scan8[4*i] ] = sl->ref_cache[list][ scan8[4*i]+1 ];
 904                     continue;
 905                 }
 906                 sl->ref_cache[list][ scan8[4*i]   ]=sl->ref_cache[list][ scan8[4*i]+1 ]=
 907                 sl->ref_cache[list][ scan8[4*i]+8 ]=sl->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
 908
 909                 if(IS_DIR(sl->sub_mb_type[i], 0, list)){
 910                     const int sub_mb_type= sl->sub_mb_type[i];
 911                     const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
 912                     for(j=0; j<sub_partition_count[i]; j++){
 913                         int mx, my;
 914                         const int index= 4*i + block_width*j;
 915                         int16_t (* mv_cache)[2]= &sl->mv_cache[list][ scan8[index] ];
 916                         pred_motion(h, sl, index, block_width, list, sl->ref_cache[list][ scan8[index] ], &mx, &my);
 917                         mx += get_se_golomb(&sl->gb);
 918                         my += get_se_golomb(&sl->gb);
 919                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
 920
 921                         if(IS_SUB_8X8(sub_mb_type)){
 922                             mv_cache[ 1 ][0]=
 923                             mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
 924                             mv_cache[ 1 ][1]=
 925                             mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
 926                         }else if(IS_SUB_8X4(sub_mb_type)){
 927                             mv_cache[ 1 ][0]= mx;
 928                             mv_cache[ 1 ][1]= my;
 929                         }else if(IS_SUB_4X8(sub_mb_type)){
 930                             mv_cache[ 8 ][0]= mx;
 931                             mv_cache[ 8 ][1]= my;
 932                         }
 933                         mv_cache[ 0 ][0]= mx;
 934                         mv_cache[ 0 ][1]= my;
 935                     }
 936                 }else{
 937                     uint32_t *p= (uint32_t *)&sl->mv_cache[list][ scan8[4*i] ][0];
 938                     p[0] = p[1]=
 939                     p[8] = p[9]= 0;
 940                 }
 941             }
 942         }
 943     }else if(IS_DIRECT(mb_type)){
 944         ff_h264_pred_direct_motion(h, sl, &mb_type);
 945         dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
 946     }else{
 947         int list, mx, my, i;
 948          //FIXME we should set ref_idx_l? to 0 if we use that later ...
 949         if(IS_16X16(mb_type)){
 950             for (list = 0; list < sl->list_count; list++) {
 951                     unsigned int val;
 952                     if(IS_DIR(mb_type, 0, list)){
 953                         int rc = sl->ref_count[list] << MB_MBAFF(sl);
 954                         if (rc == 1) {
 955                             val= 0;
 956                         } else if (rc == 2) {
 957                             val= get_bits1(&sl->gb)^1;
 958                         }else{
 959                             val= get_ue_golomb_31(&sl->gb);
 960                             if (val >= rc) {
 961                                 av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
 962                                 return -1;
 963                             }
 964                         }
 965                     fill_rectangle(&sl->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
 966                     }
 967             }
 968             for (list = 0; list < sl->list_count; list++) {
 969                 if(IS_DIR(mb_type, 0, list)){
 970                     pred_motion(h, sl, 0, 4, list, sl->ref_cache[list][ scan8[0] ], &mx, &my);
 971                     mx += get_se_golomb(&sl->gb);
 972                     my += get_se_golomb(&sl->gb);
 973                     ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
 974
 975                     fill_rectangle(sl->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
 976                 }
 977             }
 978         }
 979         else if(IS_16X8(mb_type)){
 980             for (list = 0; list < sl->list_count; list++) {
 981                     for(i=0; i<2; i++){
 982                         unsigned int val;
 983                         if(IS_DIR(mb_type, i, list)){
 984                             int rc = sl->ref_count[list] << MB_MBAFF(sl);
 985                             if (rc == 1) {
 986                                 val= 0;
 987                             } else if (rc == 2) {
 988                                 val= get_bits1(&sl->gb)^1;
 989                             }else{
 990                                 val= get_ue_golomb_31(&sl->gb);
 991                                 if (val >= rc) {
 992                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
 993                                     return -1;
 994                                 }
 995                             }
 996                         }else
 997                             val= LIST_NOT_USED&0xFF;
 998                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
 999                     }
1000             }
1001             for (list = 0; list < sl->list_count; list++) {
1002                 for(i=0; i<2; i++){
1003                     unsigned int val;
1004                     if(IS_DIR(mb_type, i, list)){
1005                         pred_16x8_motion(h, sl, 8*i, list, sl->ref_cache[list][scan8[0] + 16*i], &mx, &my);
1006                         mx += get_se_golomb(&sl->gb);
1007                         my += get_se_golomb(&sl->gb);
1008                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1009
1010                         val= pack16to32(mx,my);
1011                     }else
1012                         val=0;
1013                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
1014                 }
1015             }
1016         }else{
1017             assert(IS_8X16(mb_type));
1018             for (list = 0; list < sl->list_count; list++) {
1019                     for(i=0; i<2; i++){
1020                         unsigned int val;
1021                         if(IS_DIR(mb_type, i, list)){ //FIXME optimize
1022                             int rc = sl->ref_count[list] << MB_MBAFF(sl);
1023                             if (rc == 1) {
1024                                 val= 0;
1025                             } else if (rc == 2) {
1026                                 val= get_bits1(&sl->gb)^1;
1027                             }else{
1028                                 val= get_ue_golomb_31(&sl->gb);
1029                                 if (val >= rc) {
1030                                     av_log(h->avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
1031                                     return -1;
1032                                 }
1033                             }
1034                         }else
1035                             val= LIST_NOT_USED&0xFF;
1036                         fill_rectangle(&sl->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
1037                     }
1038             }
1039             for (list = 0; list < sl->list_count; list++) {
1040                 for(i=0; i<2; i++){
1041                     unsigned int val;
1042                     if(IS_DIR(mb_type, i, list)){
1043                         pred_8x16_motion(h, sl, i*4, list, sl->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
1044                         mx += get_se_golomb(&sl->gb);
1045                         my += get_se_golomb(&sl->gb);
1046                         ff_tlog(h->avctx, "final mv:%d %d\n", mx, my);
1047
1048                         val= pack16to32(mx,my);
1049                     }else
1050                         val=0;
1051                     fill_rectangle(sl->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
1052                 }
1053             }
1054         }
1055     }
1056
1057     if(IS_INTER(mb_type))
1058         write_back_motion(h, sl, mb_type);
1059
1060     if(!IS_INTRA16x16(mb_type)){
1061         cbp= get_ue_golomb(&sl->gb);
1062
1063         if(decode_chroma){
1064             if(cbp > 47){
1065                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1066                 return -1;
1067             }
1068             if (IS_INTRA4x4(mb_type))
1069                 cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1070             else
1071                 cbp = ff_h264_golomb_to_inter_cbp[cbp];
1072         }else{
1073             if(cbp > 15){
1074                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1075                 return -1;
1076             }
1077             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1078             else                     cbp= golomb_to_inter_cbp_gray[cbp];
1079         }
1080     }
1081
1082     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1083         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1084     }
1085     sl->cbp=
1086     h->cbp_table[mb_xy]= cbp;
1087     h->cur_pic.mb_type[mb_xy] = mb_type;
1088
1089     if(cbp || IS_INTRA16x16(mb_type)){
1090         int i4x4, i8x8, chroma_idx;
1091         int dquant;
1092         int ret;
1093         GetBitContext *gb = &sl->gb;
1094         const uint8_t *scan, *scan8x8;
1095         const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
1096
1097         if(IS_INTERLACED(mb_type)){
1098             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1099             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1100         }else{
1101             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1102             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1103         }
1104
1105         dquant= get_se_golomb(&sl->gb);
1106
1107         sl->qscale += dquant;
1108
1109         if (((unsigned)sl->qscale) > max_qp){
1110             if (sl->qscale < 0) sl->qscale += max_qp + 1;
1111             else                sl->qscale -= max_qp+1;
1112             if (((unsigned)sl->qscale) > max_qp){
1113                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1114                 return -1;
1115             }
1116         }
1117
1118         sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
1119         sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
1120
1121         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1122             return -1;
1123         }
1124         h->cbp_table[mb_xy] |= ret << 12;
1125         if (CHROMA444(h)) {
1126             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1127                 return -1;
1128             }
1129             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1130                 return -1;
1131             }
1132         } else if (CHROMA422(h)) {
1133             if(cbp&0x30){
1134                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1135                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1136                                         CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_chroma422_dc_scan,
1137                                         NULL, 8) < 0) {
1138                         return -1;
1139                     }
1140             }
1141
1142             if(cbp&0x20){
1143                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1144                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1145                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1146                     for (i8x8 = 0; i8x8 < 2; i8x8++) {
1147                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
1148                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1149                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1150                                 return -1;
1151                             mb += 16 << pixel_shift;
1152                         }
1153                     }
1154                 }
1155             }else{
1156                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1157                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1158             }
1159         } else /* yuv420 */ {
1160             if(cbp&0x30){
1161                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1162                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16 * 16 * chroma_idx) << pixel_shift),
1163                                         CHROMA_DC_BLOCK_INDEX + chroma_idx, ff_h264_chroma_dc_scan, NULL, 4) < 0) {
1164                         return -1;
1165                     }
1166             }
1167
1168             if(cbp&0x20){
1169                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1170                     const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1171                     for(i4x4=0; i4x4<4; i4x4++){
1172                         const int index= 16 + 16*chroma_idx + i4x4;
1173                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
1174                             return -1;
1175                         }
1176                     }
1177                 }
1178             }else{
1179                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1180                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1181             }
1182         }
1183     }else{
1184         fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1185         fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1186         fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1187     }
1188     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1189     write_back_non_zero_count(h, sl);
1190
1191     return 0;
1192 }