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