Libav
|
00001 /* 00002 * H.26L/H.264/AVC/JVT/14496-10/... cavlc bitstream decoding 00003 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at> 00004 * 00005 * This file is part of FFmpeg. 00006 * 00007 * FFmpeg is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * FFmpeg is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with FFmpeg; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 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" // FIXME FIXME FIXME 00035 #include "h264_mvpred.h" 00036 #include "golomb.h" 00037 00038 //#undef NDEBUG 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 * This is a one time safety check to make sure that 00292 * the packed static coeff_token_vlc table sizes 00293 * were initialized correctly. 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_num, coeff_token, total_coeff, i, j, trailing_ones, run_before; 00371 00372 //FIXME put trailing_onex into the context 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 h->non_zero_count_cache[ scan8[n] ]= total_coeff; 00387 } 00388 } 00389 00390 //FIXME set last_non_zero? 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 //first coefficient has suffix_length equal to 0 or 1 00422 if(prefix<14){ //FIXME try to build a large unified VLC table for all this 00423 if(suffix_length) 00424 level_code= (prefix<<1) + get_bits1(gb); //part 00425 else 00426 level_code= prefix; //part 00427 }else if(prefix==14){ 00428 if(suffix_length) 00429 level_code= (prefix<<1) + get_bits1(gb); //part 00430 else 00431 level_code= prefix + get_bits(gb, 4); //part 00432 }else{ 00433 level_code= 30 + get_bits(gb, prefix-3); //part 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 //remaining coefficients have suffix_length > 0 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 coeff_num = zeros_left + total_coeff - 1; 00492 j = scantable[coeff_num]; 00493 if(n > 24){ 00494 block[j] = level[0]; 00495 for(i=1;i<total_coeff;i++) { 00496 if(zeros_left <= 0) 00497 run_before = 0; 00498 else if(zeros_left < 7){ 00499 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); 00500 }else{ 00501 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); 00502 } 00503 zeros_left -= run_before; 00504 coeff_num -= 1 + run_before; 00505 j= scantable[ coeff_num ]; 00506 00507 block[j]= level[i]; 00508 } 00509 }else{ 00510 block[j] = (level[0] * qmul[j] + 32)>>6; 00511 for(i=1;i<total_coeff;i++) { 00512 if(zeros_left <= 0) 00513 run_before = 0; 00514 else if(zeros_left < 7){ 00515 run_before= get_vlc2(gb, (run_vlc-1)[zeros_left].table, RUN_VLC_BITS, 1); 00516 }else{ 00517 run_before= get_vlc2(gb, run7_vlc.table, RUN7_VLC_BITS, 2); 00518 } 00519 zeros_left -= run_before; 00520 coeff_num -= 1 + run_before; 00521 j= scantable[ coeff_num ]; 00522 00523 block[j]= (level[i] * qmul[j] + 32)>>6; 00524 } 00525 } 00526 00527 if(zeros_left<0){ 00528 av_log(h->s.avctx, AV_LOG_ERROR, "negative number of zero coeffs at %d %d\n", s->mb_x, s->mb_y); 00529 return -1; 00530 } 00531 00532 return 0; 00533 } 00534 00535 int ff_h264_decode_mb_cavlc(H264Context *h){ 00536 MpegEncContext * const s = &h->s; 00537 int mb_xy; 00538 int partition_count; 00539 unsigned int mb_type, cbp; 00540 int dct8x8_allowed= h->pps.transform_8x8_mode; 00541 00542 mb_xy = h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; 00543 00544 tprintf(s->avctx, "pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); 00545 cbp = 0; /* avoid warning. FIXME: find a solution without slowing 00546 down the code */ 00547 if(h->slice_type_nos != FF_I_TYPE){ 00548 if(s->mb_skip_run==-1) 00549 s->mb_skip_run= get_ue_golomb(&s->gb); 00550 00551 if (s->mb_skip_run--) { 00552 if(FRAME_MBAFF && (s->mb_y&1) == 0){ 00553 if(s->mb_skip_run==0) 00554 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); 00555 } 00556 decode_mb_skip(h); 00557 return 0; 00558 } 00559 } 00560 if(FRAME_MBAFF){ 00561 if( (s->mb_y&1) == 0 ) 00562 h->mb_mbaff = h->mb_field_decoding_flag = get_bits1(&s->gb); 00563 } 00564 00565 h->prev_mb_skipped= 0; 00566 00567 mb_type= get_ue_golomb(&s->gb); 00568 if(h->slice_type_nos == FF_B_TYPE){ 00569 if(mb_type < 23){ 00570 partition_count= b_mb_type_info[mb_type].partition_count; 00571 mb_type= b_mb_type_info[mb_type].type; 00572 }else{ 00573 mb_type -= 23; 00574 goto decode_intra_mb; 00575 } 00576 }else if(h->slice_type_nos == FF_P_TYPE){ 00577 if(mb_type < 5){ 00578 partition_count= p_mb_type_info[mb_type].partition_count; 00579 mb_type= p_mb_type_info[mb_type].type; 00580 }else{ 00581 mb_type -= 5; 00582 goto decode_intra_mb; 00583 } 00584 }else{ 00585 assert(h->slice_type_nos == FF_I_TYPE); 00586 if(h->slice_type == FF_SI_TYPE && mb_type) 00587 mb_type--; 00588 decode_intra_mb: 00589 if(mb_type > 25){ 00590 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); 00591 return -1; 00592 } 00593 partition_count=0; 00594 cbp= i_mb_type_info[mb_type].cbp; 00595 h->intra16x16_pred_mode= i_mb_type_info[mb_type].pred_mode; 00596 mb_type= i_mb_type_info[mb_type].type; 00597 } 00598 00599 if(MB_FIELD) 00600 mb_type |= MB_TYPE_INTERLACED; 00601 00602 h->slice_table[ mb_xy ]= h->slice_num; 00603 00604 if(IS_INTRA_PCM(mb_type)){ 00605 unsigned int x; 00606 00607 // We assume these blocks are very rare so we do not optimize it. 00608 align_get_bits(&s->gb); 00609 00610 // The pixels are stored in the same order as levels in h->mb array. 00611 for(x=0; x < (CHROMA ? 384 : 256); x++){ 00612 ((uint8_t*)h->mb)[x]= get_bits(&s->gb, 8); 00613 } 00614 00615 // In deblocking, the quantizer is 0 00616 s->current_picture.qscale_table[mb_xy]= 0; 00617 // All coeffs are present 00618 memset(h->non_zero_count[mb_xy], 16, 32); 00619 00620 s->current_picture.mb_type[mb_xy]= mb_type; 00621 return 0; 00622 } 00623 00624 if(MB_MBAFF){ 00625 h->ref_count[0] <<= 1; 00626 h->ref_count[1] <<= 1; 00627 } 00628 00629 fill_decode_neighbors(h, mb_type); 00630 fill_decode_caches(h, mb_type); 00631 00632 //mb_pred 00633 if(IS_INTRA(mb_type)){ 00634 int pred_mode; 00635 // init_top_left_availability(h); 00636 if(IS_INTRA4x4(mb_type)){ 00637 int i; 00638 int di = 1; 00639 if(dct8x8_allowed && get_bits1(&s->gb)){ 00640 mb_type |= MB_TYPE_8x8DCT; 00641 di = 4; 00642 } 00643 00644 // fill_intra4x4_pred_table(h); 00645 for(i=0; i<16; i+=di){ 00646 int mode= pred_intra_mode(h, i); 00647 00648 if(!get_bits1(&s->gb)){ 00649 const int rem_mode= get_bits(&s->gb, 3); 00650 mode = rem_mode + (rem_mode >= mode); 00651 } 00652 00653 if(di==4) 00654 fill_rectangle( &h->intra4x4_pred_mode_cache[ scan8[i] ], 2, 2, 8, mode, 1 ); 00655 else 00656 h->intra4x4_pred_mode_cache[ scan8[i] ] = mode; 00657 } 00658 ff_h264_write_back_intra_pred_mode(h); 00659 if( ff_h264_check_intra4x4_pred_mode(h) < 0) 00660 return -1; 00661 }else{ 00662 h->intra16x16_pred_mode= ff_h264_check_intra_pred_mode(h, h->intra16x16_pred_mode); 00663 if(h->intra16x16_pred_mode < 0) 00664 return -1; 00665 } 00666 if(CHROMA){ 00667 pred_mode= ff_h264_check_intra_pred_mode(h, get_ue_golomb_31(&s->gb)); 00668 if(pred_mode < 0) 00669 return -1; 00670 h->chroma_pred_mode= pred_mode; 00671 } 00672 }else if(partition_count==4){ 00673 int i, j, sub_partition_count[4], list, ref[2][4]; 00674 00675 if(h->slice_type_nos == FF_B_TYPE){ 00676 for(i=0; i<4; i++){ 00677 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb); 00678 if(h->sub_mb_type[i] >=13){ 00679 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); 00680 return -1; 00681 } 00682 sub_partition_count[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; 00683 h->sub_mb_type[i]= b_sub_mb_type_info[ h->sub_mb_type[i] ].type; 00684 } 00685 if( IS_DIRECT(h->sub_mb_type[0]|h->sub_mb_type[1]|h->sub_mb_type[2]|h->sub_mb_type[3])) { 00686 ff_h264_pred_direct_motion(h, &mb_type); 00687 h->ref_cache[0][scan8[4]] = 00688 h->ref_cache[1][scan8[4]] = 00689 h->ref_cache[0][scan8[12]] = 00690 h->ref_cache[1][scan8[12]] = PART_NOT_AVAILABLE; 00691 } 00692 }else{ 00693 assert(h->slice_type_nos == FF_P_TYPE); //FIXME SP correct ? 00694 for(i=0; i<4; i++){ 00695 h->sub_mb_type[i]= get_ue_golomb_31(&s->gb); 00696 if(h->sub_mb_type[i] >=4){ 00697 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); 00698 return -1; 00699 } 00700 sub_partition_count[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].partition_count; 00701 h->sub_mb_type[i]= p_sub_mb_type_info[ h->sub_mb_type[i] ].type; 00702 } 00703 } 00704 00705 for(list=0; list<h->list_count; list++){ 00706 int ref_count= IS_REF0(mb_type) ? 1 : h->ref_count[list]; 00707 for(i=0; i<4; i++){ 00708 if(IS_DIRECT(h->sub_mb_type[i])) continue; 00709 if(IS_DIR(h->sub_mb_type[i], 0, list)){ 00710 unsigned int tmp; 00711 if(ref_count == 1){ 00712 tmp= 0; 00713 }else if(ref_count == 2){ 00714 tmp= get_bits1(&s->gb)^1; 00715 }else{ 00716 tmp= get_ue_golomb_31(&s->gb); 00717 if(tmp>=ref_count){ 00718 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", tmp); 00719 return -1; 00720 } 00721 } 00722 ref[list][i]= tmp; 00723 }else{ 00724 //FIXME 00725 ref[list][i] = -1; 00726 } 00727 } 00728 } 00729 00730 if(dct8x8_allowed) 00731 dct8x8_allowed = get_dct8x8_allowed(h); 00732 00733 for(list=0; list<h->list_count; list++){ 00734 for(i=0; i<4; i++){ 00735 if(IS_DIRECT(h->sub_mb_type[i])) { 00736 h->ref_cache[list][ scan8[4*i] ] = h->ref_cache[list][ scan8[4*i]+1 ]; 00737 continue; 00738 } 00739 h->ref_cache[list][ scan8[4*i] ]=h->ref_cache[list][ scan8[4*i]+1 ]= 00740 h->ref_cache[list][ scan8[4*i]+8 ]=h->ref_cache[list][ scan8[4*i]+9 ]= ref[list][i]; 00741 00742 if(IS_DIR(h->sub_mb_type[i], 0, list)){ 00743 const int sub_mb_type= h->sub_mb_type[i]; 00744 const int block_width= (sub_mb_type & (MB_TYPE_16x16|MB_TYPE_16x8)) ? 2 : 1; 00745 for(j=0; j<sub_partition_count[i]; j++){ 00746 int mx, my; 00747 const int index= 4*i + block_width*j; 00748 int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; 00749 pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); 00750 mx += get_se_golomb(&s->gb); 00751 my += get_se_golomb(&s->gb); 00752 tprintf(s->avctx, "final mv:%d %d\n", mx, my); 00753 00754 if(IS_SUB_8X8(sub_mb_type)){ 00755 mv_cache[ 1 ][0]= 00756 mv_cache[ 8 ][0]= mv_cache[ 9 ][0]= mx; 00757 mv_cache[ 1 ][1]= 00758 mv_cache[ 8 ][1]= mv_cache[ 9 ][1]= my; 00759 }else if(IS_SUB_8X4(sub_mb_type)){ 00760 mv_cache[ 1 ][0]= mx; 00761 mv_cache[ 1 ][1]= my; 00762 }else if(IS_SUB_4X8(sub_mb_type)){ 00763 mv_cache[ 8 ][0]= mx; 00764 mv_cache[ 8 ][1]= my; 00765 } 00766 mv_cache[ 0 ][0]= mx; 00767 mv_cache[ 0 ][1]= my; 00768 } 00769 }else{ 00770 uint32_t *p= (uint32_t *)&h->mv_cache[list][ scan8[4*i] ][0]; 00771 p[0] = p[1]= 00772 p[8] = p[9]= 0; 00773 } 00774 } 00775 } 00776 }else if(IS_DIRECT(mb_type)){ 00777 ff_h264_pred_direct_motion(h, &mb_type); 00778 dct8x8_allowed &= h->sps.direct_8x8_inference_flag; 00779 }else{ 00780 int list, mx, my, i; 00781 //FIXME we should set ref_idx_l? to 0 if we use that later ... 00782 if(IS_16X16(mb_type)){ 00783 for(list=0; list<h->list_count; list++){ 00784 unsigned int val; 00785 if(IS_DIR(mb_type, 0, list)){ 00786 if(h->ref_count[list]==1){ 00787 val= 0; 00788 }else if(h->ref_count[list]==2){ 00789 val= get_bits1(&s->gb)^1; 00790 }else{ 00791 val= get_ue_golomb_31(&s->gb); 00792 if(val >= h->ref_count[list]){ 00793 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); 00794 return -1; 00795 } 00796 } 00797 fill_rectangle(&h->ref_cache[list][ scan8[0] ], 4, 4, 8, val, 1); 00798 } 00799 } 00800 for(list=0; list<h->list_count; list++){ 00801 if(IS_DIR(mb_type, 0, list)){ 00802 pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); 00803 mx += get_se_golomb(&s->gb); 00804 my += get_se_golomb(&s->gb); 00805 tprintf(s->avctx, "final mv:%d %d\n", mx, my); 00806 00807 fill_rectangle(h->mv_cache[list][ scan8[0] ], 4, 4, 8, pack16to32(mx,my), 4); 00808 } 00809 } 00810 } 00811 else if(IS_16X8(mb_type)){ 00812 for(list=0; list<h->list_count; list++){ 00813 for(i=0; i<2; i++){ 00814 unsigned int val; 00815 if(IS_DIR(mb_type, i, list)){ 00816 if(h->ref_count[list] == 1){ 00817 val= 0; 00818 }else if(h->ref_count[list] == 2){ 00819 val= get_bits1(&s->gb)^1; 00820 }else{ 00821 val= get_ue_golomb_31(&s->gb); 00822 if(val >= h->ref_count[list]){ 00823 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); 00824 return -1; 00825 } 00826 } 00827 }else 00828 val= LIST_NOT_USED&0xFF; 00829 fill_rectangle(&h->ref_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 1); 00830 } 00831 } 00832 for(list=0; list<h->list_count; list++){ 00833 for(i=0; i<2; i++){ 00834 unsigned int val; 00835 if(IS_DIR(mb_type, i, list)){ 00836 pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); 00837 mx += get_se_golomb(&s->gb); 00838 my += get_se_golomb(&s->gb); 00839 tprintf(s->avctx, "final mv:%d %d\n", mx, my); 00840 00841 val= pack16to32(mx,my); 00842 }else 00843 val=0; 00844 fill_rectangle(h->mv_cache[list][ scan8[0] + 16*i ], 4, 2, 8, val, 4); 00845 } 00846 } 00847 }else{ 00848 assert(IS_8X16(mb_type)); 00849 for(list=0; list<h->list_count; list++){ 00850 for(i=0; i<2; i++){ 00851 unsigned int val; 00852 if(IS_DIR(mb_type, i, list)){ //FIXME optimize 00853 if(h->ref_count[list]==1){ 00854 val= 0; 00855 }else if(h->ref_count[list]==2){ 00856 val= get_bits1(&s->gb)^1; 00857 }else{ 00858 val= get_ue_golomb_31(&s->gb); 00859 if(val >= h->ref_count[list]){ 00860 av_log(h->s.avctx, AV_LOG_ERROR, "ref %u overflow\n", val); 00861 return -1; 00862 } 00863 } 00864 }else 00865 val= LIST_NOT_USED&0xFF; 00866 fill_rectangle(&h->ref_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 1); 00867 } 00868 } 00869 for(list=0; list<h->list_count; list++){ 00870 for(i=0; i<2; i++){ 00871 unsigned int val; 00872 if(IS_DIR(mb_type, i, list)){ 00873 pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); 00874 mx += get_se_golomb(&s->gb); 00875 my += get_se_golomb(&s->gb); 00876 tprintf(s->avctx, "final mv:%d %d\n", mx, my); 00877 00878 val= pack16to32(mx,my); 00879 }else 00880 val=0; 00881 fill_rectangle(h->mv_cache[list][ scan8[0] + 2*i ], 2, 4, 8, val, 4); 00882 } 00883 } 00884 } 00885 } 00886 00887 if(IS_INTER(mb_type)) 00888 write_back_motion(h, mb_type); 00889 00890 if(!IS_INTRA16x16(mb_type)){ 00891 cbp= get_ue_golomb(&s->gb); 00892 if(cbp > 47){ 00893 av_log(h->s.avctx, AV_LOG_ERROR, "cbp too large (%u) at %d %d\n", cbp, s->mb_x, s->mb_y); 00894 return -1; 00895 } 00896 00897 if(CHROMA){ 00898 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp[cbp]; 00899 else cbp= golomb_to_inter_cbp [cbp]; 00900 }else{ 00901 if(IS_INTRA4x4(mb_type)) cbp= golomb_to_intra4x4_cbp_gray[cbp]; 00902 else cbp= golomb_to_inter_cbp_gray[cbp]; 00903 } 00904 } 00905 00906 if(dct8x8_allowed && (cbp&15) && !IS_INTRA(mb_type)){ 00907 mb_type |= MB_TYPE_8x8DCT*get_bits1(&s->gb); 00908 } 00909 h->cbp= 00910 h->cbp_table[mb_xy]= cbp; 00911 s->current_picture.mb_type[mb_xy]= mb_type; 00912 00913 if(cbp || IS_INTRA16x16(mb_type)){ 00914 int i8x8, i4x4, chroma_idx; 00915 int dquant; 00916 GetBitContext *gb= IS_INTRA(mb_type) ? h->intra_gb_ptr : h->inter_gb_ptr; 00917 const uint8_t *scan, *scan8x8, *dc_scan; 00918 00919 if(IS_INTERLACED(mb_type)){ 00920 scan8x8= s->qscale ? h->field_scan8x8_cavlc : h->field_scan8x8_cavlc_q0; 00921 scan= s->qscale ? h->field_scan : h->field_scan_q0; 00922 dc_scan= luma_dc_field_scan; 00923 }else{ 00924 scan8x8= s->qscale ? h->zigzag_scan8x8_cavlc : h->zigzag_scan8x8_cavlc_q0; 00925 scan= s->qscale ? h->zigzag_scan : h->zigzag_scan_q0; 00926 dc_scan= luma_dc_zigzag_scan; 00927 } 00928 00929 dquant= get_se_golomb(&s->gb); 00930 00931 s->qscale += dquant; 00932 00933 if(((unsigned)s->qscale) > 51){ 00934 if(s->qscale<0) s->qscale+= 52; 00935 else s->qscale-= 52; 00936 if(((unsigned)s->qscale) > 51){ 00937 av_log(h->s.avctx, AV_LOG_ERROR, "dquant out of range (%d) at %d %d\n", dquant, s->mb_x, s->mb_y); 00938 return -1; 00939 } 00940 } 00941 00942 h->chroma_qp[0]= get_chroma_qp(h, 0, s->qscale); 00943 h->chroma_qp[1]= get_chroma_qp(h, 1, s->qscale); 00944 if(IS_INTRA16x16(mb_type)){ 00945 if( decode_residual(h, h->intra_gb_ptr, h->mb, LUMA_DC_BLOCK_INDEX, dc_scan, h->dequant4_coeff[0][s->qscale], 16) < 0){ 00946 return -1; //FIXME continue if partitioned and other return -1 too 00947 } 00948 00949 assert((cbp&15) == 0 || (cbp&15) == 15); 00950 00951 if(cbp&15){ 00952 for(i8x8=0; i8x8<4; i8x8++){ 00953 for(i4x4=0; i4x4<4; i4x4++){ 00954 const int index= i4x4 + 4*i8x8; 00955 if( decode_residual(h, h->intra_gb_ptr, h->mb + 16*index, index, scan + 1, h->dequant4_coeff[0][s->qscale], 15) < 0 ){ 00956 return -1; 00957 } 00958 } 00959 } 00960 }else{ 00961 fill_rectangle(&h->non_zero_count_cache[scan8[0]], 4, 4, 8, 0, 1); 00962 } 00963 }else{ 00964 for(i8x8=0; i8x8<4; i8x8++){ 00965 if(cbp & (1<<i8x8)){ 00966 if(IS_8x8DCT(mb_type)){ 00967 DCTELEM *buf = &h->mb[64*i8x8]; 00968 uint8_t *nnz; 00969 for(i4x4=0; i4x4<4; i4x4++){ 00970 if( decode_residual(h, gb, buf, i4x4+4*i8x8, scan8x8+16*i4x4, 00971 h->dequant8_coeff[IS_INTRA( mb_type ) ? 0:1][s->qscale], 16) <0 ) 00972 return -1; 00973 } 00974 nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; 00975 nnz[0] += nnz[1] + nnz[8] + nnz[9]; 00976 }else{ 00977 for(i4x4=0; i4x4<4; i4x4++){ 00978 const int index= i4x4 + 4*i8x8; 00979 00980 if( decode_residual(h, gb, h->mb + 16*index, index, scan, h->dequant4_coeff[IS_INTRA( mb_type ) ? 0:3][s->qscale], 16) <0 ){ 00981 return -1; 00982 } 00983 } 00984 } 00985 }else{ 00986 uint8_t * const nnz= &h->non_zero_count_cache[ scan8[4*i8x8] ]; 00987 nnz[0] = nnz[1] = nnz[8] = nnz[9] = 0; 00988 } 00989 } 00990 } 00991 00992 if(cbp&0x30){ 00993 for(chroma_idx=0; chroma_idx<2; chroma_idx++) 00994 if( decode_residual(h, gb, h->mb + 256 + 16*4*chroma_idx, CHROMA_DC_BLOCK_INDEX, chroma_dc_scan, NULL, 4) < 0){ 00995 return -1; 00996 } 00997 } 00998 00999 if(cbp&0x20){ 01000 for(chroma_idx=0; chroma_idx<2; chroma_idx++){ 01001 const uint32_t *qmul = h->dequant4_coeff[chroma_idx+1+(IS_INTRA( mb_type ) ? 0:3)][h->chroma_qp[chroma_idx]]; 01002 for(i4x4=0; i4x4<4; i4x4++){ 01003 const int index= 16 + 4*chroma_idx + i4x4; 01004 if( decode_residual(h, gb, h->mb + 16*index, index, scan + 1, qmul, 15) < 0){ 01005 return -1; 01006 } 01007 } 01008 } 01009 }else{ 01010 uint8_t * const nnz= &h->non_zero_count_cache[0]; 01011 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = 01012 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; 01013 } 01014 }else{ 01015 uint8_t * const nnz= &h->non_zero_count_cache[0]; 01016 fill_rectangle(&nnz[scan8[0]], 4, 4, 8, 0, 1); 01017 nnz[ scan8[16]+0 ] = nnz[ scan8[16]+1 ] =nnz[ scan8[16]+8 ] =nnz[ scan8[16]+9 ] = 01018 nnz[ scan8[20]+0 ] = nnz[ scan8[20]+1 ] =nnz[ scan8[20]+8 ] =nnz[ scan8[20]+9 ] = 0; 01019 } 01020 s->current_picture.qscale_table[mb_xy]= s->qscale; 01021 write_back_non_zero_count(h); 01022 01023 if(MB_MBAFF){ 01024 h->ref_count[0] >>= 1; 01025 h->ref_count[1] >>= 1; 01026 } 01027 01028 return 0; 01029 } 01030