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 if (get_bits_left(&s->gb) < mb_size) {
00773 av_log(s->avctx, AV_LOG_ERROR, "Not enough data for an intra PCM block.\n");
00774 return AVERROR_INVALIDDATA;
00775 }
00776
00777
00778 for(x=0; x < mb_size; x++){
00779 ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8);
00780 }
00781
00782
00783 s->current_picture.f.qscale_table[mb_xy] = 0;
00784
00785 memset(h->non_zero_count[mb_xy], 16, 48);
00786
00787 s->current_picture.f.mb_type[mb_xy] = mb_type;
00788 return 0;
00789 }
00790
00791 if(MB_MBAFF){
00792 h->ref_count[0] <<= 1;
00793 h->ref_count[1] <<= 1;
00794 }
00795
00796 fill_decode_neighbors(h, mb_type);
00797 fill_decode_caches(h, mb_type);
00798
00799
00800 if(IS_INTRA(mb_type)){
00801 int pred_mode;
00802
00803 if(IS_INTRA4x4(mb_type)){
00804 int i;
00805 int di = 1;
00806 if(dct8x8_allowed && get_bits1(&s->gb)){
00807 mb_type |= MB_TYPE_8x8DCT;
00808 di = 4;
00809 }
00810
00811
00812 for(i=0; i<16; i+=di){
00813 int mode= pred_intra_mode(h, i);
00814
00815 if(!get_bits1(&s->gb)){
00816 const int rem_mode= get_bits(&s->gb, 3);
00817 mode = rem_mode + (rem_mode >= mode);
00818 }
00819
00820 if(di==4)
00821 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 );
00822 else
00823 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode;
00824 }
00825 write_back_intra_pred_mode(h);
00826 if( ff_h264_check_intra4x4_pred_mode(h) < 0)
00827 return -1;
00828 }else{
00829 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode, 0);
00830 if(h->intra16x16_pred_mode < 0)
00831 return -1;
00832 }
00833 if(decode_chroma){
00834 pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb), 1);
00835 if(pred_mode < 0)
00836 return -1;
00837 h->chroma_pred_mode= pred_mode;
00838 } else {
00839 h->chroma_pred_mode = DC_128_PRED8x8;
00840 }
00841 }else if(partition_count==4){
00842 int i, j, sub_partition_count[4], list, ref[2][4];
00843
00844 if(h->slice_type_nos == AV_PICTURE_TYPE_B){
00845 for(i=0; i<4; i++){
00846 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00847 if(h->sub_mb_type[i] >=13){
00848 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);
00849 return -1;
00850 }
00851 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00852 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00853 }
00854 if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) {
00855 ff_h264_pred_direct_motion(h, &mb_type);
00856 h->ref_cache[0][scan8[4]] =
00857 h->ref_cache[1][scan8[4]] =
00858 h->ref_cache[0][scan8[12]] =
00859 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE;
00860 }
00861 }else{
00862 assert(h->slice_type_nos == AV_PICTURE_TYPE_P);
00863 for(i=0; i<4; i++){
00864 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb);
00865 if(h->sub_mb_type[i] >=4){
00866 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);
00867 return -1;
00868 }
00869 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count;
00870 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type;
00871 }
00872 }
00873
00874 for(list=0; list<h->list_count; list++){
00875 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list];
00876 for(i=0; i<4; i++){
00877 if(IS_DIRECT(h->sub_mb_type[i])) continue;
00878 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00879 unsigned int tmp;
00880 if(ref_count == 1){
00881 tmp= 0;
00882 }else if(ref_count == 2){
00883 tmp= get_bits1(&s->gb)^1;
00884 }else{
00885 tmp= get_ue_golomb_31(&s->gb);
00886 if(tmp>=ref_count){
00887 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp);
00888 return -1;
00889 }
00890 }
00891 ref[list][i]= tmp;
00892 }else{
00893
00894 ref[list][i] = -1;
00895 }
00896 }
00897 }
00898
00899 if(dct8x8_allowed)
00900 dct8x8_allowed = get_dct8x8_allowed(h);
00901
00902 for(list=0; list<h->list_count; list++){
00903 for(i=0; i<4; i++){
00904 if(IS_DIRECT(h->sub_mb_type[i])) {
00905 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ];
00906 continue;
00907 }
00908 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]=
00909 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i];
00910
00911 if(IS_DIR(h->sub_mb_type[i], 0, list)){
00912 const int sub_mb_type= h->sub_mb_type[i];
00913 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1;
00914 for(j=0; j<sub_partition_count[i]; j++){
00915 int mx, my;
00916 const int index= 4*i + block_width*j;
00917 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
00918 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
00919 mx += get_se_golomb(&s->gb);
00920 my += get_se_golomb(&s->gb);
00921 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00922
00923 if(IS_SUB_8X8(sub_mb_type)){
00924 mv_cache[ 1 ][0]=
00925 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx;
00926 mv_cache[ 1 ][1]=
00927 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my;
00928 }else if(IS_SUB_8X4(sub_mb_type)){
00929 mv_cache[ 1 ][0]= mx;
00930 mv_cache[ 1 ][1]= my;
00931 }else if(IS_SUB_4X8(sub_mb_type)){
00932 mv_cache[ 8 ][0]= mx;
00933 mv_cache[ 8 ][1]= my;
00934 }
00935 mv_cache[ 0 ][0]= mx;
00936 mv_cache[ 0 ][1]= my;
00937 }
00938 }else{
00939 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0];
00940 p[0] = p[1]=
00941 p[8] = p[9]= 0;
00942 }
00943 }
00944 }
00945 }else if(IS_DIRECT(mb_type)){
00946 ff_h264_pred_direct_motion(h, &mb_type);
00947 dct8x8_allowed &= h->sps.direct_8x8_inference_flag;
00948 }else{
00949 int list, mx, my, i;
00950
00951 if(IS_16X16(mb_type)){
00952 for(list=0; list<h->list_count; list++){
00953 unsigned int val;
00954 if(IS_DIR(mb_type, 0, list)){
00955 if(h->ref_count[list]==1){
00956 val= 0;
00957 }else if(h->ref_count[list]==2){
00958 val= get_bits1(&s->gb)^1;
00959 }else{
00960 val= get_ue_golomb_31(&s->gb);
00961 if(val >= h->ref_count[list]){
00962 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00963 return -1;
00964 }
00965 }
00966 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1);
00967 }
00968 }
00969 for(list=0; list<h->list_count; list++){
00970 if(IS_DIR(mb_type, 0, list)){
00971 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
00972 mx += get_se_golomb(&s->gb);
00973 my += get_se_golomb(&s->gb);
00974 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
00975
00976 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4);
00977 }
00978 }
00979 }
00980 else if(IS_16X8(mb_type)){
00981 for(list=0; list<h->list_count; list++){
00982 for(i=0; i<2; i++){
00983 unsigned int val;
00984 if(IS_DIR(mb_type, i, list)){
00985 if(h->ref_count[list] == 1){
00986 val= 0;
00987 }else if(h->ref_count[list] == 2){
00988 val= get_bits1(&s->gb)^1;
00989 }else{
00990 val= get_ue_golomb_31(&s->gb);
00991 if(val >= h->ref_count[list]){
00992 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
00993 return -1;
00994 }
00995 }
00996 }else
00997 val= LIST_NOT_USED&0xFF;
00998 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1);
00999 }
01000 }
01001 for(list=0; list<h->list_count; list++){
01002 for(i=0; i<2; i++){
01003 unsigned int val;
01004 if(IS_DIR(mb_type, i, list)){
01005 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
01006 mx += get_se_golomb(&s->gb);
01007 my += get_se_golomb(&s->gb);
01008 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01009
01010 val= pack16to32(mx,my);
01011 }else
01012 val=0;
01013 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4);
01014 }
01015 }
01016 }else{
01017 assert(IS_8X16(mb_type));
01018 for(list=0; list<h->list_count; list++){
01019 for(i=0; i<2; i++){
01020 unsigned int val;
01021 if(IS_DIR(mb_type, i, list)){
01022 if(h->ref_count[list]==1){
01023 val= 0;
01024 }else if(h->ref_count[list]==2){
01025 val= get_bits1(&s->gb)^1;
01026 }else{
01027 val= get_ue_golomb_31(&s->gb);
01028 if(val >= h->ref_count[list]){
01029 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val);
01030 return -1;
01031 }
01032 }
01033 }else
01034 val= LIST_NOT_USED&0xFF;
01035 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1);
01036 }
01037 }
01038 for(list=0; list<h->list_count; list++){
01039 for(i=0; i<2; i++){
01040 unsigned int val;
01041 if(IS_DIR(mb_type, i, list)){
01042 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
01043 mx += get_se_golomb(&s->gb);
01044 my += get_se_golomb(&s->gb);
01045 tprintf(s->avctx, "final mv:%d %d\n", mx, my);
01046
01047 val= pack16to32(mx,my);
01048 }else
01049 val=0;
01050 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4);
01051 }
01052 }
01053 }
01054 }
01055
01056 if(IS_INTER(mb_type))
01057 write_back_motion(h, mb_type);
01058
01059 if(!IS_INTRA16x16(mb_type)){
01060 cbp= get_ue_golomb(&s->gb);
01061
01062 if(decode_chroma){
01063 if(cbp > 47){
01064 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01065 return -1;
01066 }
01067 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp];
01068 else cbp= golomb_to_inter_cbp [cbp];
01069 }else{
01070 if(cbp > 15){
01071 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y);
01072 return -1;
01073 }
01074 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp];
01075 else cbp= golomb_to_inter_cbp_gray[cbp];
01076 }
01077 }
01078
01079 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){
01080 mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb);
01081 }
01082 h->cbp=
01083 h->cbp_table[mb_xy]= cbp;
01084 s->current_picture.f.mb_type[mb_xy] = mb_type;
01085
01086 if(cbp || IS_INTRA16x16(mb_type)){
01087 int i4x4, i8x8, chroma_idx;
01088 int dquant;
01089 int ret;
01090 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr;
01091 const uint8_t *scan, *scan8x8;
01092 const int max_qp = 51 + 6*(h->sps.bit_depth_luma-8);
01093
01094 if(IS_INTERLACED(mb_type)){
01095 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0;
01096 scan= s->qscale ? h->field_scan : h->field_scan_q0;
01097 }else{
01098 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0;
01099 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0;
01100 }
01101
01102 dquant= get_se_golomb(&s->gb);
01103
01104 s->qscale += dquant;
01105
01106 if(((unsigned)s->qscale) > max_qp){
01107 if(s->qscale<0) s->qscale+= max_qp+1;
01108 else s->qscale-= max_qp+1;
01109 if(((unsigned)s->qscale) > max_qp){
01110 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y);
01111 return -1;
01112 }
01113 }
01114
01115 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale);
01116 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale);
01117
01118 if( (ret = decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 0)) < 0 ){
01119 return -1;
01120 }
01121 h->cbp_table[mb_xy] |= ret << 12;
01122 if(CHROMA444){
01123 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 1) < 0 ){
01124 return -1;
01125 }
01126 if( decode_luma_residual(h, gb, scan, scan8x8, pixel_shift, mb_type, cbp, 2) < 0 ){
01127 return -1;
01128 }
01129 } else if (CHROMA422) {
01130 if(cbp&0x30){
01131 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01132 if (decode_residual(h, gb, h->mb + ((256 + 16*16*chroma_idx) << pixel_shift),
01133 CHROMA_DC_BLOCK_INDEX+chroma_idx, chroma422_dc_scan,
01134 NULL, 8) < 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 < 2; 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 } else {
01157 if(cbp&0x30){
01158 for(chroma_idx=0; chroma_idx<2; chroma_idx++)
01159 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){
01160 return -1;
01161 }
01162 }
01163
01164 if(cbp&0x20){
01165 for(chroma_idx=0; chroma_idx<2; chroma_idx++){
01166 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]];
01167 for(i4x4=0; i4x4<4; i4x4++){
01168 const int index= 16 + 16*chroma_idx + i4x4;
01169 if( decode_residual(h, gb, h->mb + (16*index << pixel_shift), index, scan + 1, qmul, 15) < 0){
01170 return -1;
01171 }
01172 }
01173 }
01174 }else{
01175 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01176 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01177 }
01178 }
01179 }else{
01180 fill_rectangle(&h->non_zero_count_cache[scan8[ 0]], 4, 4, 8, 0, 1);
01181 fill_rectangle(&h->non_zero_count_cache[scan8[16]], 4, 4, 8, 0, 1);
01182 fill_rectangle(&h->non_zero_count_cache[scan8[32]], 4, 4, 8, 0, 1);
01183 }
01184 s->current_picture.f.qscale_table[mb_xy] = s->qscale;
01185 write_back_non_zero_count(h);
01186
01187 if(MB_MBAFF){
01188 h->ref_count[0] >>= 1;
01189 h->ref_count[1] >>= 1;
01190 }
01191
01192 return 0;
01193 }
01194