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
00039
00040 #include <assert.h>
00041
00042 static const uint8_t golomb_to_inter_cbp_gray[16]={
00043 0, 1, 2, 4, 8, 3, 5,10,12,15, 7,11,13,14, 6, 9,
00044 };
00045
00046 static const uint8_t golomb_to_intra4x4_cbp_gray[16]={
00047 15, 0, 7,11,13,14, 3, 5,10,12, 1, 2, 4, 8, 6, 9,
00048 };
00049
00050 static const uint8_t chroma_dc_coeff_token_len[4*5]={
00051 2, 0, 0, 0,
00052 6, 1, 0, 0,
00053 6, 6, 3, 0,
00054 6, 7, 7, 6,
00055 6, 8, 8, 7,
00056 };
00057
00058 static const uint8_t chroma_dc_coeff_token_bits[4*5]={
00059 1, 0, 0, 0,
00060 7, 1, 0, 0,
00061 4, 6, 1, 0,
00062 3, 3, 2, 5,
00063 2, 3, 2, 0,
00064 };
00065
00066 static const uint8_t chroma422_dc_coeff_token_len[4*9]={
00067 1, 0, 0, 0,
00068 7, 2, 0, 0,
00069 7, 7, 3, 0,
00070 9, 7, 7, 5,
00071 9, 9, 7, 6,
00072 10, 10, 9, 7,
00073 11, 11, 10, 7,
00074 12, 12, 11, 10,
00075 13, 12, 12, 11,
00076 };
00077
00078 static const uint8_t chroma422_dc_coeff_token_bits[4*9]={
00079 1, 0, 0, 0,
00080 15, 1, 0, 0,
00081 14, 13, 1, 0,
00082 7, 12, 11, 1,
00083 6, 5, 10, 1,
00084 7, 6, 4, 9,
00085 7, 6, 5, 8,
00086 7, 6, 5, 4,
00087 7, 5, 4, 4,
00088 };
00089
00090 static const uint8_t coeff_token_len[4][4*17]={
00091 {
00092 1, 0, 0, 0,
00093 6, 2, 0, 0, 8, 6, 3, 0, 9, 8, 7, 5, 10, 9, 8, 6,
00094 11,10, 9, 7, 13,11,10, 8, 13,13,11, 9, 13,13,13,10,
00095 14,14,13,11, 14,14,14,13, 15,15,14,14, 15,15,15,14,
00096 16,15,15,15, 16,16,16,15, 16,16,16,16, 16,16,16,16,
00097 },
00098 {
00099 2, 0, 0, 0,
00100 6, 2, 0, 0, 6, 5, 3, 0, 7, 6, 6, 4, 8, 6, 6, 4,
00101 8, 7, 7, 5, 9, 8, 8, 6, 11, 9, 9, 6, 11,11,11, 7,
00102 12,11,11, 9, 12,12,12,11, 12,12,12,11, 13,13,13,12,
00103 13,13,13,13, 13,14,13,13, 14,14,14,13, 14,14,14,14,
00104 },
00105 {
00106 4, 0, 0, 0,
00107 6, 4, 0, 0, 6, 5, 4, 0, 6, 5, 5, 4, 7, 5, 5, 4,
00108 7, 5, 5, 4, 7, 6, 6, 4, 7, 6, 6, 4, 8, 7, 7, 5,
00109 8, 8, 7, 6, 9, 8, 8, 7, 9, 9, 8, 8, 9, 9, 9, 8,
00110 10, 9, 9, 9, 10,10,10,10, 10,10,10,10, 10,10,10,10,
00111 },
00112 {
00113 6, 0, 0, 0,
00114 6, 6, 0, 0, 6, 6, 6, 0, 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 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00118 }
00119 };
00120
00121 static const uint8_t coeff_token_bits[4][4*17]={
00122 {
00123 1, 0, 0, 0,
00124 5, 1, 0, 0, 7, 4, 1, 0, 7, 6, 5, 3, 7, 6, 5, 3,
00125 7, 6, 5, 4, 15, 6, 5, 4, 11,14, 5, 4, 8,10,13, 4,
00126 15,14, 9, 4, 11,10,13,12, 15,14, 9,12, 11,10,13, 8,
00127 15, 1, 9,12, 11,14,13, 8, 7,10, 9,12, 4, 6, 5, 8,
00128 },
00129 {
00130 3, 0, 0, 0,
00131 11, 2, 0, 0, 7, 7, 3, 0, 7,10, 9, 5, 7, 6, 5, 4,
00132 4, 6, 5, 6, 7, 6, 5, 8, 15, 6, 5, 4, 11,14,13, 4,
00133 15,10, 9, 4, 11,14,13,12, 8,10, 9, 8, 15,14,13,12,
00134 11,10, 9,12, 7,11, 6, 8, 9, 8,10, 1, 7, 6, 5, 4,
00135 },
00136 {
00137 15, 0, 0, 0,
00138 15,14, 0, 0, 11,15,13, 0, 8,12,14,12, 15,10,11,11,
00139 11, 8, 9,10, 9,14,13, 9, 8,10, 9, 8, 15,14,13,13,
00140 11,14,10,12, 15,10,13,12, 11,14, 9,12, 8,10,13, 8,
00141 13, 7, 9,12, 9,12,11,10, 5, 8, 7, 6, 1, 4, 3, 2,
00142 },
00143 {
00144 3, 0, 0, 0,
00145 0, 1, 0, 0, 4, 5, 6, 0, 8, 9,10,11, 12,13,14,15,
00146 16,17,18,19, 20,21,22,23, 24,25,26,27, 28,29,30,31,
00147 32,33,34,35, 36,37,38,39, 40,41,42,43, 44,45,46,47,
00148 48,49,50,51, 52,53,54,55, 56,57,58,59, 60,61,62,63,
00149 }
00150 };
00151
00152 static const uint8_t total_zeros_len[16][16]= {
00153 {1,3,3,4,4,5,5,6,6,7,7,8,8,9,9,9},
00154 {3,3,3,3,3,4,4,4,4,5,5,6,6,6,6},
00155 {4,3,3,3,4,4,3,3,4,5,5,6,5,6},
00156 {5,3,4,4,3,3,3,4,3,4,5,5,5},
00157 {4,4,4,3,3,3,3,3,4,5,4,5},
00158 {6,5,3,3,3,3,3,3,4,3,6},
00159 {6,5,3,3,3,2,3,4,3,6},
00160 {6,4,5,3,2,2,3,3,6},
00161 {6,6,4,2,2,3,2,5},
00162 {5,5,3,2,2,2,4},
00163 {4,4,3,3,1,3},
00164 {4,4,2,1,3},
00165 {3,3,1,2},
00166 {2,2,1},
00167 {1,1},
00168 };
00169
00170 static const uint8_t total_zeros_bits[16][16]= {
00171 {1,3,2,3,2,3,2,3,2,3,2,3,2,3,2,1},
00172 {7,6,5,4,3,5,4,3,2,3,2,3,2,1,0},
00173 {5,7,6,5,4,3,4,3,2,3,2,1,1,0},
00174 {3,7,5,4,6,5,4,3,3,2,2,1,0},
00175 {5,4,3,7,6,5,4,3,2,1,1,0},
00176 {1,1,7,6,5,4,3,2,1,1,0},
00177 {1,1,5,4,3,3,2,1,1,0},
00178 {1,1,1,3,3,2,2,1,0},
00179 {1,0,1,3,2,1,1,1},
00180 {1,0,1,3,2,1,1},
00181 {0,1,1,2,1,3},
00182 {0,1,1,1,1},
00183 {0,1,1,1},
00184 {0,1,1},
00185 {0,1},
00186 };
00187
00188 static const uint8_t chroma_dc_total_zeros_len[3][4]= {
00189 { 1, 2, 3, 3,},
00190 { 1, 2, 2, 0,},
00191 { 1, 1, 0, 0,},
00192 };
00193
00194 static const uint8_t chroma_dc_total_zeros_bits[3][4]= {
00195 { 1, 1, 1, 0,},
00196 { 1, 1, 0, 0,},
00197 { 1, 0, 0, 0,},
00198 };
00199
00200 static const uint8_t chroma422_dc_total_zeros_len[7][8]= {
00201 { 1, 3, 3, 4, 4, 4, 5, 5 },
00202 { 3, 2, 3, 3, 3, 3, 3 },
00203 { 3, 3, 2, 2, 3, 3 },
00204 { 3, 2, 2, 2, 3 },
00205 { 2, 2, 2, 2 },
00206 { 2, 2, 1 },
00207 { 1, 1 },
00208 };
00209
00210 static const uint8_t chroma422_dc_total_zeros_bits[7][8]= {
00211 { 1, 2, 3, 2, 3, 1, 1, 0 },
00212 { 0, 1, 1, 4, 5, 6, 7 },
00213 { 0, 1, 1, 2, 6, 7 },
00214 { 6, 0, 1, 2, 7 },
00215 { 0, 1, 2, 3 },
00216 { 0, 1, 1 },
00217 { 0, 1 },
00218 };
00219
00220 static const uint8_t run_len[7][16]={
00221 {1,1},
00222 {1,2,2},
00223 {2,2,2,2},
00224 {2,2,2,3,3},
00225 {2,2,3,3,3,3},
00226 {2,3,3,3,3,3,3},
00227 {3,3,3,3,3,3,3,4,5,6,7,8,9,10,11},
00228 };
00229
00230 static const uint8_t run_bits[7][16]={
00231 {1,0},
00232 {1,1,0},
00233 {3,2,1,0},
00234 {3,2,1,1,0},
00235 {3,2,3,2,1,0},
00236 {3,0,1,3,2,5,4},
00237 {7,6,5,4,3,2,1,1,1,1,1,1,1,1,1},
00238 };
00239
00240 static VLC coeff_token_vlc[4];
00241 static VLC_TYPE coeff_token_vlc_tables[520+332+280+256][2];
00242 static const int coeff_token_vlc_tables_size[4]={520,332,280,256};
00243
00244 static VLC chroma_dc_coeff_token_vlc;
00245 static VLC_TYPE chroma_dc_coeff_token_vlc_table[256][2];
00246 static const int chroma_dc_coeff_token_vlc_table_size = 256;
00247
00248 static VLC chroma422_dc_coeff_token_vlc;
00249 static VLC_TYPE chroma422_dc_coeff_token_vlc_table[8192][2];
00250 static const int chroma422_dc_coeff_token_vlc_table_size = 8192;
00251
00252 static VLC total_zeros_vlc[15];
00253 static VLC_TYPE total_zeros_vlc_tables[15][512][2];
00254 static const int total_zeros_vlc_tables_size = 512;
00255
00256 static VLC chroma_dc_total_zeros_vlc[3];
00257 static VLC_TYPE chroma_dc_total_zeros_vlc_tables[3][8][2];
00258 static const int chroma_dc_total_zeros_vlc_tables_size = 8;
00259
00260 static VLC chroma422_dc_total_zeros_vlc[7];
00261 static VLC_TYPE chroma422_dc_total_zeros_vlc_tables[7][32][2];
00262 static const int chroma422_dc_total_zeros_vlc_tables_size = 32;
00263
00264 static VLC run_vlc[6];
00265 static VLC_TYPE run_vlc_tables[6][8][2];
00266 static const int run_vlc_tables_size = 8;
00267
00268 static VLC run7_vlc;
00269 static VLC_TYPE run7_vlc_table[96][2];
00270 static const int run7_vlc_table_size = 96;
00271
00272 #define LEVEL_TAB_BITS 8
00273 static int8_t cavlc_level_tab[7][1<<LEVEL_TAB_BITS][2];
00274
00275 #define CHROMA_DC_COEFF_TOKEN_VLC_BITS 8
00276 #define CHROMA422_DC_COEFF_TOKEN_VLC_BITS 13
00277 #define COEFF_TOKEN_VLC_BITS 8
00278 #define TOTAL_ZEROS_VLC_BITS 9
00279 #define CHROMA_DC_TOTAL_ZEROS_VLC_BITS 3
00280 #define CHROMA422_DC_TOTAL_ZEROS_VLC_BITS 5
00281 #define RUN_VLC_BITS 3
00282 #define RUN7_VLC_BITS 6
00283
00288 static inline int pred_non_zero_count(H264Context *h, int n){
00289 const int index8= scan8[n];
00290 const int left= h->non_zero_count_cache[index8 - 1];
00291 const int top = h->non_zero_count_cache[index8 - 8];
00292 int i= left + top;
00293
00294 if(i<64) i= (i+1)>>1;
00295
00296 tprintf(h->s.avctx, "pred_nnz L%X T%X n%d s%d P%X\n", left, top, n, scan8[n], i&31);
00297
00298 return i&31;
00299 }
00300
00301 static av_cold void init_cavlc_level_tab(void){
00302 int suffix_length;
00303 unsigned int i;
00304
00305 for(suffix_length=0; suffix_length<7; suffix_length++){
00306 for(i=0; i<(1<<LEVEL_TAB_BITS); i++){
00307 int prefix= LEVEL_TAB_BITS - av_log2(2*i);
00308
00309 if(prefix + 1 + suffix_length <= LEVEL_TAB_BITS){
00310 int level_code = (prefix << suffix_length) +
00311 (i >> (av_log2(i) - suffix_length)) - (1 << suffix_length);
00312 int mask = -(level_code&1);
00313 level_code = (((2 + level_code) >> 1) ^ mask) - mask;
00314 cavlc_level_tab[suffix_length][i][0]= level_code;
00315 cavlc_level_tab[suffix_length][i][1]= prefix + 1 + suffix_length;
00316 }else if(prefix + 1 <= LEVEL_TAB_BITS){
00317 cavlc_level_tab[suffix_length][i][0]= prefix+100;
00318 cavlc_level_tab[suffix_length][i][1]= prefix + 1;
00319 }else{
00320 cavlc_level_tab[suffix_length][i][0]= LEVEL_TAB_BITS+100;
00321 cavlc_level_tab[suffix_length][i][1]= LEVEL_TAB_BITS;
00322 }
00323 }
00324 }
00325 }
00326
00327 av_cold void ff_h264_decode_init_vlc(void){
00328 static int done = 0;
00329
00330 if (!done) {
00331 int i;
00332 int offset;
00333 done = 1;
00334
00335 chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table;
00336 chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size;
00337 init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5,
00338 &chroma_dc_coeff_token_len [0], 1, 1,
00339 &chroma_dc_coeff_token_bits[0], 1, 1,
00340 INIT_VLC_USE_NEW_STATIC);
00341
00342 chroma422_dc_coeff_token_vlc.table = chroma422_dc_coeff_token_vlc_table;
00343 chroma422_dc_coeff_token_vlc.table_allocated = chroma422_dc_coeff_token_vlc_table_size;
00344 init_vlc(&chroma422_dc_coeff_token_vlc, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 4*9,
00345 &chroma422_dc_coeff_token_len [0], 1, 1,
00346 &chroma422_dc_coeff_token_bits[0], 1, 1,
00347 INIT_VLC_USE_NEW_STATIC);
00348
00349 offset = 0;
00350 for(i=0; i<4; i++){
00351 coeff_token_vlc[i].table = coeff_token_vlc_tables+offset;
00352 coeff_token_vlc[i].table_allocated = coeff_token_vlc_tables_size[i];
00353 init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4*17,
00354 &coeff_token_len [i][0], 1, 1,
00355 &coeff_token_bits[i][0], 1, 1,
00356 INIT_VLC_USE_NEW_STATIC);
00357 offset += coeff_token_vlc_tables_size[i];
00358 }
00359
00360
00361
00362
00363
00364 assert(offset == FF_ARRAY_ELEMS(coeff_token_vlc_tables));
00365
00366 for(i=0; i<3; i++){
00367 chroma_dc_total_zeros_vlc[i].table = chroma_dc_total_zeros_vlc_tables[i];
00368 chroma_dc_total_zeros_vlc[i].table_allocated = chroma_dc_total_zeros_vlc_tables_size;
00369 init_vlc(&chroma_dc_total_zeros_vlc[i],
00370 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 4,
00371 &chroma_dc_total_zeros_len [i][0], 1, 1,
00372 &chroma_dc_total_zeros_bits[i][0], 1, 1,
00373 INIT_VLC_USE_NEW_STATIC);
00374 }
00375
00376 for(i=0; i<7; i++){
00377 chroma422_dc_total_zeros_vlc[i].table = chroma422_dc_total_zeros_vlc_tables[i];
00378 chroma422_dc_total_zeros_vlc[i].table_allocated = chroma422_dc_total_zeros_vlc_tables_size;
00379 init_vlc(&chroma422_dc_total_zeros_vlc[i],
00380 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 8,
00381 &chroma422_dc_total_zeros_len [i][0], 1, 1,
00382 &chroma422_dc_total_zeros_bits[i][0], 1, 1,
00383 INIT_VLC_USE_NEW_STATIC);
00384 }
00385
00386 for(i=0; i<15; i++){
00387 total_zeros_vlc[i].table = total_zeros_vlc_tables[i];
00388 total_zeros_vlc[i].table_allocated = total_zeros_vlc_tables_size;
00389 init_vlc(&total_zeros_vlc[i],
00390 TOTAL_ZEROS_VLC_BITS, 16,
00391 &total_zeros_len [i][0], 1, 1,
00392 &total_zeros_bits[i][0], 1, 1,
00393 INIT_VLC_USE_NEW_STATIC);
00394 }
00395
00396 for(i=0; i<6; i++){
00397 run_vlc[i].table = run_vlc_tables[i];
00398 run_vlc[i].table_allocated = run_vlc_tables_size;
00399 init_vlc(&run_vlc[i],
00400 RUN_VLC_BITS, 7,
00401 &run_len [i][0], 1, 1,
00402 &run_bits[i][0], 1, 1,
00403 INIT_VLC_USE_NEW_STATIC);
00404 }
00405 run7_vlc.table = run7_vlc_table,
00406 run7_vlc.table_allocated = run7_vlc_table_size;
00407 init_vlc(&run7_vlc, RUN7_VLC_BITS, 16,
00408 &run_len [6][0], 1, 1,
00409 &run_bits[6][0], 1, 1,
00410 INIT_VLC_USE_NEW_STATIC);
00411
00412 init_cavlc_level_tab();
00413 }
00414 }
00415
00419 static inline int get_level_prefix(GetBitContext *gb){
00420 unsigned int buf;
00421 int log;
00422
00423 OPEN_READER(re, gb);
00424 UPDATE_CACHE(re, gb);
00425 buf=GET_CACHE(re, gb);
00426
00427 log= 32 - av_log2(buf);
00428 #ifdef TRACE
00429 print_bin(buf>>(32-log), log);
00430 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__);
00431 #endif
00432
00433 LAST_SKIP_BITS(re, gb, log);
00434 CLOSE_READER(re, gb);
00435
00436 return log-1;
00437 }
00438
00446 static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){
00447 MpegEncContext * const s = &h->s;
00448 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};
00449 int level[16];
00450 int zeros_left, coeff_token, total_coeff, i, trailing_ones, run_before;
00451
00452
00453
00454 if(max_coeff <= 8){
00455 if (max_coeff == 4)
00456 coeff_token = get_vlc2(gb, chroma_dc_coeff_token_vlc.table, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 1);
00457 else
00458 coeff_token = get_vlc2(gb, chroma422_dc_coeff_token_vlc.table, CHROMA422_DC_COEFF_TOKEN_VLC_BITS, 1);
00459 total_coeff= coeff_token>>2;
00460 }else{
00461 if(n >= LUMA_DC_BLOCK_INDEX){
00462 total_coeff= pred_non_zero_count(h, (n - LUMA_DC_BLOCK_INDEX)*16);
00463 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00464 total_coeff= coeff_token>>2;
00465 }else{
00466 total_coeff= pred_non_zero_count(h, n);
00467 coeff_token= get_vlc2(gb, coeff_token_vlc[ coeff_token_table_index[total_coeff] ].table, COEFF_TOKEN_VLC_BITS, 2);
00468 total_coeff= coeff_token>>2;
00469 }
00470 }
00471 h->non_zero_count_cache[ scan8[n] ]= total_coeff;
00472
00473
00474
00475 if(total_coeff==0)
00476 return 0;
00477 if(total_coeff > (unsigned)max_coeff) {
00478 av_log(h->s.avctx, AV_LOG_ERROR, "corrupted macroblock %d %d (total_coeff=%d)\n", s->mb_x, s->mb_y, total_coeff);
00479 return -1;
00480 }
00481
00482 trailing_ones= coeff_token&3;
00483 tprintf(h->s.avctx, "trailing:%d, total:%d\n", trailing_ones, total_coeff);
00484 assert(total_coeff<=16);
00485
00486 i = show_bits(gb, 3);
00487 skip_bits(gb, trailing_ones);
00488 level[0] = 1-((i&4)>>1);
00489 level[1] = 1-((i&2) );
00490 level[2] = 1-((i&1)<<1);
00491
00492 if(trailing_ones<total_coeff) {
00493 int mask, prefix;
00494 int suffix_length = total_coeff > 10 & trailing_ones < 3;
00495 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00496 int level_code= cavlc_level_tab[suffix_length][bitsi][0];
00497
00498 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00499 if(level_code >= 100){
00500 prefix= level_code - 100;
00501 if(prefix == LEVEL_TAB_BITS)
00502 prefix += get_level_prefix(gb);
00503
00504
00505 if(prefix<14){
00506 if(suffix_length)
00507 level_code= (prefix<<1) + get_bits1(gb);
00508 else
00509 level_code= prefix;
00510 }else if(prefix==14){
00511 if(suffix_length)
00512 level_code= (prefix<<1) + get_bits1(gb);
00513 else
00514 level_code= prefix + get_bits(gb, 4);
00515 }else{
00516 level_code= 30 + get_bits(gb, prefix-3);
00517 if(prefix>=16){
00518 if(prefix > 25+3){
00519 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid level prefix\n");
00520 return -1;
00521 }
00522 level_code += (1<<(prefix-3))-4096;
00523 }
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 assert((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 assert(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 static const uint16_t mb_sizes[4] = {256,384,512,768};
00769 const int mb_size = mb_sizes[h->sps.chroma_format_idc]*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 assert(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 assert(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 }
01172
