Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

h264: move some neighbour information into the per-slice context

Browse Source
pull/125/head
Anton Khirnov 10 years ago
parent 4bd5ac200d
commit 8b00f4df20
9 changed files with 156 additions and 144 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 26
      libavcodec/h264.h
  2. 47
      libavcodec/h264_cabac.c
  3. 12
      libavcodec/h264_cavlc.c
  4. 29
      libavcodec/h264_loopfilter.c
  5. 5
      libavcodec/h264_mb.c
  6. 8
      libavcodec/h264_mb_template.c
  7. 158
      libavcodec/h264_mvpred.h
  8. 12
      libavcodec/h264_slice.c
  9. 3
      libavcodec/svq3.c

26
libavcodec/h264.h
Unescape View File

@ -320,6 +320,19 @@ typedef struct H264SliceContext {
int chroma_pred_mode; int chroma_pred_mode;
int intra16x16_pred_mode; int intra16x16_pred_mode;
int topleft_mb_xy;
int top_mb_xy;
int topright_mb_xy;
int left_mb_xy[LEFT_MBS];
int topleft_type;
int top_type;
int topright_type;
int left_type[LEFT_MBS];
const uint8_t *left_block;
int topleft_partition;
} H264SliceContext; } H264SliceContext;
/** /**
@ -357,19 +370,6 @@ typedef struct H264Context {
int workaround_bugs; int workaround_bugs;
// prediction stuff // prediction stuff
int topleft_mb_xy;
int top_mb_xy;
int topright_mb_xy;
int left_mb_xy[LEFT_MBS];
int topleft_type;
int top_type;
int topright_type;
int left_type[LEFT_MBS];
const uint8_t *left_block;
int topleft_partition;
int8_t intra4x4_pred_mode_cache[5 * 8]; int8_t intra4x4_pred_mode_cache[5 * 8];
int8_t(*intra4x4_pred_mode); int8_t(*intra4x4_pred_mode);
H264PredContext hpc; H264PredContext hpc;

47
libavcodec/h264_cabac.c
Unescape View File

@ -1293,15 +1293,17 @@ static int decode_cabac_field_decoding_flag(H264Context *h) {
return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] ); return get_cabac_noinline( &h->cabac, &(h->cabac_state+70)[ctx] );
} }
static int decode_cabac_intra_mb_type(H264Context *h, int ctx_base, int intra_slice) { static int decode_cabac_intra_mb_type(H264Context *h, H264SliceContext *sl,
int ctx_base, int intra_slice)
{
uint8_t *state= &h->cabac_state[ctx_base]; uint8_t *state= &h->cabac_state[ctx_base];
int mb_type; int mb_type;
if(intra_slice){ if(intra_slice){
int ctx=0; int ctx=0;
if( h->left_type[LTOP] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) if (sl->left_type[LTOP] & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
ctx++; ctx++;
if( h->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM)) if (sl->top_type & (MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM))
ctx++; ctx++;
if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 ) if( get_cabac_noinline( &h->cabac, &state[ctx] ) == 0 )
return 0; /* I4x4 */ return 0; /* I4x4 */
@ -1371,17 +1373,18 @@ static int decode_cabac_mb_intra4x4_pred_mode( H264Context *h, int pred_mode ) {
return mode + ( mode >= pred_mode ); return mode + ( mode >= pred_mode );
} }
static int decode_cabac_mb_chroma_pre_mode( H264Context *h) { static int decode_cabac_mb_chroma_pre_mode(H264Context *h, H264SliceContext *sl)
const int mba_xy = h->left_mb_xy[0]; {
const int mbb_xy = h->top_mb_xy; const int mba_xy = sl->left_mb_xy[0];
const int mbb_xy = sl->top_mb_xy;
int ctx = 0; int ctx = 0;
/* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */ /* No need to test for IS_INTRA4x4 and IS_INTRA16x16, as we set chroma_pred_mode_table to 0 */
if( h->left_type[LTOP] && h->chroma_pred_mode_table[mba_xy] != 0 ) if (sl->left_type[LTOP] && h->chroma_pred_mode_table[mba_xy] != 0)
ctx++; ctx++;
if( h->top_type && h->chroma_pred_mode_table[mbb_xy] != 0 ) if (sl->top_type && h->chroma_pred_mode_table[mbb_xy] != 0)
ctx++; ctx++;
if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 ) if( get_cabac_noinline( &h->cabac, &h->cabac_state[64+ctx] ) == 0 )
@ -1928,15 +1931,15 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
sl->prev_mb_skipped = 0; sl->prev_mb_skipped = 0;
fill_decode_neighbors(h, -(MB_FIELD(h))); fill_decode_neighbors(h, sl, -(MB_FIELD(h)));
if( h->slice_type_nos == AV_PICTURE_TYPE_B ) { if( h->slice_type_nos == AV_PICTURE_TYPE_B ) {
int ctx = 0; int ctx = 0;
assert(h->slice_type_nos == AV_PICTURE_TYPE_B); assert(h->slice_type_nos == AV_PICTURE_TYPE_B);
if( !IS_DIRECT( h->left_type[LTOP]-1 ) ) if (!IS_DIRECT(sl->left_type[LTOP] - 1))
ctx++; ctx++;
if( !IS_DIRECT( h->top_type-1 ) ) if (!IS_DIRECT(sl->top_type - 1))
ctx++; ctx++;
if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){ if( !get_cabac_noinline( &h->cabac, &h->cabac_state[27+ctx] ) ){
@ -1952,7 +1955,7 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
if( bits < 8 ){ if( bits < 8 ){
mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */ mb_type= bits + 3; /* B_Bi_16x16 through B_L1_L0_16x8 */
}else if( bits == 13 ){ }else if( bits == 13 ){
mb_type= decode_cabac_intra_mb_type(h, 32, 0); mb_type = decode_cabac_intra_mb_type(h, sl, 32, 0);
goto decode_intra_mb; goto decode_intra_mb;
}else if( bits == 14 ){ }else if( bits == 14 ){
mb_type= 11; /* B_L1_L0_8x16 */ mb_type= 11; /* B_L1_L0_8x16 */
@ -1978,11 +1981,11 @@ int ff_h264_decode_mb_cabac(H264Context *h, H264SliceContext *sl)
partition_count= p_mb_type_info[mb_type].partition_count; partition_count= p_mb_type_info[mb_type].partition_count;
mb_type= p_mb_type_info[mb_type].type; mb_type= p_mb_type_info[mb_type].type;
} else { } else {
mb_type= decode_cabac_intra_mb_type(h, 17, 0); mb_type = decode_cabac_intra_mb_type(h, sl, 17, 0);
goto decode_intra_mb; goto decode_intra_mb;
} }
} else { } else {
mb_type= decode_cabac_intra_mb_type(h, 3, 1); mb_type = decode_cabac_intra_mb_type(h, sl, 3, 1);
if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type) if(h->slice_type == AV_PICTURE_TYPE_SI && mb_type)
mb_type--; mb_type--;
assert(h->slice_type_nos == AV_PICTURE_TYPE_I); assert(h->slice_type_nos == AV_PICTURE_TYPE_I);
@ -2031,7 +2034,7 @@ decode_intra_mb:
return 0; return 0;
} }
fill_decode_caches(h, mb_type); fill_decode_caches(h, sl, mb_type);
if( IS_INTRA( mb_type ) ) { if( IS_INTRA( mb_type ) ) {
int i, pred_mode; int i, pred_mode;
@ -2060,7 +2063,7 @@ decode_intra_mb:
} }
if(decode_chroma){ if(decode_chroma){
h->chroma_pred_mode_table[mb_xy] = h->chroma_pred_mode_table[mb_xy] =
pred_mode = decode_cabac_mb_chroma_pre_mode( h ); pred_mode = decode_cabac_mb_chroma_pre_mode(h, sl);
pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode, 1 ); pred_mode= ff_h264_check_intra_pred_mode( h, pred_mode, 1 );
if( pred_mode < 0 ) return -1; if( pred_mode < 0 ) return -1;
@ -2136,7 +2139,7 @@ decode_intra_mb:
const int index= 4*i + block_width*j; const int index= 4*i + block_width*j;
int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ]; uint8_t (* mvd_cache)[2]= &h->mvd_cache[list][ scan8[index] ];
pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); pred_motion(h, sl, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
DECODE_CABAC_MB_MVD( h, list, index) DECODE_CABAC_MB_MVD( h, list, index)
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -2200,7 +2203,7 @@ decode_intra_mb:
for(list=0; list<h->list_count; list++){ for(list=0; list<h->list_count; list++){
if(IS_DIR(mb_type, 0, list)){ if(IS_DIR(mb_type, 0, list)){
int mx,my,mpx,mpy; int mx,my,mpx,mpy;
pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); pred_motion(h, sl, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
DECODE_CABAC_MB_MVD( h, list, 0) DECODE_CABAC_MB_MVD( h, list, 0)
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -2231,7 +2234,7 @@ decode_intra_mb:
for(i=0; i<2; i++){ for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){ if(IS_DIR(mb_type, i, list)){
int mx,my,mpx,mpy; int mx,my,mpx,mpy;
pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); pred_16x8_motion(h, sl, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
DECODE_CABAC_MB_MVD( h, list, 8*i) DECODE_CABAC_MB_MVD( h, list, 8*i)
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -2266,7 +2269,7 @@ decode_intra_mb:
for(i=0; i<2; i++){ for(i=0; i<2; i++){
if(IS_DIR(mb_type, i, list)){ if(IS_DIR(mb_type, i, list)){
int mx,my,mpx,mpy; int mx,my,mpx,mpy;
pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); pred_8x16_motion(h, sl, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
DECODE_CABAC_MB_MVD( h, list, 4*i) DECODE_CABAC_MB_MVD( h, list, 4*i)
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -2304,7 +2307,7 @@ decode_intra_mb:
int i; int i;
uint8_t *nnz_cache = h->non_zero_count_cache; uint8_t *nnz_cache = h->non_zero_count_cache;
for (i = 0; i < 2; i++){ for (i = 0; i < 2; i++){
if (h->left_type[LEFT(i)] && !IS_8x8DCT(h->left_type[LEFT(i)])){ if (sl->left_type[LEFT(i)] && !IS_8x8DCT(sl->left_type[LEFT(i)])) {
nnz_cache[3+8* 1 + 2*8*i]= nnz_cache[3+8* 1 + 2*8*i]=
nnz_cache[3+8* 2 + 2*8*i]= nnz_cache[3+8* 2 + 2*8*i]=
nnz_cache[3+8* 6 + 2*8*i]= nnz_cache[3+8* 6 + 2*8*i]=
@ -2313,7 +2316,7 @@ decode_intra_mb:
nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0; nnz_cache[3+8*12 + 2*8*i]= IS_INTRA(mb_type) ? 64 : 0;
} }
} }
if (h->top_type && !IS_8x8DCT(h->top_type)){ if (sl->top_type && !IS_8x8DCT(sl->top_type)){
uint32_t top_empty = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 0x40404040; uint32_t top_empty = CABAC(h) && !IS_INTRA(mb_type) ? 0 : 0x40404040;
AV_WN32A(&nnz_cache[4+8* 0], top_empty); AV_WN32A(&nnz_cache[4+8* 0], top_empty);
AV_WN32A(&nnz_cache[4+8* 5], top_empty); AV_WN32A(&nnz_cache[4+8* 5], top_empty);

12
libavcodec/h264_cavlc.c
Unescape View File

@ -781,8 +781,8 @@ decode_intra_mb:
return 0; return 0;
} }
fill_decode_neighbors(h, mb_type); fill_decode_neighbors(h, sl, mb_type);
fill_decode_caches(h, mb_type); fill_decode_caches(h, sl, mb_type);
//mb_pred //mb_pred
if(IS_INTRA(mb_type)){ if(IS_INTRA(mb_type)){
@ -903,7 +903,7 @@ decode_intra_mb:
int mx, my; int mx, my;
const int index= 4*i + block_width*j; const int index= 4*i + block_width*j;
int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ]; int16_t (* mv_cache)[2]= &h->mv_cache[list][ scan8[index] ];
pred_motion(h, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my); pred_motion(h, sl, index, block_width, list, h->ref_cache[list][ scan8[index] ], &mx, &my);
mx += get_se_golomb(&h->gb); mx += get_se_golomb(&h->gb);
my += get_se_golomb(&h->gb); my += get_se_golomb(&h->gb);
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -957,7 +957,7 @@ decode_intra_mb:
} }
for(list=0; list<h->list_count; list++){ for(list=0; list<h->list_count; list++){
if(IS_DIR(mb_type, 0, list)){ if(IS_DIR(mb_type, 0, list)){
pred_motion(h, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my); pred_motion(h, sl, 0, 4, list, h->ref_cache[list][ scan8[0] ], &mx, &my);
mx += get_se_golomb(&h->gb); mx += get_se_golomb(&h->gb);
my += get_se_golomb(&h->gb); my += get_se_golomb(&h->gb);
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -992,7 +992,7 @@ decode_intra_mb:
for(i=0; i<2; i++){ for(i=0; i<2; i++){
unsigned int val; unsigned int val;
if(IS_DIR(mb_type, i, list)){ if(IS_DIR(mb_type, i, list)){
pred_16x8_motion(h, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my); pred_16x8_motion(h, sl, 8*i, list, h->ref_cache[list][scan8[0] + 16*i], &mx, &my);
mx += get_se_golomb(&h->gb); mx += get_se_golomb(&h->gb);
my += get_se_golomb(&h->gb); my += get_se_golomb(&h->gb);
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);
@ -1030,7 +1030,7 @@ decode_intra_mb:
for(i=0; i<2; i++){ for(i=0; i<2; i++){
unsigned int val; unsigned int val;
if(IS_DIR(mb_type, i, list)){ if(IS_DIR(mb_type, i, list)){
pred_8x16_motion(h, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my); pred_8x16_motion(h, sl, i*4, list, h->ref_cache[list][ scan8[0] + 2*i ], &mx, &my);
mx += get_se_golomb(&h->gb); mx += get_se_golomb(&h->gb);
my += get_se_golomb(&h->gb); my += get_se_golomb(&h->gb);
tprintf(h->avctx, "final mv:%d %d\n", mx, my); tprintf(h->avctx, "final mv:%d %d\n", mx, my);

29
libavcodec/h264_loopfilter.c
Unescape View File

@ -235,6 +235,7 @@ static av_always_inline void filter_mb_edgech(uint8_t *pix, int stride,
} }
static av_always_inline void h264_filter_mb_fast_internal(H264Context *h, static av_always_inline void h264_filter_mb_fast_internal(H264Context *h,
H264SliceContext *sl,
int mb_x, int mb_y, int mb_x, int mb_y,
uint8_t *img_y, uint8_t *img_y,
uint8_t *img_cb, uint8_t *img_cb,
@ -248,8 +249,8 @@ static av_always_inline void h264_filter_mb_fast_internal(H264Context *h,
int chroma422 = CHROMA422(h); int chroma422 = CHROMA422(h);
int mb_xy = h->mb_xy; int mb_xy = h->mb_xy;
int left_type= h->left_type[LTOP]; int left_type = sl->left_type[LTOP];
int top_type= h->top_type; int top_type = sl->top_type;
int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8); int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
int a = 52 + h->slice_alpha_c0_offset - qp_bd_offset; int a = 52 + h->slice_alpha_c0_offset - qp_bd_offset;
@ -258,7 +259,7 @@ static av_always_inline void h264_filter_mb_fast_internal(H264Context *h,
int mb_type = h->cur_pic.mb_type[mb_xy]; int mb_type = h->cur_pic.mb_type[mb_xy];
int qp = h->cur_pic.qscale_table[mb_xy]; int qp = h->cur_pic.qscale_table[mb_xy];
int qp0 = h->cur_pic.qscale_table[mb_xy - 1]; int qp0 = h->cur_pic.qscale_table[mb_xy - 1];
int qp1 = h->cur_pic.qscale_table[h->top_mb_xy]; int qp1 = h->cur_pic.qscale_table[sl->top_mb_xy];
int qpc = get_chroma_qp( h, 0, qp ); int qpc = get_chroma_qp( h, 0, qp );
int qpc0 = get_chroma_qp( h, 0, qp0 ); int qpc0 = get_chroma_qp( h, 0, qp0 );
int qpc1 = get_chroma_qp( h, 0, qp1 ); int qpc1 = get_chroma_qp( h, 0, qp1 );
@ -427,12 +428,12 @@ void ff_h264_filter_mb_fast(H264Context *h, H264SliceContext *sl,
} }
#if CONFIG_SMALL #if CONFIG_SMALL
h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, h->pixel_shift); h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, h->pixel_shift);
#else #else
if(h->pixel_shift){ if(h->pixel_shift){
h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1); h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 1);
}else{ }else{
h264_filter_mb_fast_internal(h, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0); h264_filter_mb_fast_internal(h, sl, mb_x, mb_y, img_y, img_cb, img_cr, linesize, uvlinesize, 0);
} }
#endif #endif
} }
@ -478,8 +479,8 @@ static av_always_inline void filter_mb_dir(H264Context *h, H264SliceContext *sl,
int chroma_qp_avg[2]; int chroma_qp_avg[2];
int chroma444 = CHROMA444(h); int chroma444 = CHROMA444(h);
int chroma422 = CHROMA422(h); int chroma422 = CHROMA422(h);
const int mbm_xy = dir == 0 ? mb_xy -1 : h->top_mb_xy; const int mbm_xy = dir == 0 ? mb_xy -1 : sl->top_mb_xy;
const int mbm_type = dir == 0 ? h->left_type[LTOP] : h->top_type; const int mbm_type = dir == 0 ? sl->left_type[LTOP] : sl->top_type;
// how often to recheck mv-based bS when iterating between edges // how often to recheck mv-based bS when iterating between edges
static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1}, static const uint8_t mask_edge_tab[2][8]={{0,3,3,3,1,1,1,1},
@ -726,9 +727,9 @@ void ff_h264_filter_mb(H264Context *h, H264SliceContext *sl,
if (FRAME_MBAFF(h) if (FRAME_MBAFF(h)
// and current and left pair do not have the same interlaced type // and current and left pair do not have the same interlaced type
&& IS_INTERLACED(mb_type^h->left_type[LTOP]) && IS_INTERLACED(mb_type ^ sl->left_type[LTOP])
// and left mb is in available to us // and left mb is in available to us
&& h->left_type[LTOP]) { && sl->left_type[LTOP]) {
/* First vertical edge is different in MBAFF frames /* First vertical edge is different in MBAFF frames
* There are 8 different bS to compute and 2 different Qp * There are 8 different bS to compute and 2 different Qp
*/ */
@ -756,8 +757,8 @@ void ff_h264_filter_mb(H264Context *h, H264SliceContext *sl,
const uint8_t *off= offset[MB_FIELD(h)][mb_y&1]; const uint8_t *off= offset[MB_FIELD(h)][mb_y&1];
for( i = 0; i < 8; i++ ) { for( i = 0; i < 8; i++ ) {
int j= MB_FIELD(h) ? i>>2 : i&1; int j= MB_FIELD(h) ? i>>2 : i&1;
int mbn_xy = h->left_mb_xy[LEFT(j)]; int mbn_xy = sl->left_mb_xy[LEFT(j)];
int mbn_type= h->left_type[LEFT(j)]; int mbn_type = sl->left_type[LEFT(j)];
if( IS_INTRA( mbn_type ) ) if( IS_INTRA( mbn_type ) )
bS[i] = 4; bS[i] = 4;
@ -772,8 +773,8 @@ void ff_h264_filter_mb(H264Context *h, H264SliceContext *sl,
} }
mb_qp = h->cur_pic.qscale_table[mb_xy]; mb_qp = h->cur_pic.qscale_table[mb_xy];
mbn0_qp = h->cur_pic.qscale_table[h->left_mb_xy[0]]; mbn0_qp = h->cur_pic.qscale_table[sl->left_mb_xy[0]];
mbn1_qp = h->cur_pic.qscale_table[h->left_mb_xy[1]]; mbn1_qp = h->cur_pic.qscale_table[sl->left_mb_xy[1]];
qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1; qp[0] = ( mb_qp + mbn0_qp + 1 ) >> 1;
bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) + bqp[0] = ( get_chroma_qp( h, 0, mb_qp ) +
get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1; get_chroma_qp( h, 0, mbn0_qp ) + 1 ) >> 1;

5
libavcodec/h264_mb.c
Unescape View File

@ -496,7 +496,8 @@ static av_always_inline void prefetch_motion(H264Context *h, int list,
} }
} }
static av_always_inline void xchg_mb_border(H264Context *h, uint8_t *src_y, static av_always_inline void xchg_mb_border(H264Context *h, H264SliceContext *sl,
uint8_t *src_y,
uint8_t *src_cb, uint8_t *src_cr, uint8_t *src_cb, uint8_t *src_cr,
int linesize, int uvlinesize, int linesize, int uvlinesize,
int xchg, int chroma444, int xchg, int chroma444,
@ -519,7 +520,7 @@ static av_always_inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
if (h->deblocking_filter == 2) { if (h->deblocking_filter == 2) {
deblock_topleft = h->slice_table[h->mb_xy - 1 - h->mb_stride] == h->slice_num; deblock_topleft = h->slice_table[h->mb_xy - 1 - h->mb_stride] == h->slice_num;
deblock_top = h->top_type; deblock_top = sl->top_type;
} else { } else {
deblock_topleft = (h->mb_x > 0); deblock_topleft = (h->mb_x > 0);
deblock_top = (h->mb_y > !!MB_FIELD(h)); deblock_top = (h->mb_y > !!MB_FIELD(h));

8
libavcodec/h264_mb_template.c
Unescape View File

@ -159,7 +159,7 @@ static av_noinline void FUNC(hl_decode_mb)(H264Context *h, H264SliceContext *sl)
} else { } else {
if (IS_INTRA(mb_type)) { if (IS_INTRA(mb_type)) {
if (h->deblocking_filter) if (h->deblocking_filter)
xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT); uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT);
if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) { if (SIMPLE || !CONFIG_GRAY || !(h->flags & CODEC_FLAG_GRAY)) {
@ -172,7 +172,7 @@ static av_noinline void FUNC(hl_decode_mb)(H264Context *h, H264SliceContext *sl)
block_offset, linesize, dest_y, 0); block_offset, linesize, dest_y, 0);
if (h->deblocking_filter) if (h->deblocking_filter)
xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize, xchg_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT); uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT);
} else if (is_h264) { } else if (is_h264) {
if (chroma422) { if (chroma422) {
@ -343,7 +343,7 @@ static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h, H264SliceContext
} else { } else {
if (IS_INTRA(mb_type)) { if (IS_INTRA(mb_type)) {
if (h->deblocking_filter) if (h->deblocking_filter)
xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
linesize, 1, 1, SIMPLE, PIXEL_SHIFT); linesize, 1, 1, SIMPLE, PIXEL_SHIFT);
for (p = 0; p < plane_count; p++) for (p = 0; p < plane_count; p++)
@ -352,7 +352,7 @@ static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h, H264SliceContext
block_offset, linesize, dest[p], p); block_offset, linesize, dest[p], p);
if (h->deblocking_filter) if (h->deblocking_filter)
xchg_mb_border(h, dest[0], dest[1], dest[2], linesize, xchg_mb_border(h, sl, dest[0], dest[1], dest[2], linesize,
linesize, 0, 1, SIMPLE, PIXEL_SHIFT); linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
} else { } else {
FUNC(hl_motion_444)(h, sl, dest[0], dest[1], dest[2], FUNC(hl_motion_444)(h, sl, dest[0], dest[1], dest[2],

158
libavcodec/h264_mvpred.h
Unescape View File

@ -35,7 +35,8 @@
#include <assert.h> #include <assert.h>
static av_always_inline int fetch_diagonal_mv(H264Context *h, const int16_t **C, static av_always_inline int fetch_diagonal_mv(H264Context *h, H264SliceContext *sl,
const int16_t **C,
int i, int list, int part_width) int i, int list, int part_width)
{ {
const int topright_ref = h->ref_cache[list][i - 8 + part_width]; const int topright_ref = h->ref_cache[list][i - 8 + part_width];
@ -61,13 +62,13 @@ static av_always_inline int fetch_diagonal_mv(H264Context *h, const int16_t **C,
AV_ZERO32(h->mv_cache[list][scan8[0] - 2]); AV_ZERO32(h->mv_cache[list][scan8[0] - 2]);
*C = h->mv_cache[list][scan8[0] - 2]; *C = h->mv_cache[list][scan8[0] - 2];
if (!MB_FIELD(h) && IS_INTERLACED(h->left_type[0])) { if (!MB_FIELD(h) && IS_INTERLACED(sl->left_type[0])) {
SET_DIAG_MV(* 2, >> 1, h->left_mb_xy[0] + h->mb_stride, SET_DIAG_MV(* 2, >> 1, sl->left_mb_xy[0] + h->mb_stride,
(h->mb_y & 1) * 2 + (i >> 5)); (h->mb_y & 1) * 2 + (i >> 5));
} }
if (MB_FIELD(h) && !IS_INTERLACED(h->left_type[0])) { if (MB_FIELD(h) && !IS_INTERLACED(sl->left_type[0])) {
// left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK. // left shift will turn LIST_NOT_USED into PART_NOT_AVAILABLE, but that's OK.
SET_DIAG_MV(/ 2, << 1, h->left_mb_xy[i >= 36], ((i >> 2)) & 3); SET_DIAG_MV(/ 2, << 1, sl->left_mb_xy[i >= 36], ((i >> 2)) & 3);
} }
} }
#undef SET_DIAG_MV #undef SET_DIAG_MV
@ -91,7 +92,9 @@ static av_always_inline int fetch_diagonal_mv(H264Context *h, const int16_t **C,
* @param mx the x component of the predicted motion vector * @param mx the x component of the predicted motion vector
* @param my the y component of the predicted motion vector * @param my the y component of the predicted motion vector
*/ */
static av_always_inline void pred_motion(H264Context *const h, int n, static av_always_inline void pred_motion(H264Context *const h,
H264SliceContext *sl,
int n,
int part_width, int list, int ref, int part_width, int list, int ref,
int *const mx, int *const my) int *const mx, int *const my)
{ {
@ -113,7 +116,7 @@ static av_always_inline void pred_motion(H264Context *const h, int n,
* . . . L . . . . * . . . L . . . .
*/ */
diagonal_ref = fetch_diagonal_mv(h, &C, index8, list, part_width); diagonal_ref = fetch_diagonal_mv(h, sl, &C, index8, list, part_width);
match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref); match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
tprintf(h->avctx, "pred_motion match_count=%d\n", match_count); tprintf(h->avctx, "pred_motion match_count=%d\n", match_count);
if (match_count > 1) { //most common if (match_count > 1) { //most common
@ -155,6 +158,7 @@ static av_always_inline void pred_motion(H264Context *const h, int n,
* @param my the y component of the predicted motion vector * @param my the y component of the predicted motion vector
*/ */
static av_always_inline void pred_16x8_motion(H264Context *const h, static av_always_inline void pred_16x8_motion(H264Context *const h,
H264SliceContext *sl,
int n, int list, int ref, int n, int list, int ref,
int *const mx, int *const my) int *const mx, int *const my)
{ {
@ -185,7 +189,7 @@ static av_always_inline void pred_16x8_motion(H264Context *const h,
} }
//RARE //RARE
pred_motion(h, n, 4, list, ref, mx, my); pred_motion(h, sl, n, 4, list, ref, mx, my);
} }
/** /**
@ -195,6 +199,7 @@ static av_always_inline void pred_16x8_motion(H264Context *const h,
* @param my the y component of the predicted motion vector * @param my the y component of the predicted motion vector
*/ */
static av_always_inline void pred_8x16_motion(H264Context *const h, static av_always_inline void pred_8x16_motion(H264Context *const h,
H264SliceContext *sl,
int n, int list, int ref, int n, int list, int ref,
int *const mx, int *const my) int *const mx, int *const my)
{ {
@ -214,7 +219,7 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
const int16_t *C; const int16_t *C;
int diagonal_ref; int diagonal_ref;
diagonal_ref = fetch_diagonal_mv(h, &C, scan8[4], list, 2); diagonal_ref = fetch_diagonal_mv(h, sl, &C, scan8[4], list, 2);
tprintf(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n", tprintf(h->avctx, "pred_8x16: (%2d %2d %2d) at %2d %2d %d list %d\n",
diagonal_ref, C[0], C[1], h->mb_x, h->mb_y, n, list); diagonal_ref, C[0], C[1], h->mb_x, h->mb_y, n, list);
@ -227,7 +232,7 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
} }
//RARE //RARE
pred_motion(h, n, 2, list, ref, mx, my); pred_motion(h, sl, n, 2, list, ref, mx, my);
} }
#define FIX_MV_MBAFF(type, refn, mvn, idx) \ #define FIX_MV_MBAFF(type, refn, mvn, idx) \
@ -249,7 +254,8 @@ static av_always_inline void pred_8x16_motion(H264Context *const h,
} \ } \
} }
static av_always_inline void pred_pskip_motion(H264Context *const h) static av_always_inline void pred_pskip_motion(H264Context *const h,
H264SliceContext *sl)
{ {
DECLARE_ALIGNED(4, static const int16_t, zeromv)[2] = { 0 }; DECLARE_ALIGNED(4, static const int16_t, zeromv)[2] = { 0 };
DECLARE_ALIGNED(4, int16_t, mvbuf)[3][2]; DECLARE_ALIGNED(4, int16_t, mvbuf)[3][2];
@ -266,26 +272,26 @@ static av_always_inline void pred_pskip_motion(H264Context *const h)
* FIXME: this is a partial duplicate of the logic in fill_decode_caches, * FIXME: this is a partial duplicate of the logic in fill_decode_caches,
* but it's faster this way. Is there a way to avoid this duplication? * but it's faster this way. Is there a way to avoid this duplication?
*/ */
if (USES_LIST(h->left_type[LTOP], 0)) { if (USES_LIST(sl->left_type[LTOP], 0)) {
left_ref = ref[4 * h->left_mb_xy[LTOP] + 1 + (h->left_block[0] & ~1)]; left_ref = ref[4 * sl->left_mb_xy[LTOP] + 1 + (sl->left_block[0] & ~1)];
A = mv[h->mb2b_xy[h->left_mb_xy[LTOP]] + 3 + b_stride * h->left_block[0]]; A = mv[h->mb2b_xy[sl->left_mb_xy[LTOP]] + 3 + b_stride * sl->left_block[0]];
FIX_MV_MBAFF(h->left_type[LTOP], left_ref, A, 0); FIX_MV_MBAFF(sl->left_type[LTOP], left_ref, A, 0);
if (!(left_ref | AV_RN32A(A))) if (!(left_ref | AV_RN32A(A)))
goto zeromv; goto zeromv;
} else if (h->left_type[LTOP]) { } else if (sl->left_type[LTOP]) {
left_ref = LIST_NOT_USED; left_ref = LIST_NOT_USED;
A = zeromv; A = zeromv;
} else { } else {
goto zeromv; goto zeromv;
} }
if (USES_LIST(h->top_type, 0)) { if (USES_LIST(sl->top_type, 0)) {
top_ref = ref[4 * h->top_mb_xy + 2]; top_ref = ref[4 * sl->top_mb_xy + 2];
B = mv[h->mb2b_xy[h->top_mb_xy] + 3 * b_stride]; B = mv[h->mb2b_xy[sl->top_mb_xy] + 3 * b_stride];
FIX_MV_MBAFF(h->top_type, top_ref, B, 1); FIX_MV_MBAFF(sl->top_type, top_ref, B, 1);
if (!(top_ref | AV_RN32A(B))) if (!(top_ref | AV_RN32A(B)))
goto zeromv; goto zeromv;
} else if (h->top_type) { } else if (sl->top_type) {
top_ref = LIST_NOT_USED; top_ref = LIST_NOT_USED;
B = zeromv; B = zeromv;
} else { } else {
@ -295,21 +301,21 @@ static av_always_inline void pred_pskip_motion(H264Context *const h)
tprintf(h->avctx, "pred_pskip: (%d) (%d) at %2d %2d\n", tprintf(h->avctx, "pred_pskip: (%d) (%d) at %2d %2d\n",
top_ref, left_ref, h->mb_x, h->mb_y); top_ref, left_ref, h->mb_x, h->mb_y);
if (USES_LIST(h->topright_type, 0)) { if (USES_LIST(sl->topright_type, 0)) {
diagonal_ref = ref[4 * h->topright_mb_xy + 2]; diagonal_ref = ref[4 * sl->topright_mb_xy + 2];
C = mv[h->mb2b_xy[h->topright_mb_xy] + 3 * b_stride]; C = mv[h->mb2b_xy[sl->topright_mb_xy] + 3 * b_stride];
FIX_MV_MBAFF(h->topright_type, diagonal_ref, C, 2); FIX_MV_MBAFF(sl->topright_type, diagonal_ref, C, 2);
} else if (h->topright_type) { } else if (sl->topright_type) {
diagonal_ref = LIST_NOT_USED; diagonal_ref = LIST_NOT_USED;
C = zeromv; C = zeromv;
} else { } else {
if (USES_LIST(h->topleft_type, 0)) { if (USES_LIST(sl->topleft_type, 0)) {
diagonal_ref = ref[4 * h->topleft_mb_xy + 1 + diagonal_ref = ref[4 * sl->topleft_mb_xy + 1 +
(h->topleft_partition & 2)]; (sl->topleft_partition & 2)];
C = mv[h->mb2b_xy[h->topleft_mb_xy] + 3 + b_stride + C = mv[h->mb2b_xy[sl->topleft_mb_xy] + 3 + b_stride +
(h->topleft_partition & 2 * b_stride)]; (sl->topleft_partition & 2 * b_stride)];
FIX_MV_MBAFF(h->topleft_type, diagonal_ref, C, 2); FIX_MV_MBAFF(sl->topleft_type, diagonal_ref, C, 2);
} else if (h->topleft_type) { } else if (sl->topleft_type) {
diagonal_ref = LIST_NOT_USED; diagonal_ref = LIST_NOT_USED;
C = zeromv; C = zeromv;
} else { } else {
@ -347,7 +353,7 @@ zeromv:
return; return;
} }
static void fill_decode_neighbors(H264Context *h, int mb_type) static void fill_decode_neighbors(H264Context *h, H264SliceContext *sl, int mb_type)
{ {
const int mb_xy = h->mb_xy; const int mb_xy = h->mb_xy;
int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS]; int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
@ -358,7 +364,7 @@ static void fill_decode_neighbors(H264Context *h, int mb_type)
{ 0, 2, 0, 2, 7, 10, 7, 10, 3 + 0 * 4, 3 + 2 * 4, 3 + 0 * 4, 3 + 2 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 4 * 4, 1 + 8 * 4 } { 0, 2, 0, 2, 7, 10, 7, 10, 3 + 0 * 4, 3 + 2 * 4, 3 + 0 * 4, 3 + 2 * 4, 1 + 4 * 4, 1 + 8 * 4, 1 + 4 * 4, 1 + 8 * 4 }
}; };
h->topleft_partition = -1; sl->topleft_partition = -1;
top_xy = mb_xy - (h->mb_stride << MB_FIELD(h)); top_xy = mb_xy - (h->mb_stride << MB_FIELD(h));
@ -368,7 +374,7 @@ static void fill_decode_neighbors(H264Context *h, int mb_type)
topleft_xy = top_xy - 1; topleft_xy = top_xy - 1;
topright_xy = top_xy + 1; topright_xy = top_xy + 1;
left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1; left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
h->left_block = left_block_options[0]; sl->left_block = left_block_options[0];
if (FRAME_MBAFF(h)) { if (FRAME_MBAFF(h)) {
const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]); const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
const int curr_mb_field_flag = IS_INTERLACED(mb_type); const int curr_mb_field_flag = IS_INTERLACED(mb_type);
@ -377,13 +383,13 @@ static void fill_decode_neighbors(H264Context *h, int mb_type)
left_xy[LBOT] = left_xy[LTOP] = mb_xy - h->mb_stride - 1; left_xy[LBOT] = left_xy[LTOP] = mb_xy - h->mb_stride - 1;
if (curr_mb_field_flag) { if (curr_mb_field_flag) {
left_xy[LBOT] += h->mb_stride; left_xy[LBOT] += h->mb_stride;
h->left_block = left_block_options[3]; sl->left_block = left_block_options[3];
} else { } else {
topleft_xy += h->mb_stride; topleft_xy += h->mb_stride;
/* take top left mv from the middle of the mb, as opposed /* take top left mv from the middle of the mb, as opposed
* to all other modes which use the bottom right partition */ * to all other modes which use the bottom right partition */
h->topleft_partition = 0; sl->topleft_partition = 0;
h->left_block = left_block_options[1]; sl->left_block = left_block_options[1];
} }
} }
} else { } else {
@ -395,66 +401,66 @@ static void fill_decode_neighbors(H264Context *h, int mb_type)
if (left_mb_field_flag != curr_mb_field_flag) { if (left_mb_field_flag != curr_mb_field_flag) {
if (curr_mb_field_flag) { if (curr_mb_field_flag) {
left_xy[LBOT] += h->mb_stride; left_xy[LBOT] += h->mb_stride;
h->left_block = left_block_options[3]; sl->left_block = left_block_options[3];
} else { } else {
h->left_block = left_block_options[2]; sl->left_block = left_block_options[2];
} }
} }
} }
} }
h->topleft_mb_xy = topleft_xy; sl->topleft_mb_xy = topleft_xy;
h->top_mb_xy = top_xy; sl->top_mb_xy = top_xy;
h->topright_mb_xy = topright_xy; sl->topright_mb_xy = topright_xy;
h->left_mb_xy[LTOP] = left_xy[LTOP]; sl->left_mb_xy[LTOP] = left_xy[LTOP];
h->left_mb_xy[LBOT] = left_xy[LBOT]; sl->left_mb_xy[LBOT] = left_xy[LBOT];
//FIXME do we need all in the context? //FIXME do we need all in the context?
h->topleft_type = h->cur_pic.mb_type[topleft_xy]; sl->topleft_type = h->cur_pic.mb_type[topleft_xy];
h->top_type = h->cur_pic.mb_type[top_xy]; sl->top_type = h->cur_pic.mb_type[top_xy];
h->topright_type = h->cur_pic.mb_type[topright_xy]; sl->topright_type = h->cur_pic.mb_type[topright_xy];
h->left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]]; sl->left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
h->left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]]; sl->left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
if (FMO) { if (FMO) {
if (h->slice_table[topleft_xy] != h->slice_num) if (h->slice_table[topleft_xy] != h->slice_num)
h->topleft_type = 0; sl->topleft_type = 0;
if (h->slice_table[top_xy] != h->slice_num) if (h->slice_table[top_xy] != h->slice_num)
h->top_type = 0; sl->top_type = 0;
if (h->slice_table[left_xy[LTOP]] != h->slice_num) if (h->slice_table[left_xy[LTOP]] != h->slice_num)
h->left_type[LTOP] = h->left_type[LBOT] = 0; sl->left_type[LTOP] = sl->left_type[LBOT] = 0;
} else { } else {
if (h->slice_table[topleft_xy] != h->slice_num) { if (h->slice_table[topleft_xy] != h->slice_num) {
h->topleft_type = 0; sl->topleft_type = 0;
if (h->slice_table[top_xy] != h->slice_num) if (h->slice_table[top_xy] != h->slice_num)
h->top_type = 0; sl->top_type = 0;
if (h->slice_table[left_xy[LTOP]] != h->slice_num) if (h->slice_table[left_xy[LTOP]] != h->slice_num)
h->left_type[LTOP] = h->left_type[LBOT] = 0; sl->left_type[LTOP] = sl->left_type[LBOT] = 0;
} }
} }
if (h->slice_table[topright_xy] != h->slice_num) if (h->slice_table[topright_xy] != h->slice_num)
h->topright_type = 0; sl->topright_type = 0;
} }
static void fill_decode_caches(H264Context *h, int mb_type) static void fill_decode_caches(H264Context *h, H264SliceContext *sl, int mb_type)
{ {
int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS]; int topleft_xy, top_xy, topright_xy, left_xy[LEFT_MBS];
int topleft_type, top_type, topright_type, left_type[LEFT_MBS]; int topleft_type, top_type, topright_type, left_type[LEFT_MBS];
const uint8_t *left_block = h->left_block; const uint8_t *left_block = sl->left_block;
int i; int i;
uint8_t *nnz; uint8_t *nnz;
uint8_t *nnz_cache; uint8_t *nnz_cache;
topleft_xy = h->topleft_mb_xy; topleft_xy = sl->topleft_mb_xy;
top_xy = h->top_mb_xy; top_xy = sl->top_mb_xy;
topright_xy = h->topright_mb_xy; topright_xy = sl->topright_mb_xy;
left_xy[LTOP] = h->left_mb_xy[LTOP]; left_xy[LTOP] = sl->left_mb_xy[LTOP];
left_xy[LBOT] = h->left_mb_xy[LBOT]; left_xy[LBOT] = sl->left_mb_xy[LBOT];
topleft_type = h->topleft_type; topleft_type = sl->topleft_type;
top_type = h->top_type; top_type = sl->top_type;
topright_type = h->topright_type; topright_type = sl->topright_type;
left_type[LTOP] = h->left_type[LTOP]; left_type[LTOP] = sl->left_type[LTOP];
left_type[LBOT] = h->left_type[LBOT]; left_type[LBOT] = sl->left_type[LBOT];
if (!IS_SKIP(mb_type)) { if (!IS_SKIP(mb_type)) {
if (IS_INTRA(mb_type)) { if (IS_INTRA(mb_type)) {
@ -667,8 +673,8 @@ static void fill_decode_caches(H264Context *h, int mb_type)
if (ref_cache[4 - 1 * 8] < 0) { if (ref_cache[4 - 1 * 8] < 0) {
if (USES_LIST(topleft_type, list)) { if (USES_LIST(topleft_type, list)) {
const int b_xy = h->mb2b_xy[topleft_xy] + 3 + b_stride + const int b_xy = h->mb2b_xy[topleft_xy] + 3 + b_stride +
(h->topleft_partition & 2 * b_stride); (sl->topleft_partition & 2 * b_stride);
const int b8_xy = 4 * topleft_xy + 1 + (h->topleft_partition & 2); const int b8_xy = 4 * topleft_xy + 1 + (sl->topleft_partition & 2);
AV_COPY32(mv_cache[-1 - 1 * 8], mv[b_xy]); AV_COPY32(mv_cache[-1 - 1 * 8], mv[b_xy]);
ref_cache[-1 - 1 * 8] = ref[b8_xy]; ref_cache[-1 - 1 * 8] = ref[b8_xy];
} else { } else {
@ -808,16 +814,16 @@ static void av_unused decode_mb_skip(H264Context *h, H264SliceContext *sl)
// just for fill_caches. pred_direct_motion will set the real mb_type // just for fill_caches. pred_direct_motion will set the real mb_type
mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 | MB_TYPE_SKIP; mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 | MB_TYPE_SKIP;
if (h->direct_spatial_mv_pred) { if (h->direct_spatial_mv_pred) {
fill_decode_neighbors(h, mb_type); fill_decode_neighbors(h, sl, mb_type);
fill_decode_caches(h, mb_type); //FIXME check what is needed and what not ... fill_decode_caches(h, sl, mb_type); //FIXME check what is needed and what not ...
} }
ff_h264_pred_direct_motion(h, &mb_type); ff_h264_pred_direct_motion(h, &mb_type);
mb_type |= MB_TYPE_SKIP; mb_type |= MB_TYPE_SKIP;
} else { } else {
mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P1L0 | MB_TYPE_SKIP; mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P1L0 | MB_TYPE_SKIP;
fill_decode_neighbors(h, mb_type); fill_decode_neighbors(h, sl, mb_type);
pred_pskip_motion(h); pred_pskip_motion(h, sl);
} }
write_back_motion(h, mb_type); write_back_motion(h, mb_type);

12
libavcodec/h264_slice.c
Unescape View File

@ -1932,9 +1932,9 @@ static int fill_filter_caches(H264Context *h, H264SliceContext *sl, int mb_type)
} }
} }
h->top_mb_xy = top_xy; sl->top_mb_xy = top_xy;
h->left_mb_xy[LTOP] = left_xy[LTOP]; sl->left_mb_xy[LTOP] = left_xy[LTOP];
h->left_mb_xy[LBOT] = left_xy[LBOT]; sl->left_mb_xy[LBOT] = left_xy[LBOT];
{ {
/* For sufficiently low qp, filtering wouldn't do anything. /* For sufficiently low qp, filtering wouldn't do anything.
* This is a conservative estimate: could also check beta_offset * This is a conservative estimate: could also check beta_offset
@ -1970,9 +1970,9 @@ static int fill_filter_caches(H264Context *h, H264SliceContext *sl, int mb_type)
if (h->slice_table[left_xy[LBOT]] == 0xFFFF) if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
left_type[LTOP] = left_type[LBOT] = 0; left_type[LTOP] = left_type[LBOT] = 0;
} }
h->top_type = top_type; sl->top_type = top_type;
h->left_type[LTOP] = left_type[LTOP]; sl->left_type[LTOP] = left_type[LTOP];
h->left_type[LBOT] = left_type[LBOT]; sl->left_type[LBOT] = left_type[LBOT];
if (IS_INTRA(mb_type)) if (IS_INTRA(mb_type))
return 0; return 0;

3
libavcodec/svq3.c
Unescape View File

@ -369,6 +369,7 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
{ {
int i, j, k, mx, my, dx, dy, x, y; int i, j, k, mx, my, dx, dy, x, y;
H264Context *h = &s->h; H264Context *h = &s->h;
H264SliceContext *sl = &h->slice_ctx[0];
const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1); const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
const int part_height = 16 >> ((unsigned)(size + 1) / 3); const int part_height = 16 >> ((unsigned)(size + 1) / 3);
const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0; const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
@ -386,7 +387,7 @@ static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
(j >> 1 & 4) + (i & 8); (j >> 1 & 4) + (i & 8);
if (mode != PREDICT_MODE) { if (mode != PREDICT_MODE) {
pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my); pred_motion(h, sl, k, part_width >> 2, dir, 1, &mx, &my);
} else { } else {
mx = s->next_pic->motion_val[0][b_xy][0] << 1; mx = s->next_pic->motion_val[0][b_xy][0] << 1;
my = s->next_pic->motion_val[0][b_xy][1] << 1; my = s->next_pic->motion_val[0][b_xy][1] << 1;

Write Preview
Loading…
Cancel
Save