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
00030 #include "internal.h"
00031 #include "avcodec.h"
00032 #include "mpegvideo.h"
00033 #include "h264.h"
00034 #include "h264data.h"
00035 #include "h264_mvpred.h"
00036 #include "golomb.h"
00037
00038
00039 #include <assert.h>
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 assert(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 assert(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 + get_bits(gb, prefix-3);
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 }
00524
00525 if(trailing_ones < 3) level_code += 2;
00526
00527 suffix_length = 2;
00528 mask= -(level_code&1);
00529 level[trailing_ones]= (((2+level_code)>>1) ^ mask) - mask;
00530 }else{
00531 level_code += ((level_code>>31)|1) & -(trailing_ones < 3);
00532
00533 suffix_length = 1 + (level_code + 3U > 6U);
00534 level[trailing_ones]= level_code;
00535 }
00536
00537
00538 for(i=trailing_ones+1;i<total_coeff;i++) {
00539 static const unsigned int suffix_limit[7] = {0,3,6,12,24,48,INT_MAX };
00540 int bitsi= show_bits(gb, LEVEL_TAB_BITS);
00541 level_code= cavlc_level_tab[suffix_length][bitsi][0];
00542
00543 skip_bits(gb, cavlc_level_tab[suffix_length][bitsi][1]);
00544 if(level_code >= 100){
00545 prefix= level_code - 100;
00546 if(prefix == LEVEL_TAB_BITS){
00547 prefix += get_level_prefix(gb);
00548 }
00549 if(prefix<15){
00550 level_code = (prefix<<suffix_length) + get_bits(gb, suffix_length);
00551 }else{
00552 level_code = (15<<suffix_length) + get_bits(gb, prefix-3);
00553 if(prefix>=16)
00554 level_code += (1<<(prefix-3))-4096;
00555 }
00556 mask= -(level_code&1);
00557 level_code= (((2+level_code)>>1) ^ mask) - mask;
00558 }
00559 level[i]= level_code;
00560 suffix_length+= suffix_limit[suffix_length] + level_code > 2U*suffix_limit[suffix_length];
00561 }
00562 }
00563
00564 if(total_coeff == max_coeff)
00565 zeros_left=0;
00566 else{
00567 if (max_coeff <= 8) {
00568 if (max_coeff == 4)
00569 zeros_left = get_vlc2(gb, (chroma_dc_total_zeros_vlc-1)[total_coeff].table,
00570 CHROMA_DC_TOTAL_ZEROS_VLC_BITS, 1);
00571 else
00572 zeros_left = get_vlc2(gb, (chroma422_dc_total_zeros_vlc-1)[total_coeff].table,
00573 CHROMA422_DC_TOTAL_ZEROS_VLC_BITS, 1);
00574 } else {
00575 zeros_left= get_vlc2(gb, (total_zeros_vlc-1)[ total_coeff ].table, TOTAL_ZEROS_VLC_BITS, 1);
00576 }
00577 }
00578
00579 #define STORE_BLOCK(type) \
00580 scantable += zeros_left + total_coeff - 1; \
00581 if(n >= LUMA_DC_BLOCK_INDEX){ \
00582 ((type*)block)[*scantable] = level[0]; \
00583 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
00584 if(zeros_left < 7) \
00585 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
00586 else \
00587 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
00588 zeros_left -= run_before; \
00589 scantable -= 1 + run_before; \
00590 ((type*)block)[*scantable]= level[i]; \
00591 } \
00592 for(;i<total_coeff;i++) { \
00593 scantable--; \
00594 ((type*)block)[*scantable]= level[i]; \
00595 } \
00596 }else{ \
00597 ((type*)block)[*scantable] = ((int)(level[0] * qmul[*scantable] + 32))>>6; \
00598 for(i=1;i<total_coeff && zeros_left > 0;i++) { \
00599 if(zeros_left < 7) \
00600 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); \
00601 else \
00602 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); \
00603 zeros_left -= run_before; \
00604 scantable -= 1 + run_before; \
00605 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
00606 } \
00607 for(;i<total_coeff;i++) { \
00608 scantable--; \
00609 ((type*)block)[*scantable]= ((int)(level[i] * qmul[*scantable] + 32))>>6; \
00610 } \
00611 }
00612
00613 if (h->pixel_shift) {
00614 STORE_BLOCK(int32_t)
00615 } else {
00616 STORE_BLOCK(int16_t)
00617 }
00618
00619 if(zeros_left<0){
00620 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y);
00621 return -1;
00622 }
00623
00624 return 0;
00625 }
00626
00627 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){
00628 int i4x4, i8x8;
00629 MpegEncContext * const s = &h->s;
00630 int qscale = p == 0 ? s->qscale : h->chroma_qp[p-1];
00631 if(IS_INTRA16x16(mb_type)){
00632 AV_ZERO128(h->mb_luma_dc[p]+0);
00633 AV_ZERO128(h->mb_luma_dc[p]+8);
00634 AV_ZERO128(h->mb_luma_dc[p]+16);
00635 AV_ZERO128(h->mb_luma_dc[p]+24);
00636 if( decode_residual(h, h->intra_gb_ptr, h->mb_luma_dc[p], LUMA_DC_BLOCK_INDEX+p, scan, NULL, 16) < 0){
00637 return -1;
00638 }
00639
00640 assert((cbp&15) == 0 || (cbp&15) == 15);
00641
00642 if(cbp&15){
00643 for(i8x8=0; i8x8<4; i8x8++){
00644 for(i4x4=0; i4x4<4; i4x4++){
00645 const int index= i4x4 + 4*i8x8 + p*16;
00646 if( decode_residual(h, h->intra_gb_ptr, h->mb + (16*index << pixel_shift),
00647 index, scan + 1, h->dequant4_coeff[p][qscale], 15) < 0 ){
00648 return -1;
00649 }
00650 }
00651 }
00652 return 0xf;
00653 }else{
00654 fill_rectangle(&h->non_zero_count_cache[scan8[p*16]], 4, 4, 8, 0, 1);
00655 return 0;
00656 }
00657 }else{
00658 int cqm = (IS_INTRA( mb_type ) ? 0:3)+p;
00659
00660 int new_cbp = 0;
00661 for(i8x8=0; i8x8<4; i8x8++){
00662 if(cbp & (1<<i8x8)){
00663 if(IS_8x8DCT(mb_type)){
00664 DCTELEM *buf = &h->mb[64*i8x8+256*p << pixel_shift];
00665 uint8_t *nnz;
00666 for(i4x4=0; i4x4<4; i4x4++){
00667 const int index= i4x4 + 4*i8x8 + p*16;
00668 if( decode_residual(h, gb, buf, index, scan8x8+16*i4x4,
00669 h->dequant8_coeff[cqm][qscale], 16) < 0 )
00670 return -1;
00671 }
00672 nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
00673 nnz[0] += nnz[1] + nnz[8] + nnz[9];
00674 new_cbp |= !!nnz[0] << i8x8;
00675 }else{
00676 for(i4x4=0; i4x4<4; i4x4++){
00677 const int index= i4x4 + 4*i8x8 + p*16;
00678 if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index,
00679 scan, h->dequant4_coeff[cqm][qscale], 16) < 0 ){
00680 return -1;
00681 }
00682 new_cbp |= h->non_zero_count_cache[ scan8[index] ] << i8x8;
00683 }
00684 }
00685 }else{
00686 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8+p*16] ];
00687 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0;
00688 }
00689 }
00690 return new_cbp;
00691 }
00692 }
00693
00694 int ff_h264_decode_mb_cavlc(H264Context *h){
00695 MpegEncContext * const s = &h->s;
00696 int mb_xy;
00697 int partition_count;
00698 unsigned int mb_type, cbp;
00699 int dct8x8_allowed= h->pps.transform_8x8_mode;
00700 int decode_chroma = h->sps.chroma_format_idc == 1 || h->sps.chroma_format_idc == 2;
00701 const int pixel_shift = h->pixel_shift;
00702
00703 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
00704
00705 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y);
00706 cbp = 0;
00707
00708 if(h->slice_type_nos != AV_PICTURE_TYPE_I){
00709 if(s->mb_skip_run==-1)
00710 s->mb_skip_run= get_ue_golomb(&s->gb);
00711
00712 if (s->mb_skip_run--) {
00713 if(FRAME_MBAFF && (s->mb_y&1) == 0){
00714 if(s->mb_skip_run==0)
00715 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00716 }
00717 decode_mb_skip(h);
00718 return 0;
00719 }
00720 }
00721 if(FRAME_MBAFF){
00722 if( (s->mb_y&1) == 0 )
00723 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb);
00724 }
00725
00726 h->prev_mb_skipped= 0;
00727
00728 mb_type= get_ue_golomb(&s->gb);
00729 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00730 if(mb_type < 23){
00731 partition_count= b_mb_type_info[mb_type].partition_count;
00732 mb_type= b_mb_type_info[mb_type].type;
00733 }else{
00734 mb_type -= 23;
00735 goto decode_intra_mb;
00736 }
00737 }else if(h->slice_type_nos == AV_PICTURE_TYPE_P){
00738 if(mb_type < 5){
00739 partition_count= p_mb_type_info[mb_type].partition_count;
00740 mb_type= p_mb_type_info[mb_type].type;
00741 }else{
00742 mb_type -= 5;
00743 goto decode_intra_mb;
00744 }
00745 }else{
00746 assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
00747 if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
00748 mb_type--;
00749 decode_intra_mb:
00750 if(mb_type > 25){
00751 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);
00752 return -1;
00753 }
00754 partition_count=0;
00755 cbp= i_mb_type_info[mb_type].cbp;
00756 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode;
00757 mb_type= i_mb_type_info[mb_type].type;
00758 }
00759
00760 if(MB_FIELD)
00761 mb_type |= MB_TYPE_INTERLACED;
00762
00763 h->slice_table[ mb_xy ]= h->slice_num;
00764
00765 if(IS_INTRA_PCM(mb_type)){
00766 unsigned int x;
00767 static const uint16_t mb_sizes[4] = {256,384,512,768};
00768 const int mb_size = mb_sizes[h->sps.chroma_format_idc]*h->sps.bit_depth_luma >> 3;
00769
00770
00771 align_get_bits(&s->gb);
00772
00773
00774 for(x=0; x < mb_size; x++){
00775 ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00776 }
00777
00778
00779 s->current_picture.f.qscale_table[mb_xy] = 0;
00780
00781 memset(h->non_zero_count[mb_xy], 16, 48);
00782
00783 s->current_picture.f.mb_type[mb_xy] = mb_type;
00784 return 0;
00785 }
00786
00787 if(MB_MBAFF){
00788 h->ref_count[0] <<= 1;
00789 h->ref_count[1] <<= 1;
00790 }
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 assert(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 : h->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(h->ref_count[list]==1){
00952 val= 0;
00953 }else if(h->ref_count[list]==2){
00954 val= get_bits1(&s->gb)^1;
00955 }else{
00956 val= get_ue_golomb_31(&s->gb);
00957 if(val >= h->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(h->ref_count[list] == 1){
00982 val= 0;
00983 }else if(h->ref_count[list] == 2){
00984 val= get_bits1(&s->gb)^1;
00985 }else{
00986 val= get_ue_golomb_31(&s->gb);
00987 if(val >= h->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 assert(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(h->ref_count[list]==1){
01019 val= 0;
01020 }else if(h->ref_count[list]==2){
01021 val= get_bits1(&s->gb)^1;
01022 }else{
01023 val= get_ue_golomb_31(&s->gb);
01024 if(val >= h->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 }
01074
01075 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
01076 mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
01077 }
01078 h->cbp=
01079 h->cbp_table[mb_xy]= cbp;
01080 s->current_picture.f.mb_type[mb_xy] = mb_type;
01081
01082 if(cbp || IS_INTRA16x16(mb_type)){
01083 int i4x4, i8x8, chroma_idx;
01084 int dquant;
01085 int ret;
01086 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
01087 const uint8_t *scan, *scan8x8;
01088 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
01089
01090 if(IS_INTERLACED(mb_type)){
01091 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
01092 scan= s->qscale ? h->field_scan : h->field_scan_q0;
01093 }else{
01094 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
01095 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01096 }
01097
01098 dquant= get_se_golomb(&s->gb);
01099
01100 s->qscale += dquant;
01101
01102 if(((unsigned)s->qscale) > max_qp){
01103 if(s->qscale<0) s->qscale+= max_qp+1;
01104 else s->qscale-= max_qp+1;
01105 if(((unsigned)s->qscale) > max_qp){
01106 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
01107 return -1;
01108 }
01109 }
01110
01111 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
01112 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
01113
01114 if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
01115 return -1;
01116 }
01117 h->cbp_table[mb_xy] |= ret << 12;
01118 if(CHROMA444){
01119 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
01120 return -1;
01121 }
01122 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
01123 return -1;
01124 }
01125 } else if (CHROMA422) {
01126 if(cbp&0x30){
01127 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01128 if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
01129 CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
01130 NULL, 8) < 0) {
01131 return -1;
01132 }
01133 }
01134
01135 if(cbp&0x20){
01136 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01137 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01138 DCTELEM *mb = h->mb + (16*(16 + 16*chroma_idx) << pixel_shift);
01139 for (i8x8 = 0; i8x8 < 2; i8x8++) {
01140 for (i4x4 = 0; i4x4 < 4; i4x4++) {
01141 const int index = 16 + 16*chroma_idx + 8*i8x8 + i4x4;
01142 if (decode_residual(h, gb, mb, index, scan + 1, qmul, 15) < 0)
01143 return -1;
01144 mb += 16 << pixel_shift;
01145 }
01146 }
01147 }
01148 }else{
01149 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01150 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01151 }
01152 } else {
01153 if(cbp&0x30){
01154 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01155 if( decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift), CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma_dc_scan, NULL, 4) < 0){
01156 return -1;
01157 }
01158 }
01159
01160 if(cbp&0x20){
01161 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01162 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01163 for(i4x4=0; i4x4<4; i4x4++){
01164 const int index= 16 + 16*chroma_idx + i4x4;
01165 if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
01166 return -1;
01167 }
01168 }
01169 }
01170 }else{
01171 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01172 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01173 }
01174 }
01175 }else{
01176 fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
01177 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01178 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01179 }
01180 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
01181 write_back_non_zero_count(h);
01182
01183 if(MB_MBAFF){
01184 h->ref_count[0] >>= 1;
01185 h->ref_count[1] >>= 1;
01186 }
01187
01188 return 0;
01189 }
01190