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 unsigned local_ref_count[2];
00704
00705 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00706
00707 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
00708 cbp = 0;
00709
00710 if(h->slice_type_nos != AV_PICTURE_TYPE_I){
00711 if(s->mb_skip_run==-1)
00712 s->mb_skip_run= get_ue_golomb(&s->gb);
00713
00714 if (s->mb_skip_run--) {
00715 if(FRAME_MBAFF && (s->mb_y&1) == 0){
00716 if(s->mb_skip_run==0)
00717 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00718 }
00719 decode_mb_skip(h);
00720 return 0;
00721 }
00722 }
00723 if(FRAME_MBAFF){
00724 if( (s->mb_y&1) == 0 )
00725 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00726 }
00727
00728 h->prev_mb_skipped= 0;
00729
00730 mb_type= get_ue_golomb(&s->gb);
00731 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00732 if(mb_type < 23){
00733 partition_count= b_mb_type_info[mb_type].partition_count;
00734 mb_type= b_mb_type_info[mb_type].type;
00735 }else{
00736 mb_type -= 23;
00737 goto decode_intra_mb;
00738 }
00739 }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
00740 if(mb_type < 5){
00741 partition_count= p_mb_type_info[mb_type].partition_count;
00742 mb_type= p_mb_type_info[mb_type].type;
00743 }else{
00744 mb_type -= 5;
00745 goto decode_intra_mb;
00746 }
00747 }else{
00748 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_I);
00749 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
00750 mb_type--;
00751 decode_intra_mb:
00752 if(mb_type > 25){
00753 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);
00754 return -1;
00755 }
00756 partition_count=0;
00757 cbp= i_mb_type_info[mb_type].cbp;
00758 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
00759 mb_type= i_mb_type_info[mb_type].type;
00760 }
00761
00762 if(MB_FIELD)
00763 mb_type |= MB_TYPE_INTERLACED;
00764
00765 h->slice_table[ mb_xy ]= h->slice_num;
00766
00767 if(IS_INTRA_PCM(mb_type)){
00768 unsigned int x;
00769 const int mb_size = ff_h264_mb_sizes[h->sps.chroma_format_idc] *
00770 h->sps.bit_depth_luma >> 3;
00771
00772
00773 align_get_bits(&s->gb);
00774
00775
00776 for(x=0; x < mb_size; x++){
00777 ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00778 }
00779
00780
00781 s->current_picture.f.qscale_table[mb_xy] = 0;
00782
00783 memset(h->non_zero_count[mb_xy], 16, 48);
00784
00785 s->current_picture.f.mb_type[mb_xy] = mb_type;
00786 return 0;
00787 }
00788
00789 local_ref_count[0] = h->ref_count[0] << MB_MBAFF;
00790 local_ref_count[1] = h->ref_count[1] << MB_MBAFF;
00791
00792 fill_decode_neighbors(h, mb_type);
00793 fill_decode_caches(h, mb_type);
00794
00795
00796 if(IS_INTRA(mb_type)){
00797 int pred_mode;
00798
00799 if(IS_INTRA4x4(mb_type)){
00800 int i;
00801 int di = 1;
00802 if(dct8x8_allowed && get_bits1(&s->gb)){
00803 mb_type |= MB_TYPE_8x8DCT;
00804 di = 4;
00805 }
00806
00807
00808 for(i=0; i<16; i+=di){
00809 int mode= pred_intra_mode(h, i);
00810
00811 if(!get_bits1(&s->gb)){
00812 const int rem_mode= get_bits(&s->gb, 3);
00813 mode = rem_mode + (rem_mode >= mode);
00814 }
00815
00816 if(di==4)
00817 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
00818 else
00819 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
00820 }
00821 write_back_intra_pred_mode(h);
00822 if( ff_h264_check_intra4x4_pred_mode(h) < 0)
00823 return -1;
00824 }else{
00825 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
00826 if(h->intra16x16_pred_mode < 0)
00827 return -1;
00828 }
00829 if(decode_chroma){
00830 pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb), 1);
00831 if(pred_mode < 0)
00832 return -1;
00833 h->chroma_pred_mode= pred_mode;
00834 } else {
00835 h->chroma_pred_mode = DC_128_PRED8x8;
00836 }
00837 }else if(partition_count==4){
00838 int i, j, sub_partition_count[4], list, ref[2][4];
00839
00840 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00841 for(i=0; i<4; i++){
00842 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00843 if(h->sub_mb_type[i] >=13){
00844 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);
00845 return -1;
00846 }
00847 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00848 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00849 }
00850 if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
00851 ff_h264_pred_direct_motion(h, &mb_type);
00852 h->ref_cache[0][scan8[4]] =
00853 h->ref_cache[1][scan8[4]] =
00854 h->ref_cache[0][scan8[12]] =
00855 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
00856 }
00857 }else{
00858 av_assert2(h->slice_type_nos == AV_PICTURE_TYPE_P);
00859 for(i=0; i<4; i++){
00860 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00861 if(h->sub_mb_type[i] >=4){
00862 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);
00863 return -1;
00864 }
00865 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00866 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00867 }
00868 }
00869
00870 for(list=0; list<h->list_count; list++){
00871 int ref_count= IS_REF0(mb_type) ? 1 : local_ref_count[list];
00872 for(i=0; i<4; i++){
00873 if(IS_DIRECT(h->sub_mb_type[i])) continue;
00874 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00875 unsigned int tmp;
00876 if(ref_count == 1){
00877 tmp= 0;
00878 }else if(ref_count == 2){
00879 tmp= get_bits1(&s->gb)^1;
00880 }else{
00881 tmp= get_ue_golomb_31(&s->gb);
00882 if(tmp>=ref_count){
00883 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
00884 return -1;
00885 }
00886 }
00887 ref[list][i]= tmp;
00888 }else{
00889
00890 ref[list][i] = -1;
00891 }
00892 }
00893 }
00894
00895 if(dct8x8_allowed)
00896 dct8x8_allowed = get_dct8x8_allowed(h);
00897
00898 for(list=0; list<h->list_count; list++){
00899 for(i=0; i<4; i++){
00900 if(IS_DIRECT(h->sub_mb_type[i])) {
00901 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
00902 continue;
00903 }
00904 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
00905 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
00906
00907 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00908 const int sub_mb_type= h->sub_mb_type[i];
00909 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
00910 for(j=0; j<sub_partition_count[i]; j++){
00911 int mx, my;
00912 const int index= 4*i + block_width*j;
00913 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
00914 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
00915 mx += get_se_golomb(&s->gb);
00916 my += get_se_golomb(&s->gb);
00917 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00918
00919 if(IS_SUB_8X8(sub_mb_type)){
00920 mv_cache[ 1 ][0]=
00921 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
00922 mv_cache[ 1 ][1]=
00923 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
00924 }else if(IS_SUB_8X4(sub_mb_type)){
00925 mv_cache[ 1 ][0]= mx;
00926 mv_cache[ 1 ][1]= my;
00927 }else if(IS_SUB_4X8(sub_mb_type)){
00928 mv_cache[ 8 ][0]= mx;
00929 mv_cache[ 8 ][1]= my;
00930 }
00931 mv_cache[ 0 ][0]= mx;
00932 mv_cache[ 0 ][1]= my;
00933 }
00934 }else{
00935 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
00936 p[0] = p[1]=
00937 p[8] = p[9]= 0;
00938 }
00939 }
00940 }
00941 }else if(IS_DIRECT(mb_type)){
00942 ff_h264_pred_direct_motion(h, &mb_type);
00943 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
00944 }else{
00945 int list, mx, my, i;
00946
00947 if(IS_16X16(mb_type)){
00948 for(list=0; list<h->list_count; list++){
00949 unsigned int val;
00950 if(IS_DIR(mb_type, 0, list)){
00951 if(local_ref_count[list]==1){
00952 val= 0;
00953 }else if(local_ref_count[list]==2){
00954 val= get_bits1(&s->gb)^1;
00955 }else{
00956 val= get_ue_golomb_31(&s->gb);
00957 if(val >= local_ref_count[list]){
00958 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00959 return -1;
00960 }
00961 }
00962 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
00963 }
00964 }
00965 for(list=0; list<h->list_count; list++){
00966 if(IS_DIR(mb_type, 0, list)){
00967 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
00968 mx += get_se_golomb(&s->gb);
00969 my += get_se_golomb(&s->gb);
00970 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00971
00972 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
00973 }
00974 }
00975 }
00976 else if(IS_16X8(mb_type)){
00977 for(list=0; list<h->list_count; list++){
00978 for(i=0; i<2; i++){
00979 unsigned int val;
00980 if(IS_DIR(mb_type, i, list)){
00981 if(local_ref_count[list] == 1){
00982 val= 0;
00983 }else if(local_ref_count[list] == 2){
00984 val= get_bits1(&s->gb)^1;
00985 }else{
00986 val= get_ue_golomb_31(&s->gb);
00987 if(val >= local_ref_count[list]){
00988 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00989 return -1;
00990 }
00991 }
00992 }else
00993 val= LIST_NOT_USED&0xFF;
00994 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
00995 }
00996 }
00997 for(list=0; list<h->list_count; list++){
00998 for(i=0; i<2; i++){
00999 unsigned int val;
01000 if(IS_DIR(mb_type, i, list)){
01001 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01002 mx += get_se_golomb(&s->gb);
01003 my += get_se_golomb(&s->gb);
01004 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01005
01006 val= pack16to32(mx,my);
01007 }else
01008 val=0;
01009 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
01010 }
01011 }
01012 }else{
01013 av_assert2(IS_8X16(mb_type));
01014 for(list=0; list<h->list_count; list++){
01015 for(i=0; i<2; i++){
01016 unsigned int val;
01017 if(IS_DIR(mb_type, i, list)){
01018 if(local_ref_count[list]==1){
01019 val= 0;
01020 }else if(local_ref_count[list]==2){
01021 val= get_bits1(&s->gb)^1;
01022 }else{
01023 val= get_ue_golomb_31(&s->gb);
01024 if(val >= local_ref_count[list]){
01025 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
01026 return -1;
01027 }
01028 }
01029 }else
01030 val= LIST_NOT_USED&0xFF;
01031 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
01032 }
01033 }
01034 for(list=0; list<h->list_count; list++){
01035 for(i=0; i<2; i++){
01036 unsigned int val;
01037 if(IS_DIR(mb_type, i, list)){
01038 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01039 mx += get_se_golomb(&s->gb);
01040 my += get_se_golomb(&s->gb);
01041 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01042
01043 val= pack16to32(mx,my);
01044 }else
01045 val=0;
01046 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
01047 }
01048 }
01049 }
01050 }
01051
01052 if(IS_INTER(mb_type))
01053 write_back_motion(h, mb_type);
01054
01055 if(!IS_INTRA16x16(mb_type)){
01056 cbp= get_ue_golomb(&s->gb);
01057
01058 if(decode_chroma){
01059 if(cbp > 47){
01060 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01061 return -1;
01062 }
01063 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
01064 else cbp= golomb_to_inter_cbp [cbp];
01065 }else{
01066 if(cbp > 15){
01067 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01068 return -1;
01069 }
01070 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
01071 else cbp= golomb_to_inter_cbp_gray[cbp];
01072 }
01073 } else {
01074 if (!decode_chroma && cbp>15) {
01075 av_log(s->avctx, AV_LOG_ERROR, "gray chroma\n");
01076 return AVERROR_INVALIDDATA;
01077 }
01078 }
01079
01080 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
01081 mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
01082 }
01083 h->cbp=
01084 h->cbp_table[mb_xy]= cbp;
01085 s->current_picture.f.mb_type[mb_xy] = mb_type;
01086
01087 if(cbp || IS_INTRA16x16(mb_type)){
01088 int i4x4, i8x8, chroma_idx;
01089 int dquant;
01090 int ret;
01091 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
01092 const uint8_t *scan, *scan8x8;
01093 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
01094
01095 if(IS_INTERLACED(mb_type)){
01096 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
01097 scan= s->qscale ? h->field_scan : h->field_scan_q0;
01098 }else{
01099 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
01100 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01101 }
01102
01103 dquant= get_se_golomb(&s->gb);
01104
01105 s->qscale += dquant;
01106
01107 if(((unsigned)s->qscale) > max_qp){
01108 if(s->qscale<0) s->qscale+= max_qp+1;
01109 else s->qscale-= max_qp+1;
01110 if(((unsigned)s->qscale) > max_qp){
01111 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
01112 return -1;
01113 }
01114 }
01115
01116 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
01117 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
01118
01119 if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
01120 return -1;
01121 }
01122 h->cbp_table[mb_xy] |= ret << 12;
01123 if(CHROMA444){
01124 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
01125 return -1;
01126 }
01127 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
01128 return -1;
01129 }
01130 } else {
01131 const int num_c8x8 = h->sps.chroma_format_idc;
01132
01133 if(cbp&0x30){
01134 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01135 if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
01136 CHROMA_DC_BLOCK_INDEX+chroma_idx,
01137 CHROMA422 ? chroma422_dc_scan : chroma_dc_scan,
01138 NULL, 4*num_c8x8) < 0) {
01139 return -1;
01140 }
01141 }
01142
01143 if(cbp&0x20){
01144 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01145 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01146 DCTELEM *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
01147 for (i8x8=0; i8x8<num_c8x8; i8x8++) {
01148 for (i4x4=0; i4x4<4; i4x4++) {
01149 const int index= 16 + 16*chroma_idx + 8*i8x8 + i4x4;
01150 if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
01151 return -1;
01152 mb += 16<<pixel_shift;
01153 }
01154 }
01155 }
01156 }else{
01157 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01158 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01159 }
01160 }
01161 }else{
01162 fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
01163 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01164 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01165 }
01166 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
01167 write_back_non_zero_count(h);
01168
01169 return 0;
01170 }
