00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00028 #define CABAC 0
00029 #define UNCHECKED_BITSTREAM_READER 1
00030
00031 #include "internal.h"
00032 #include "avcodec.h"
00033 #include "mpegvideo.h"
00034 #include "h264.h"
00035 #include "h264data.h"
00036 #include "h264_mvpred.h"
00037 #include "golomb.h"
00038 #include "libavutil/avassert.h"
00039
00040
00041 static const uint8_t golomb_to_inter_cbp_gray[16]={
00042 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
00043 };
00044
00045 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
00046 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
00047 };
00048
00049 static const uint8_t chroma_dc_coeff_token_len[4*5]={
00050 2, 0, 0, 0,
00051 6, 1, 0, 0,
00052 6, 6, 3, 0,
00053 6, 7, 7, 6,
00054 6, 8, 8, 7,
00055 };
00056
00057 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
00058 1, 0, 0, 0,
00059 7, 1, 0, 0,
00060 4, 6, 1, 0,
00061 3, 3, 2, 5,
00062 2, 3, 2, 0,
00063 };
00064
00065 static const uint8_t chroma422_dc_coeff_token_len[4*9]={
00066 1, 0, 0, 0,
00067 7, 2, 0, 0,
00068 7, 7, 3, 0,
00069 9, 7, 7, 5,
00070 9, 9, 7, 6,
00071 10, 10, 9, 7,
00072 11, 11, 10, 7,
00073 12, 12, 11, 10,
00074 13, 12, 12, 11,
00075 };
00076
00077 static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
00078 1, 0, 0, 0,
00079 15, 1, 0, 0,
00080 14, 13, 1, 0,
00081 7, 12, 11, 1,
00082 6, 5, 10, 1,
00083 7, 6, 4, 9,
00084 7, 6, 5, 8,
00085 7, 6, 5, 4,
00086 7, 5, 4, 4,
00087 };
00088
00089 static const uint8_t coeff_token_len[4][4*17]={
00090 {
00091 1, 0, 0, 0,
00092 6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
00093 11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
00094 14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
00095 16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
00096 },
00097 {
00098 2, 0, 0, 0,
00099 6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
00100 8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
00101 12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
00102 13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
00103 },
00104 {
00105 4, 0, 0, 0,
00106 6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
00107 7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
00108 8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
00109 10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
00110 },
00111 {
00112 6, 0, 0, 0,
00113 6, 6, 0, 0, 6, 6, 6, 0, 6, 6, 6, 6, 6, 6, 6, 6,
00114 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00115 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00116 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00117 }
00118 };
00119
00120 static const uint8_t coeff_token_bits[4][4*17]={
00121 {
00122 1, 0, 0, 0,
00123 5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
00124 7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
00125 15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
00126 15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
00127 },
00128 {
00129 3, 0, 0, 0,
00130 11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
00131 4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
00132 15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
00133 11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
00134 },
00135 {
00136 15, 0, 0, 0,
00137 15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
00138 11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
00139 11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
00140 13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
00141 },
00142 {
00143 3, 0, 0, 0,
00144 0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
00145 16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
00146 32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
00147 48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
00148 }
00149 };
00150
00151 static const uint8_t total_zeros_len[16][16]= {
00152 {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
00153 {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
00154 {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
00155 {5,3,4,4,3,3,3,4,3,4,5,5,5},
00156 {4,4,4,3,3,3,3,3,4,5,4,5},
00157 {6,5,3,3,3,3,3,3,4,3,6},
00158 {6,5,3,3,3,2,3,4,3,6},
00159 {6,4,5,3,2,2,3,3,6},
00160 {6,6,4,2,2,3,2,5},
00161 {5,5,3,2,2,2,4},
00162 {4,4,3,3,1,3},
00163 {4,4,2,1,3},
00164 {3,3,1,2},
00165 {2,2,1},
00166 {1,1},
00167 };
00168
00169 static const uint8_t total_zeros_bits[16][16]= {
00170 {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
00171 {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
00172 {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
00173 {3,7,5,4,6,5,4,3,3,2,2,1,0},
00174 {5,4,3,7,6,5,4,3,2,1,1,0},
00175 {1,1,7,6,5,4,3,2,1,1,0},
00176 {1,1,5,4,3,3,2,1,1,0},
00177 {1,1,1,3,3,2,2,1,0},
00178 {1,0,1,3,2,1,1,1},
00179 {1,0,1,3,2,1,1},
00180 {0,1,1,2,1,3},
00181 {0,1,1,1,1},
00182 {0,1,1,1},
00183 {0,1,1},
00184 {0,1},
00185 };
00186
00187 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
00188 { 1, 2, 3, 3,},
00189 { 1, 2, 2, 0,},
00190 { 1, 1, 0, 0,},
00191 };
00192
00193 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
00194 { 1, 1, 1, 0,},
00195 { 1, 1, 0, 0,},
00196 { 1, 0, 0, 0,},
00197 };
00198
00199 static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
00200 { 1, 3, 3, 4, 4, 4, 5, 5 },
00201 { 3, 2, 3, 3, 3, 3, 3 },
00202 { 3, 3, 2, 2, 3, 3 },
00203 { 3, 2, 2, 2, 3 },
00204 { 2, 2, 2, 2 },
00205 { 2, 2, 1 },
00206 { 1, 1 },
00207 };
00208
00209 static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
00210 { 1, 2, 3, 2, 3, 1, 1, 0 },
00211 { 0, 1, 1, 4, 5, 6, 7 },
00212 { 0, 1, 1, 2, 6, 7 },
00213 { 6, 0, 1, 2, 7 },
00214 { 0, 1, 2, 3 },
00215 { 0, 1, 1 },
00216 { 0, 1 },
00217 };
00218
00219 static const uint8_t run_len[7][16]={
00220 {1,1},
00221 {1,2,2},
00222 {2,2,2,2},
00223 {2,2,2,3,3},
00224 {2,2,3,3,3,3},
00225 {2,3,3,3,3,3,3},
00226 {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
00227 };
00228
00229 static const uint8_t run_bits[7][16]={
00230 {1,0},
00231 {1,1,0},
00232 {3,2,1,0},
00233 {3,2,1,1,0},
00234 {3,2,3,2,1,0},
00235 {3,0,1,3,2,5,4},
00236 {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
00237 };
00238
00239 static VLC coeff_token_vlc[4];
00240 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
00241 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
00242
00243 static VLC chroma_dc_coeff_token_vlc;
00244 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
00245 static const int chroma_dc_coeff_token_vlc_table_size = 256;
00246
00247 static VLC chroma422_dc_coeff_token_vlc;
00248 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
00249 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
00250
00251 static VLC total_zeros_vlc[15];
00252 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
00253 static const int total_zeros_vlc_tables_size = 512;
00254
00255 static VLC chroma_dc_total_zeros_vlc[3];
00256 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
00257 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
00258
00259 static VLC chroma422_dc_total_zeros_vlc[7];
00260 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
00261 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
00262
00263 static VLC run_vlc[6];
00264 static VLC_TYPE run_vlc_tables[6][8][2];
00265 static const int run_vlc_tables_size = 8;
00266
00267 static VLC run7_vlc;
00268 static VLC_TYPE run7_vlc_table[96][2];
00269 static const int run7_vlc_table_size = 96;
00270
00271 #define LEVEL_TAB_BITS 8
00272 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
00273
00274 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
00275 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
00276 #define COEFF_TOKEN_VLC_BITS 8
00277 #define TOTAL_ZEROS_VLC_BITS 9
00278 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
00279 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
00280 #define RUN_VLC_BITS 3
00281 #define RUN7_VLC_BITS 6
00282
00287 static inline int pred_non_zero_count(H264Context *h, int n){
00288 const int index8= scan8[n];
00289 const int left= h->non_zero_count_cache[index8 - 1];
00290 const int top = h->non_zero_count_cache[index8 - 8];
00291 int i= left + top;
00292
00293 if(i<64) i= (i+1)>>1;
00294
00295 tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
00296
00297 return i&31;
00298 }
00299
00300 static av_cold void init_cavlc_level_tab(void){
00301 int suffix_length;
00302 unsigned int i;
00303
00304 for(suffix_length=0; suffix_length<7; suffix_length++){
00305 for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
00306 int prefix= LEVEL_TAB_BITS - av_log2(2*i);
00307
00308 if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
00309 int level_code = (prefix << suffix_length) +
00310 (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
00311 int mask = -(level_code&1);
00312 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
00313 cavlc_level_tab[suffix_length][i][0]= level_code;
00314 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
00315 }else if(prefix + 1 <= LEVEL_TAB_BITS){
00316 cavlc_level_tab[suffix_length][i][0]= prefix+100;
00317 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
00318 }else{
00319 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
00320 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
00321 }
00322 }
00323 }
00324 }
00325
00326 av_cold void ff_h264_decode_init_vlc(void){
00327 static int done = 0;
00328
00329 if (!done) {
00330 int i;
00331 int offset;
00332 done = 1;
00333
00334 chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
00335 chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
00336 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
00337 &chroma_dc_coeff_token_len [0], 1, 1,
00338 &chroma_dc_coeff_token_bits[0], 1, 1,
00339 INIT_VLC_USE_NEW_STATIC);
00340
00341 chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
00342 chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
00343 init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
00344 &chroma422_dc_coeff_token_len [0], 1, 1,
00345 &chroma422_dc_coeff_token_bits[0], 1, 1,
00346 INIT_VLC_USE_NEW_STATIC);
00347
00348 offset = 0;
00349 for(i=0; i<4; i++){
00350 coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
00351 coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
00352 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
00353 &coeff_token_len [i][0], 1, 1,
00354 &coeff_token_bits[i][0], 1, 1,
00355 INIT_VLC_USE_NEW_STATIC);
00356 offset += coeff_token_vlc_tables_size[i];
00357 }
00358
00359
00360
00361
00362
00363 av_assert0(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
00364
00365 for(i=0; i<3; i++){
00366 chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
00367 chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
00368 init_vlc(&chroma_dc_total_zeros_vlc[i],
00369 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
00370 &chroma_dc_total_zeros_len [i][0], 1, 1,
00371 &chroma_dc_total_zeros_bits[i][0], 1, 1,
00372 INIT_VLC_USE_NEW_STATIC);
00373 }
00374
00375 for(i=0; i<7; i++){
00376 chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
00377 chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
00378 init_vlc(&chroma422_dc_total_zeros_vlc[i],
00379 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
00380 &chroma422_dc_total_zeros_len [i][0], 1, 1,
00381 &chroma422_dc_total_zeros_bits[i][0], 1, 1,
00382 INIT_VLC_USE_NEW_STATIC);
00383 }
00384
00385 for(i=0; i<15; i++){
00386 total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
00387 total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
00388 init_vlc(&total_zeros_vlc[i],
00389 TOTAL_ZEROS_VLC_BITS, 16,
00390 &total_zeros_len [i][0], 1, 1,
00391 &total_zeros_bits[i][0], 1, 1,
00392 INIT_VLC_USE_NEW_STATIC);
00393 }
00394
00395 for(i=0; i<6; i++){
00396 run_vlc[i].table = run_vlc_tables[i];
00397 run_vlc[i].table_allocated = run_vlc_tables_size;
00398 init_vlc(&run_vlc[i],
00399 RUN_VLC_BITS, 7,
00400 &run_len [i][0], 1, 1,
00401 &run_bits[i][0], 1, 1,
00402 INIT_VLC_USE_NEW_STATIC);
00403 }
00404 run7_vlc.table = run7_vlc_table,
00405 run7_vlc.table_allocated = run7_vlc_table_size;
00406 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
00407 &run_len [6][0], 1, 1,
00408 &run_bits[6][0], 1, 1,
00409 INIT_VLC_USE_NEW_STATIC);
00410
00411 init_cavlc_level_tab();
00412 }
00413 }
00414
00418 static inline int get_level_prefix(GetBitContext *gb){
00419 unsigned int buf;
00420 int log;
00421
00422 OPEN_READER(re, gb);
00423 UPDATE_CACHE(re, gb);
00424 buf=GET_CACHE(re, gb);
00425
00426 log= 32 - av_log2(buf);
00427 #ifdef TRACE
00428 print_bin(buf>>(32-log), log);
00429 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__);
00430 #endif
00431
00432 LAST_SKIP_BITS(re, gb, log);
00433 CLOSE_READER(re, gb);
00434
00435 return log-1;
00436 }
00437
00445 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
00446 MpegEncContext * const s = &h->s;
00447 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};
00448 int level[16];
00449 int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
00450
00451
00452
00453 if(max_coeff <= 8){
00454 if (max_coeff == 4)
00455 coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
00456 else
00457 coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
00458 total_coeff= coeff_token>>2;
00459 }else{
00460 if(n >= LUMA_DC_BLOCK_INDEX){
00461 total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
00462 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00463 total_coeff= coeff_token>>2;
00464 }else{
00465 total_coeff= pred_non_zero_count(h, n);
00466 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00467 total_coeff= coeff_token>>2;
00468 }
00469 }
00470 h->non_zero_count_cache[ scan8[n] ]= total_coeff;
00471
00472
00473
00474 if(total_coeff==0)
00475 return 0;
00476 if(total_coeff > (unsigned)max_coeff) {
00477 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
00478 return -1;
00479 }
00480
00481 trailing_ones= coeff_token&3;
00482 tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
00483 av_assert2(total_coeff<=16);
00484
00485 i = show_bits(gb, 3);
00486 skip_bits(gb, trailing_ones);
00487 level[0] = 1-((i&4)>>1);
00488 level[1] = 1-((i&2) );
00489 level[2] = 1-((i&1)<<1);
00490
00491 if(trailing_ones<total_coeff) {
00492 int mask, prefix;
00493 int suffix_length = total_coeff > 10 & trailing_ones < 3;
00494 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00495 int level_code= cavlc_level_tab[suffix_length][bitsi][0];
00496
00497 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00498 if(level_code >= 100){
00499 prefix= level_code - 100;
00500 if(prefix == LEVEL_TAB_BITS)
00501 prefix += get_level_prefix(gb);
00502
00503
00504 if(prefix<14){
00505 if(suffix_length)
00506 level_code= (prefix<<1) + get_bits1(gb);
00507 else
00508 level_code= prefix;
00509 }else if(prefix==14){
00510 if(suffix_length)
00511 level_code= (prefix<<1) + get_bits1(gb);
00512 else
00513 level_code= prefix + get_bits(gb, 4);
00514 }else{
00515 level_code= 30;
00516 if(prefix>=16){
00517 if(prefix > 25+3){
00518 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid level prefix\n");
00519 return -1;
00520 }
00521 level_code += (1<<(prefix-3))-4096;
00522 }
00523 level_code += get_bits(gb, prefix-3);
00524 }
00525
00526 if(trailing_ones < 3) level_code += 2;
00527
00528 suffix_length = 2;
00529 mask= -(level_code&1);
00530 level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
00531 }else{
00532 level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
00533
00534 suffix_length = 1 + (level_code + 3U > 6U);
00535 level[trailing_ones]= level_code;
00536 }
00537
00538
00539 for(i=trailing_ones+1;i<total_coeff;i++) {
00540 static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
00541 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00542 level_code= cavlc_level_tab[suffix_length][bitsi][0];
00543
00544 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00545 if(level_code >= 100){
00546 prefix= level_code - 100;
00547 if(prefix == LEVEL_TAB_BITS){
00548 prefix += get_level_prefix(gb);
00549 }
00550 if(prefix<15){
00551 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
00552 }else{
00553 level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
00554 if(prefix>=16)
00555 level_code += (1<<(prefix-3))-4096;
00556 }
00557 mask= -(level_code&1);
00558 level_code= (((2+level_code)>>1) ^ mask) - mask;
00559 }
00560 level[i]= level_code;
00561 suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
00562 }
00563 }
00564
00565 if(total_coeff == max_coeff)
00566 zeros_left=0;
00567 else{
00568 if (max_coeff <= 8) {
00569 if (max_coeff == 4)
00570 zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
00571 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
00572 else
00573 zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
00574 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
00575 } else {
00576 zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
00577 }
00578 }
00579
00580 #define STORE_BLOCK(type) \
00581 scantable += zeros_left + total_coeff - 1; \
00582 if(n >= LUMA_DC_BLOCK_INDEX){ \
00583 ((type*)block)[*scantable] = level[0]; \
00584 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
00585 if(zeros_left < 7) \
00586 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
00587 else \
00588 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
00589 zeros_left -= run_before; \
00590 scantable -= 1 + run_before; \
00591 ((type*)block)[*scantable]= level[i]; \
00592 } \
00593 for(;i<total_coeff;i++) { \
00594 scantable--; \
00595 ((type*)block)[*scantable]= level[i]; \
00596 } \
00597 }else{ \
00598 ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
00599 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
00600 if(zeros_left < 7) \
00601 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
00602 else \
00603 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
00604 zeros_left -= run_before; \
00605 scantable -= 1 + run_before; \
00606 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
00607 } \
00608 for(;i<total_coeff;i++) { \
00609 scantable--; \
00610 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
00611 } \
00612 }
00613
00614 if (h->pixel_shift) {
00615 STORE_BLOCK(int32_t)
00616 } else {
00617 STORE_BLOCK(int16_t)
00618 }
00619
00620 if(zeros_left<0){
00621 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
00622 return -1;
00623 }
00624
00625 return 0;
00626 }
00627
00628 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){
00629 int i4x4, i8x8;
00630 MpegEncContext * const s = &h->s;
00631 int qscale = p == 0 ? s->qscale : h->chroma_qp[p-1];
00632 if(IS_INTRA16x16(mb_type)){
00633 AV_ZERO128(h->mb_luma_dc[p]+0);
00634 AV_ZERO128(h->mb_luma_dc[p]+8);
00635 AV_ZERO128(h->mb_luma_dc[p]+16);
00636 AV_ZERO128(h->mb_luma_dc[p]+24);
00637 if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
00638 return -1;
00639 }
00640
00641 av_assert2((cbp&15) == 0 || (cbp&15) == 15);
00642
00643 if(cbp&15){
00644 for(i8x8=0; i8x8<4; i8x8++){
00645 for(i4x4=0; i4x4<4; i4x4++){
00646 const int index= i4x4 + 4*i8x8 + p*16;
00647 if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
00648 index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
00649 return -1;
00650 }
00651 }
00652 }
00653 return 0xf;
00654 }else{
00655 fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
00656 return 0;
00657 }
00658 }else{
00659 int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
00660
00661 int new_cbp = 0;
00662 for(i8x8=0; i8x8<4; i8x8++){
00663 if(cbp & (1<<i8x8)){
00664 if(IS_8x8DCT(mb_type)){
00665 DCTELEM *buf = &h->mb[64*i8x8+256*p << pixel_shift];
00666 uint8_t *nnz;
00667 for(i4x4=0; i4x4<4; i4x4++){
00668 const int index= i4x4 + 4*i8x8 + p*16;
00669 if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
00670 h->dequant8_coeff[cqm][qscale], 16) < 0 )
00671 return -1;
00672 }
00673 nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
00674 nnz[0] += nnz[1] + nnz[8] + nnz[9];
00675 new_cbp |= !!nnz[0] << i8x8;
00676 }else{
00677 for(i4x4=0; i4x4<4; i4x4++){
00678 const int index= i4x4 + 4*i8x8 + p*16;
00679 if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
00680 scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
00681 return -1;
00682 }
00683 new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
00684 }
00685 }
00686 }else{
00687 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
00688 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
00689 }
00690 }
00691 return new_cbp;
00692 }
00693 }
00694
00695 int ff_h264_decode_mb_cavlc(H264Context *h){
00696 MpegEncContext * const s = &h->s;
00697 int mb_xy;
00698 int partition_count;
00699 unsigned int mb_type, cbp;
00700 int dct8x8_allowed= h->pps.transform_8x8_mode;
00701 int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
00702 const int pixel_shift = h->pixel_shift;
00703
00704 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00705
00706 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
00707 cbp = 0;
00708
00709 if(h->slice_type_nos != AV_PICTURE_TYPE_I){
00710 if(s->mb_skip_run==-1)
00711 s->mb_skip_run= get_ue_golomb(&s->gb);
00712
00713 if (s->mb_skip_run--) {
00714 if(FRAME_MBAFF && (s->mb_y&1) == 0){
00715 if(s->mb_skip_run==0)
00716 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00717 }
00718 decode_mb_skip(h);
00719 return 0;
00720 }
00721 }
00722 if(FRAME_MBAFF){
00723 if( (s->mb_y&1) == 0 )
00724 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00725 }
00726
00727 h->prev_mb_skipped= 0;
00728
00729 mb_type= get_ue_golomb(&s->gb);
00730 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00731 if(mb_type < 23){
00732 partition_count= b_mb_type_info[mb_type].partition_count;
00733 mb_type= b_mb_type_info[mb_type].type;
00734 }else{
00735 mb_type -= 23;
00736 goto decode_intra_mb;
00737 }
00738 }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
00739 if(mb_type < 5){
00740 partition_count= p_mb_type_info[mb_type].partition_count;
00741 mb_type= p_mb_type_info[mb_type].type;
00742 }else{
00743 mb_type -= 5;
00744 goto decode_intra_mb;
00745 }
00746 }else{
00747 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
00748 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
00749 mb_type--;
00750 decode_intra_mb:
00751 if(mb_type > 25){
00752 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);
00753 return -1;
00754 }
00755 partition_count=0;
00756 cbp= i_mb_type_info[mb_type].cbp;
00757 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
00758 mb_type= i_mb_type_info[mb_type].type;
00759 }
00760
00761 if(MB_FIELD)
00762 mb_type |= MB_TYPE_INTERLACED;
00763
00764 h->slice_table[ mb_xy ]= h->slice_num;
00765
00766 if(IS_INTRA_PCM(mb_type)){
00767 unsigned int x;
00768 const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
00769 h->sps.bit_depth_luma >> 3;
00770
00771
00772 align_get_bits(&s->gb);
00773
00774
00775 for(x=0; x < mb_size; x++){
00776 ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00777 }
00778
00779
00780 s->current_picture.f.qscale_table[mb_xy] = 0;
00781
00782 memset(h->non_zero_count[mb_xy], 16, 48);
00783
00784 s->current_picture.f.mb_type[mb_xy] = mb_type;
00785 return 0;
00786 }
00787
00788 if(MB_MBAFF){
00789 h->ref_count[0] <<= 1;
00790 h->ref_count[1] <<= 1;
00791 }
00792
00793 fill_decode_neighbors(h, mb_type);
00794 fill_decode_caches(h, mb_type);
00795
00796
00797 if(IS_INTRA(mb_type)){
00798 int pred_mode;
00799
00800 if(IS_INTRA4x4(mb_type)){
00801 int i;
00802 int di = 1;
00803 if(dct8x8_allowed && get_bits1(&s->gb)){
00804 mb_type |= MB_TYPE_8x8DCT;
00805 di = 4;
00806 }
00807
00808
00809 for(i=0; i<16; i+=di){
00810 int mode= pred_intra_mode(h, i);
00811
00812 if(!get_bits1(&s->gb)){
00813 const int rem_mode= get_bits(&s->gb, 3);
00814 mode = rem_mode + (rem_mode >= mode);
00815 }
00816
00817 if(di==4)
00818 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
00819 else
00820 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
00821 }
00822 write_back_intra_pred_mode(h);
00823 if( ff_h264_check_intra4x4_pred_mode(h) < 0)
00824 return -1;
00825 }else{
00826 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
00827 if(h->intra16x16_pred_mode < 0)
00828 return -1;
00829 }
00830 if(decode_chroma){
00831 pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb), 1);
00832 if(pred_mode < 0)
00833 return -1;
00834 h->chroma_pred_mode= pred_mode;
00835 } else {
00836 h->chroma_pred_mode = DC_128_PRED8x8;
00837 }
00838 }else if(partition_count==4){
00839 int i, j, sub_partition_count[4], list, ref[2][4];
00840
00841 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00842 for(i=0; i<4; i++){
00843 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00844 if(h->sub_mb_type[i] >=13){
00845 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);
00846 return -1;
00847 }
00848 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00849 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00850 }
00851 if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
00852 ff_h264_pred_direct_motion(h, &mb_type);
00853 h->ref_cache[0][scan8[4]] =
00854 h->ref_cache[1][scan8[4]] =
00855 h->ref_cache[0][scan8[12]] =
00856 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
00857 }
00858 }else{
00859 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P);
00860 for(i=0; i<4; i++){
00861 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00862 if(h->sub_mb_type[i] >=4){
00863 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);
00864 return -1;
00865 }
00866 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00867 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00868 }
00869 }
00870
00871 for(list=0; list<h->list_count; list++){
00872 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
00873 for(i=0; i<4; i++){
00874 if(IS_DIRECT(h->sub_mb_type[i])) continue;
00875 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00876 unsigned int tmp;
00877 if(ref_count == 1){
00878 tmp= 0;
00879 }else if(ref_count == 2){
00880 tmp= get_bits1(&s->gb)^1;
00881 }else{
00882 tmp= get_ue_golomb_31(&s->gb);
00883 if(tmp>=ref_count){
00884 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
00885 return -1;
00886 }
00887 }
00888 ref[list][i]= tmp;
00889 }else{
00890
00891 ref[list][i] = -1;
00892 }
00893 }
00894 }
00895
00896 if(dct8x8_allowed)
00897 dct8x8_allowed = get_dct8x8_allowed(h);
00898
00899 for(list=0; list<h->list_count; list++){
00900 for(i=0; i<4; i++){
00901 if(IS_DIRECT(h->sub_mb_type[i])) {
00902 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
00903 continue;
00904 }
00905 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
00906 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
00907
00908 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00909 const int sub_mb_type= h->sub_mb_type[i];
00910 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
00911 for(j=0; j<sub_partition_count[i]; j++){
00912 int mx, my;
00913 const int index= 4*i + block_width*j;
00914 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
00915 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
00916 mx += get_se_golomb(&s->gb);
00917 my += get_se_golomb(&s->gb);
00918 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00919
00920 if(IS_SUB_8X8(sub_mb_type)){
00921 mv_cache[ 1 ][0]=
00922 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
00923 mv_cache[ 1 ][1]=
00924 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
00925 }else if(IS_SUB_8X4(sub_mb_type)){
00926 mv_cache[ 1 ][0]= mx;
00927 mv_cache[ 1 ][1]= my;
00928 }else if(IS_SUB_4X8(sub_mb_type)){
00929 mv_cache[ 8 ][0]= mx;
00930 mv_cache[ 8 ][1]= my;
00931 }
00932 mv_cache[ 0 ][0]= mx;
00933 mv_cache[ 0 ][1]= my;
00934 }
00935 }else{
00936 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
00937 p[0] = p[1]=
00938 p[8] = p[9]= 0;
00939 }
00940 }
00941 }
00942 }else if(IS_DIRECT(mb_type)){
00943 ff_h264_pred_direct_motion(h, &mb_type);
00944 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
00945 }else{
00946 int list, mx, my, i;
00947
00948 if(IS_16X16(mb_type)){
00949 for(list=0; list<h->list_count; list++){
00950 unsigned int val;
00951 if(IS_DIR(mb_type, 0, list)){
00952 if(h->ref_count[list]==1){
00953 val= 0;
00954 }else if(h->ref_count[list]==2){
00955 val= get_bits1(&s->gb)^1;
00956 }else{
00957 val= get_ue_golomb_31(&s->gb);
00958 if(val >= h->ref_count[list]){
00959 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00960 return -1;
00961 }
00962 }
00963 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
00964 }
00965 }
00966 for(list=0; list<h->list_count; list++){
00967 if(IS_DIR(mb_type, 0, list)){
00968 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
00969 mx += get_se_golomb(&s->gb);
00970 my += get_se_golomb(&s->gb);
00971 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00972
00973 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
00974 }
00975 }
00976 }
00977 else if(IS_16X8(mb_type)){
00978 for(list=0; list<h->list_count; list++){
00979 for(i=0; i<2; i++){
00980 unsigned int val;
00981 if(IS_DIR(mb_type, i, list)){
00982 if(h->ref_count[list] == 1){
00983 val= 0;
00984 }else if(h->ref_count[list] == 2){
00985 val= get_bits1(&s->gb)^1;
00986 }else{
00987 val= get_ue_golomb_31(&s->gb);
00988 if(val >= h->ref_count[list]){
00989 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00990 return -1;
00991 }
00992 }
00993 }else
00994 val= LIST_NOT_USED&0xFF;
00995 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
00996 }
00997 }
00998 for(list=0; list<h->list_count; list++){
00999 for(i=0; i<2; i++){
01000 unsigned int val;
01001 if(IS_DIR(mb_type, i, list)){
01002 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01003 mx += get_se_golomb(&s->gb);
01004 my += get_se_golomb(&s->gb);
01005 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01006
01007 val= pack16to32(mx,my);
01008 }else
01009 val=0;
01010 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
01011 }
01012 }
01013 }else{
01014 av_assert2(IS_8X16(mb_type));
01015 for(list=0; list<h->list_count; list++){
01016 for(i=0; i<2; i++){
01017 unsigned int val;
01018 if(IS_DIR(mb_type, i, list)){
01019 if(h->ref_count[list]==1){
01020 val= 0;
01021 }else if(h->ref_count[list]==2){
01022 val= get_bits1(&s->gb)^1;
01023 }else{
01024 val= get_ue_golomb_31(&s->gb);
01025 if(val >= h->ref_count[list]){
01026 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
01027 return -1;
01028 }
01029 }
01030 }else
01031 val= LIST_NOT_USED&0xFF;
01032 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
01033 }
01034 }
01035 for(list=0; list<h->list_count; list++){
01036 for(i=0; i<2; i++){
01037 unsigned int val;
01038 if(IS_DIR(mb_type, i, list)){
01039 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01040 mx += get_se_golomb(&s->gb);
01041 my += get_se_golomb(&s->gb);
01042 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01043
01044 val= pack16to32(mx,my);
01045 }else
01046 val=0;
01047 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
01048 }
01049 }
01050 }
01051 }
01052
01053 if(IS_INTER(mb_type))
01054 write_back_motion(h, mb_type);
01055
01056 if(!IS_INTRA16x16(mb_type)){
01057 cbp= get_ue_golomb(&s->gb);
01058
01059 if(decode_chroma){
01060 if(cbp > 47){
01061 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01062 return -1;
01063 }
01064 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
01065 else cbp= golomb_to_inter_cbp [cbp];
01066 }else{
01067 if(cbp > 15){
01068 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01069 return -1;
01070 }
01071 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
01072 else cbp= golomb_to_inter_cbp_gray[cbp];
01073 }
01074 }
01075
01076 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
01077 mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
01078 }
01079 h->cbp=
01080 h->cbp_table[mb_xy]= cbp;
01081 s->current_picture.f.mb_type[mb_xy] = mb_type;
01082
01083 if(cbp || IS_INTRA16x16(mb_type)){
01084 int i4x4, i8x8, chroma_idx;
01085 int dquant;
01086 int ret;
01087 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
01088 const uint8_t *scan, *scan8x8;
01089 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
01090
01091 if(IS_INTERLACED(mb_type)){
01092 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
01093 scan= s->qscale ? h->field_scan : h->field_scan_q0;
01094 }else{
01095 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
01096 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01097 }
01098
01099 dquant= get_se_golomb(&s->gb);
01100
01101 s->qscale += dquant;
01102
01103 if(((unsigned)s->qscale) > max_qp){
01104 if(s->qscale<0) s->qscale+= max_qp+1;
01105 else s->qscale-= max_qp+1;
01106 if(((unsigned)s->qscale) > max_qp){
01107 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
01108 return -1;
01109 }
01110 }
01111
01112 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
01113 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
01114
01115 if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
01116 return -1;
01117 }
01118 h->cbp_table[mb_xy] |= ret << 12;
01119 if(CHROMA444){
01120 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
01121 return -1;
01122 }
01123 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
01124 return -1;
01125 }
01126 } else {
01127 const int num_c8x8 = h->sps.chroma_format_idc;
01128
01129 if(cbp&0x30){
01130 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01131 if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
01132 CHROMA_DC_BLOCK_INDEX+chroma_idx,
01133 CHROMA422 ? chroma422_dc_scan : chroma_dc_scan,
01134 NULL, 4*num_c8x8) < 0) {
01135 return -1;
01136 }
01137 }
01138
01139 if(cbp&0x20){
01140 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01141 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01142 DCTELEM *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
01143 for (i8x8=0; i8x8<num_c8x8; i8x8++) {
01144 for (i4x4=0; i4x4<4; i4x4++) {
01145 const int index= 16 + 16*chroma_idx + 8*i8x8 + i4x4;
01146 if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
01147 return -1;
01148 mb += 16<<pixel_shift;
01149 }
01150 }
01151 }
01152 }else{
01153 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01154 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01155 }
01156 }
01157 }else{
01158 fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
01159 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01160 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01161 }
01162 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
01163 write_back_non_zero_count(h);
01164
01165 if(MB_MBAFF){
01166 h->ref_count[0] >>= 1;
01167 h->ref_count[1] >>= 1;
01168 }
01169
01170 return 0;
01171 }
