Libav
|
00001 /* 00002 * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder 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 #include "internal.h" 00029 #include "dsputil.h" 00030 #include "avcodec.h" 00031 #include "mpegvideo.h" 00032 #include "h264.h" 00033 #include "h264data.h" 00034 #include "h264_mvpred.h" 00035 #include "h264_parser.h" 00036 #include "golomb.h" 00037 #include "mathops.h" 00038 #include "rectangle.h" 00039 #include "vdpau_internal.h" 00040 00041 #include "cabac.h" 00042 00043 //#undef NDEBUG 00044 #include <assert.h> 00045 00046 static const uint8_t rem6[52]={ 00047 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 00048 }; 00049 00050 static const uint8_t div6[52]={ 00051 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 00052 }; 00053 00054 void ff_h264_write_back_intra_pred_mode(H264Context *h){ 00055 int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy]; 00056 00057 AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4); 00058 mode[4]= h->intra4x4_pred_mode_cache[7+8*3]; 00059 mode[5]= h->intra4x4_pred_mode_cache[7+8*2]; 00060 mode[6]= h->intra4x4_pred_mode_cache[7+8*1]; 00061 } 00062 00066 int ff_h264_check_intra4x4_pred_mode(H264Context *h){ 00067 MpegEncContext * const s = &h->s; 00068 static const int8_t top [12]= {-1, 0,LEFT_DC_PRED,-1,-1,-1,-1,-1, 0}; 00069 static const int8_t left[12]= { 0,-1, TOP_DC_PRED, 0,-1,-1,-1, 0,-1,DC_128_PRED}; 00070 int i; 00071 00072 if(!(h->top_samples_available&0x8000)){ 00073 for(i=0; i<4; i++){ 00074 int status= top[ h->intra4x4_pred_mode_cache[scan8[0] + i] ]; 00075 if(status<0){ 00076 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); 00077 return -1; 00078 } else if(status){ 00079 h->intra4x4_pred_mode_cache[scan8[0] + i]= status; 00080 } 00081 } 00082 } 00083 00084 if((h->left_samples_available&0x8888)!=0x8888){ 00085 static const int mask[4]={0x8000,0x2000,0x80,0x20}; 00086 for(i=0; i<4; i++){ 00087 if(!(h->left_samples_available&mask[i])){ 00088 int status= left[ h->intra4x4_pred_mode_cache[scan8[0] + 8*i] ]; 00089 if(status<0){ 00090 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra4x4 mode %d at %d %d\n", status, s->mb_x, s->mb_y); 00091 return -1; 00092 } else if(status){ 00093 h->intra4x4_pred_mode_cache[scan8[0] + 8*i]= status; 00094 } 00095 } 00096 } 00097 } 00098 00099 return 0; 00100 } //FIXME cleanup like ff_h264_check_intra_pred_mode 00101 00105 int ff_h264_check_intra_pred_mode(H264Context *h, int mode){ 00106 MpegEncContext * const s = &h->s; 00107 static const int8_t top [7]= {LEFT_DC_PRED8x8, 1,-1,-1}; 00108 static const int8_t left[7]= { TOP_DC_PRED8x8,-1, 2,-1,DC_128_PRED8x8}; 00109 00110 if(mode > 6U) { 00111 av_log(h->s.avctx, AV_LOG_ERROR, "out of range intra chroma pred mode at %d %d\n", s->mb_x, s->mb_y); 00112 return -1; 00113 } 00114 00115 if(!(h->top_samples_available&0x8000)){ 00116 mode= top[ mode ]; 00117 if(mode<0){ 00118 av_log(h->s.avctx, AV_LOG_ERROR, "top block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); 00119 return -1; 00120 } 00121 } 00122 00123 if((h->left_samples_available&0x8080) != 0x8080){ 00124 mode= left[ mode ]; 00125 if(h->left_samples_available&0x8080){ //mad cow disease mode, aka MBAFF + constrained_intra_pred 00126 mode= ALZHEIMER_DC_L0T_PRED8x8 + (!(h->left_samples_available&0x8000)) + 2*(mode == DC_128_PRED8x8); 00127 } 00128 if(mode<0){ 00129 av_log(h->s.avctx, AV_LOG_ERROR, "left block unavailable for requested intra mode at %d %d\n", s->mb_x, s->mb_y); 00130 return -1; 00131 } 00132 } 00133 00134 return mode; 00135 } 00136 00137 const uint8_t *ff_h264_decode_nal(H264Context *h, const uint8_t *src, int *dst_length, int *consumed, int length){ 00138 int i, si, di; 00139 uint8_t *dst; 00140 int bufidx; 00141 00142 // src[0]&0x80; //forbidden bit 00143 h->nal_ref_idc= src[0]>>5; 00144 h->nal_unit_type= src[0]&0x1F; 00145 00146 src++; length--; 00147 #if 0 00148 for(i=0; i<length; i++) 00149 printf("%2X ", src[i]); 00150 #endif 00151 00152 #if HAVE_FAST_UNALIGNED 00153 # if HAVE_FAST_64BIT 00154 # define RS 7 00155 for(i=0; i+1<length; i+=9){ 00156 if(!((~AV_RN64A(src+i) & (AV_RN64A(src+i) - 0x0100010001000101ULL)) & 0x8000800080008080ULL)) 00157 # else 00158 # define RS 3 00159 for(i=0; i+1<length; i+=5){ 00160 if(!((~AV_RN32A(src+i) & (AV_RN32A(src+i) - 0x01000101U)) & 0x80008080U)) 00161 # endif 00162 continue; 00163 if(i>0 && !src[i]) i--; 00164 while(src[i]) i++; 00165 #else 00166 # define RS 0 00167 for(i=0; i+1<length; i+=2){ 00168 if(src[i]) continue; 00169 if(i>0 && src[i-1]==0) i--; 00170 #endif 00171 if(i+2<length && src[i+1]==0 && src[i+2]<=3){ 00172 if(src[i+2]!=3){ 00173 /* startcode, so we must be past the end */ 00174 length=i; 00175 } 00176 break; 00177 } 00178 i-= RS; 00179 } 00180 00181 if(i>=length-1){ //no escaped 0 00182 *dst_length= length; 00183 *consumed= length+1; //+1 for the header 00184 return src; 00185 } 00186 00187 bufidx = h->nal_unit_type == NAL_DPC ? 1 : 0; // use second escape buffer for inter data 00188 av_fast_malloc(&h->rbsp_buffer[bufidx], &h->rbsp_buffer_size[bufidx], length+FF_INPUT_BUFFER_PADDING_SIZE); 00189 dst= h->rbsp_buffer[bufidx]; 00190 00191 if (dst == NULL){ 00192 return NULL; 00193 } 00194 00195 //printf("decoding esc\n"); 00196 memcpy(dst, src, i); 00197 si=di=i; 00198 while(si+2<length){ 00199 //remove escapes (very rare 1:2^22) 00200 if(src[si+2]>3){ 00201 dst[di++]= src[si++]; 00202 dst[di++]= src[si++]; 00203 }else if(src[si]==0 && src[si+1]==0){ 00204 if(src[si+2]==3){ //escape 00205 dst[di++]= 0; 00206 dst[di++]= 0; 00207 si+=3; 00208 continue; 00209 }else //next start code 00210 goto nsc; 00211 } 00212 00213 dst[di++]= src[si++]; 00214 } 00215 while(si<length) 00216 dst[di++]= src[si++]; 00217 nsc: 00218 00219 memset(dst+di, 0, FF_INPUT_BUFFER_PADDING_SIZE); 00220 00221 *dst_length= di; 00222 *consumed= si + 1;//+1 for the header 00223 //FIXME store exact number of bits in the getbitcontext (it is needed for decoding) 00224 return dst; 00225 } 00226 00227 int ff_h264_decode_rbsp_trailing(H264Context *h, const uint8_t *src){ 00228 int v= *src; 00229 int r; 00230 00231 tprintf(h->s.avctx, "rbsp trailing %X\n", v); 00232 00233 for(r=1; r<9; r++){ 00234 if(v&1) return r; 00235 v>>=1; 00236 } 00237 return 0; 00238 } 00239 00244 static void h264_luma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ 00245 #define stride 16 00246 int i; 00247 int temp[16]; //FIXME check if this is a good idea 00248 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; 00249 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; 00250 00251 //memset(block, 64, 2*256); 00252 //return; 00253 for(i=0; i<4; i++){ 00254 const int offset= y_offset[i]; 00255 const int z0= block[offset+stride*0] + block[offset+stride*4]; 00256 const int z1= block[offset+stride*0] - block[offset+stride*4]; 00257 const int z2= block[offset+stride*1] - block[offset+stride*5]; 00258 const int z3= block[offset+stride*1] + block[offset+stride*5]; 00259 00260 temp[4*i+0]= z0+z3; 00261 temp[4*i+1]= z1+z2; 00262 temp[4*i+2]= z1-z2; 00263 temp[4*i+3]= z0-z3; 00264 } 00265 00266 for(i=0; i<4; i++){ 00267 const int offset= x_offset[i]; 00268 const int z0= temp[4*0+i] + temp[4*2+i]; 00269 const int z1= temp[4*0+i] - temp[4*2+i]; 00270 const int z2= temp[4*1+i] - temp[4*3+i]; 00271 const int z3= temp[4*1+i] + temp[4*3+i]; 00272 00273 block[stride*0 +offset]= ((((z0 + z3)*qmul + 128 ) >> 8)); //FIXME think about merging this into decode_residual 00274 block[stride*2 +offset]= ((((z1 + z2)*qmul + 128 ) >> 8)); 00275 block[stride*8 +offset]= ((((z1 - z2)*qmul + 128 ) >> 8)); 00276 block[stride*10+offset]= ((((z0 - z3)*qmul + 128 ) >> 8)); 00277 } 00278 } 00279 00280 #if 0 00281 00285 static void h264_luma_dc_dct_c(DCTELEM *block/*, int qp*/){ 00286 // const int qmul= dequant_coeff[qp][0]; 00287 int i; 00288 int temp[16]; //FIXME check if this is a good idea 00289 static const int x_offset[4]={0, 1*stride, 4* stride, 5*stride}; 00290 static const int y_offset[4]={0, 2*stride, 8* stride, 10*stride}; 00291 00292 for(i=0; i<4; i++){ 00293 const int offset= y_offset[i]; 00294 const int z0= block[offset+stride*0] + block[offset+stride*4]; 00295 const int z1= block[offset+stride*0] - block[offset+stride*4]; 00296 const int z2= block[offset+stride*1] - block[offset+stride*5]; 00297 const int z3= block[offset+stride*1] + block[offset+stride*5]; 00298 00299 temp[4*i+0]= z0+z3; 00300 temp[4*i+1]= z1+z2; 00301 temp[4*i+2]= z1-z2; 00302 temp[4*i+3]= z0-z3; 00303 } 00304 00305 for(i=0; i<4; i++){ 00306 const int offset= x_offset[i]; 00307 const int z0= temp[4*0+i] + temp[4*2+i]; 00308 const int z1= temp[4*0+i] - temp[4*2+i]; 00309 const int z2= temp[4*1+i] - temp[4*3+i]; 00310 const int z3= temp[4*1+i] + temp[4*3+i]; 00311 00312 block[stride*0 +offset]= (z0 + z3)>>1; 00313 block[stride*2 +offset]= (z1 + z2)>>1; 00314 block[stride*8 +offset]= (z1 - z2)>>1; 00315 block[stride*10+offset]= (z0 - z3)>>1; 00316 } 00317 } 00318 #endif 00319 00320 #undef xStride 00321 #undef stride 00322 00323 static void chroma_dc_dequant_idct_c(DCTELEM *block, int qp, int qmul){ 00324 const int stride= 16*2; 00325 const int xStride= 16; 00326 int a,b,c,d,e; 00327 00328 a= block[stride*0 + xStride*0]; 00329 b= block[stride*0 + xStride*1]; 00330 c= block[stride*1 + xStride*0]; 00331 d= block[stride*1 + xStride*1]; 00332 00333 e= a-b; 00334 a= a+b; 00335 b= c-d; 00336 c= c+d; 00337 00338 block[stride*0 + xStride*0]= ((a+c)*qmul) >> 7; 00339 block[stride*0 + xStride*1]= ((e+b)*qmul) >> 7; 00340 block[stride*1 + xStride*0]= ((a-c)*qmul) >> 7; 00341 block[stride*1 + xStride*1]= ((e-b)*qmul) >> 7; 00342 } 00343 00344 #if 0 00345 static void chroma_dc_dct_c(DCTELEM *block){ 00346 const int stride= 16*2; 00347 const int xStride= 16; 00348 int a,b,c,d,e; 00349 00350 a= block[stride*0 + xStride*0]; 00351 b= block[stride*0 + xStride*1]; 00352 c= block[stride*1 + xStride*0]; 00353 d= block[stride*1 + xStride*1]; 00354 00355 e= a-b; 00356 a= a+b; 00357 b= c-d; 00358 c= c+d; 00359 00360 block[stride*0 + xStride*0]= (a+c); 00361 block[stride*0 + xStride*1]= (e+b); 00362 block[stride*1 + xStride*0]= (a-c); 00363 block[stride*1 + xStride*1]= (e-b); 00364 } 00365 #endif 00366 00367 static inline void mc_dir_part(H264Context *h, Picture *pic, int n, int square, int chroma_height, int delta, int list, 00368 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 00369 int src_x_offset, int src_y_offset, 00370 qpel_mc_func *qpix_op, h264_chroma_mc_func chroma_op){ 00371 MpegEncContext * const s = &h->s; 00372 const int mx= h->mv_cache[list][ scan8[n] ][0] + src_x_offset*8; 00373 int my= h->mv_cache[list][ scan8[n] ][1] + src_y_offset*8; 00374 const int luma_xy= (mx&3) + ((my&3)<<2); 00375 uint8_t * src_y = pic->data[0] + (mx>>2) + (my>>2)*h->mb_linesize; 00376 uint8_t * src_cb, * src_cr; 00377 int extra_width= h->emu_edge_width; 00378 int extra_height= h->emu_edge_height; 00379 int emu=0; 00380 const int full_mx= mx>>2; 00381 const int full_my= my>>2; 00382 const int pic_width = 16*s->mb_width; 00383 const int pic_height = 16*s->mb_height >> MB_FIELD; 00384 00385 if(mx&7) extra_width -= 3; 00386 if(my&7) extra_height -= 3; 00387 00388 if( full_mx < 0-extra_width 00389 || full_my < 0-extra_height 00390 || full_mx + 16/*FIXME*/ > pic_width + extra_width 00391 || full_my + 16/*FIXME*/ > pic_height + extra_height){ 00392 ff_emulated_edge_mc(s->edge_emu_buffer, src_y - 2 - 2*h->mb_linesize, h->mb_linesize, 16+5, 16+5/*FIXME*/, full_mx-2, full_my-2, pic_width, pic_height); 00393 src_y= s->edge_emu_buffer + 2 + 2*h->mb_linesize; 00394 emu=1; 00395 } 00396 00397 qpix_op[luma_xy](dest_y, src_y, h->mb_linesize); //FIXME try variable height perhaps? 00398 if(!square){ 00399 qpix_op[luma_xy](dest_y + delta, src_y + delta, h->mb_linesize); 00400 } 00401 00402 if(CONFIG_GRAY && s->flags&CODEC_FLAG_GRAY) return; 00403 00404 if(MB_FIELD){ 00405 // chroma offset when predicting from a field of opposite parity 00406 my += 2 * ((s->mb_y & 1) - (pic->reference - 1)); 00407 emu |= (my>>3) < 0 || (my>>3) + 8 >= (pic_height>>1); 00408 } 00409 src_cb= pic->data[1] + (mx>>3) + (my>>3)*h->mb_uvlinesize; 00410 src_cr= pic->data[2] + (mx>>3) + (my>>3)*h->mb_uvlinesize; 00411 00412 if(emu){ 00413 ff_emulated_edge_mc(s->edge_emu_buffer, src_cb, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1); 00414 src_cb= s->edge_emu_buffer; 00415 } 00416 chroma_op(dest_cb, src_cb, h->mb_uvlinesize, chroma_height, mx&7, my&7); 00417 00418 if(emu){ 00419 ff_emulated_edge_mc(s->edge_emu_buffer, src_cr, h->mb_uvlinesize, 9, 9/*FIXME*/, (mx>>3), (my>>3), pic_width>>1, pic_height>>1); 00420 src_cr= s->edge_emu_buffer; 00421 } 00422 chroma_op(dest_cr, src_cr, h->mb_uvlinesize, chroma_height, mx&7, my&7); 00423 } 00424 00425 static inline void mc_part_std(H264Context *h, int n, int square, int chroma_height, int delta, 00426 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 00427 int x_offset, int y_offset, 00428 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, 00429 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, 00430 int list0, int list1){ 00431 MpegEncContext * const s = &h->s; 00432 qpel_mc_func *qpix_op= qpix_put; 00433 h264_chroma_mc_func chroma_op= chroma_put; 00434 00435 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; 00436 dest_cb += x_offset + y_offset*h->mb_uvlinesize; 00437 dest_cr += x_offset + y_offset*h->mb_uvlinesize; 00438 x_offset += 8*s->mb_x; 00439 y_offset += 8*(s->mb_y >> MB_FIELD); 00440 00441 if(list0){ 00442 Picture *ref= &h->ref_list[0][ h->ref_cache[0][ scan8[n] ] ]; 00443 mc_dir_part(h, ref, n, square, chroma_height, delta, 0, 00444 dest_y, dest_cb, dest_cr, x_offset, y_offset, 00445 qpix_op, chroma_op); 00446 00447 qpix_op= qpix_avg; 00448 chroma_op= chroma_avg; 00449 } 00450 00451 if(list1){ 00452 Picture *ref= &h->ref_list[1][ h->ref_cache[1][ scan8[n] ] ]; 00453 mc_dir_part(h, ref, n, square, chroma_height, delta, 1, 00454 dest_y, dest_cb, dest_cr, x_offset, y_offset, 00455 qpix_op, chroma_op); 00456 } 00457 } 00458 00459 static inline void mc_part_weighted(H264Context *h, int n, int square, int chroma_height, int delta, 00460 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 00461 int x_offset, int y_offset, 00462 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, 00463 h264_weight_func luma_weight_op, h264_weight_func chroma_weight_op, 00464 h264_biweight_func luma_weight_avg, h264_biweight_func chroma_weight_avg, 00465 int list0, int list1){ 00466 MpegEncContext * const s = &h->s; 00467 00468 dest_y += 2*x_offset + 2*y_offset*h-> mb_linesize; 00469 dest_cb += x_offset + y_offset*h->mb_uvlinesize; 00470 dest_cr += x_offset + y_offset*h->mb_uvlinesize; 00471 x_offset += 8*s->mb_x; 00472 y_offset += 8*(s->mb_y >> MB_FIELD); 00473 00474 if(list0 && list1){ 00475 /* don't optimize for luma-only case, since B-frames usually 00476 * use implicit weights => chroma too. */ 00477 uint8_t *tmp_cb = s->obmc_scratchpad; 00478 uint8_t *tmp_cr = s->obmc_scratchpad + 8; 00479 uint8_t *tmp_y = s->obmc_scratchpad + 8*h->mb_uvlinesize; 00480 int refn0 = h->ref_cache[0][ scan8[n] ]; 00481 int refn1 = h->ref_cache[1][ scan8[n] ]; 00482 00483 mc_dir_part(h, &h->ref_list[0][refn0], n, square, chroma_height, delta, 0, 00484 dest_y, dest_cb, dest_cr, 00485 x_offset, y_offset, qpix_put, chroma_put); 00486 mc_dir_part(h, &h->ref_list[1][refn1], n, square, chroma_height, delta, 1, 00487 tmp_y, tmp_cb, tmp_cr, 00488 x_offset, y_offset, qpix_put, chroma_put); 00489 00490 if(h->use_weight == 2){ 00491 int weight0 = h->implicit_weight[refn0][refn1][s->mb_y&1]; 00492 int weight1 = 64 - weight0; 00493 luma_weight_avg( dest_y, tmp_y, h-> mb_linesize, 5, weight0, weight1, 0); 00494 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, 5, weight0, weight1, 0); 00495 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, 5, weight0, weight1, 0); 00496 }else{ 00497 luma_weight_avg(dest_y, tmp_y, h->mb_linesize, h->luma_log2_weight_denom, 00498 h->luma_weight[refn0][0][0] , h->luma_weight[refn1][1][0], 00499 h->luma_weight[refn0][0][1] + h->luma_weight[refn1][1][1]); 00500 chroma_weight_avg(dest_cb, tmp_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, 00501 h->chroma_weight[refn0][0][0][0] , h->chroma_weight[refn1][1][0][0], 00502 h->chroma_weight[refn0][0][0][1] + h->chroma_weight[refn1][1][0][1]); 00503 chroma_weight_avg(dest_cr, tmp_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, 00504 h->chroma_weight[refn0][0][1][0] , h->chroma_weight[refn1][1][1][0], 00505 h->chroma_weight[refn0][0][1][1] + h->chroma_weight[refn1][1][1][1]); 00506 } 00507 }else{ 00508 int list = list1 ? 1 : 0; 00509 int refn = h->ref_cache[list][ scan8[n] ]; 00510 Picture *ref= &h->ref_list[list][refn]; 00511 mc_dir_part(h, ref, n, square, chroma_height, delta, list, 00512 dest_y, dest_cb, dest_cr, x_offset, y_offset, 00513 qpix_put, chroma_put); 00514 00515 luma_weight_op(dest_y, h->mb_linesize, h->luma_log2_weight_denom, 00516 h->luma_weight[refn][list][0], h->luma_weight[refn][list][1]); 00517 if(h->use_weight_chroma){ 00518 chroma_weight_op(dest_cb, h->mb_uvlinesize, h->chroma_log2_weight_denom, 00519 h->chroma_weight[refn][list][0][0], h->chroma_weight[refn][list][0][1]); 00520 chroma_weight_op(dest_cr, h->mb_uvlinesize, h->chroma_log2_weight_denom, 00521 h->chroma_weight[refn][list][1][0], h->chroma_weight[refn][list][1][1]); 00522 } 00523 } 00524 } 00525 00526 static inline void mc_part(H264Context *h, int n, int square, int chroma_height, int delta, 00527 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 00528 int x_offset, int y_offset, 00529 qpel_mc_func *qpix_put, h264_chroma_mc_func chroma_put, 00530 qpel_mc_func *qpix_avg, h264_chroma_mc_func chroma_avg, 00531 h264_weight_func *weight_op, h264_biweight_func *weight_avg, 00532 int list0, int list1){ 00533 if((h->use_weight==2 && list0 && list1 00534 && (h->implicit_weight[ h->ref_cache[0][scan8[n]] ][ h->ref_cache[1][scan8[n]] ][h->s.mb_y&1] != 32)) 00535 || h->use_weight==1) 00536 mc_part_weighted(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, 00537 x_offset, y_offset, qpix_put, chroma_put, 00538 weight_op[0], weight_op[3], weight_avg[0], weight_avg[3], list0, list1); 00539 else 00540 mc_part_std(h, n, square, chroma_height, delta, dest_y, dest_cb, dest_cr, 00541 x_offset, y_offset, qpix_put, chroma_put, qpix_avg, chroma_avg, list0, list1); 00542 } 00543 00544 static inline void prefetch_motion(H264Context *h, int list){ 00545 /* fetch pixels for estimated mv 4 macroblocks ahead 00546 * optimized for 64byte cache lines */ 00547 MpegEncContext * const s = &h->s; 00548 const int refn = h->ref_cache[list][scan8[0]]; 00549 if(refn >= 0){ 00550 const int mx= (h->mv_cache[list][scan8[0]][0]>>2) + 16*s->mb_x + 8; 00551 const int my= (h->mv_cache[list][scan8[0]][1]>>2) + 16*s->mb_y; 00552 uint8_t **src= h->ref_list[list][refn].data; 00553 int off= mx + (my + (s->mb_x&3)*4)*h->mb_linesize + 64; 00554 s->dsp.prefetch(src[0]+off, s->linesize, 4); 00555 off= (mx>>1) + ((my>>1) + (s->mb_x&7))*s->uvlinesize + 64; 00556 s->dsp.prefetch(src[1]+off, src[2]-src[1], 2); 00557 } 00558 } 00559 00560 static void hl_motion(H264Context *h, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, 00561 qpel_mc_func (*qpix_put)[16], h264_chroma_mc_func (*chroma_put), 00562 qpel_mc_func (*qpix_avg)[16], h264_chroma_mc_func (*chroma_avg), 00563 h264_weight_func *weight_op, h264_biweight_func *weight_avg){ 00564 MpegEncContext * const s = &h->s; 00565 const int mb_xy= h->mb_xy; 00566 const int mb_type= s->current_picture.mb_type[mb_xy]; 00567 00568 assert(IS_INTER(mb_type)); 00569 00570 prefetch_motion(h, 0); 00571 00572 if(IS_16X16(mb_type)){ 00573 mc_part(h, 0, 1, 8, 0, dest_y, dest_cb, dest_cr, 0, 0, 00574 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0], 00575 weight_op, weight_avg, 00576 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); 00577 }else if(IS_16X8(mb_type)){ 00578 mc_part(h, 0, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 0, 00579 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], 00580 &weight_op[1], &weight_avg[1], 00581 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); 00582 mc_part(h, 8, 0, 4, 8, dest_y, dest_cb, dest_cr, 0, 4, 00583 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0], 00584 &weight_op[1], &weight_avg[1], 00585 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); 00586 }else if(IS_8X16(mb_type)){ 00587 mc_part(h, 0, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0, 00588 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], 00589 &weight_op[2], &weight_avg[2], 00590 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1)); 00591 mc_part(h, 4, 0, 8, 8*h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0, 00592 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], 00593 &weight_op[2], &weight_avg[2], 00594 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1)); 00595 }else{ 00596 int i; 00597 00598 assert(IS_8X8(mb_type)); 00599 00600 for(i=0; i<4; i++){ 00601 const int sub_mb_type= h->sub_mb_type[i]; 00602 const int n= 4*i; 00603 int x_offset= (i&1)<<2; 00604 int y_offset= (i&2)<<1; 00605 00606 if(IS_SUB_8X8(sub_mb_type)){ 00607 mc_part(h, n, 1, 4, 0, dest_y, dest_cb, dest_cr, x_offset, y_offset, 00608 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1], 00609 &weight_op[3], &weight_avg[3], 00610 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00611 }else if(IS_SUB_8X4(sub_mb_type)){ 00612 mc_part(h, n , 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset, 00613 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], 00614 &weight_op[4], &weight_avg[4], 00615 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00616 mc_part(h, n+2, 0, 2, 4, dest_y, dest_cb, dest_cr, x_offset, y_offset+2, 00617 qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1], 00618 &weight_op[4], &weight_avg[4], 00619 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00620 }else if(IS_SUB_4X8(sub_mb_type)){ 00621 mc_part(h, n , 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset, y_offset, 00622 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], 00623 &weight_op[5], &weight_avg[5], 00624 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00625 mc_part(h, n+1, 0, 4, 4*h->mb_linesize, dest_y, dest_cb, dest_cr, x_offset+2, y_offset, 00626 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], 00627 &weight_op[5], &weight_avg[5], 00628 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00629 }else{ 00630 int j; 00631 assert(IS_SUB_4X4(sub_mb_type)); 00632 for(j=0; j<4; j++){ 00633 int sub_x_offset= x_offset + 2*(j&1); 00634 int sub_y_offset= y_offset + (j&2); 00635 mc_part(h, n+j, 1, 2, 0, dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset, 00636 qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2], 00637 &weight_op[6], &weight_avg[6], 00638 IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1)); 00639 } 00640 } 00641 } 00642 } 00643 00644 prefetch_motion(h, 1); 00645 } 00646 00647 00648 static void free_tables(H264Context *h){ 00649 int i; 00650 H264Context *hx; 00651 av_freep(&h->intra4x4_pred_mode); 00652 av_freep(&h->chroma_pred_mode_table); 00653 av_freep(&h->cbp_table); 00654 av_freep(&h->mvd_table[0]); 00655 av_freep(&h->mvd_table[1]); 00656 av_freep(&h->direct_table); 00657 av_freep(&h->non_zero_count); 00658 av_freep(&h->slice_table_base); 00659 h->slice_table= NULL; 00660 av_freep(&h->list_counts); 00661 00662 av_freep(&h->mb2b_xy); 00663 av_freep(&h->mb2br_xy); 00664 00665 for(i = 0; i < MAX_THREADS; i++) { 00666 hx = h->thread_context[i]; 00667 if(!hx) continue; 00668 av_freep(&hx->top_borders[1]); 00669 av_freep(&hx->top_borders[0]); 00670 av_freep(&hx->s.obmc_scratchpad); 00671 av_freep(&hx->rbsp_buffer[1]); 00672 av_freep(&hx->rbsp_buffer[0]); 00673 hx->rbsp_buffer_size[0] = 0; 00674 hx->rbsp_buffer_size[1] = 0; 00675 if (i) av_freep(&h->thread_context[i]); 00676 } 00677 } 00678 00679 static void init_dequant8_coeff_table(H264Context *h){ 00680 int i,q,x; 00681 const int transpose = (h->h264dsp.h264_idct8_add != ff_h264_idct8_add_c); //FIXME ugly 00682 h->dequant8_coeff[0] = h->dequant8_buffer[0]; 00683 h->dequant8_coeff[1] = h->dequant8_buffer[1]; 00684 00685 for(i=0; i<2; i++ ){ 00686 if(i && !memcmp(h->pps.scaling_matrix8[0], h->pps.scaling_matrix8[1], 64*sizeof(uint8_t))){ 00687 h->dequant8_coeff[1] = h->dequant8_buffer[0]; 00688 break; 00689 } 00690 00691 for(q=0; q<52; q++){ 00692 int shift = div6[q]; 00693 int idx = rem6[q]; 00694 for(x=0; x<64; x++) 00695 h->dequant8_coeff[i][q][transpose ? (x>>3)|((x&7)<<3) : x] = 00696 ((uint32_t)dequant8_coeff_init[idx][ dequant8_coeff_init_scan[((x>>1)&12) | (x&3)] ] * 00697 h->pps.scaling_matrix8[i][x]) << shift; 00698 } 00699 } 00700 } 00701 00702 static void init_dequant4_coeff_table(H264Context *h){ 00703 int i,j,q,x; 00704 const int transpose = (h->h264dsp.h264_idct_add != ff_h264_idct_add_c); //FIXME ugly 00705 for(i=0; i<6; i++ ){ 00706 h->dequant4_coeff[i] = h->dequant4_buffer[i]; 00707 for(j=0; j<i; j++){ 00708 if(!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i], 16*sizeof(uint8_t))){ 00709 h->dequant4_coeff[i] = h->dequant4_buffer[j]; 00710 break; 00711 } 00712 } 00713 if(j<i) 00714 continue; 00715 00716 for(q=0; q<52; q++){ 00717 int shift = div6[q] + 2; 00718 int idx = rem6[q]; 00719 for(x=0; x<16; x++) 00720 h->dequant4_coeff[i][q][transpose ? (x>>2)|((x<<2)&0xF) : x] = 00721 ((uint32_t)dequant4_coeff_init[idx][(x&1) + ((x>>2)&1)] * 00722 h->pps.scaling_matrix4[i][x]) << shift; 00723 } 00724 } 00725 } 00726 00727 static void init_dequant_tables(H264Context *h){ 00728 int i,x; 00729 init_dequant4_coeff_table(h); 00730 if(h->pps.transform_8x8_mode) 00731 init_dequant8_coeff_table(h); 00732 if(h->sps.transform_bypass){ 00733 for(i=0; i<6; i++) 00734 for(x=0; x<16; x++) 00735 h->dequant4_coeff[i][0][x] = 1<<6; 00736 if(h->pps.transform_8x8_mode) 00737 for(i=0; i<2; i++) 00738 for(x=0; x<64; x++) 00739 h->dequant8_coeff[i][0][x] = 1<<6; 00740 } 00741 } 00742 00743 00744 int ff_h264_alloc_tables(H264Context *h){ 00745 MpegEncContext * const s = &h->s; 00746 const int big_mb_num= s->mb_stride * (s->mb_height+1); 00747 const int row_mb_num= 2*s->mb_stride*s->avctx->thread_count; 00748 int x,y; 00749 00750 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->intra4x4_pred_mode, row_mb_num * 8 * sizeof(uint8_t), fail) 00751 00752 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->non_zero_count , big_mb_num * 32 * sizeof(uint8_t), fail) 00753 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->slice_table_base , (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base), fail) 00754 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->cbp_table, big_mb_num * sizeof(uint16_t), fail) 00755 00756 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->chroma_pred_mode_table, big_mb_num * sizeof(uint8_t), fail) 00757 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[0], 16*row_mb_num * sizeof(uint8_t), fail); 00758 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mvd_table[1], 16*row_mb_num * sizeof(uint8_t), fail); 00759 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->direct_table, 4*big_mb_num * sizeof(uint8_t) , fail); 00760 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->list_counts, big_mb_num * sizeof(uint8_t), fail) 00761 00762 memset(h->slice_table_base, -1, (big_mb_num+s->mb_stride) * sizeof(*h->slice_table_base)); 00763 h->slice_table= h->slice_table_base + s->mb_stride*2 + 1; 00764 00765 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2b_xy , big_mb_num * sizeof(uint32_t), fail); 00766 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->mb2br_xy , big_mb_num * sizeof(uint32_t), fail); 00767 for(y=0; y<s->mb_height; y++){ 00768 for(x=0; x<s->mb_width; x++){ 00769 const int mb_xy= x + y*s->mb_stride; 00770 const int b_xy = 4*x + 4*y*h->b_stride; 00771 00772 h->mb2b_xy [mb_xy]= b_xy; 00773 h->mb2br_xy[mb_xy]= 8*(FMO ? mb_xy : (mb_xy % (2*s->mb_stride))); 00774 } 00775 } 00776 00777 s->obmc_scratchpad = NULL; 00778 00779 if(!h->dequant4_coeff[0]) 00780 init_dequant_tables(h); 00781 00782 return 0; 00783 fail: 00784 free_tables(h); 00785 return -1; 00786 } 00787 00791 static void clone_tables(H264Context *dst, H264Context *src, int i){ 00792 MpegEncContext * const s = &src->s; 00793 dst->intra4x4_pred_mode = src->intra4x4_pred_mode + i*8*2*s->mb_stride; 00794 dst->non_zero_count = src->non_zero_count; 00795 dst->slice_table = src->slice_table; 00796 dst->cbp_table = src->cbp_table; 00797 dst->mb2b_xy = src->mb2b_xy; 00798 dst->mb2br_xy = src->mb2br_xy; 00799 dst->chroma_pred_mode_table = src->chroma_pred_mode_table; 00800 dst->mvd_table[0] = src->mvd_table[0] + i*8*2*s->mb_stride; 00801 dst->mvd_table[1] = src->mvd_table[1] + i*8*2*s->mb_stride; 00802 dst->direct_table = src->direct_table; 00803 dst->list_counts = src->list_counts; 00804 00805 dst->s.obmc_scratchpad = NULL; 00806 ff_h264_pred_init(&dst->hpc, src->s.codec_id); 00807 } 00808 00813 static int context_init(H264Context *h){ 00814 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[0], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail) 00815 FF_ALLOCZ_OR_GOTO(h->s.avctx, h->top_borders[1], h->s.mb_width * (16+8+8) * sizeof(uint8_t), fail) 00816 00817 h->ref_cache[0][scan8[5 ]+1] = h->ref_cache[0][scan8[7 ]+1] = h->ref_cache[0][scan8[13]+1] = 00818 h->ref_cache[1][scan8[5 ]+1] = h->ref_cache[1][scan8[7 ]+1] = h->ref_cache[1][scan8[13]+1] = PART_NOT_AVAILABLE; 00819 00820 return 0; 00821 fail: 00822 return -1; // free_tables will clean up for us 00823 } 00824 00825 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size); 00826 00827 static av_cold void common_init(H264Context *h){ 00828 MpegEncContext * const s = &h->s; 00829 00830 s->width = s->avctx->width; 00831 s->height = s->avctx->height; 00832 s->codec_id= s->avctx->codec->id; 00833 00834 ff_h264dsp_init(&h->h264dsp); 00835 ff_h264_pred_init(&h->hpc, s->codec_id); 00836 00837 h->dequant_coeff_pps= -1; 00838 s->unrestricted_mv=1; 00839 s->decode=1; //FIXME 00840 00841 dsputil_init(&s->dsp, s->avctx); // needed so that idct permutation is known early 00842 00843 memset(h->pps.scaling_matrix4, 16, 6*16*sizeof(uint8_t)); 00844 memset(h->pps.scaling_matrix8, 16, 2*64*sizeof(uint8_t)); 00845 } 00846 00847 av_cold int ff_h264_decode_init(AVCodecContext *avctx){ 00848 H264Context *h= avctx->priv_data; 00849 MpegEncContext * const s = &h->s; 00850 00851 MPV_decode_defaults(s); 00852 00853 s->avctx = avctx; 00854 common_init(h); 00855 00856 s->out_format = FMT_H264; 00857 s->workaround_bugs= avctx->workaround_bugs; 00858 00859 // set defaults 00860 // s->decode_mb= ff_h263_decode_mb; 00861 s->quarter_sample = 1; 00862 if(!avctx->has_b_frames) 00863 s->low_delay= 1; 00864 00865 avctx->chroma_sample_location = AVCHROMA_LOC_LEFT; 00866 00867 ff_h264_decode_init_vlc(); 00868 00869 h->thread_context[0] = h; 00870 h->outputed_poc = INT_MIN; 00871 h->prev_poc_msb= 1<<16; 00872 h->x264_build = -1; 00873 ff_h264_reset_sei(h); 00874 if(avctx->codec_id == CODEC_ID_H264){ 00875 if(avctx->ticks_per_frame == 1){ 00876 s->avctx->time_base.den *=2; 00877 } 00878 avctx->ticks_per_frame = 2; 00879 } 00880 00881 if(avctx->extradata_size > 0 && avctx->extradata && *(char *)avctx->extradata == 1){ 00882 int i, cnt, nalsize; 00883 unsigned char *p = avctx->extradata; 00884 00885 h->is_avc = 1; 00886 00887 if(avctx->extradata_size < 7) { 00888 av_log(avctx, AV_LOG_ERROR, "avcC too short\n"); 00889 return -1; 00890 } 00891 /* sps and pps in the avcC always have length coded with 2 bytes, 00892 so put a fake nal_length_size = 2 while parsing them */ 00893 h->nal_length_size = 2; 00894 // Decode sps from avcC 00895 cnt = *(p+5) & 0x1f; // Number of sps 00896 p += 6; 00897 for (i = 0; i < cnt; i++) { 00898 nalsize = AV_RB16(p) + 2; 00899 if(decode_nal_units(h, p, nalsize) < 0) { 00900 av_log(avctx, AV_LOG_ERROR, "Decoding sps %d from avcC failed\n", i); 00901 return -1; 00902 } 00903 p += nalsize; 00904 } 00905 // Decode pps from avcC 00906 cnt = *(p++); // Number of pps 00907 for (i = 0; i < cnt; i++) { 00908 nalsize = AV_RB16(p) + 2; 00909 if(decode_nal_units(h, p, nalsize) != nalsize) { 00910 av_log(avctx, AV_LOG_ERROR, "Decoding pps %d from avcC failed\n", i); 00911 return -1; 00912 } 00913 p += nalsize; 00914 } 00915 // Now store right nal length size, that will be use to parse all other nals 00916 h->nal_length_size = ((*(((char*)(avctx->extradata))+4))&0x03)+1; 00917 } else { 00918 h->is_avc = 0; 00919 if(decode_nal_units(h, s->avctx->extradata, s->avctx->extradata_size) < 0) 00920 return -1; 00921 } 00922 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames < h->sps.num_reorder_frames){ 00923 s->avctx->has_b_frames = h->sps.num_reorder_frames; 00924 s->low_delay = 0; 00925 } 00926 00927 return 0; 00928 } 00929 00930 int ff_h264_frame_start(H264Context *h){ 00931 MpegEncContext * const s = &h->s; 00932 int i; 00933 00934 if(MPV_frame_start(s, s->avctx) < 0) 00935 return -1; 00936 ff_er_frame_start(s); 00937 /* 00938 * MPV_frame_start uses pict_type to derive key_frame. 00939 * This is incorrect for H.264; IDR markings must be used. 00940 * Zero here; IDR markings per slice in frame or fields are ORed in later. 00941 * See decode_nal_units(). 00942 */ 00943 s->current_picture_ptr->key_frame= 0; 00944 s->current_picture_ptr->mmco_reset= 0; 00945 00946 assert(s->linesize && s->uvlinesize); 00947 00948 for(i=0; i<16; i++){ 00949 h->block_offset[i]= 4*((scan8[i] - scan8[0])&7) + 4*s->linesize*((scan8[i] - scan8[0])>>3); 00950 h->block_offset[24+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->linesize*((scan8[i] - scan8[0])>>3); 00951 } 00952 for(i=0; i<4; i++){ 00953 h->block_offset[16+i]= 00954 h->block_offset[20+i]= 4*((scan8[i] - scan8[0])&7) + 4*s->uvlinesize*((scan8[i] - scan8[0])>>3); 00955 h->block_offset[24+16+i]= 00956 h->block_offset[24+20+i]= 4*((scan8[i] - scan8[0])&7) + 8*s->uvlinesize*((scan8[i] - scan8[0])>>3); 00957 } 00958 00959 /* can't be in alloc_tables because linesize isn't known there. 00960 * FIXME: redo bipred weight to not require extra buffer? */ 00961 for(i = 0; i < s->avctx->thread_count; i++) 00962 if(!h->thread_context[i]->s.obmc_scratchpad) 00963 h->thread_context[i]->s.obmc_scratchpad = av_malloc(16*2*s->linesize + 8*2*s->uvlinesize); 00964 00965 /* some macroblocks can be accessed before they're available in case of lost slices, mbaff or threading*/ 00966 memset(h->slice_table, -1, (s->mb_height*s->mb_stride-1) * sizeof(*h->slice_table)); 00967 00968 // s->decode= (s->flags&CODEC_FLAG_PSNR) || !s->encoding || s->current_picture.reference /*|| h->contains_intra*/ || 1; 00969 00970 // We mark the current picture as non-reference after allocating it, so 00971 // that if we break out due to an error it can be released automatically 00972 // in the next MPV_frame_start(). 00973 // SVQ3 as well as most other codecs have only last/next/current and thus 00974 // get released even with set reference, besides SVQ3 and others do not 00975 // mark frames as reference later "naturally". 00976 if(s->codec_id != CODEC_ID_SVQ3) 00977 s->current_picture_ptr->reference= 0; 00978 00979 s->current_picture_ptr->field_poc[0]= 00980 s->current_picture_ptr->field_poc[1]= INT_MAX; 00981 assert(s->current_picture_ptr->long_ref==0); 00982 00983 return 0; 00984 } 00985 00986 static inline void backup_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple){ 00987 MpegEncContext * const s = &h->s; 00988 uint8_t *top_border; 00989 int top_idx = 1; 00990 00991 src_y -= linesize; 00992 src_cb -= uvlinesize; 00993 src_cr -= uvlinesize; 00994 00995 if(!simple && FRAME_MBAFF){ 00996 if(s->mb_y&1){ 00997 if(!MB_MBAFF){ 00998 top_border = h->top_borders[0][s->mb_x]; 00999 AV_COPY128(top_border, src_y + 15*linesize); 01000 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 01001 AV_COPY64(top_border+16, src_cb+7*uvlinesize); 01002 AV_COPY64(top_border+24, src_cr+7*uvlinesize); 01003 } 01004 } 01005 }else if(MB_MBAFF){ 01006 top_idx = 0; 01007 }else 01008 return; 01009 } 01010 01011 top_border = h->top_borders[top_idx][s->mb_x]; 01012 // There are two lines saved, the line above the the top macroblock of a pair, 01013 // and the line above the bottom macroblock 01014 AV_COPY128(top_border, src_y + 16*linesize); 01015 01016 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 01017 AV_COPY64(top_border+16, src_cb+8*uvlinesize); 01018 AV_COPY64(top_border+24, src_cr+8*uvlinesize); 01019 } 01020 } 01021 01022 static inline void xchg_mb_border(H264Context *h, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int xchg, int simple){ 01023 MpegEncContext * const s = &h->s; 01024 int deblock_left; 01025 int deblock_top; 01026 int top_idx = 1; 01027 uint8_t *top_border_m1; 01028 uint8_t *top_border; 01029 01030 if(!simple && FRAME_MBAFF){ 01031 if(s->mb_y&1){ 01032 if(!MB_MBAFF) 01033 return; 01034 }else{ 01035 top_idx = MB_MBAFF ? 0 : 1; 01036 } 01037 } 01038 01039 if(h->deblocking_filter == 2) { 01040 deblock_left = h->left_type[0]; 01041 deblock_top = h->top_type; 01042 } else { 01043 deblock_left = (s->mb_x > 0); 01044 deblock_top = (s->mb_y > !!MB_FIELD); 01045 } 01046 01047 src_y -= linesize + 1; 01048 src_cb -= uvlinesize + 1; 01049 src_cr -= uvlinesize + 1; 01050 01051 top_border_m1 = h->top_borders[top_idx][s->mb_x-1]; 01052 top_border = h->top_borders[top_idx][s->mb_x]; 01053 01054 #define XCHG(a,b,xchg)\ 01055 if (xchg) AV_SWAP64(b,a);\ 01056 else AV_COPY64(b,a); 01057 01058 if(deblock_top){ 01059 if(deblock_left){ 01060 XCHG(top_border_m1+8, src_y -7, 1); 01061 } 01062 XCHG(top_border+0, src_y +1, xchg); 01063 XCHG(top_border+8, src_y +9, 1); 01064 if(s->mb_x+1 < s->mb_width){ 01065 XCHG(h->top_borders[top_idx][s->mb_x+1], src_y +17, 1); 01066 } 01067 } 01068 01069 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 01070 if(deblock_top){ 01071 if(deblock_left){ 01072 XCHG(top_border_m1+16, src_cb -7, 1); 01073 XCHG(top_border_m1+24, src_cr -7, 1); 01074 } 01075 XCHG(top_border+16, src_cb+1, 1); 01076 XCHG(top_border+24, src_cr+1, 1); 01077 } 01078 } 01079 } 01080 01081 static av_always_inline void hl_decode_mb_internal(H264Context *h, int simple){ 01082 MpegEncContext * const s = &h->s; 01083 const int mb_x= s->mb_x; 01084 const int mb_y= s->mb_y; 01085 const int mb_xy= h->mb_xy; 01086 const int mb_type= s->current_picture.mb_type[mb_xy]; 01087 uint8_t *dest_y, *dest_cb, *dest_cr; 01088 int linesize, uvlinesize /*dct_offset*/; 01089 int i; 01090 int *block_offset = &h->block_offset[0]; 01091 const int transform_bypass = !simple && (s->qscale == 0 && h->sps.transform_bypass); 01092 /* is_h264 should always be true if SVQ3 is disabled. */ 01093 const int is_h264 = !CONFIG_SVQ3_DECODER || simple || s->codec_id == CODEC_ID_H264; 01094 void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride); 01095 void (*idct_dc_add)(uint8_t *dst, DCTELEM *block, int stride); 01096 01097 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16; 01098 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8; 01099 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8; 01100 01101 s->dsp.prefetch(dest_y + (s->mb_x&3)*4*s->linesize + 64, s->linesize, 4); 01102 s->dsp.prefetch(dest_cb + (s->mb_x&7)*s->uvlinesize + 64, dest_cr - dest_cb, 2); 01103 01104 h->list_counts[mb_xy]= h->list_count; 01105 01106 if (!simple && MB_FIELD) { 01107 linesize = h->mb_linesize = s->linesize * 2; 01108 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2; 01109 block_offset = &h->block_offset[24]; 01110 if(mb_y&1){ //FIXME move out of this function? 01111 dest_y -= s->linesize*15; 01112 dest_cb-= s->uvlinesize*7; 01113 dest_cr-= s->uvlinesize*7; 01114 } 01115 if(FRAME_MBAFF) { 01116 int list; 01117 for(list=0; list<h->list_count; list++){ 01118 if(!USES_LIST(mb_type, list)) 01119 continue; 01120 if(IS_16X16(mb_type)){ 01121 int8_t *ref = &h->ref_cache[list][scan8[0]]; 01122 fill_rectangle(ref, 4, 4, 8, (16+*ref)^(s->mb_y&1), 1); 01123 }else{ 01124 for(i=0; i<16; i+=4){ 01125 int ref = h->ref_cache[list][scan8[i]]; 01126 if(ref >= 0) 01127 fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2, 8, (16+ref)^(s->mb_y&1), 1); 01128 } 01129 } 01130 } 01131 } 01132 } else { 01133 linesize = h->mb_linesize = s->linesize; 01134 uvlinesize = h->mb_uvlinesize = s->uvlinesize; 01135 // dct_offset = s->linesize * 16; 01136 } 01137 01138 if (!simple && IS_INTRA_PCM(mb_type)) { 01139 for (i=0; i<16; i++) { 01140 memcpy(dest_y + i* linesize, h->mb + i*8, 16); 01141 } 01142 for (i=0; i<8; i++) { 01143 memcpy(dest_cb+ i*uvlinesize, h->mb + 128 + i*4, 8); 01144 memcpy(dest_cr+ i*uvlinesize, h->mb + 160 + i*4, 8); 01145 } 01146 } else { 01147 if(IS_INTRA(mb_type)){ 01148 if(h->deblocking_filter) 01149 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 1, simple); 01150 01151 if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){ 01152 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cb, uvlinesize); 01153 h->hpc.pred8x8[ h->chroma_pred_mode ](dest_cr, uvlinesize); 01154 } 01155 01156 if(IS_INTRA4x4(mb_type)){ 01157 if(simple || !s->encoding){ 01158 if(IS_8x8DCT(mb_type)){ 01159 if(transform_bypass){ 01160 idct_dc_add = 01161 idct_add = s->dsp.add_pixels8; 01162 }else{ 01163 idct_dc_add = h->h264dsp.h264_idct8_dc_add; 01164 idct_add = h->h264dsp.h264_idct8_add; 01165 } 01166 for(i=0; i<16; i+=4){ 01167 uint8_t * const ptr= dest_y + block_offset[i]; 01168 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; 01169 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){ 01170 h->hpc.pred8x8l_add[dir](ptr, h->mb + i*16, linesize); 01171 }else{ 01172 const int nnz = h->non_zero_count_cache[ scan8[i] ]; 01173 h->hpc.pred8x8l[ dir ](ptr, (h->topleft_samples_available<<i)&0x8000, 01174 (h->topright_samples_available<<i)&0x4000, linesize); 01175 if(nnz){ 01176 if(nnz == 1 && h->mb[i*16]) 01177 idct_dc_add(ptr, h->mb + i*16, linesize); 01178 else 01179 idct_add (ptr, h->mb + i*16, linesize); 01180 } 01181 } 01182 } 01183 }else{ 01184 if(transform_bypass){ 01185 idct_dc_add = 01186 idct_add = s->dsp.add_pixels4; 01187 }else{ 01188 idct_dc_add = h->h264dsp.h264_idct_dc_add; 01189 idct_add = h->h264dsp.h264_idct_add; 01190 } 01191 for(i=0; i<16; i++){ 01192 uint8_t * const ptr= dest_y + block_offset[i]; 01193 const int dir= h->intra4x4_pred_mode_cache[ scan8[i] ]; 01194 01195 if(transform_bypass && h->sps.profile_idc==244 && dir<=1){ 01196 h->hpc.pred4x4_add[dir](ptr, h->mb + i*16, linesize); 01197 }else{ 01198 uint8_t *topright; 01199 int nnz, tr; 01200 if(dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED){ 01201 const int topright_avail= (h->topright_samples_available<<i)&0x8000; 01202 assert(mb_y || linesize <= block_offset[i]); 01203 if(!topright_avail){ 01204 tr= ptr[3 - linesize]*0x01010101; 01205 topright= (uint8_t*) &tr; 01206 }else 01207 topright= ptr + 4 - linesize; 01208 }else 01209 topright= NULL; 01210 01211 h->hpc.pred4x4[ dir ](ptr, topright, linesize); 01212 nnz = h->non_zero_count_cache[ scan8[i] ]; 01213 if(nnz){ 01214 if(is_h264){ 01215 if(nnz == 1 && h->mb[i*16]) 01216 idct_dc_add(ptr, h->mb + i*16, linesize); 01217 else 01218 idct_add (ptr, h->mb + i*16, linesize); 01219 }else 01220 ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, 0); 01221 } 01222 } 01223 } 01224 } 01225 } 01226 }else{ 01227 h->hpc.pred16x16[ h->intra16x16_pred_mode ](dest_y , linesize); 01228 if(is_h264){ 01229 if(!transform_bypass) 01230 h264_luma_dc_dequant_idct_c(h->mb, s->qscale, h->dequant4_coeff[0][s->qscale][0]); 01231 }else 01232 ff_svq3_luma_dc_dequant_idct_c(h->mb, s->qscale); 01233 } 01234 if(h->deblocking_filter) 01235 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0, simple); 01236 }else if(is_h264){ 01237 hl_motion(h, dest_y, dest_cb, dest_cr, 01238 s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab, 01239 s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab, 01240 h->h264dsp.weight_h264_pixels_tab, h->h264dsp.biweight_h264_pixels_tab); 01241 } 01242 01243 01244 if(!IS_INTRA4x4(mb_type)){ 01245 if(is_h264){ 01246 if(IS_INTRA16x16(mb_type)){ 01247 if(transform_bypass){ 01248 if(h->sps.profile_idc==244 && (h->intra16x16_pred_mode==VERT_PRED8x8 || h->intra16x16_pred_mode==HOR_PRED8x8)){ 01249 h->hpc.pred16x16_add[h->intra16x16_pred_mode](dest_y, block_offset, h->mb, linesize); 01250 }else{ 01251 for(i=0; i<16; i++){ 01252 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]) 01253 s->dsp.add_pixels4(dest_y + block_offset[i], h->mb + i*16, linesize); 01254 } 01255 } 01256 }else{ 01257 h->h264dsp.h264_idct_add16intra(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache); 01258 } 01259 }else if(h->cbp&15){ 01260 if(transform_bypass){ 01261 const int di = IS_8x8DCT(mb_type) ? 4 : 1; 01262 idct_add= IS_8x8DCT(mb_type) ? s->dsp.add_pixels8 : s->dsp.add_pixels4; 01263 for(i=0; i<16; i+=di){ 01264 if(h->non_zero_count_cache[ scan8[i] ]){ 01265 idct_add(dest_y + block_offset[i], h->mb + i*16, linesize); 01266 } 01267 } 01268 }else{ 01269 if(IS_8x8DCT(mb_type)){ 01270 h->h264dsp.h264_idct8_add4(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache); 01271 }else{ 01272 h->h264dsp.h264_idct_add16(dest_y, block_offset, h->mb, linesize, h->non_zero_count_cache); 01273 } 01274 } 01275 } 01276 }else{ 01277 for(i=0; i<16; i++){ 01278 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ //FIXME benchmark weird rule, & below 01279 uint8_t * const ptr= dest_y + block_offset[i]; 01280 ff_svq3_add_idct_c(ptr, h->mb + i*16, linesize, s->qscale, IS_INTRA(mb_type) ? 1 : 0); 01281 } 01282 } 01283 } 01284 } 01285 01286 if((simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)) && (h->cbp&0x30)){ 01287 uint8_t *dest[2] = {dest_cb, dest_cr}; 01288 if(transform_bypass){ 01289 if(IS_INTRA(mb_type) && h->sps.profile_idc==244 && (h->chroma_pred_mode==VERT_PRED8x8 || h->chroma_pred_mode==HOR_PRED8x8)){ 01290 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0], block_offset + 16, h->mb + 16*16, uvlinesize); 01291 h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1], block_offset + 20, h->mb + 20*16, uvlinesize); 01292 }else{ 01293 idct_add = s->dsp.add_pixels4; 01294 for(i=16; i<16+8; i++){ 01295 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]) 01296 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize); 01297 } 01298 } 01299 }else{ 01300 chroma_dc_dequant_idct_c(h->mb + 16*16, h->chroma_qp[0], h->dequant4_coeff[IS_INTRA(mb_type) ? 1:4][h->chroma_qp[0]][0]); 01301 chroma_dc_dequant_idct_c(h->mb + 16*16+4*16, h->chroma_qp[1], h->dequant4_coeff[IS_INTRA(mb_type) ? 2:5][h->chroma_qp[1]][0]); 01302 if(is_h264){ 01303 idct_add = h->h264dsp.h264_idct_add; 01304 idct_dc_add = h->h264dsp.h264_idct_dc_add; 01305 for(i=16; i<16+8; i++){ 01306 if(h->non_zero_count_cache[ scan8[i] ]) 01307 idct_add (dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize); 01308 else if(h->mb[i*16]) 01309 idct_dc_add(dest[(i&4)>>2] + block_offset[i], h->mb + i*16, uvlinesize); 01310 } 01311 }else{ 01312 for(i=16; i<16+8; i++){ 01313 if(h->non_zero_count_cache[ scan8[i] ] || h->mb[i*16]){ 01314 uint8_t * const ptr= dest[(i&4)>>2] + block_offset[i]; 01315 ff_svq3_add_idct_c(ptr, h->mb + i*16, uvlinesize, ff_h264_chroma_qp[s->qscale + 12] - 12, 2); 01316 } 01317 } 01318 } 01319 } 01320 } 01321 } 01322 if(h->cbp || IS_INTRA(mb_type)) 01323 s->dsp.clear_blocks(h->mb); 01324 } 01325 01329 static void hl_decode_mb_simple(H264Context *h){ 01330 hl_decode_mb_internal(h, 1); 01331 } 01332 01336 static void av_noinline hl_decode_mb_complex(H264Context *h){ 01337 hl_decode_mb_internal(h, 0); 01338 } 01339 01340 void ff_h264_hl_decode_mb(H264Context *h){ 01341 MpegEncContext * const s = &h->s; 01342 const int mb_xy= h->mb_xy; 01343 const int mb_type= s->current_picture.mb_type[mb_xy]; 01344 int is_complex = CONFIG_SMALL || h->is_complex || IS_INTRA_PCM(mb_type) || s->qscale == 0; 01345 01346 if (is_complex) 01347 hl_decode_mb_complex(h); 01348 else hl_decode_mb_simple(h); 01349 } 01350 01351 static int pred_weight_table(H264Context *h){ 01352 MpegEncContext * const s = &h->s; 01353 int list, i; 01354 int luma_def, chroma_def; 01355 01356 h->use_weight= 0; 01357 h->use_weight_chroma= 0; 01358 h->luma_log2_weight_denom= get_ue_golomb(&s->gb); 01359 h->chroma_log2_weight_denom= get_ue_golomb(&s->gb); 01360 luma_def = 1<<h->luma_log2_weight_denom; 01361 chroma_def = 1<<h->chroma_log2_weight_denom; 01362 01363 for(list=0; list<2; list++){ 01364 h->luma_weight_flag[list] = 0; 01365 h->chroma_weight_flag[list] = 0; 01366 for(i=0; i<h->ref_count[list]; i++){ 01367 int luma_weight_flag, chroma_weight_flag; 01368 01369 luma_weight_flag= get_bits1(&s->gb); 01370 if(luma_weight_flag){ 01371 h->luma_weight[i][list][0]= get_se_golomb(&s->gb); 01372 h->luma_weight[i][list][1]= get_se_golomb(&s->gb); 01373 if( h->luma_weight[i][list][0] != luma_def 01374 || h->luma_weight[i][list][1] != 0) { 01375 h->use_weight= 1; 01376 h->luma_weight_flag[list]= 1; 01377 } 01378 }else{ 01379 h->luma_weight[i][list][0]= luma_def; 01380 h->luma_weight[i][list][1]= 0; 01381 } 01382 01383 if(CHROMA){ 01384 chroma_weight_flag= get_bits1(&s->gb); 01385 if(chroma_weight_flag){ 01386 int j; 01387 for(j=0; j<2; j++){ 01388 h->chroma_weight[i][list][j][0]= get_se_golomb(&s->gb); 01389 h->chroma_weight[i][list][j][1]= get_se_golomb(&s->gb); 01390 if( h->chroma_weight[i][list][j][0] != chroma_def 01391 || h->chroma_weight[i][list][j][1] != 0) { 01392 h->use_weight_chroma= 1; 01393 h->chroma_weight_flag[list]= 1; 01394 } 01395 } 01396 }else{ 01397 int j; 01398 for(j=0; j<2; j++){ 01399 h->chroma_weight[i][list][j][0]= chroma_def; 01400 h->chroma_weight[i][list][j][1]= 0; 01401 } 01402 } 01403 } 01404 } 01405 if(h->slice_type_nos != FF_B_TYPE) break; 01406 } 01407 h->use_weight= h->use_weight || h->use_weight_chroma; 01408 return 0; 01409 } 01410 01416 static void implicit_weight_table(H264Context *h, int field){ 01417 MpegEncContext * const s = &h->s; 01418 int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1; 01419 01420 for (i = 0; i < 2; i++) { 01421 h->luma_weight_flag[i] = 0; 01422 h->chroma_weight_flag[i] = 0; 01423 } 01424 01425 if(field < 0){ 01426 cur_poc = s->current_picture_ptr->poc; 01427 if( h->ref_count[0] == 1 && h->ref_count[1] == 1 && !FRAME_MBAFF 01428 && h->ref_list[0][0].poc + h->ref_list[1][0].poc == 2*cur_poc){ 01429 h->use_weight= 0; 01430 h->use_weight_chroma= 0; 01431 return; 01432 } 01433 ref_start= 0; 01434 ref_count0= h->ref_count[0]; 01435 ref_count1= h->ref_count[1]; 01436 }else{ 01437 cur_poc = s->current_picture_ptr->field_poc[field]; 01438 ref_start= 16; 01439 ref_count0= 16+2*h->ref_count[0]; 01440 ref_count1= 16+2*h->ref_count[1]; 01441 } 01442 01443 h->use_weight= 2; 01444 h->use_weight_chroma= 2; 01445 h->luma_log2_weight_denom= 5; 01446 h->chroma_log2_weight_denom= 5; 01447 01448 for(ref0=ref_start; ref0 < ref_count0; ref0++){ 01449 int poc0 = h->ref_list[0][ref0].poc; 01450 for(ref1=ref_start; ref1 < ref_count1; ref1++){ 01451 int poc1 = h->ref_list[1][ref1].poc; 01452 int td = av_clip(poc1 - poc0, -128, 127); 01453 int w= 32; 01454 if(td){ 01455 int tb = av_clip(cur_poc - poc0, -128, 127); 01456 int tx = (16384 + (FFABS(td) >> 1)) / td; 01457 int dist_scale_factor = (tb*tx + 32) >> 8; 01458 if(dist_scale_factor >= -64 && dist_scale_factor <= 128) 01459 w = 64 - dist_scale_factor; 01460 } 01461 if(field<0){ 01462 h->implicit_weight[ref0][ref1][0]= 01463 h->implicit_weight[ref0][ref1][1]= w; 01464 }else{ 01465 h->implicit_weight[ref0][ref1][field]=w; 01466 } 01467 } 01468 } 01469 } 01470 01474 static void idr(H264Context *h){ 01475 ff_h264_remove_all_refs(h); 01476 h->prev_frame_num= 0; 01477 h->prev_frame_num_offset= 0; 01478 h->prev_poc_msb= 01479 h->prev_poc_lsb= 0; 01480 } 01481 01482 /* forget old pics after a seek */ 01483 static void flush_dpb(AVCodecContext *avctx){ 01484 H264Context *h= avctx->priv_data; 01485 int i; 01486 for(i=0; i<MAX_DELAYED_PIC_COUNT; i++) { 01487 if(h->delayed_pic[i]) 01488 h->delayed_pic[i]->reference= 0; 01489 h->delayed_pic[i]= NULL; 01490 } 01491 h->outputed_poc= INT_MIN; 01492 h->prev_interlaced_frame = 1; 01493 idr(h); 01494 if(h->s.current_picture_ptr) 01495 h->s.current_picture_ptr->reference= 0; 01496 h->s.first_field= 0; 01497 ff_h264_reset_sei(h); 01498 ff_mpeg_flush(avctx); 01499 } 01500 01501 static int init_poc(H264Context *h){ 01502 MpegEncContext * const s = &h->s; 01503 const int max_frame_num= 1<<h->sps.log2_max_frame_num; 01504 int field_poc[2]; 01505 Picture *cur = s->current_picture_ptr; 01506 01507 h->frame_num_offset= h->prev_frame_num_offset; 01508 if(h->frame_num < h->prev_frame_num) 01509 h->frame_num_offset += max_frame_num; 01510 01511 if(h->sps.poc_type==0){ 01512 const int max_poc_lsb= 1<<h->sps.log2_max_poc_lsb; 01513 01514 if (h->poc_lsb < h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb >= max_poc_lsb/2) 01515 h->poc_msb = h->prev_poc_msb + max_poc_lsb; 01516 else if(h->poc_lsb > h->prev_poc_lsb && h->prev_poc_lsb - h->poc_lsb < -max_poc_lsb/2) 01517 h->poc_msb = h->prev_poc_msb - max_poc_lsb; 01518 else 01519 h->poc_msb = h->prev_poc_msb; 01520 //printf("poc: %d %d\n", h->poc_msb, h->poc_lsb); 01521 field_poc[0] = 01522 field_poc[1] = h->poc_msb + h->poc_lsb; 01523 if(s->picture_structure == PICT_FRAME) 01524 field_poc[1] += h->delta_poc_bottom; 01525 }else if(h->sps.poc_type==1){ 01526 int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc; 01527 int i; 01528 01529 if(h->sps.poc_cycle_length != 0) 01530 abs_frame_num = h->frame_num_offset + h->frame_num; 01531 else 01532 abs_frame_num = 0; 01533 01534 if(h->nal_ref_idc==0 && abs_frame_num > 0) 01535 abs_frame_num--; 01536 01537 expected_delta_per_poc_cycle = 0; 01538 for(i=0; i < h->sps.poc_cycle_length; i++) 01539 expected_delta_per_poc_cycle += h->sps.offset_for_ref_frame[ i ]; //FIXME integrate during sps parse 01540 01541 if(abs_frame_num > 0){ 01542 int poc_cycle_cnt = (abs_frame_num - 1) / h->sps.poc_cycle_length; 01543 int frame_num_in_poc_cycle = (abs_frame_num - 1) % h->sps.poc_cycle_length; 01544 01545 expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle; 01546 for(i = 0; i <= frame_num_in_poc_cycle; i++) 01547 expectedpoc = expectedpoc + h->sps.offset_for_ref_frame[ i ]; 01548 } else 01549 expectedpoc = 0; 01550 01551 if(h->nal_ref_idc == 0) 01552 expectedpoc = expectedpoc + h->sps.offset_for_non_ref_pic; 01553 01554 field_poc[0] = expectedpoc + h->delta_poc[0]; 01555 field_poc[1] = field_poc[0] + h->sps.offset_for_top_to_bottom_field; 01556 01557 if(s->picture_structure == PICT_FRAME) 01558 field_poc[1] += h->delta_poc[1]; 01559 }else{ 01560 int poc= 2*(h->frame_num_offset + h->frame_num); 01561 01562 if(!h->nal_ref_idc) 01563 poc--; 01564 01565 field_poc[0]= poc; 01566 field_poc[1]= poc; 01567 } 01568 01569 if(s->picture_structure != PICT_BOTTOM_FIELD) 01570 s->current_picture_ptr->field_poc[0]= field_poc[0]; 01571 if(s->picture_structure != PICT_TOP_FIELD) 01572 s->current_picture_ptr->field_poc[1]= field_poc[1]; 01573 cur->poc= FFMIN(cur->field_poc[0], cur->field_poc[1]); 01574 01575 return 0; 01576 } 01577 01578 01582 static void init_scan_tables(H264Context *h){ 01583 int i; 01584 if(h->h264dsp.h264_idct_add == ff_h264_idct_add_c){ //FIXME little ugly 01585 memcpy(h->zigzag_scan, zigzag_scan, 16*sizeof(uint8_t)); 01586 memcpy(h-> field_scan, field_scan, 16*sizeof(uint8_t)); 01587 }else{ 01588 for(i=0; i<16; i++){ 01589 #define T(x) (x>>2) | ((x<<2) & 0xF) 01590 h->zigzag_scan[i] = T(zigzag_scan[i]); 01591 h-> field_scan[i] = T( field_scan[i]); 01592 #undef T 01593 } 01594 } 01595 if(h->h264dsp.h264_idct8_add == ff_h264_idct8_add_c){ 01596 memcpy(h->zigzag_scan8x8, ff_zigzag_direct, 64*sizeof(uint8_t)); 01597 memcpy(h->zigzag_scan8x8_cavlc, zigzag_scan8x8_cavlc, 64*sizeof(uint8_t)); 01598 memcpy(h->field_scan8x8, field_scan8x8, 64*sizeof(uint8_t)); 01599 memcpy(h->field_scan8x8_cavlc, field_scan8x8_cavlc, 64*sizeof(uint8_t)); 01600 }else{ 01601 for(i=0; i<64; i++){ 01602 #define T(x) (x>>3) | ((x&7)<<3) 01603 h->zigzag_scan8x8[i] = T(ff_zigzag_direct[i]); 01604 h->zigzag_scan8x8_cavlc[i] = T(zigzag_scan8x8_cavlc[i]); 01605 h->field_scan8x8[i] = T(field_scan8x8[i]); 01606 h->field_scan8x8_cavlc[i] = T(field_scan8x8_cavlc[i]); 01607 #undef T 01608 } 01609 } 01610 if(h->sps.transform_bypass){ //FIXME same ugly 01611 h->zigzag_scan_q0 = zigzag_scan; 01612 h->zigzag_scan8x8_q0 = ff_zigzag_direct; 01613 h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc; 01614 h->field_scan_q0 = field_scan; 01615 h->field_scan8x8_q0 = field_scan8x8; 01616 h->field_scan8x8_cavlc_q0 = field_scan8x8_cavlc; 01617 }else{ 01618 h->zigzag_scan_q0 = h->zigzag_scan; 01619 h->zigzag_scan8x8_q0 = h->zigzag_scan8x8; 01620 h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc; 01621 h->field_scan_q0 = h->field_scan; 01622 h->field_scan8x8_q0 = h->field_scan8x8; 01623 h->field_scan8x8_cavlc_q0 = h->field_scan8x8_cavlc; 01624 } 01625 } 01626 01627 static void field_end(H264Context *h){ 01628 MpegEncContext * const s = &h->s; 01629 AVCodecContext * const avctx= s->avctx; 01630 s->mb_y= 0; 01631 01632 s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264; 01633 s->current_picture_ptr->pict_type= s->pict_type; 01634 01635 if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 01636 ff_vdpau_h264_set_reference_frames(s); 01637 01638 if(!s->dropable) { 01639 ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index); 01640 h->prev_poc_msb= h->poc_msb; 01641 h->prev_poc_lsb= h->poc_lsb; 01642 } 01643 h->prev_frame_num_offset= h->frame_num_offset; 01644 h->prev_frame_num= h->frame_num; 01645 01646 if (avctx->hwaccel) { 01647 if (avctx->hwaccel->end_frame(avctx) < 0) 01648 av_log(avctx, AV_LOG_ERROR, "hardware accelerator failed to decode picture\n"); 01649 } 01650 01651 if (CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 01652 ff_vdpau_h264_picture_complete(s); 01653 01654 /* 01655 * FIXME: Error handling code does not seem to support interlaced 01656 * when slices span multiple rows 01657 * The ff_er_add_slice calls don't work right for bottom 01658 * fields; they cause massive erroneous error concealing 01659 * Error marking covers both fields (top and bottom). 01660 * This causes a mismatched s->error_count 01661 * and a bad error table. Further, the error count goes to 01662 * INT_MAX when called for bottom field, because mb_y is 01663 * past end by one (callers fault) and resync_mb_y != 0 01664 * causes problems for the first MB line, too. 01665 */ 01666 if (!FIELD_PICTURE) 01667 ff_er_frame_end(s); 01668 01669 MPV_frame_end(s); 01670 01671 h->current_slice=0; 01672 } 01673 01677 static void clone_slice(H264Context *dst, H264Context *src) 01678 { 01679 memcpy(dst->block_offset, src->block_offset, sizeof(dst->block_offset)); 01680 dst->s.current_picture_ptr = src->s.current_picture_ptr; 01681 dst->s.current_picture = src->s.current_picture; 01682 dst->s.linesize = src->s.linesize; 01683 dst->s.uvlinesize = src->s.uvlinesize; 01684 dst->s.first_field = src->s.first_field; 01685 01686 dst->prev_poc_msb = src->prev_poc_msb; 01687 dst->prev_poc_lsb = src->prev_poc_lsb; 01688 dst->prev_frame_num_offset = src->prev_frame_num_offset; 01689 dst->prev_frame_num = src->prev_frame_num; 01690 dst->short_ref_count = src->short_ref_count; 01691 01692 memcpy(dst->short_ref, src->short_ref, sizeof(dst->short_ref)); 01693 memcpy(dst->long_ref, src->long_ref, sizeof(dst->long_ref)); 01694 memcpy(dst->default_ref_list, src->default_ref_list, sizeof(dst->default_ref_list)); 01695 memcpy(dst->ref_list, src->ref_list, sizeof(dst->ref_list)); 01696 01697 memcpy(dst->dequant4_coeff, src->dequant4_coeff, sizeof(src->dequant4_coeff)); 01698 memcpy(dst->dequant8_coeff, src->dequant8_coeff, sizeof(src->dequant8_coeff)); 01699 } 01700 01710 static int decode_slice_header(H264Context *h, H264Context *h0){ 01711 MpegEncContext * const s = &h->s; 01712 MpegEncContext * const s0 = &h0->s; 01713 unsigned int first_mb_in_slice; 01714 unsigned int pps_id; 01715 int num_ref_idx_active_override_flag; 01716 unsigned int slice_type, tmp, i, j; 01717 int default_ref_list_done = 0; 01718 int last_pic_structure; 01719 01720 s->dropable= h->nal_ref_idc == 0; 01721 01722 if((s->avctx->flags2 & CODEC_FLAG2_FAST) && !h->nal_ref_idc){ 01723 s->me.qpel_put= s->dsp.put_2tap_qpel_pixels_tab; 01724 s->me.qpel_avg= s->dsp.avg_2tap_qpel_pixels_tab; 01725 }else{ 01726 s->me.qpel_put= s->dsp.put_h264_qpel_pixels_tab; 01727 s->me.qpel_avg= s->dsp.avg_h264_qpel_pixels_tab; 01728 } 01729 01730 first_mb_in_slice= get_ue_golomb(&s->gb); 01731 01732 if(first_mb_in_slice == 0){ //FIXME better field boundary detection 01733 if(h0->current_slice && FIELD_PICTURE){ 01734 field_end(h); 01735 } 01736 01737 h0->current_slice = 0; 01738 if (!s0->first_field) 01739 s->current_picture_ptr= NULL; 01740 } 01741 01742 slice_type= get_ue_golomb_31(&s->gb); 01743 if(slice_type > 9){ 01744 av_log(h->s.avctx, AV_LOG_ERROR, "slice type too large (%d) at %d %d\n", h->slice_type, s->mb_x, s->mb_y); 01745 return -1; 01746 } 01747 if(slice_type > 4){ 01748 slice_type -= 5; 01749 h->slice_type_fixed=1; 01750 }else 01751 h->slice_type_fixed=0; 01752 01753 slice_type= golomb_to_pict_type[ slice_type ]; 01754 if (slice_type == FF_I_TYPE 01755 || (h0->current_slice != 0 && slice_type == h0->last_slice_type) ) { 01756 default_ref_list_done = 1; 01757 } 01758 h->slice_type= slice_type; 01759 h->slice_type_nos= slice_type & 3; 01760 01761 s->pict_type= h->slice_type; // to make a few old functions happy, it's wrong though 01762 01763 pps_id= get_ue_golomb(&s->gb); 01764 if(pps_id>=MAX_PPS_COUNT){ 01765 av_log(h->s.avctx, AV_LOG_ERROR, "pps_id out of range\n"); 01766 return -1; 01767 } 01768 if(!h0->pps_buffers[pps_id]) { 01769 av_log(h->s.avctx, AV_LOG_ERROR, "non-existing PPS %u referenced\n", pps_id); 01770 return -1; 01771 } 01772 h->pps= *h0->pps_buffers[pps_id]; 01773 01774 if(!h0->sps_buffers[h->pps.sps_id]) { 01775 av_log(h->s.avctx, AV_LOG_ERROR, "non-existing SPS %u referenced\n", h->pps.sps_id); 01776 return -1; 01777 } 01778 h->sps = *h0->sps_buffers[h->pps.sps_id]; 01779 01780 s->avctx->profile = h->sps.profile_idc; 01781 s->avctx->level = h->sps.level_idc; 01782 s->avctx->refs = h->sps.ref_frame_count; 01783 01784 if(h == h0 && h->dequant_coeff_pps != pps_id){ 01785 h->dequant_coeff_pps = pps_id; 01786 init_dequant_tables(h); 01787 } 01788 01789 s->mb_width= h->sps.mb_width; 01790 s->mb_height= h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag); 01791 01792 h->b_stride= s->mb_width*4; 01793 01794 s->width = 16*s->mb_width - 2*FFMIN(h->sps.crop_right, 7); 01795 if(h->sps.frame_mbs_only_flag) 01796 s->height= 16*s->mb_height - 2*FFMIN(h->sps.crop_bottom, 7); 01797 else 01798 s->height= 16*s->mb_height - 4*FFMIN(h->sps.crop_bottom, 3); 01799 01800 if (s->context_initialized 01801 && ( s->width != s->avctx->width || s->height != s->avctx->height 01802 || av_cmp_q(h->sps.sar, s->avctx->sample_aspect_ratio))) { 01803 if(h != h0) 01804 return -1; // width / height changed during parallelized decoding 01805 free_tables(h); 01806 flush_dpb(s->avctx); 01807 MPV_common_end(s); 01808 } 01809 if (!s->context_initialized) { 01810 if(h != h0) 01811 return -1; // we cant (re-)initialize context during parallel decoding 01812 01813 avcodec_set_dimensions(s->avctx, s->width, s->height); 01814 s->avctx->sample_aspect_ratio= h->sps.sar; 01815 if(!s->avctx->sample_aspect_ratio.den) 01816 s->avctx->sample_aspect_ratio.den = 1; 01817 01818 if(h->sps.video_signal_type_present_flag){ 01819 s->avctx->color_range = h->sps.full_range ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG; 01820 if(h->sps.colour_description_present_flag){ 01821 s->avctx->color_primaries = h->sps.color_primaries; 01822 s->avctx->color_trc = h->sps.color_trc; 01823 s->avctx->colorspace = h->sps.colorspace; 01824 } 01825 } 01826 01827 if(h->sps.timing_info_present_flag){ 01828 int64_t den= h->sps.time_scale; 01829 if(h->x264_build < 44U) 01830 den *= 2; 01831 av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den, 01832 h->sps.num_units_in_tick, den, 1<<30); 01833 } 01834 s->avctx->pix_fmt = s->avctx->get_format(s->avctx, s->avctx->codec->pix_fmts); 01835 s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt); 01836 01837 if (MPV_common_init(s) < 0) 01838 return -1; 01839 s->first_field = 0; 01840 h->prev_interlaced_frame = 1; 01841 01842 init_scan_tables(h); 01843 ff_h264_alloc_tables(h); 01844 01845 for(i = 1; i < s->avctx->thread_count; i++) { 01846 H264Context *c; 01847 c = h->thread_context[i] = av_malloc(sizeof(H264Context)); 01848 memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext)); 01849 memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext)); 01850 c->h264dsp = h->h264dsp; 01851 c->sps = h->sps; 01852 c->pps = h->pps; 01853 init_scan_tables(c); 01854 clone_tables(c, h, i); 01855 } 01856 01857 for(i = 0; i < s->avctx->thread_count; i++) 01858 if(context_init(h->thread_context[i]) < 0) 01859 return -1; 01860 } 01861 01862 h->frame_num= get_bits(&s->gb, h->sps.log2_max_frame_num); 01863 01864 h->mb_mbaff = 0; 01865 h->mb_aff_frame = 0; 01866 last_pic_structure = s0->picture_structure; 01867 if(h->sps.frame_mbs_only_flag){ 01868 s->picture_structure= PICT_FRAME; 01869 }else{ 01870 if(get_bits1(&s->gb)) { //field_pic_flag 01871 s->picture_structure= PICT_TOP_FIELD + get_bits1(&s->gb); //bottom_field_flag 01872 } else { 01873 s->picture_structure= PICT_FRAME; 01874 h->mb_aff_frame = h->sps.mb_aff; 01875 } 01876 } 01877 h->mb_field_decoding_flag= s->picture_structure != PICT_FRAME; 01878 01879 if(h0->current_slice == 0){ 01880 while(h->frame_num != h->prev_frame_num && 01881 h->frame_num != (h->prev_frame_num+1)%(1<<h->sps.log2_max_frame_num)){ 01882 av_log(NULL, AV_LOG_DEBUG, "Frame num gap %d %d\n", h->frame_num, h->prev_frame_num); 01883 if (ff_h264_frame_start(h) < 0) 01884 return -1; 01885 h->prev_frame_num++; 01886 h->prev_frame_num %= 1<<h->sps.log2_max_frame_num; 01887 s->current_picture_ptr->frame_num= h->prev_frame_num; 01888 ff_h264_execute_ref_pic_marking(h, NULL, 0); 01889 } 01890 01891 /* See if we have a decoded first field looking for a pair... */ 01892 if (s0->first_field) { 01893 assert(s0->current_picture_ptr); 01894 assert(s0->current_picture_ptr->data[0]); 01895 assert(s0->current_picture_ptr->reference != DELAYED_PIC_REF); 01896 01897 /* figure out if we have a complementary field pair */ 01898 if (!FIELD_PICTURE || s->picture_structure == last_pic_structure) { 01899 /* 01900 * Previous field is unmatched. Don't display it, but let it 01901 * remain for reference if marked as such. 01902 */ 01903 s0->current_picture_ptr = NULL; 01904 s0->first_field = FIELD_PICTURE; 01905 01906 } else { 01907 if (h->nal_ref_idc && 01908 s0->current_picture_ptr->reference && 01909 s0->current_picture_ptr->frame_num != h->frame_num) { 01910 /* 01911 * This and previous field were reference, but had 01912 * different frame_nums. Consider this field first in 01913 * pair. Throw away previous field except for reference 01914 * purposes. 01915 */ 01916 s0->first_field = 1; 01917 s0->current_picture_ptr = NULL; 01918 01919 } else { 01920 /* Second field in complementary pair */ 01921 s0->first_field = 0; 01922 } 01923 } 01924 01925 } else { 01926 /* Frame or first field in a potentially complementary pair */ 01927 assert(!s0->current_picture_ptr); 01928 s0->first_field = FIELD_PICTURE; 01929 } 01930 01931 if((!FIELD_PICTURE || s0->first_field) && ff_h264_frame_start(h) < 0) { 01932 s0->first_field = 0; 01933 return -1; 01934 } 01935 } 01936 if(h != h0) 01937 clone_slice(h, h0); 01938 01939 s->current_picture_ptr->frame_num= h->frame_num; //FIXME frame_num cleanup 01940 01941 assert(s->mb_num == s->mb_width * s->mb_height); 01942 if(first_mb_in_slice << FIELD_OR_MBAFF_PICTURE >= s->mb_num || 01943 first_mb_in_slice >= s->mb_num){ 01944 av_log(h->s.avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n"); 01945 return -1; 01946 } 01947 s->resync_mb_x = s->mb_x = first_mb_in_slice % s->mb_width; 01948 s->resync_mb_y = s->mb_y = (first_mb_in_slice / s->mb_width) << FIELD_OR_MBAFF_PICTURE; 01949 if (s->picture_structure == PICT_BOTTOM_FIELD) 01950 s->resync_mb_y = s->mb_y = s->mb_y + 1; 01951 assert(s->mb_y < s->mb_height); 01952 01953 if(s->picture_structure==PICT_FRAME){ 01954 h->curr_pic_num= h->frame_num; 01955 h->max_pic_num= 1<< h->sps.log2_max_frame_num; 01956 }else{ 01957 h->curr_pic_num= 2*h->frame_num + 1; 01958 h->max_pic_num= 1<<(h->sps.log2_max_frame_num + 1); 01959 } 01960 01961 if(h->nal_unit_type == NAL_IDR_SLICE){ 01962 get_ue_golomb(&s->gb); /* idr_pic_id */ 01963 } 01964 01965 if(h->sps.poc_type==0){ 01966 h->poc_lsb= get_bits(&s->gb, h->sps.log2_max_poc_lsb); 01967 01968 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME){ 01969 h->delta_poc_bottom= get_se_golomb(&s->gb); 01970 } 01971 } 01972 01973 if(h->sps.poc_type==1 && !h->sps.delta_pic_order_always_zero_flag){ 01974 h->delta_poc[0]= get_se_golomb(&s->gb); 01975 01976 if(h->pps.pic_order_present==1 && s->picture_structure==PICT_FRAME) 01977 h->delta_poc[1]= get_se_golomb(&s->gb); 01978 } 01979 01980 init_poc(h); 01981 01982 if(h->pps.redundant_pic_cnt_present){ 01983 h->redundant_pic_count= get_ue_golomb(&s->gb); 01984 } 01985 01986 //set defaults, might be overridden a few lines later 01987 h->ref_count[0]= h->pps.ref_count[0]; 01988 h->ref_count[1]= h->pps.ref_count[1]; 01989 01990 if(h->slice_type_nos != FF_I_TYPE){ 01991 if(h->slice_type_nos == FF_B_TYPE){ 01992 h->direct_spatial_mv_pred= get_bits1(&s->gb); 01993 } 01994 num_ref_idx_active_override_flag= get_bits1(&s->gb); 01995 01996 if(num_ref_idx_active_override_flag){ 01997 h->ref_count[0]= get_ue_golomb(&s->gb) + 1; 01998 if(h->slice_type_nos==FF_B_TYPE) 01999 h->ref_count[1]= get_ue_golomb(&s->gb) + 1; 02000 02001 if(h->ref_count[0]-1 > 32-1 || h->ref_count[1]-1 > 32-1){ 02002 av_log(h->s.avctx, AV_LOG_ERROR, "reference overflow\n"); 02003 h->ref_count[0]= h->ref_count[1]= 1; 02004 return -1; 02005 } 02006 } 02007 if(h->slice_type_nos == FF_B_TYPE) 02008 h->list_count= 2; 02009 else 02010 h->list_count= 1; 02011 }else 02012 h->list_count= 0; 02013 02014 if(!default_ref_list_done){ 02015 ff_h264_fill_default_ref_list(h); 02016 } 02017 02018 if(h->slice_type_nos!=FF_I_TYPE && ff_h264_decode_ref_pic_list_reordering(h) < 0) 02019 return -1; 02020 02021 if(h->slice_type_nos!=FF_I_TYPE){ 02022 s->last_picture_ptr= &h->ref_list[0][0]; 02023 ff_copy_picture(&s->last_picture, s->last_picture_ptr); 02024 } 02025 if(h->slice_type_nos==FF_B_TYPE){ 02026 s->next_picture_ptr= &h->ref_list[1][0]; 02027 ff_copy_picture(&s->next_picture, s->next_picture_ptr); 02028 } 02029 02030 if( (h->pps.weighted_pred && h->slice_type_nos == FF_P_TYPE ) 02031 || (h->pps.weighted_bipred_idc==1 && h->slice_type_nos== FF_B_TYPE ) ) 02032 pred_weight_table(h); 02033 else if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){ 02034 implicit_weight_table(h, -1); 02035 }else { 02036 h->use_weight = 0; 02037 for (i = 0; i < 2; i++) { 02038 h->luma_weight_flag[i] = 0; 02039 h->chroma_weight_flag[i] = 0; 02040 } 02041 } 02042 02043 if(h->nal_ref_idc) 02044 ff_h264_decode_ref_pic_marking(h0, &s->gb); 02045 02046 if(FRAME_MBAFF){ 02047 ff_h264_fill_mbaff_ref_list(h); 02048 02049 if(h->pps.weighted_bipred_idc==2 && h->slice_type_nos== FF_B_TYPE){ 02050 implicit_weight_table(h, 0); 02051 implicit_weight_table(h, 1); 02052 } 02053 } 02054 02055 if(h->slice_type_nos==FF_B_TYPE && !h->direct_spatial_mv_pred) 02056 ff_h264_direct_dist_scale_factor(h); 02057 ff_h264_direct_ref_list_init(h); 02058 02059 if( h->slice_type_nos != FF_I_TYPE && h->pps.cabac ){ 02060 tmp = get_ue_golomb_31(&s->gb); 02061 if(tmp > 2){ 02062 av_log(s->avctx, AV_LOG_ERROR, "cabac_init_idc overflow\n"); 02063 return -1; 02064 } 02065 h->cabac_init_idc= tmp; 02066 } 02067 02068 h->last_qscale_diff = 0; 02069 tmp = h->pps.init_qp + get_se_golomb(&s->gb); 02070 if(tmp>51){ 02071 av_log(s->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp); 02072 return -1; 02073 } 02074 s->qscale= tmp; 02075 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); 02076 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); 02077 //FIXME qscale / qp ... stuff 02078 if(h->slice_type == FF_SP_TYPE){ 02079 get_bits1(&s->gb); /* sp_for_switch_flag */ 02080 } 02081 if(h->slice_type==FF_SP_TYPE || h->slice_type == FF_SI_TYPE){ 02082 get_se_golomb(&s->gb); /* slice_qs_delta */ 02083 } 02084 02085 h->deblocking_filter = 1; 02086 h->slice_alpha_c0_offset = 52; 02087 h->slice_beta_offset = 52; 02088 if( h->pps.deblocking_filter_parameters_present ) { 02089 tmp= get_ue_golomb_31(&s->gb); 02090 if(tmp > 2){ 02091 av_log(s->avctx, AV_LOG_ERROR, "deblocking_filter_idc %u out of range\n", tmp); 02092 return -1; 02093 } 02094 h->deblocking_filter= tmp; 02095 if(h->deblocking_filter < 2) 02096 h->deblocking_filter^= 1; // 1<->0 02097 02098 if( h->deblocking_filter ) { 02099 h->slice_alpha_c0_offset += get_se_golomb(&s->gb) << 1; 02100 h->slice_beta_offset += get_se_golomb(&s->gb) << 1; 02101 if( h->slice_alpha_c0_offset > 104U 02102 || h->slice_beta_offset > 104U){ 02103 av_log(s->avctx, AV_LOG_ERROR, "deblocking filter parameters %d %d out of range\n", h->slice_alpha_c0_offset, h->slice_beta_offset); 02104 return -1; 02105 } 02106 } 02107 } 02108 02109 if( s->avctx->skip_loop_filter >= AVDISCARD_ALL 02110 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY && h->slice_type_nos != FF_I_TYPE) 02111 ||(s->avctx->skip_loop_filter >= AVDISCARD_BIDIR && h->slice_type_nos == FF_B_TYPE) 02112 ||(s->avctx->skip_loop_filter >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) 02113 h->deblocking_filter= 0; 02114 02115 if(h->deblocking_filter == 1 && h0->max_contexts > 1) { 02116 if(s->avctx->flags2 & CODEC_FLAG2_FAST) { 02117 /* Cheat slightly for speed: 02118 Do not bother to deblock across slices. */ 02119 h->deblocking_filter = 2; 02120 } else { 02121 h0->max_contexts = 1; 02122 if(!h0->single_decode_warning) { 02123 av_log(s->avctx, AV_LOG_INFO, "Cannot parallelize deblocking type 1, decoding such frames in sequential order\n"); 02124 h0->single_decode_warning = 1; 02125 } 02126 if(h != h0) 02127 return 1; // deblocking switched inside frame 02128 } 02129 } 02130 h->qp_thresh= 15 + 52 - FFMIN(h->slice_alpha_c0_offset, h->slice_beta_offset) - FFMAX3(0, h->pps.chroma_qp_index_offset[0], h->pps.chroma_qp_index_offset[1]); 02131 02132 #if 0 //FMO 02133 if( h->pps.num_slice_groups > 1 && h->pps.mb_slice_group_map_type >= 3 && h->pps.mb_slice_group_map_type <= 5) 02134 slice_group_change_cycle= get_bits(&s->gb, ?); 02135 #endif 02136 02137 h0->last_slice_type = slice_type; 02138 h->slice_num = ++h0->current_slice; 02139 if(h->slice_num >= MAX_SLICES){ 02140 av_log(s->avctx, AV_LOG_ERROR, "Too many slices, increase MAX_SLICES and recompile\n"); 02141 } 02142 02143 for(j=0; j<2; j++){ 02144 int id_list[16]; 02145 int *ref2frm= h->ref2frm[h->slice_num&(MAX_SLICES-1)][j]; 02146 for(i=0; i<16; i++){ 02147 id_list[i]= 60; 02148 if(h->ref_list[j][i].data[0]){ 02149 int k; 02150 uint8_t *base= h->ref_list[j][i].base[0]; 02151 for(k=0; k<h->short_ref_count; k++) 02152 if(h->short_ref[k]->base[0] == base){ 02153 id_list[i]= k; 02154 break; 02155 } 02156 for(k=0; k<h->long_ref_count; k++) 02157 if(h->long_ref[k] && h->long_ref[k]->base[0] == base){ 02158 id_list[i]= h->short_ref_count + k; 02159 break; 02160 } 02161 } 02162 } 02163 02164 ref2frm[0]= 02165 ref2frm[1]= -1; 02166 for(i=0; i<16; i++) 02167 ref2frm[i+2]= 4*id_list[i] 02168 +(h->ref_list[j][i].reference&3); 02169 ref2frm[18+0]= 02170 ref2frm[18+1]= -1; 02171 for(i=16; i<48; i++) 02172 ref2frm[i+4]= 4*id_list[(i-16)>>1] 02173 +(h->ref_list[j][i].reference&3); 02174 } 02175 02176 h->emu_edge_width= (s->flags&CODEC_FLAG_EMU_EDGE) ? 0 : 16; 02177 h->emu_edge_height= (FRAME_MBAFF || FIELD_PICTURE) ? 0 : h->emu_edge_width; 02178 02179 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ 02180 av_log(h->s.avctx, AV_LOG_DEBUG, "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n", 02181 h->slice_num, 02182 (s->picture_structure==PICT_FRAME ? "F" : s->picture_structure==PICT_TOP_FIELD ? "T" : "B"), 02183 first_mb_in_slice, 02184 av_get_pict_type_char(h->slice_type), h->slice_type_fixed ? " fix" : "", h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "", 02185 pps_id, h->frame_num, 02186 s->current_picture_ptr->field_poc[0], s->current_picture_ptr->field_poc[1], 02187 h->ref_count[0], h->ref_count[1], 02188 s->qscale, 02189 h->deblocking_filter, h->slice_alpha_c0_offset/2-26, h->slice_beta_offset/2-26, 02190 h->use_weight, 02191 h->use_weight==1 && h->use_weight_chroma ? "c" : "", 02192 h->slice_type == FF_B_TYPE ? (h->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "" 02193 ); 02194 } 02195 02196 return 0; 02197 } 02198 02199 int ff_h264_get_slice_type(const H264Context *h) 02200 { 02201 switch (h->slice_type) { 02202 case FF_P_TYPE: return 0; 02203 case FF_B_TYPE: return 1; 02204 case FF_I_TYPE: return 2; 02205 case FF_SP_TYPE: return 3; 02206 case FF_SI_TYPE: return 4; 02207 default: return -1; 02208 } 02209 } 02210 02215 static int fill_filter_caches(H264Context *h, int mb_type){ 02216 MpegEncContext * const s = &h->s; 02217 const int mb_xy= h->mb_xy; 02218 int top_xy, left_xy[2]; 02219 int top_type, left_type[2]; 02220 02221 top_xy = mb_xy - (s->mb_stride << MB_FIELD); 02222 02223 //FIXME deblocking could skip the intra and nnz parts. 02224 02225 /* Wow, what a mess, why didn't they simplify the interlacing & intra 02226 * stuff, I can't imagine that these complex rules are worth it. */ 02227 02228 left_xy[1] = left_xy[0] = mb_xy-1; 02229 if(FRAME_MBAFF){ 02230 const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]); 02231 const int curr_mb_field_flag = IS_INTERLACED(mb_type); 02232 if(s->mb_y&1){ 02233 if (left_mb_field_flag != curr_mb_field_flag) { 02234 left_xy[0] -= s->mb_stride; 02235 } 02236 }else{ 02237 if(curr_mb_field_flag){ 02238 top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1); 02239 } 02240 if (left_mb_field_flag != curr_mb_field_flag) { 02241 left_xy[1] += s->mb_stride; 02242 } 02243 } 02244 } 02245 02246 h->top_mb_xy = top_xy; 02247 h->left_mb_xy[0] = left_xy[0]; 02248 h->left_mb_xy[1] = left_xy[1]; 02249 { 02250 //for sufficiently low qp, filtering wouldn't do anything 02251 //this is a conservative estimate: could also check beta_offset and more accurate chroma_qp 02252 int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice 02253 int qp = s->current_picture.qscale_table[mb_xy]; 02254 if(qp <= qp_thresh 02255 && (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh) 02256 && (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){ 02257 if(!FRAME_MBAFF) 02258 return 1; 02259 if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh) 02260 && (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh)) 02261 return 1; 02262 } 02263 } 02264 02265 top_type = s->current_picture.mb_type[top_xy] ; 02266 left_type[0] = s->current_picture.mb_type[left_xy[0]]; 02267 left_type[1] = s->current_picture.mb_type[left_xy[1]]; 02268 if(h->deblocking_filter == 2){ 02269 if(h->slice_table[top_xy ] != h->slice_num) top_type= 0; 02270 if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0; 02271 }else{ 02272 if(h->slice_table[top_xy ] == 0xFFFF) top_type= 0; 02273 if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0; 02274 } 02275 h->top_type = top_type ; 02276 h->left_type[0]= left_type[0]; 02277 h->left_type[1]= left_type[1]; 02278 02279 if(IS_INTRA(mb_type)) 02280 return 0; 02281 02282 AV_COPY64(&h->non_zero_count_cache[0+8*1], &h->non_zero_count[mb_xy][ 0]); 02283 AV_COPY64(&h->non_zero_count_cache[0+8*2], &h->non_zero_count[mb_xy][ 8]); 02284 AV_COPY32(&h->non_zero_count_cache[0+8*5], &h->non_zero_count[mb_xy][16]); 02285 AV_COPY32(&h->non_zero_count_cache[4+8*3], &h->non_zero_count[mb_xy][20]); 02286 AV_COPY64(&h->non_zero_count_cache[0+8*4], &h->non_zero_count[mb_xy][24]); 02287 02288 h->cbp= h->cbp_table[mb_xy]; 02289 02290 { 02291 int list; 02292 for(list=0; list<h->list_count; list++){ 02293 int8_t *ref; 02294 int y, b_stride; 02295 int16_t (*mv_dst)[2]; 02296 int16_t (*mv_src)[2]; 02297 02298 if(!USES_LIST(mb_type, list)){ 02299 fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4); 02300 AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u); 02301 AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u); 02302 AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u); 02303 AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u); 02304 continue; 02305 } 02306 02307 ref = &s->current_picture.ref_index[list][4*mb_xy]; 02308 { 02309 int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); 02310 AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); 02311 AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); 02312 ref += 2; 02313 AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); 02314 AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101); 02315 } 02316 02317 b_stride = h->b_stride; 02318 mv_dst = &h->mv_cache[list][scan8[0]]; 02319 mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride]; 02320 for(y=0; y<4; y++){ 02321 AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride); 02322 } 02323 02324 } 02325 } 02326 02327 02328 /* 02329 0 . T T. T T T T 02330 1 L . .L . . . . 02331 2 L . .L . . . . 02332 3 . T TL . . . . 02333 4 L . .L . . . . 02334 5 L . .. . . . . 02335 */ 02336 //FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec) 02337 if(top_type){ 02338 AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][4+3*8]); 02339 } 02340 02341 if(left_type[0]){ 02342 h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][7+0*8]; 02343 h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][7+1*8]; 02344 h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][7+2*8]; 02345 h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][7+3*8]; 02346 } 02347 02348 // CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs 02349 if(!CABAC && h->pps.transform_8x8_mode){ 02350 if(IS_8x8DCT(top_type)){ 02351 h->non_zero_count_cache[4+8*0]= 02352 h->non_zero_count_cache[5+8*0]= h->cbp_table[top_xy] & 4; 02353 h->non_zero_count_cache[6+8*0]= 02354 h->non_zero_count_cache[7+8*0]= h->cbp_table[top_xy] & 8; 02355 } 02356 if(IS_8x8DCT(left_type[0])){ 02357 h->non_zero_count_cache[3+8*1]= 02358 h->non_zero_count_cache[3+8*2]= h->cbp_table[left_xy[0]]&2; //FIXME check MBAFF 02359 } 02360 if(IS_8x8DCT(left_type[1])){ 02361 h->non_zero_count_cache[3+8*3]= 02362 h->non_zero_count_cache[3+8*4]= h->cbp_table[left_xy[1]]&8; //FIXME check MBAFF 02363 } 02364 02365 if(IS_8x8DCT(mb_type)){ 02366 h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]= 02367 h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= h->cbp & 1; 02368 02369 h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]= 02370 h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= h->cbp & 2; 02371 02372 h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]= 02373 h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= h->cbp & 4; 02374 02375 h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]= 02376 h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= h->cbp & 8; 02377 } 02378 } 02379 02380 if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){ 02381 int list; 02382 for(list=0; list<h->list_count; list++){ 02383 if(USES_LIST(top_type, list)){ 02384 const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride; 02385 const int b8_xy= 4*top_xy + 2; 02386 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); 02387 AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]); 02388 h->ref_cache[list][scan8[0] + 0 - 1*8]= 02389 h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]]; 02390 h->ref_cache[list][scan8[0] + 2 - 1*8]= 02391 h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]]; 02392 }else{ 02393 AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]); 02394 AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u); 02395 } 02396 02397 if(!IS_INTERLACED(mb_type^left_type[0])){ 02398 if(USES_LIST(left_type[0], list)){ 02399 const int b_xy= h->mb2b_xy[left_xy[0]] + 3; 02400 const int b8_xy= 4*left_xy[0] + 1; 02401 int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2); 02402 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]); 02403 AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]); 02404 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]); 02405 AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]); 02406 h->ref_cache[list][scan8[0] - 1 + 0 ]= 02407 h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]]; 02408 h->ref_cache[list][scan8[0] - 1 +16 ]= 02409 h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]]; 02410 }else{ 02411 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]); 02412 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]); 02413 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]); 02414 AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]); 02415 h->ref_cache[list][scan8[0] - 1 + 0 ]= 02416 h->ref_cache[list][scan8[0] - 1 + 8 ]= 02417 h->ref_cache[list][scan8[0] - 1 + 16 ]= 02418 h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED; 02419 } 02420 } 02421 } 02422 } 02423 02424 return 0; 02425 } 02426 02427 static void loop_filter(H264Context *h){ 02428 MpegEncContext * const s = &h->s; 02429 uint8_t *dest_y, *dest_cb, *dest_cr; 02430 int linesize, uvlinesize, mb_x, mb_y; 02431 const int end_mb_y= s->mb_y + FRAME_MBAFF; 02432 const int old_slice_type= h->slice_type; 02433 02434 if(h->deblocking_filter) { 02435 for(mb_x= 0; mb_x<s->mb_width; mb_x++){ 02436 for(mb_y=end_mb_y - FRAME_MBAFF; mb_y<= end_mb_y; mb_y++){ 02437 int mb_xy, mb_type; 02438 mb_xy = h->mb_xy = mb_x + mb_y*s->mb_stride; 02439 h->slice_num= h->slice_table[mb_xy]; 02440 mb_type= s->current_picture.mb_type[mb_xy]; 02441 h->list_count= h->list_counts[mb_xy]; 02442 02443 if(FRAME_MBAFF) 02444 h->mb_mbaff = h->mb_field_decoding_flag = !!IS_INTERLACED(mb_type); 02445 02446 s->mb_x= mb_x; 02447 s->mb_y= mb_y; 02448 dest_y = s->current_picture.data[0] + (mb_x + mb_y * s->linesize ) * 16; 02449 dest_cb = s->current_picture.data[1] + (mb_x + mb_y * s->uvlinesize) * 8; 02450 dest_cr = s->current_picture.data[2] + (mb_x + mb_y * s->uvlinesize) * 8; 02451 //FIXME simplify above 02452 02453 if (MB_FIELD) { 02454 linesize = h->mb_linesize = s->linesize * 2; 02455 uvlinesize = h->mb_uvlinesize = s->uvlinesize * 2; 02456 if(mb_y&1){ //FIXME move out of this function? 02457 dest_y -= s->linesize*15; 02458 dest_cb-= s->uvlinesize*7; 02459 dest_cr-= s->uvlinesize*7; 02460 } 02461 } else { 02462 linesize = h->mb_linesize = s->linesize; 02463 uvlinesize = h->mb_uvlinesize = s->uvlinesize; 02464 } 02465 backup_mb_border(h, dest_y, dest_cb, dest_cr, linesize, uvlinesize, 0); 02466 if(fill_filter_caches(h, mb_type)) 02467 continue; 02468 h->chroma_qp[0] = get_chroma_qp(h, 0, s->current_picture.qscale_table[mb_xy]); 02469 h->chroma_qp[1] = get_chroma_qp(h, 1, s->current_picture.qscale_table[mb_xy]); 02470 02471 if (FRAME_MBAFF) { 02472 ff_h264_filter_mb (h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize); 02473 } else { 02474 ff_h264_filter_mb_fast(h, mb_x, mb_y, dest_y, dest_cb, dest_cr, linesize, uvlinesize); 02475 } 02476 } 02477 } 02478 } 02479 h->slice_type= old_slice_type; 02480 s->mb_x= 0; 02481 s->mb_y= end_mb_y - FRAME_MBAFF; 02482 h->chroma_qp[0] = get_chroma_qp(h, 0, s->qscale); 02483 h->chroma_qp[1] = get_chroma_qp(h, 1, s->qscale); 02484 } 02485 02486 static void predict_field_decoding_flag(H264Context *h){ 02487 MpegEncContext * const s = &h->s; 02488 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; 02489 int mb_type = (h->slice_table[mb_xy-1] == h->slice_num) 02490 ? s->current_picture.mb_type[mb_xy-1] 02491 : (h->slice_table[mb_xy-s->mb_stride] == h->slice_num) 02492 ? s->current_picture.mb_type[mb_xy-s->mb_stride] 02493 : 0; 02494 h->mb_mbaff = h->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0; 02495 } 02496 02497 static int decode_slice(struct AVCodecContext *avctx, void *arg){ 02498 H264Context *h = *(void**)arg; 02499 MpegEncContext * const s = &h->s; 02500 const int part_mask= s->partitioned_frame ? (AC_END|AC_ERROR) : 0x7F; 02501 02502 s->mb_skip_run= -1; 02503 02504 h->is_complex = FRAME_MBAFF || s->picture_structure != PICT_FRAME || s->codec_id != CODEC_ID_H264 || 02505 (CONFIG_GRAY && (s->flags&CODEC_FLAG_GRAY)); 02506 02507 if( h->pps.cabac ) { 02508 /* realign */ 02509 align_get_bits( &s->gb ); 02510 02511 /* init cabac */ 02512 ff_init_cabac_states( &h->cabac); 02513 ff_init_cabac_decoder( &h->cabac, 02514 s->gb.buffer + get_bits_count(&s->gb)/8, 02515 (get_bits_left(&s->gb) + 7)/8); 02516 02517 ff_h264_init_cabac_states(h); 02518 02519 for(;;){ 02520 //START_TIMER 02521 int ret = ff_h264_decode_mb_cabac(h); 02522 int eos; 02523 //STOP_TIMER("decode_mb_cabac") 02524 02525 if(ret>=0) ff_h264_hl_decode_mb(h); 02526 02527 if( ret >= 0 && FRAME_MBAFF ) { //FIXME optimal? or let mb_decode decode 16x32 ? 02528 s->mb_y++; 02529 02530 ret = ff_h264_decode_mb_cabac(h); 02531 02532 if(ret>=0) ff_h264_hl_decode_mb(h); 02533 s->mb_y--; 02534 } 02535 eos = get_cabac_terminate( &h->cabac ); 02536 02537 if((s->workaround_bugs & FF_BUG_TRUNCATED) && h->cabac.bytestream > h->cabac.bytestream_end + 2){ 02538 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02539 return 0; 02540 } 02541 if( ret < 0 || h->cabac.bytestream > h->cabac.bytestream_end + 2) { 02542 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d, bytestream (%td)\n", s->mb_x, s->mb_y, h->cabac.bytestream_end - h->cabac.bytestream); 02543 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); 02544 return -1; 02545 } 02546 02547 if( ++s->mb_x >= s->mb_width ) { 02548 s->mb_x = 0; 02549 loop_filter(h); 02550 ff_draw_horiz_band(s, 16*s->mb_y, 16); 02551 ++s->mb_y; 02552 if(FIELD_OR_MBAFF_PICTURE) { 02553 ++s->mb_y; 02554 if(FRAME_MBAFF && s->mb_y < s->mb_height) 02555 predict_field_decoding_flag(h); 02556 } 02557 } 02558 02559 if( eos || s->mb_y >= s->mb_height ) { 02560 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); 02561 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02562 return 0; 02563 } 02564 } 02565 02566 } else { 02567 for(;;){ 02568 int ret = ff_h264_decode_mb_cavlc(h); 02569 02570 if(ret>=0) ff_h264_hl_decode_mb(h); 02571 02572 if(ret>=0 && FRAME_MBAFF){ //FIXME optimal? or let mb_decode decode 16x32 ? 02573 s->mb_y++; 02574 ret = ff_h264_decode_mb_cavlc(h); 02575 02576 if(ret>=0) ff_h264_hl_decode_mb(h); 02577 s->mb_y--; 02578 } 02579 02580 if(ret<0){ 02581 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); 02582 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); 02583 02584 return -1; 02585 } 02586 02587 if(++s->mb_x >= s->mb_width){ 02588 s->mb_x=0; 02589 loop_filter(h); 02590 ff_draw_horiz_band(s, 16*s->mb_y, 16); 02591 ++s->mb_y; 02592 if(FIELD_OR_MBAFF_PICTURE) { 02593 ++s->mb_y; 02594 if(FRAME_MBAFF && s->mb_y < s->mb_height) 02595 predict_field_decoding_flag(h); 02596 } 02597 if(s->mb_y >= s->mb_height){ 02598 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); 02599 02600 if(get_bits_count(&s->gb) == s->gb.size_in_bits ) { 02601 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02602 02603 return 0; 02604 }else{ 02605 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02606 02607 return -1; 02608 } 02609 } 02610 } 02611 02612 if(get_bits_count(&s->gb) >= s->gb.size_in_bits && s->mb_skip_run<=0){ 02613 tprintf(s->avctx, "slice end %d %d\n", get_bits_count(&s->gb), s->gb.size_in_bits); 02614 if(get_bits_count(&s->gb) == s->gb.size_in_bits ){ 02615 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02616 02617 return 0; 02618 }else{ 02619 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); 02620 02621 return -1; 02622 } 02623 } 02624 } 02625 } 02626 02627 #if 0 02628 for(;s->mb_y < s->mb_height; s->mb_y++){ 02629 for(;s->mb_x < s->mb_width; s->mb_x++){ 02630 int ret= decode_mb(h); 02631 02632 ff_h264_hl_decode_mb(h); 02633 02634 if(ret<0){ 02635 av_log(s->avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); 02636 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); 02637 02638 return -1; 02639 } 02640 02641 if(++s->mb_x >= s->mb_width){ 02642 s->mb_x=0; 02643 if(++s->mb_y >= s->mb_height){ 02644 if(get_bits_count(s->gb) == s->gb.size_in_bits){ 02645 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02646 02647 return 0; 02648 }else{ 02649 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02650 02651 return -1; 02652 } 02653 } 02654 } 02655 02656 if(get_bits_count(s->?gb) >= s->gb?.size_in_bits){ 02657 if(get_bits_count(s->gb) == s->gb.size_in_bits){ 02658 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, (AC_END|DC_END|MV_END)&part_mask); 02659 02660 return 0; 02661 }else{ 02662 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x, s->mb_y, (AC_ERROR|DC_ERROR|MV_ERROR)&part_mask); 02663 02664 return -1; 02665 } 02666 } 02667 } 02668 s->mb_x=0; 02669 ff_draw_horiz_band(s, 16*s->mb_y, 16); 02670 } 02671 #endif 02672 return -1; //not reached 02673 } 02674 02681 static void execute_decode_slices(H264Context *h, int context_count){ 02682 MpegEncContext * const s = &h->s; 02683 AVCodecContext * const avctx= s->avctx; 02684 H264Context *hx; 02685 int i; 02686 02687 if (s->avctx->hwaccel) 02688 return; 02689 if(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 02690 return; 02691 if(context_count == 1) { 02692 decode_slice(avctx, &h); 02693 } else { 02694 for(i = 1; i < context_count; i++) { 02695 hx = h->thread_context[i]; 02696 hx->s.error_recognition = avctx->error_recognition; 02697 hx->s.error_count = 0; 02698 } 02699 02700 avctx->execute(avctx, (void *)decode_slice, 02701 h->thread_context, NULL, context_count, sizeof(void*)); 02702 02703 /* pull back stuff from slices to master context */ 02704 hx = h->thread_context[context_count - 1]; 02705 s->mb_x = hx->s.mb_x; 02706 s->mb_y = hx->s.mb_y; 02707 s->dropable = hx->s.dropable; 02708 s->picture_structure = hx->s.picture_structure; 02709 for(i = 1; i < context_count; i++) 02710 h->s.error_count += h->thread_context[i]->s.error_count; 02711 } 02712 } 02713 02714 02715 static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size){ 02716 MpegEncContext * const s = &h->s; 02717 AVCodecContext * const avctx= s->avctx; 02718 int buf_index=0; 02719 H264Context *hx; 02720 int context_count = 0; 02721 int next_avc= h->is_avc ? 0 : buf_size; 02722 02723 h->max_contexts = avctx->thread_count; 02724 #if 0 02725 int i; 02726 for(i=0; i<50; i++){ 02727 av_log(NULL, AV_LOG_ERROR,"%02X ", buf[i]); 02728 } 02729 #endif 02730 if(!(s->flags2 & CODEC_FLAG2_CHUNKS)){ 02731 h->current_slice = 0; 02732 if (!s->first_field) 02733 s->current_picture_ptr= NULL; 02734 ff_h264_reset_sei(h); 02735 } 02736 02737 for(;;){ 02738 int consumed; 02739 int dst_length; 02740 int bit_length; 02741 const uint8_t *ptr; 02742 int i, nalsize = 0; 02743 int err; 02744 02745 if(buf_index >= next_avc) { 02746 if(buf_index >= buf_size) break; 02747 nalsize = 0; 02748 for(i = 0; i < h->nal_length_size; i++) 02749 nalsize = (nalsize << 8) | buf[buf_index++]; 02750 if(nalsize <= 1 || nalsize > buf_size - buf_index){ 02751 if(nalsize == 1){ 02752 buf_index++; 02753 continue; 02754 }else{ 02755 av_log(h->s.avctx, AV_LOG_ERROR, "AVC: nal size %d\n", nalsize); 02756 break; 02757 } 02758 } 02759 next_avc= buf_index + nalsize; 02760 } else { 02761 // start code prefix search 02762 for(; buf_index + 3 < next_avc; buf_index++){ 02763 // This should always succeed in the first iteration. 02764 if(buf[buf_index] == 0 && buf[buf_index+1] == 0 && buf[buf_index+2] == 1) 02765 break; 02766 } 02767 02768 if(buf_index+3 >= buf_size) break; 02769 02770 buf_index+=3; 02771 if(buf_index >= next_avc) continue; 02772 } 02773 02774 hx = h->thread_context[context_count]; 02775 02776 ptr= ff_h264_decode_nal(hx, buf + buf_index, &dst_length, &consumed, next_avc - buf_index); 02777 if (ptr==NULL || dst_length < 0){ 02778 return -1; 02779 } 02780 i= buf_index + consumed; 02781 if((s->workaround_bugs & FF_BUG_AUTODETECT) && i+3<next_avc && 02782 buf[i]==0x00 && buf[i+1]==0x00 && buf[i+2]==0x01 && buf[i+3]==0xE0) 02783 s->workaround_bugs |= FF_BUG_TRUNCATED; 02784 02785 if(!(s->workaround_bugs & FF_BUG_TRUNCATED)){ 02786 while(ptr[dst_length - 1] == 0 && dst_length > 0) 02787 dst_length--; 02788 } 02789 bit_length= !dst_length ? 0 : (8*dst_length - ff_h264_decode_rbsp_trailing(h, ptr + dst_length - 1)); 02790 02791 if(s->avctx->debug&FF_DEBUG_STARTCODE){ 02792 av_log(h->s.avctx, AV_LOG_DEBUG, "NAL %d at %d/%d length %d\n", hx->nal_unit_type, buf_index, buf_size, dst_length); 02793 } 02794 02795 if (h->is_avc && (nalsize != consumed) && nalsize){ 02796 av_log(h->s.avctx, AV_LOG_DEBUG, "AVC: Consumed only %d bytes instead of %d\n", consumed, nalsize); 02797 } 02798 02799 buf_index += consumed; 02800 02801 if( (s->hurry_up == 1 && h->nal_ref_idc == 0) //FIXME do not discard SEI id 02802 ||(avctx->skip_frame >= AVDISCARD_NONREF && h->nal_ref_idc == 0)) 02803 continue; 02804 02805 again: 02806 err = 0; 02807 switch(hx->nal_unit_type){ 02808 case NAL_IDR_SLICE: 02809 if (h->nal_unit_type != NAL_IDR_SLICE) { 02810 av_log(h->s.avctx, AV_LOG_ERROR, "Invalid mix of idr and non-idr slices"); 02811 return -1; 02812 } 02813 idr(h); //FIXME ensure we don't loose some frames if there is reordering 02814 case NAL_SLICE: 02815 init_get_bits(&hx->s.gb, ptr, bit_length); 02816 hx->intra_gb_ptr= 02817 hx->inter_gb_ptr= &hx->s.gb; 02818 hx->s.data_partitioning = 0; 02819 02820 if((err = decode_slice_header(hx, h))) 02821 break; 02822 02823 if (h->current_slice == 1) { 02824 if (s->avctx->hwaccel && s->avctx->hwaccel->start_frame(s->avctx, NULL, 0) < 0) 02825 return -1; 02826 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU) 02827 ff_vdpau_h264_picture_start(s); 02828 } 02829 02830 s->current_picture_ptr->key_frame |= 02831 (hx->nal_unit_type == NAL_IDR_SLICE) || 02832 (h->sei_recovery_frame_cnt >= 0); 02833 if(hx->redundant_pic_count==0 && hx->s.hurry_up < 5 02834 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) 02835 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=FF_B_TYPE) 02836 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE) 02837 && avctx->skip_frame < AVDISCARD_ALL){ 02838 if(avctx->hwaccel) { 02839 if (avctx->hwaccel->decode_slice(avctx, &buf[buf_index - consumed], consumed) < 0) 02840 return -1; 02841 }else 02842 if(CONFIG_H264_VDPAU_DECODER && s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU){ 02843 static const uint8_t start_code[] = {0x00, 0x00, 0x01}; 02844 ff_vdpau_add_data_chunk(s, start_code, sizeof(start_code)); 02845 ff_vdpau_add_data_chunk(s, &buf[buf_index - consumed], consumed ); 02846 }else 02847 context_count++; 02848 } 02849 break; 02850 case NAL_DPA: 02851 init_get_bits(&hx->s.gb, ptr, bit_length); 02852 hx->intra_gb_ptr= 02853 hx->inter_gb_ptr= NULL; 02854 02855 if ((err = decode_slice_header(hx, h)) < 0) 02856 break; 02857 02858 hx->s.data_partitioning = 1; 02859 02860 break; 02861 case NAL_DPB: 02862 init_get_bits(&hx->intra_gb, ptr, bit_length); 02863 hx->intra_gb_ptr= &hx->intra_gb; 02864 break; 02865 case NAL_DPC: 02866 init_get_bits(&hx->inter_gb, ptr, bit_length); 02867 hx->inter_gb_ptr= &hx->inter_gb; 02868 02869 if(hx->redundant_pic_count==0 && hx->intra_gb_ptr && hx->s.data_partitioning 02870 && s->context_initialized 02871 && s->hurry_up < 5 02872 && (avctx->skip_frame < AVDISCARD_NONREF || hx->nal_ref_idc) 02873 && (avctx->skip_frame < AVDISCARD_BIDIR || hx->slice_type_nos!=FF_B_TYPE) 02874 && (avctx->skip_frame < AVDISCARD_NONKEY || hx->slice_type_nos==FF_I_TYPE) 02875 && avctx->skip_frame < AVDISCARD_ALL) 02876 context_count++; 02877 break; 02878 case NAL_SEI: 02879 init_get_bits(&s->gb, ptr, bit_length); 02880 ff_h264_decode_sei(h); 02881 break; 02882 case NAL_SPS: 02883 init_get_bits(&s->gb, ptr, bit_length); 02884 ff_h264_decode_seq_parameter_set(h); 02885 02886 if(s->flags& CODEC_FLAG_LOW_DELAY) 02887 s->low_delay=1; 02888 02889 if(avctx->has_b_frames < 2) 02890 avctx->has_b_frames= !s->low_delay; 02891 break; 02892 case NAL_PPS: 02893 init_get_bits(&s->gb, ptr, bit_length); 02894 02895 ff_h264_decode_picture_parameter_set(h, bit_length); 02896 02897 break; 02898 case NAL_AUD: 02899 case NAL_END_SEQUENCE: 02900 case NAL_END_STREAM: 02901 case NAL_FILLER_DATA: 02902 case NAL_SPS_EXT: 02903 case NAL_AUXILIARY_SLICE: 02904 break; 02905 default: 02906 av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", hx->nal_unit_type, bit_length); 02907 } 02908 02909 if(context_count == h->max_contexts) { 02910 execute_decode_slices(h, context_count); 02911 context_count = 0; 02912 } 02913 02914 if (err < 0) 02915 av_log(h->s.avctx, AV_LOG_ERROR, "decode_slice_header error\n"); 02916 else if(err == 1) { 02917 /* Slice could not be decoded in parallel mode, copy down 02918 * NAL unit stuff to context 0 and restart. Note that 02919 * rbsp_buffer is not transferred, but since we no longer 02920 * run in parallel mode this should not be an issue. */ 02921 h->nal_unit_type = hx->nal_unit_type; 02922 h->nal_ref_idc = hx->nal_ref_idc; 02923 hx = h; 02924 goto again; 02925 } 02926 } 02927 if(context_count) 02928 execute_decode_slices(h, context_count); 02929 return buf_index; 02930 } 02931 02935 static int get_consumed_bytes(MpegEncContext *s, int pos, int buf_size){ 02936 if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...) 02937 if(pos+10>buf_size) pos=buf_size; // oops ;) 02938 02939 return pos; 02940 } 02941 02942 static int decode_frame(AVCodecContext *avctx, 02943 void *data, int *data_size, 02944 AVPacket *avpkt) 02945 { 02946 const uint8_t *buf = avpkt->data; 02947 int buf_size = avpkt->size; 02948 H264Context *h = avctx->priv_data; 02949 MpegEncContext *s = &h->s; 02950 AVFrame *pict = data; 02951 int buf_index; 02952 02953 s->flags= avctx->flags; 02954 s->flags2= avctx->flags2; 02955 02956 /* end of stream, output what is still in the buffers */ 02957 if (buf_size == 0) { 02958 Picture *out; 02959 int i, out_idx; 02960 02961 //FIXME factorize this with the output code below 02962 out = h->delayed_pic[0]; 02963 out_idx = 0; 02964 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++) 02965 if(h->delayed_pic[i]->poc < out->poc){ 02966 out = h->delayed_pic[i]; 02967 out_idx = i; 02968 } 02969 02970 for(i=out_idx; h->delayed_pic[i]; i++) 02971 h->delayed_pic[i] = h->delayed_pic[i+1]; 02972 02973 if(out){ 02974 *data_size = sizeof(AVFrame); 02975 *pict= *(AVFrame*)out; 02976 } 02977 02978 return 0; 02979 } 02980 02981 buf_index=decode_nal_units(h, buf, buf_size); 02982 if(buf_index < 0) 02983 return -1; 02984 02985 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) && !s->current_picture_ptr){ 02986 if (avctx->skip_frame >= AVDISCARD_NONREF || s->hurry_up) return 0; 02987 av_log(avctx, AV_LOG_ERROR, "no frame!\n"); 02988 return -1; 02989 } 02990 02991 if(!(s->flags2 & CODEC_FLAG2_CHUNKS) || (s->mb_y >= s->mb_height && s->mb_height)){ 02992 Picture *out = s->current_picture_ptr; 02993 Picture *cur = s->current_picture_ptr; 02994 int i, pics, out_of_order, out_idx; 02995 02996 field_end(h); 02997 02998 if (cur->field_poc[0]==INT_MAX || cur->field_poc[1]==INT_MAX) { 02999 /* Wait for second field. */ 03000 *data_size = 0; 03001 03002 } else { 03003 cur->interlaced_frame = 0; 03004 cur->repeat_pict = 0; 03005 03006 /* Signal interlacing information externally. */ 03007 /* Prioritize picture timing SEI information over used decoding process if it exists. */ 03008 03009 if(h->sps.pic_struct_present_flag){ 03010 switch (h->sei_pic_struct) 03011 { 03012 case SEI_PIC_STRUCT_FRAME: 03013 break; 03014 case SEI_PIC_STRUCT_TOP_FIELD: 03015 case SEI_PIC_STRUCT_BOTTOM_FIELD: 03016 cur->interlaced_frame = 1; 03017 break; 03018 case SEI_PIC_STRUCT_TOP_BOTTOM: 03019 case SEI_PIC_STRUCT_BOTTOM_TOP: 03020 if (FIELD_OR_MBAFF_PICTURE) 03021 cur->interlaced_frame = 1; 03022 else 03023 // try to flag soft telecine progressive 03024 cur->interlaced_frame = h->prev_interlaced_frame; 03025 break; 03026 case SEI_PIC_STRUCT_TOP_BOTTOM_TOP: 03027 case SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM: 03028 // Signal the possibility of telecined film externally (pic_struct 5,6) 03029 // From these hints, let the applications decide if they apply deinterlacing. 03030 cur->repeat_pict = 1; 03031 break; 03032 case SEI_PIC_STRUCT_FRAME_DOUBLING: 03033 // Force progressive here, as doubling interlaced frame is a bad idea. 03034 cur->repeat_pict = 2; 03035 break; 03036 case SEI_PIC_STRUCT_FRAME_TRIPLING: 03037 cur->repeat_pict = 4; 03038 break; 03039 } 03040 03041 if ((h->sei_ct_type & 3) && h->sei_pic_struct <= SEI_PIC_STRUCT_BOTTOM_TOP) 03042 cur->interlaced_frame = (h->sei_ct_type & (1<<1)) != 0; 03043 }else{ 03044 /* Derive interlacing flag from used decoding process. */ 03045 cur->interlaced_frame = FIELD_OR_MBAFF_PICTURE; 03046 } 03047 h->prev_interlaced_frame = cur->interlaced_frame; 03048 03049 if (cur->field_poc[0] != cur->field_poc[1]){ 03050 /* Derive top_field_first from field pocs. */ 03051 cur->top_field_first = cur->field_poc[0] < cur->field_poc[1]; 03052 }else{ 03053 if(cur->interlaced_frame || h->sps.pic_struct_present_flag){ 03054 /* Use picture timing SEI information. Even if it is a information of a past frame, better than nothing. */ 03055 if(h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM 03056 || h->sei_pic_struct == SEI_PIC_STRUCT_TOP_BOTTOM_TOP) 03057 cur->top_field_first = 1; 03058 else 03059 cur->top_field_first = 0; 03060 }else{ 03061 /* Most likely progressive */ 03062 cur->top_field_first = 0; 03063 } 03064 } 03065 03066 //FIXME do something with unavailable reference frames 03067 03068 /* Sort B-frames into display order */ 03069 03070 if(h->sps.bitstream_restriction_flag 03071 && s->avctx->has_b_frames < h->sps.num_reorder_frames){ 03072 s->avctx->has_b_frames = h->sps.num_reorder_frames; 03073 s->low_delay = 0; 03074 } 03075 03076 if( s->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT 03077 && !h->sps.bitstream_restriction_flag){ 03078 s->avctx->has_b_frames= MAX_DELAYED_PIC_COUNT; 03079 s->low_delay= 0; 03080 } 03081 03082 pics = 0; 03083 while(h->delayed_pic[pics]) pics++; 03084 03085 assert(pics <= MAX_DELAYED_PIC_COUNT); 03086 03087 h->delayed_pic[pics++] = cur; 03088 if(cur->reference == 0) 03089 cur->reference = DELAYED_PIC_REF; 03090 03091 out = h->delayed_pic[0]; 03092 out_idx = 0; 03093 for(i=1; h->delayed_pic[i] && !h->delayed_pic[i]->key_frame && !h->delayed_pic[i]->mmco_reset; i++) 03094 if(h->delayed_pic[i]->poc < out->poc){ 03095 out = h->delayed_pic[i]; 03096 out_idx = i; 03097 } 03098 if(s->avctx->has_b_frames == 0 && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) 03099 h->outputed_poc= INT_MIN; 03100 out_of_order = out->poc < h->outputed_poc; 03101 03102 if(h->sps.bitstream_restriction_flag && s->avctx->has_b_frames >= h->sps.num_reorder_frames) 03103 { } 03104 else if((out_of_order && pics-1 == s->avctx->has_b_frames && s->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) 03105 || (s->low_delay && 03106 ((h->outputed_poc != INT_MIN && out->poc > h->outputed_poc + 2) 03107 || cur->pict_type == FF_B_TYPE))) 03108 { 03109 s->low_delay = 0; 03110 s->avctx->has_b_frames++; 03111 } 03112 03113 if(out_of_order || pics > s->avctx->has_b_frames){ 03114 out->reference &= ~DELAYED_PIC_REF; 03115 for(i=out_idx; h->delayed_pic[i]; i++) 03116 h->delayed_pic[i] = h->delayed_pic[i+1]; 03117 } 03118 if(!out_of_order && pics > s->avctx->has_b_frames){ 03119 *data_size = sizeof(AVFrame); 03120 03121 if(out_idx==0 && h->delayed_pic[0] && (h->delayed_pic[0]->key_frame || h->delayed_pic[0]->mmco_reset)) { 03122 h->outputed_poc = INT_MIN; 03123 } else 03124 h->outputed_poc = out->poc; 03125 *pict= *(AVFrame*)out; 03126 }else{ 03127 av_log(avctx, AV_LOG_DEBUG, "no picture\n"); 03128 } 03129 } 03130 } 03131 03132 assert(pict->data[0] || !*data_size); 03133 ff_print_debug_info(s, pict); 03134 //printf("out %d\n", (int)pict->data[0]); 03135 03136 return get_consumed_bytes(s, buf_index, buf_size); 03137 } 03138 #if 0 03139 static inline void fill_mb_avail(H264Context *h){ 03140 MpegEncContext * const s = &h->s; 03141 const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; 03142 03143 if(s->mb_y){ 03144 h->mb_avail[0]= s->mb_x && h->slice_table[mb_xy - s->mb_stride - 1] == h->slice_num; 03145 h->mb_avail[1]= h->slice_table[mb_xy - s->mb_stride ] == h->slice_num; 03146 h->mb_avail[2]= s->mb_x+1 < s->mb_width && h->slice_table[mb_xy - s->mb_stride + 1] == h->slice_num; 03147 }else{ 03148 h->mb_avail[0]= 03149 h->mb_avail[1]= 03150 h->mb_avail[2]= 0; 03151 } 03152 h->mb_avail[3]= s->mb_x && h->slice_table[mb_xy - 1] == h->slice_num; 03153 h->mb_avail[4]= 1; //FIXME move out 03154 h->mb_avail[5]= 0; //FIXME move out 03155 } 03156 #endif 03157 03158 #ifdef TEST 03159 #undef printf 03160 #undef random 03161 #define COUNT 8000 03162 #define SIZE (COUNT*40) 03163 int main(void){ 03164 int i; 03165 uint8_t temp[SIZE]; 03166 PutBitContext pb; 03167 GetBitContext gb; 03168 // int int_temp[10000]; 03169 DSPContext dsp; 03170 AVCodecContext avctx; 03171 03172 dsputil_init(&dsp, &avctx); 03173 03174 init_put_bits(&pb, temp, SIZE); 03175 printf("testing unsigned exp golomb\n"); 03176 for(i=0; i<COUNT; i++){ 03177 START_TIMER 03178 set_ue_golomb(&pb, i); 03179 STOP_TIMER("set_ue_golomb"); 03180 } 03181 flush_put_bits(&pb); 03182 03183 init_get_bits(&gb, temp, 8*SIZE); 03184 for(i=0; i<COUNT; i++){ 03185 int j, s; 03186 03187 s= show_bits(&gb, 24); 03188 03189 START_TIMER 03190 j= get_ue_golomb(&gb); 03191 if(j != i){ 03192 printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); 03193 // return -1; 03194 } 03195 STOP_TIMER("get_ue_golomb"); 03196 } 03197 03198 03199 init_put_bits(&pb, temp, SIZE); 03200 printf("testing signed exp golomb\n"); 03201 for(i=0; i<COUNT; i++){ 03202 START_TIMER 03203 set_se_golomb(&pb, i - COUNT/2); 03204 STOP_TIMER("set_se_golomb"); 03205 } 03206 flush_put_bits(&pb); 03207 03208 init_get_bits(&gb, temp, 8*SIZE); 03209 for(i=0; i<COUNT; i++){ 03210 int j, s; 03211 03212 s= show_bits(&gb, 24); 03213 03214 START_TIMER 03215 j= get_se_golomb(&gb); 03216 if(j != i - COUNT/2){ 03217 printf("mismatch! at %d (%d should be %d) bits:%6X\n", i, j, i, s); 03218 // return -1; 03219 } 03220 STOP_TIMER("get_se_golomb"); 03221 } 03222 03223 #if 0 03224 printf("testing 4x4 (I)DCT\n"); 03225 03226 DCTELEM block[16]; 03227 uint8_t src[16], ref[16]; 03228 uint64_t error= 0, max_error=0; 03229 03230 for(i=0; i<COUNT; i++){ 03231 int j; 03232 // printf("%d %d %d\n", r1, r2, (r2-r1)*16); 03233 for(j=0; j<16; j++){ 03234 ref[j]= random()%255; 03235 src[j]= random()%255; 03236 } 03237 03238 h264_diff_dct_c(block, src, ref, 4); 03239 03240 //normalize 03241 for(j=0; j<16; j++){ 03242 // printf("%d ", block[j]); 03243 block[j]= block[j]*4; 03244 if(j&1) block[j]= (block[j]*4 + 2)/5; 03245 if(j&4) block[j]= (block[j]*4 + 2)/5; 03246 } 03247 // printf("\n"); 03248 03249 h->h264dsp.h264_idct_add(ref, block, 4); 03250 /* for(j=0; j<16; j++){ 03251 printf("%d ", ref[j]); 03252 } 03253 printf("\n");*/ 03254 03255 for(j=0; j<16; j++){ 03256 int diff= FFABS(src[j] - ref[j]); 03257 03258 error+= diff*diff; 03259 max_error= FFMAX(max_error, diff); 03260 } 03261 } 03262 printf("error=%f max_error=%d\n", ((float)error)/COUNT/16, (int)max_error ); 03263 printf("testing quantizer\n"); 03264 for(qp=0; qp<52; qp++){ 03265 for(i=0; i<16; i++) 03266 src1_block[i]= src2_block[i]= random()%255; 03267 03268 } 03269 printf("Testing NAL layer\n"); 03270 03271 uint8_t bitstream[COUNT]; 03272 uint8_t nal[COUNT*2]; 03273 H264Context h; 03274 memset(&h, 0, sizeof(H264Context)); 03275 03276 for(i=0; i<COUNT; i++){ 03277 int zeros= i; 03278 int nal_length; 03279 int consumed; 03280 int out_length; 03281 uint8_t *out; 03282 int j; 03283 03284 for(j=0; j<COUNT; j++){ 03285 bitstream[j]= (random() % 255) + 1; 03286 } 03287 03288 for(j=0; j<zeros; j++){ 03289 int pos= random() % COUNT; 03290 while(bitstream[pos] == 0){ 03291 pos++; 03292 pos %= COUNT; 03293 } 03294 bitstream[pos]=0; 03295 } 03296 03297 START_TIMER 03298 03299 nal_length= encode_nal(&h, nal, bitstream, COUNT, COUNT*2); 03300 if(nal_length<0){ 03301 printf("encoding failed\n"); 03302 return -1; 03303 } 03304 03305 out= ff_h264_decode_nal(&h, nal, &out_length, &consumed, nal_length); 03306 03307 STOP_TIMER("NAL") 03308 03309 if(out_length != COUNT){ 03310 printf("incorrect length %d %d\n", out_length, COUNT); 03311 return -1; 03312 } 03313 03314 if(consumed != nal_length){ 03315 printf("incorrect consumed length %d %d\n", nal_length, consumed); 03316 return -1; 03317 } 03318 03319 if(memcmp(bitstream, out, COUNT)){ 03320 printf("mismatch\n"); 03321 return -1; 03322 } 03323 } 03324 #endif 03325 03326 printf("Testing RBSP\n"); 03327 03328 03329 return 0; 03330 } 03331 #endif /* TEST */ 03332 03333 03334 av_cold void ff_h264_free_context(H264Context *h) 03335 { 03336 int i; 03337 03338 free_tables(h); //FIXME cleanup init stuff perhaps 03339 03340 for(i = 0; i < MAX_SPS_COUNT; i++) 03341 av_freep(h->sps_buffers + i); 03342 03343 for(i = 0; i < MAX_PPS_COUNT; i++) 03344 av_freep(h->pps_buffers + i); 03345 } 03346 03347 av_cold int ff_h264_decode_end(AVCodecContext *avctx) 03348 { 03349 H264Context *h = avctx->priv_data; 03350 MpegEncContext *s = &h->s; 03351 03352 ff_h264_free_context(h); 03353 03354 MPV_common_end(s); 03355 03356 // memset(h, 0, sizeof(H264Context)); 03357 03358 return 0; 03359 } 03360 03361 03362 AVCodec h264_decoder = { 03363 "h264", 03364 AVMEDIA_TYPE_VIDEO, 03365 CODEC_ID_H264, 03366 sizeof(H264Context), 03367 ff_h264_decode_init, 03368 NULL, 03369 ff_h264_decode_end, 03370 decode_frame, 03371 /*CODEC_CAP_DRAW_HORIZ_BAND |*/ CODEC_CAP_DR1 | CODEC_CAP_DELAY, 03372 .flush= flush_dpb, 03373 .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), 03374 .pix_fmts= ff_hwaccel_pixfmt_list_420, 03375 }; 03376 03377 #if CONFIG_H264_VDPAU_DECODER 03378 AVCodec h264_vdpau_decoder = { 03379 "h264_vdpau", 03380 AVMEDIA_TYPE_VIDEO, 03381 CODEC_ID_H264, 03382 sizeof(H264Context), 03383 ff_h264_decode_init, 03384 NULL, 03385 ff_h264_decode_end, 03386 decode_frame, 03387 CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_HWACCEL_VDPAU, 03388 .flush= flush_dpb, 03389 .long_name = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (VDPAU acceleration)"), 03390 .pix_fmts = (const enum PixelFormat[]){PIX_FMT_VDPAU_H264, PIX_FMT_NONE}, 03391 }; 03392 #endif