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