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

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