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 / MPEG-4 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 "h264dec.h"
  34 #include "h264_mvpred.h"
  35 #include "h264data.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+1];
 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+1];
 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+1];
 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+1];
 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 {
 329     int offset;
 330
 331     chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
 332     chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
 333     init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
 334              &chroma_dc_coeff_token_len [0], 1, 1,
 335              &chroma_dc_coeff_token_bits[0], 1, 1,
 336              INIT_VLC_USE_NEW_STATIC);
 337
 338     chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
 339     chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
 340     init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
 341              &chroma422_dc_coeff_token_len [0], 1, 1,
 342              &chroma422_dc_coeff_token_bits[0], 1, 1,
 343              INIT_VLC_USE_NEW_STATIC);
 344
 345     offset = 0;
 346     for (int i = 0; i < 4; i++) {
 347         coeff_token_vlc[i].table = coeff_token_vlc_tables + offset;
 348         coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
 349         init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
 350                  &coeff_token_len [i][0], 1, 1,
 351                  &coeff_token_bits[i][0], 1, 1,
 352                  INIT_VLC_USE_NEW_STATIC);
 353         offset += coeff_token_vlc_tables_size[i];
 354     }
 355     /*
 356      * This is a one time safety check to make sure that
 357      * the packed static coeff_token_vlc table sizes
 358      * were initialized correctly.
 359      */
 360     av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
 361
 362     for (int i = 0; i < 3; i++) {
 363         chroma_dc_total_zeros_vlc[i + 1].table = chroma_dc_total_zeros_vlc_tables[i];
 364         chroma_dc_total_zeros_vlc[i + 1].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
 365         init_vlc(&chroma_dc_total_zeros_vlc[i + 1],
 366                  CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
 367                  &chroma_dc_total_zeros_len [i][0], 1, 1,
 368                  &chroma_dc_total_zeros_bits[i][0], 1, 1,
 369                  INIT_VLC_USE_NEW_STATIC);
 370     }
 371
 372     for (int i = 0; i < 7; i++) {
 373         chroma422_dc_total_zeros_vlc[i + 1].table = chroma422_dc_total_zeros_vlc_tables[i];
 374         chroma422_dc_total_zeros_vlc[i + 1].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
 375         init_vlc(&chroma422_dc_total_zeros_vlc[i + 1],
 376                  CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
 377                  &chroma422_dc_total_zeros_len [i][0], 1, 1,
 378                  &chroma422_dc_total_zeros_bits[i][0], 1, 1,
 379                  INIT_VLC_USE_NEW_STATIC);
 380     }
 381
 382     for (int i = 0; i < 15; i++) {
 383         total_zeros_vlc[i + 1].table = total_zeros_vlc_tables[i];
 384         total_zeros_vlc[i + 1].table_allocated = total_zeros_vlc_tables_size;
 385         init_vlc(&total_zeros_vlc[i + 1],
 386                  TOTAL_ZEROS_VLC_BITS, 16,
 387                  &total_zeros_len [i][0], 1, 1,
 388                  &total_zeros_bits[i][0], 1, 1,
 389                  INIT_VLC_USE_NEW_STATIC);
 390     }
 391
 392     for (int i = 0; i < 6; i++) {
 393         run_vlc[i + 1].table = run_vlc_tables[i];
 394         run_vlc[i + 1].table_allocated = run_vlc_tables_size;
 395         init_vlc(&run_vlc[i + 1],
 396                  RUN_VLC_BITS, 7,
 397                  &run_len [i][0], 1, 1,
 398                  &run_bits[i][0], 1, 1,
 399                  INIT_VLC_USE_NEW_STATIC);
 400     }
 401     run7_vlc.table = run7_vlc_table;
 402     run7_vlc.table_allocated = run7_vlc_table_size;
 403     init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
 404              &run_len [6][0], 1, 1,
 405              &run_bits[6][0], 1, 1,
 406              INIT_VLC_USE_NEW_STATIC);
 407
 408     init_cavlc_level_tab();
 409 }
 410
 411 static inline int get_level_prefix(GetBitContext *gb){
 412     unsigned int buf;
 413     int log;
 414
 415     OPEN_READER(re, gb);
 416     UPDATE_CACHE(re, gb);
 417     buf=GET_CACHE(re, gb);
 418
 419     log= 32 - av_log2(buf);
 420
 421     LAST_SKIP_BITS(re, gb, log);
 422     CLOSE_READER(re, gb);
 423
 424     return log-1;
 425 }
 426
 427 /**
 428  * Decode a residual block.
 429  * @param n block index
 430  * @param scantable scantable
 431  * @param max_coeff number of coefficients in the block
 432  * @return <0 if an error occurred
 433  */
 434 static int decode_residual(const H264Context *h, H264SliceContext *sl,
 435                            GetBitContext *gb, int16_t *block, int n,
 436                            const uint8_t *scantable, const uint32_t *qmul,
 437                            int max_coeff)
 438 {
 439     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};
 440     int level[16];
 441     int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
 442
 443     //FIXME put trailing_onex into the context
 444
 445     if(max_coeff <= 8){
 446         if (max_coeff == 4)
 447             coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
 448         else
 449             coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
 450         total_coeff= coeff_token>>2;
 451     }else{
 452         if(n >= LUMA_DC_BLOCK_INDEX){
 453             total_coeff= pred_non_zero_count(h, sl, (n - LUMA_DC_BLOCK_INDEX)*16);
 454             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
 455             total_coeff= coeff_token>>2;
 456         }else{
 457             total_coeff= pred_non_zero_count(h, sl, n);
 458             coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
 459             total_coeff= coeff_token>>2;
 460         }
 461     }
 462     sl->non_zero_count_cache[scan8[n]] = total_coeff;
 463
 464     //FIXME set last_non_zero?
 465
 466     if(total_coeff==0)
 467         return 0;
 468     if(total_coeff > (unsigned)max_coeff) {
 469         av_log(h->avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", sl->mb_x, sl->mb_y, total_coeff);
 470         return -1;
 471     }
 472
 473     trailing_ones= coeff_token&3;
 474     ff_tlog(h->avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
 475     av_assert2(total_coeff<=16);
 476
 477     i = show_bits(gb, 3);
 478     skip_bits(gb, trailing_ones);
 479     level[0] = 1-((i&4)>>1);
 480     level[1] = 1-((i&2)   );
 481     level[2] = 1-((i&1)<<1);
 482
 483     if(trailing_ones<total_coeff) {
 484         int mask, prefix;
 485         int suffix_length = total_coeff > 10 & trailing_ones < 3;
 486         int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 487         int level_code= cavlc_level_tab[suffix_length][bitsi][0];
 488
 489         skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 490         if(level_code >= 100){
 491             prefix= level_code - 100;
 492             if(prefix == LEVEL_TAB_BITS)
 493                 prefix += get_level_prefix(gb);
 494
 495             //first coefficient has suffix_length equal to 0 or 1
 496             if(prefix<14){ //FIXME try to build a large unified VLC table for all this
 497                 if(suffix_length)
 498                     level_code= (prefix<<1) + get_bits1(gb); //part
 499                 else
 500                     level_code= prefix; //part
 501             }else if(prefix==14){
 502                 if(suffix_length)
 503                     level_code= (prefix<<1) + get_bits1(gb); //part
 504                 else
 505                     level_code= prefix + get_bits(gb, 4); //part
 506             }else{
 507                 level_code= 30;
 508                 if(prefix>=16){
 509                     if(prefix > 25+3){
 510                         av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
 511                         return -1;
 512                     }
 513                     level_code += (1<<(prefix-3))-4096;
 514                 }
 515                 level_code += get_bits(gb, prefix-3); //part
 516             }
 517
 518             if(trailing_ones < 3) level_code += 2;
 519
 520             suffix_length = 2;
 521             mask= -(level_code&1);
 522             level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
 523         }else{
 524             level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
 525
 526             suffix_length = 1 + (level_code + 3U > 6U);
 527             level[trailing_ones]= level_code;
 528         }
 529
 530         //remaining coefficients have suffix_length > 0
 531         for(i=trailing_ones+1;i<total_coeff;i++) {
 532             static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
 533             int bitsi= show_bits(gb, LEVEL_TAB_BITS);
 534             level_code= cavlc_level_tab[suffix_length][bitsi][0];
 535
 536             skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
 537             if(level_code >= 100){
 538                 prefix= level_code - 100;
 539                 if(prefix == LEVEL_TAB_BITS){
 540                     prefix += get_level_prefix(gb);
 541                 }
 542                 if(prefix<15){
 543                     level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
 544                 }else{
 545                     level_code = 15<<suffix_length;
 546                     if (prefix>=16) {
 547                         if(prefix > 25+3){
 548                             av_log(h->avctx, AV_LOG_ERROR, "Invalid level prefix\n");
 549                             return AVERROR_INVALIDDATA;
 550                         }
 551                         level_code += (1<<(prefix-3))-4096;
 552                     }
 553                     level_code += get_bits(gb, prefix-3);
 554                 }
 555                 mask= -(level_code&1);
 556                 level_code= (((2+level_code)>>1) ^ mask) - mask;
 557             }
 558             level[i]= level_code;
 559             suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
 560         }
 561     }
 562
 563     if(total_coeff == max_coeff)
 564         zeros_left=0;
 565     else{
 566         if (max_coeff <= 8) {
 567             if (max_coeff == 4)
 568                 zeros_left = get_vlc2(gb, chroma_dc_total_zeros_vlc[total_coeff].table,
 569                                       CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
 570             else
 571                 zeros_left = get_vlc2(gb, chroma422_dc_total_zeros_vlc[total_coeff].table,
 572                                       CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
 573         } else {
 574             zeros_left= get_vlc2(gb, total_zeros_vlc[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
 575         }
 576     }
 577
 578 #define STORE_BLOCK(type) \
 579     scantable += zeros_left + total_coeff - 1; \
 580     if(n >= LUMA_DC_BLOCK_INDEX){ \
 581         ((type*)block)[*scantable] = level[0]; \
 582         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 583             if(zeros_left < 7) \
 584                 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
 585             else \
 586                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 587             zeros_left -= run_before; \
 588             scantable -= 1 + run_before; \
 589             ((type*)block)[*scantable]= level[i]; \
 590         } \
 591         for(;i<total_coeff;i++) { \
 592             scantable--; \
 593             ((type*)block)[*scantable]= level[i]; \
 594         } \
 595     }else{ \
 596         ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
 597         for(i=1;i<total_coeff && zeros_left > 0;i++) { \
 598             if(zeros_left < 7) \
 599                 run_before= get_vlc2(gb, run_vlc[zeros_left].table, RUN_VLC_BITS, 1); \
 600             else \
 601                 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
 602             zeros_left -= run_before; \
 603             scantable -= 1 + run_before; \
 604             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
 605         } \
 606         for(;i<total_coeff;i++) { \
 607             scantable--; \
 608             ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
 609         } \
 610     }
 611
 612     if (h->pixel_shift) {
 613         STORE_BLOCK(int32_t)
 614     } else {
 615         STORE_BLOCK(int16_t)
 616     }
 617
 618     if(zeros_left<0){
 619         av_log(h->avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", sl->mb_x, sl->mb_y);
 620         return -1;
 621     }
 622
 623     return 0;
 624 }
 625
 626 static av_always_inline
 627 int decode_luma_residual(const H264Context *h, H264SliceContext *sl,
 628                          GetBitContext *gb, const uint8_t *scan,
 629                          const uint8_t *scan8x8, int pixel_shift,
 630                          int mb_type, int cbp, int p)
 631 {
 632     int i4x4, i8x8;
 633     int qscale = p == 0 ? sl->qscale : sl->chroma_qp[p - 1];
 634     if(IS_INTRA16x16(mb_type)){
 635         AV_ZERO128(sl->mb_luma_dc[p]+0);
 636         AV_ZERO128(sl->mb_luma_dc[p]+8);
 637         AV_ZERO128(sl->mb_luma_dc[p]+16);
 638         AV_ZERO128(sl->mb_luma_dc[p]+24);
 639         if (decode_residual(h, sl, gb, sl->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX + p, scan, NULL, 16) < 0) {
 640             return -1; //FIXME continue if partitioned and other return -1 too
 641         }
 642
 643         av_assert2((cbp&15) == 0 || (cbp&15) == 15);
 644
 645         if(cbp&15){
 646             for(i8x8=0; i8x8<4; i8x8++){
 647                 for(i4x4=0; i4x4<4; i4x4++){
 648                     const int index= i4x4 + 4*i8x8 + p*16;
 649                     if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift),
 650                         index, scan + 1, h->ps.pps->dequant4_coeff[p][qscale], 15) < 0 ){
 651                         return -1;
 652                     }
 653                 }
 654             }
 655             return 0xf;
 656         }else{
 657             fill_rectangle(&sl->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
 658             return 0;
 659         }
 660     }else{
 661         int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
 662         /* For CAVLC 4:4:4, we need to keep track of the luma 8x8 CBP for deblocking nnz purposes. */
 663         int new_cbp = 0;
 664         for(i8x8=0; i8x8<4; i8x8++){
 665             if(cbp & (1<<i8x8)){
 666                 if(IS_8x8DCT(mb_type)){
 667                     int16_t *buf = &sl->mb[64*i8x8+256*p << pixel_shift];
 668                     uint8_t *nnz;
 669                     for(i4x4=0; i4x4<4; i4x4++){
 670                         const int index= i4x4 + 4*i8x8 + p*16;
 671                         if( decode_residual(h, sl, gb, buf, index, scan8x8+16*i4x4,
 672                                             h->ps.pps->dequant8_coeff[cqm][qscale], 16) < 0 )
 673                             return -1;
 674                     }
 675                     nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
 676                     nnz[0] += nnz[1] + nnz[8] + nnz[9];
 677                     new_cbp |= !!nnz[0] << i8x8;
 678                 }else{
 679                     for(i4x4=0; i4x4<4; i4x4++){
 680                         const int index= i4x4 + 4*i8x8 + p*16;
 681                         if( decode_residual(h, sl, gb, sl->mb + (16*index << pixel_shift), index,
 682                                             scan, h->ps.pps->dequant4_coeff[cqm][qscale], 16) < 0 ){
 683                             return -1;
 684                         }
 685                         new_cbp |= sl->non_zero_count_cache[scan8[index]] << i8x8;
 686                     }
 687                 }
 688             }else{
 689                 uint8_t * const nnz = &sl->non_zero_count_cache[scan8[4 * i8x8 + p * 16]];
 690                 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
 691             }
 692         }
 693         return new_cbp;
 694     }
 695 }
 696
 697 int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
 698 {
 699     int mb_xy;
 700     int partition_count;
 701     unsigned int mb_type, cbp;
 702     int dct8x8_allowed = h->ps.pps->transform_8x8_mode;
 703     const int decode_chroma = h->ps.sps->chroma_format_idc == 1 || h->ps.sps->chroma_format_idc == 2;
 704     const int pixel_shift = h->pixel_shift;
 705
 706     mb_xy = sl->mb_xy = sl->mb_x + sl->mb_y*h->mb_stride;
 707
 708     ff_tlog(h->avctx, "pic:%d mb:%d/%d\n", h->poc.frame_num, sl->mb_x, sl->mb_y);
 709     cbp = 0; /* avoid warning. FIXME: find a solution without slowing
 710                 down the code */
 711     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
 712         if (sl->mb_skip_run == -1) {
 713             unsigned mb_skip_run = get_ue_golomb_long(&sl->gb);
 714             if (mb_skip_run > h->mb_num) {
 715                 av_log(h->avctx, AV_LOG_ERROR, "mb_skip_run %d is invalid\n", mb_skip_run);
 716                 return AVERROR_INVALIDDATA;
 717             }
 718             sl->mb_skip_run = mb_skip_run;
 719         }
 720
 721         if (sl->mb_skip_run--) {
 722             if (FRAME_MBAFF(h) && (sl->mb_y & 1) == 0) {
 723                 if (sl->mb_skip_run == 0)
 724                     sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 725             }
 726             decode_mb_skip(h, sl);
 727             return 0;
 728         }
 729     }
 730     if (FRAME_MBAFF(h)) {
 731         if ((sl->mb_y & 1) == 0)
 732             sl->mb_mbaff = sl->mb_field_decoding_flag = get_bits1(&sl->gb);
 733     }
 734
 735     sl->prev_mb_skipped = 0;
 736
 737     mb_type= get_ue_golomb(&sl->gb);
 738     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
 739         if(mb_type < 23){
 740             partition_count = ff_h264_b_mb_type_info[mb_type].partition_count;
 741             mb_type         = ff_h264_b_mb_type_info[mb_type].type;
 742         }else{
 743             mb_type -= 23;
 744             goto decode_intra_mb;
 745         }
 746     } else if (sl->slice_type_nos == AV_PICTURE_TYPE_P) {
 747         if(mb_type < 5){
 748             partition_count = ff_h264_p_mb_type_info[mb_type].partition_count;
 749             mb_type         = ff_h264_p_mb_type_info[mb_type].type;
 750         }else{
 751             mb_type -= 5;
 752             goto decode_intra_mb;
 753         }
 754     }else{
 755        av_assert2(sl->slice_type_nos == AV_PICTURE_TYPE_I);
 756         if (sl->slice_type == AV_PICTURE_TYPE_SI && mb_type)
 757             mb_type--;
 758 decode_intra_mb:
 759         if(mb_type > 25){
 760             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);
 761             return -1;
 762         }
 763         partition_count=0;
 764         cbp                      = ff_h264_i_mb_type_info[mb_type].cbp;
 765         sl->intra16x16_pred_mode = ff_h264_i_mb_type_info[mb_type].pred_mode;
 766         mb_type                  = ff_h264_i_mb_type_info[mb_type].type;
 767     }
 768
 769     if (MB_FIELD(sl))
 770         mb_type |= MB_TYPE_INTERLACED;
 771
 772     h->slice_table[mb_xy] = sl->slice_num;
 773
 774     if(IS_INTRA_PCM(mb_type)){
 775         const int mb_size = ff_h264_mb_sizes[h->ps.sps->chroma_format_idc] *
 776                             h->ps.sps->bit_depth_luma;
 777
 778         // We assume these blocks are very rare so we do not optimize it.
 779         sl->intra_pcm_ptr = align_get_bits(&sl->gb);
 780         if (get_bits_left(&sl->gb) < mb_size) {
 781             av_log(h->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
 782             return AVERROR_INVALIDDATA;
 783         }
 784         skip_bits_long(&sl->gb, mb_size);
 785
 786         // In deblocking, the quantizer is 0
 787         h->cur_pic.qscale_table[mb_xy] = 0;
 788         // All coeffs are present
 789         memset(h->non_zero_count[mb_xy], 16, 48);
 790
 791         h->cur_pic.mb_type[mb_xy] = mb_type;
 792         return 0;
 793     }
 794
 795     fill_decode_neighbors(h, sl, mb_type);
 796     fill_decode_caches(h, sl, mb_type);
 797
 798     //mb_pred
 799     if(IS_INTRA(mb_type)){
 800         int pred_mode;
 801 //            init_top_left_availability(h);
 802         if(IS_INTRA4x4(mb_type)){
 803             int i;
 804             int di = 1;
 805             if(dct8x8_allowed && get_bits1(&sl->gb)){
 806                 mb_type |= MB_TYPE_8x8DCT;
 807                 di = 4;
 808             }
 809
 810 //                fill_intra4x4_pred_table(h);
 811             for(i=0; i<16; i+=di){
 812                 int mode = pred_intra_mode(h, sl, i);
 813
 814                 if(!get_bits1(&sl->gb)){
 815                     const int rem_mode= get_bits(&sl->gb, 3);
 816                     mode = rem_mode + (rem_mode >= mode);
 817                 }
 818
 819                 if(di==4)
 820                     fill_rectangle(&sl->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1);
 821                 else
 822                     sl->intra4x4_pred_mode_cache[scan8[i]] = mode;
 823             }
 824             write_back_intra_pred_mode(h, sl);
 825             if (ff_h264_check_intra4x4_pred_mode(sl->intra4x4_pred_mode_cache, h->avctx,
 826                                                  sl->top_samples_available, sl->left_samples_available) < 0)
 827                 return -1;
 828         }else{
 829             sl->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 830                                                                      sl->left_samples_available, sl->intra16x16_pred_mode, 0);
 831             if (sl->intra16x16_pred_mode < 0)
 832                 return -1;
 833         }
 834         if(decode_chroma){
 835             pred_mode= ff_h264_check_intra_pred_mode(h->avctx, sl->top_samples_available,
 836                                                      sl->left_samples_available, 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] = ff_h264_b_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 854                 sl->sub_mb_type[i]     = ff_h264_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] = ff_h264_p_sub_mb_type_info[sl->sub_mb_type[i]].partition_count;
 872                 sl->sub_mb_type[i]     = ff_h264_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 += (unsigned)get_se_golomb(&sl->gb);
 922                         my += (unsigned)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->ps.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 += (unsigned)get_se_golomb(&sl->gb);
 976                     my += (unsigned)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 += (unsigned)get_se_golomb(&sl->gb);
1011                         my += (unsigned)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 += (unsigned)get_se_golomb(&sl->gb);
1049                         my += (unsigned)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))
1073                 cbp = ff_h264_golomb_to_intra4x4_cbp[cbp];
1074             else
1075                 cbp = ff_h264_golomb_to_inter_cbp[cbp];
1076         }else{
1077             if(cbp > 15){
1078                 av_log(h->avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, sl->mb_x, sl->mb_y);
1079                 return -1;
1080             }
1081             if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
1082             else                     cbp= golomb_to_inter_cbp_gray[cbp];
1083         }
1084     } else {
1085         if (!decode_chroma && cbp>15) {
1086             av_log(h->avctx, AV_LOG_ERROR, "gray chroma\n");
1087             return AVERROR_INVALIDDATA;
1088         }
1089     }
1090
1091     if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
1092         mb_type |= MB_TYPE_8x8DCT*get_bits1(&sl->gb);
1093     }
1094     sl->cbp=
1095     h->cbp_table[mb_xy]= cbp;
1096     h->cur_pic.mb_type[mb_xy] = mb_type;
1097
1098     if(cbp || IS_INTRA16x16(mb_type)){
1099         int i4x4, i8x8, chroma_idx;
1100         int dquant;
1101         int ret;
1102         GetBitContext *gb = &sl->gb;
1103         const uint8_t *scan, *scan8x8;
1104         const int max_qp = 51 + 6 * (h->ps.sps->bit_depth_luma - 8);
1105
1106         dquant= get_se_golomb(&sl->gb);
1107
1108         sl->qscale += (unsigned)dquant;
1109
1110         if (((unsigned)sl->qscale) > max_qp){
1111             if (sl->qscale < 0) sl->qscale += max_qp + 1;
1112             else                sl->qscale -= max_qp+1;
1113             if (((unsigned)sl->qscale) > max_qp){
1114                 av_log(h->avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, sl->mb_x, sl->mb_y);
1115                 sl->qscale = max_qp;
1116                 return -1;
1117             }
1118         }
1119
1120         sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
1121         sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
1122
1123         if(IS_INTERLACED(mb_type)){
1124             scan8x8 = sl->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
1125             scan    = sl->qscale ? h->field_scan : h->field_scan_q0;
1126         }else{
1127             scan8x8 = sl->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
1128             scan    = sl->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
1129         }
1130
1131         if ((ret = decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ) {
1132             return -1;
1133         }
1134         h->cbp_table[mb_xy] |= ret << 12;
1135         if (CHROMA444(h)) {
1136             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ) {
1137                 return -1;
1138             }
1139             if (decode_luma_residual(h, sl, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ) {
1140                 return -1;
1141             }
1142         } else {
1143             const int num_c8x8 = h->ps.sps->chroma_format_idc;
1144
1145             if(cbp&0x30){
1146                 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
1147                     if (decode_residual(h, sl, gb, sl->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
1148                                         CHROMA_DC_BLOCK_INDEX + chroma_idx,
1149                                         CHROMA422(h) ? ff_h264_chroma422_dc_scan : ff_h264_chroma_dc_scan,
1150                                         NULL, 4 * num_c8x8) < 0) {
1151                         return -1;
1152                     }
1153             }
1154
1155             if(cbp&0x20){
1156                 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
1157                     const uint32_t *qmul = h->ps.pps->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][sl->chroma_qp[chroma_idx]];
1158                     int16_t *mb = sl->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
1159                     for (i8x8 = 0; i8x8<num_c8x8; i8x8++) {
1160                         for (i4x4 = 0; i4x4 < 4; i4x4++) {
1161                             const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
1162                             if (decode_residual(h, sl, gb, mb, index, scan + 1, qmul, 15) < 0)
1163                                 return -1;
1164                             mb += 16 << pixel_shift;
1165                         }
1166                     }
1167                 }
1168             }else{
1169                 fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1170                 fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1171             }
1172         }
1173     }else{
1174         fill_rectangle(&sl->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
1175         fill_rectangle(&sl->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
1176         fill_rectangle(&sl->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
1177     }
1178     h->cur_pic.qscale_table[mb_xy] = sl->qscale;
1179     write_back_non_zero_count(h, sl);
1180
1181     return 0;
1182 }