#include <math.h>
#include "common/common.h"
-#include "common/cpu.h"
#include "set.h"
#include "analyse.h"
#include "macroblock.h"
#include "me.h"
-#ifdef HAVE_VISUALIZE
+#if HAVE_VISUALIZE
#include "common/visualize.h"
#endif
return -10.0 * log10( f_mse );
}
+static float x264_ssim( float ssim )
+{
+ return -10.0 * log10( 1 - ssim );
+}
+
static void x264_frame_dump( x264_t *h )
{
FILE *f = fopen( h->param.psz_dump_yuv, "r+b" );
static int x264_validate_parameters( x264_t *h )
{
-#ifdef HAVE_MMX
+#if HAVE_MMX
+#ifdef __SSE__
if( !(x264_cpu_detect() & X264_CPU_SSE) )
{
x264_log( h, X264_LOG_ERROR, "your cpu does not support SSE1, but x264 was compiled with asm support\n");
+#else
+ if( !(x264_cpu_detect() & X264_CPU_MMXEXT) )
+ {
+ x264_log( h, X264_LOG_ERROR, "your cpu does not support MMXEXT, but x264 was compiled with asm support\n");
+#endif
x264_log( h, X264_LOG_ERROR, "to run x264, recompile without asm support (configure --disable-asm)\n");
return -1;
}
h->param.i_threads = x264_clip3( h->param.i_threads, 1, X264_THREAD_MAX );
if( h->param.i_threads > 1 )
{
-#ifndef HAVE_PTHREAD
+#if !HAVE_PTHREAD
x264_log( h, X264_LOG_WARNING, "not compiled with pthread support!\n");
h->param.i_threads = 1;
#endif
h->param.rc.b_mb_tree = 0;
if( h->param.rc.b_stat_read )
h->param.rc.i_lookahead = 0;
-#ifdef HAVE_PTHREAD
- if( h->param.i_sync_lookahead )
- h->param.i_sync_lookahead = x264_clip3( h->param.i_sync_lookahead, h->i_thread_frames + h->param.i_bframe, X264_LOOKAHEAD_MAX );
+#if HAVE_PTHREAD
+ if( h->param.i_sync_lookahead < 0 )
+ h->param.i_sync_lookahead = h->param.i_bframe + 1;
+ h->param.i_sync_lookahead = X264_MIN( h->param.i_sync_lookahead, X264_LOOKAHEAD_MAX );
if( h->param.rc.b_stat_read || h->i_thread_frames == 1 )
h->param.i_sync_lookahead = 0;
#else
BOOLIFY( b_annexb );
BOOLIFY( b_vfr_input );
BOOLIFY( b_pic_struct );
+ BOOLIFY( b_fake_interlaced );
BOOLIFY( analyse.b_transform_8x8 );
BOOLIFY( analyse.b_weighted_bipred );
BOOLIFY( analyse.b_chroma_me );
memcpy( h->pixf.mbcmp_unaligned, satd ? h->pixf.satd : h->pixf.sad, sizeof(h->pixf.mbcmp_unaligned) );
h->pixf.intra_mbcmp_x3_16x16 = satd ? h->pixf.intra_satd_x3_16x16 : h->pixf.intra_sad_x3_16x16;
h->pixf.intra_mbcmp_x3_8x8c = satd ? h->pixf.intra_satd_x3_8x8c : h->pixf.intra_sad_x3_8x8c;
+ h->pixf.intra_mbcmp_x3_8x8 = satd ? h->pixf.intra_sa8d_x3_8x8 : h->pixf.intra_sad_x3_8x8;
h->pixf.intra_mbcmp_x3_4x4 = satd ? h->pixf.intra_satd_x3_4x4 : h->pixf.intra_sad_x3_4x4;
satd &= h->param.analyse.i_me_method == X264_ME_TESA;
memcpy( h->pixf.fpelcmp, satd ? h->pixf.satd : h->pixf.sad, sizeof(h->pixf.fpelcmp) );
if( x264_cqm_init( h ) < 0 )
goto fail;
- h->mb.i_mb_count = h->sps->i_mb_width * h->sps->i_mb_height;
+ h->mb.i_mb_width = h->sps->i_mb_width;
+ h->mb.i_mb_height = h->sps->i_mb_height;
+ h->mb.i_mb_count = h->mb.i_mb_width * h->mb.i_mb_height;
/* Init frames. */
- if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS )
+ if( h->param.i_bframe_adaptive == X264_B_ADAPT_TRELLIS && !h->param.rc.b_stat_read )
h->frames.i_delay = X264_MAX(h->param.i_bframe,3)*4;
else
h->frames.i_delay = h->param.i_bframe;
h->frames.i_delay = X264_MAX( h->frames.i_delay, h->param.rc.i_lookahead );
i_slicetype_length = h->frames.i_delay;
h->frames.i_delay += h->i_thread_frames - 1;
- h->frames.i_delay = X264_MIN( h->frames.i_delay, X264_LOOKAHEAD_MAX );
h->frames.i_delay += h->param.i_sync_lookahead;
h->frames.i_delay += h->param.b_vfr_input && (h->param.rc.i_rc_method == X264_RC_ABR || h->param.rc.b_stat_write
|| h->param.rc.i_vbv_buffer_size);
x264_mc_init( h->param.cpu, &h->mc );
x264_quant_init( h, h->param.cpu, &h->quantf );
x264_deblock_init( h->param.cpu, &h->loopf );
+ x264_bitstream_init( h->param.cpu, &h->bsf );
x264_dct_init_weights();
mbcmp_init( h );
if( x264_clz( temp ) != 23 )
{
x264_log( h, X264_LOG_ERROR, "CLZ test failed: x264 has been miscompiled!\n" );
-#if defined(ARCH_X86) || defined(ARCH_X86_64)
+#if ARCH_X86 || ARCH_X86_64
x264_log( h, X264_LOG_ERROR, "Are you attempting to run an SSE4a-targeted build on a CPU that\n" );
x264_log( h, X264_LOG_ERROR, "doesn't support it?\n" );
#endif
for( int i = start; i < h->out.i_nal; i++ )
{
int long_startcode = !i || h->out.nal[i].i_type == NAL_SPS || h->out.nal[i].i_type == NAL_PPS;
- int size = x264_nal_encode( nal_buffer, &h->out.nal[i], h->param.b_annexb, long_startcode );
+ int size = x264_nal_encode( h, nal_buffer, &h->out.nal[i], long_startcode );
h->out.nal[i].i_payload = size;
h->out.nal[i].p_payload = nal_buffer;
nal_buffer += size;
}
+ x264_emms();
+
return nal_buffer - (h->nal_buffer + previous_nal_size);
}
//scale full resolution frame
if( h->sh.weight[j][0].weightfn && h->param.i_threads == 1 )
{
- uint8_t *src = h->fref0[j]->filtered[0] - h->fref0[j]->i_stride[0]*i_padv - PADH;
- uint8_t *dst = h->fenc->weighted[j] - h->fenc->i_stride[0]*i_padv - PADH;
+ pixel *src = h->fref0[j]->filtered[0] - h->fref0[j]->i_stride[0]*i_padv - PADH;
+ pixel *dst = h->fenc->weighted[j] - h->fenc->i_stride[0]*i_padv - PADH;
int stride = h->fenc->i_stride[0];
int width = h->fenc->i_width[0] + PADH*2;
int height = h->fenc->i_lines[0] + i_padv*2;
{
memcpy( h->intra_border_backup[j][i],
h->fdec->plane[i] + ((mb_y*16 >> !!i) + j - 1 - h->sh.b_mbaff) * h->fdec->i_stride[i],
- h->sps->i_mb_width*16 >> !!i );
+ (h->mb.i_mb_width*16 >> !!i) * sizeof(pixel) );
}
if( b_deblock )
if( b_hpel )
{
- int end = mb_y == h->sps->i_mb_height;
+ int end = mb_y == h->mb.i_mb_height;
x264_frame_expand_border( h, h->fdec, min_y, end );
if( h->param.analyse.i_subpel_refine )
{
int overhead_guess = (NALU_OVERHEAD - (h->param.b_annexb && h->out.i_nal)) + 3;
int slice_max_size = h->param.i_slice_max_size > 0 ? (h->param.i_slice_max_size-overhead_guess)*8 : INT_MAX;
int starting_bits = bs_pos(&h->out.bs);
+ int b_deblock = h->sh.i_disable_deblocking_filter_idc != 1;
+ int b_hpel = h->fdec->b_kept_as_ref;
+ b_deblock &= b_hpel || h->param.psz_dump_yuv;
bs_realign( &h->out.bs );
/* Slice */
/* If this isn't the first slice in the threadslice, set the slice QP
* equal to the last QP in the previous slice for more accurate
* CABAC initialization. */
- if( h->sh.i_first_mb != h->i_threadslice_start * h->sps->i_mb_width )
+ if( h->sh.i_first_mb != h->i_threadslice_start * h->mb.i_mb_width )
{
h->sh.i_qp = h->mb.i_last_qp;
h->sh.i_qp_delta = h->sh.i_qp - h->pps->i_pic_init_qp;
h->mb.i_last_qp = h->sh.i_qp;
h->mb.i_last_dqp = 0;
- i_mb_y = h->sh.i_first_mb / h->sps->i_mb_width;
- i_mb_x = h->sh.i_first_mb % h->sps->i_mb_width;
+ i_mb_y = h->sh.i_first_mb / h->mb.i_mb_width;
+ i_mb_x = h->sh.i_first_mb % h->mb.i_mb_width;
i_skip = 0;
- while( (mb_xy = i_mb_x + i_mb_y * h->sps->i_mb_width) <= h->sh.i_last_mb )
+ while( (mb_xy = i_mb_x + i_mb_y * h->mb.i_mb_width) <= h->sh.i_last_mb )
{
int mb_spos = bs_pos(&h->out.bs) + x264_cabac_pos(&h->cabac);
if( h->param.i_slice_max_size > 0 )
else
h->mb.b_reencode_mb = 0;
-#ifdef HAVE_VISUALIZE
+#if HAVE_VISUALIZE
if( h->param.b_visualize )
x264_visualize_mb( h );
#endif
x264_macroblock_cache_save( h );
/* accumulate mb stats */
+ h->stat.frame.i_mb_count[h->mb.i_type]++;
int b_intra = IS_INTRA( h->mb.i_type );
if( h->param.i_log_level >= X264_LOG_INFO || h->param.rc.b_stat_write )
{
- h->stat.frame.i_mb_count[h->mb.i_type]++;
if( !b_intra && !IS_SKIP( h->mb.i_type ) && !IS_DIRECT( h->mb.i_type ) )
{
if( h->mb.i_partition != D_8x8 )
}
}
+ /* calculate deblock strength values (actual deblocking is done per-row along with hpel) */
+ if( b_deblock )
+ {
+ int mvy_limit = 4 >> h->sh.b_mbaff;
+ uint8_t (*bs)[4][4] = h->deblock_strength[h->mb.i_mb_y&h->sh.b_mbaff][h->mb.i_mb_x];
+ x264_macroblock_cache_load_deblock( h );
+ if( IS_INTRA( h->mb.type[h->mb.i_mb_xy] ) )
+ memset( bs, 3, 2*4*4*sizeof(uint8_t) );
+ else
+ h->loopf.deblock_strength( h->mb.cache.non_zero_count, h->mb.cache.ref, h->mb.cache.mv,
+ bs, mvy_limit, h->sh.i_type == SLICE_TYPE_B );
+ }
+
x264_ratecontrol_mb( h, mb_size );
if( h->sh.b_mbaff )
{
i_mb_x += i_mb_y & 1;
- i_mb_y ^= i_mb_x < h->sps->i_mb_width;
+ i_mb_y ^= i_mb_x < h->mb.i_mb_width;
}
else
i_mb_x++;
- if( i_mb_x == h->sps->i_mb_width )
+ if( i_mb_x == h->mb.i_mb_width )
{
i_mb_y++;
i_mb_x = 0;
if( x264_nal_end( h ) )
return -1;
- if( h->sh.i_last_mb == (h->i_threadslice_end * h->sps->i_mb_width - 1) )
+ if( h->sh.i_last_mb == (h->i_threadslice_end * h->mb.i_mb_width - 1) )
{
h->stat.frame.i_misc_bits = bs_pos( &h->out.bs )
+ (h->out.i_nal*NALU_OVERHEAD * 8)
if( h->param.i_sync_lookahead )
x264_lower_thread_priority( 10 );
-#ifdef HAVE_MMX
+#if HAVE_MMX
/* Misalign mask has to be set separately for each thread. */
if( h->param.cpu&X264_CPU_SSE_MISALIGN )
x264_cpu_mask_misalign_sse();
#endif
-#ifdef HAVE_VISUALIZE
+#if HAVE_VISUALIZE
if( h->param.b_visualize )
if( x264_visualize_init( h ) )
return (void *)-1;
h->sh.i_last_mb = h->sh.i_first_mb + h->param.i_slice_max_mbs - 1;
else if( h->param.i_slice_count && !h->param.b_sliced_threads )
{
- int height = h->sps->i_mb_height >> h->param.b_interlaced;
- int width = h->sps->i_mb_width << h->param.b_interlaced;
+ int height = h->mb.i_mb_height >> h->param.b_interlaced;
+ int width = h->mb.i_mb_width << h->param.b_interlaced;
i_slice_num++;
h->sh.i_last_mb = (height * i_slice_num + h->param.i_slice_count/2) / h->param.i_slice_count * width - 1;
}
h->sh.i_first_mb = h->sh.i_last_mb + 1;
}
-#ifdef HAVE_VISUALIZE
+#if HAVE_VISUALIZE
if( h->param.b_visualize )
{
x264_visualize_show( h );
static int x264_threaded_slices_write( x264_t *h )
{
void *ret = NULL;
+#if HAVE_MMX
+ if( h->param.cpu&X264_CPU_SSE_MISALIGN )
+ x264_cpu_mask_misalign_sse();
+#endif
/* set first/last mb and sync contexts */
for( int i = 0; i < h->param.i_threads; i++ )
{
t->param = h->param;
memcpy( &t->i_frame, &h->i_frame, offsetof(x264_t, rc) - offsetof(x264_t, i_frame) );
}
- int height = h->sps->i_mb_height >> h->param.b_interlaced;
+ int height = h->mb.i_mb_height >> h->param.b_interlaced;
t->i_threadslice_start = ((height * i + h->param.i_slice_count/2) / h->param.i_threads) << h->param.b_interlaced;
t->i_threadslice_end = ((height * (i+1) + h->param.i_slice_count/2) / h->param.i_threads) << h->param.b_interlaced;
- t->sh.i_first_mb = t->i_threadslice_start * h->sps->i_mb_width;
- t->sh.i_last_mb = t->i_threadslice_end * h->sps->i_mb_width - 1;
+ t->sh.i_first_mb = t->i_threadslice_start * h->mb.i_mb_width;
+ t->sh.i_last_mb = t->i_threadslice_end * h->mb.i_mb_width - 1;
}
- x264_stack_align( x264_analyse_weight_frame, h, h->sps->i_mb_height*16 + 16 );
+ x264_stack_align( x264_analyse_weight_frame, h, h->mb.i_mb_height*16 + 16 );
x264_threads_distribute_ratecontrol( h );
/* Go back and fix up the hpel on the borders between slices. */
for( int i = 1; i < h->param.i_threads; i++ )
+ {
x264_fdec_filter_row( h->thread[i], h->thread[i]->i_threadslice_start + 1, 0 );
+ if( h->sh.b_mbaff )
+ x264_fdec_filter_row( h->thread[i], h->thread[i]->i_threadslice_start + 2, 0 );
+ }
x264_threads_merge_ratecontrol( h );
return 0;
}
+void x264_encoder_intra_refresh( x264_t *h )
+{
+ h = h->thread[h->i_thread_phase];
+ h->b_queued_intra_refresh = 1;
+}
+
/****************************************************************************
* x264_encoder_encode:
* XXX: i_poc : is the poc of the current given picture
if( x264_frame_copy_picture( h, fenc, pic_in ) < 0 )
return -1;
- if( h->param.i_width != 16 * h->sps->i_mb_width ||
- h->param.i_height != 16 * h->sps->i_mb_height )
+ if( h->param.i_width != 16 * h->mb.i_mb_width ||
+ h->param.i_height != 16 * h->mb.i_mb_height )
x264_frame_expand_border_mod16( h, fenc );
fenc->i_frame = h->frames.i_input++;
fenc->i_pic_struct = PIC_STRUCT_PROGRESSIVE;
}
- if( h->frames.b_have_lowres )
- {
- if( h->param.analyse.i_weighted_pred == X264_WEIGHTP_FAKE || h->param.analyse.i_weighted_pred == X264_WEIGHTP_SMART )
- x264_weight_plane_analyse( h, fenc );
- x264_frame_init_lowres( h, fenc );
- }
-
if( h->param.rc.b_mb_tree && h->param.rc.b_stat_read )
{
- if( x264_macroblock_tree_read( h, fenc ) )
+ if( x264_macroblock_tree_read( h, fenc, pic_in->prop.quant_offsets ) )
return -1;
}
- else if( h->param.rc.i_aq_mode )
- x264_adaptive_quant_frame( h, fenc );
+ else
+ x264_adaptive_quant_frame( h, fenc, pic_in->prop.quant_offsets );
+
+ if( pic_in->prop.quant_offsets_free )
+ pic_in->prop.quant_offsets_free( pic_in->prop.quant_offsets );
+
+ if( h->frames.b_have_lowres )
+ x264_frame_init_lowres( h, fenc );
/* 2: Place the frame into the queue for its slice type decision */
x264_lookahead_put_frame( h, fenc );
/* ------------------- Get frame to be encoded ------------------------- */
/* 4: get picture to encode */
h->fenc = x264_frame_shift( h->frames.current );
- if( h->i_frame == 0 )
- h->first_pts = h->fenc->i_reordered_pts;
+ if( h->i_frame == h->i_thread_frames - 1 )
+ h->i_reordered_pts_delay = h->fenc->i_reordered_pts;
if( h->fenc->param )
{
x264_encoder_reconfig( h, h->fenc->param );
h->i_nal_type = i_nal_type;
h->i_nal_ref_idc = i_nal_ref_idc;
- if( h->param.b_intra_refresh && h->fenc->i_type == X264_TYPE_P )
+ if( h->param.b_intra_refresh )
{
- int pocdiff = (h->fdec->i_poc - h->fref0[0]->i_poc)/2;
- float increment = X264_MAX( ((float)h->sps->i_mb_width-1) / h->param.i_keyint_max, 1 );
- int max_position = (int)(increment * h->param.i_keyint_max);
- if( IS_X264_TYPE_I( h->fref0[0]->i_type ) )
- h->fdec->f_pir_position = 0;
- else
+ if( IS_X264_TYPE_I( h->fenc->i_type ) )
+ {
+ h->fdec->i_frames_since_pir = 0;
+ h->b_queued_intra_refresh = 0;
+ /* PIR is currently only supported with ref == 1, so any intra frame effectively refreshes
+ * the whole frame and counts as an intra refresh. */
+ h->fdec->f_pir_position = h->mb.i_mb_width;
+ }
+ else if( h->fenc->i_type == X264_TYPE_P )
{
+ int pocdiff = (h->fdec->i_poc - h->fref0[0]->i_poc)/2;
+ float increment = X264_MAX( ((float)h->mb.i_mb_width-1) / h->param.i_keyint_max, 1 );
h->fdec->f_pir_position = h->fref0[0]->f_pir_position;
- if( h->fdec->f_pir_position+0.5 >= max_position )
+ h->fdec->i_frames_since_pir = h->fref0[0]->i_frames_since_pir + pocdiff;
+ if( h->fdec->i_frames_since_pir >= h->param.i_keyint_max ||
+ (h->b_queued_intra_refresh && h->fdec->f_pir_position + 0.5 >= h->mb.i_mb_width) )
{
h->fdec->f_pir_position = 0;
+ h->fdec->i_frames_since_pir = 0;
+ h->b_queued_intra_refresh = 0;
h->fenc->b_keyframe = 1;
}
+ h->fdec->i_pir_start_col = h->fdec->f_pir_position+0.5;
+ h->fdec->f_pir_position += increment * pocdiff;
+ h->fdec->i_pir_end_col = h->fdec->f_pir_position+0.5;
}
- h->fdec->i_pir_start_col = h->fdec->f_pir_position+0.5;
- h->fdec->f_pir_position += increment * pocdiff;
- h->fdec->i_pir_end_col = h->fdec->f_pir_position+0.5;
}
if( h->fenc->b_keyframe )
if( h->fenc->i_type != X264_TYPE_IDR )
{
- int time_to_recovery = X264_MIN( h->sps->i_mb_width - 1, h->param.i_keyint_max ) + h->param.i_bframe;
+ int time_to_recovery = X264_MIN( h->mb.i_mb_width - 1, h->param.i_keyint_max ) + h->param.i_bframe;
x264_nal_start( h, NAL_SEI, NAL_PRIORITY_DISPOSABLE );
x264_sei_recovery_point_write( h, &h->out.bs, time_to_recovery );
x264_nal_end( h );
/* Write frame */
h->i_threadslice_start = 0;
- h->i_threadslice_end = h->sps->i_mb_height;
+ h->i_threadslice_end = h->mb.i_mb_height;
if( h->i_thread_frames > 1 )
{
if( x264_pthread_create( &h->thread_handle, NULL, (void*)x264_slices_write, h ) )
{
static const char mb_chars[] = { 'i', 'i', 'I', 'C', 'P', '8', 'S',
'D', '<', 'X', 'B', 'X', '>', 'B', 'B', 'B', 'B', '8', 'S' };
- for( int mb_xy = 0; mb_xy < h->sps->i_mb_width * h->sps->i_mb_height; mb_xy++ )
+ for( int mb_xy = 0; mb_xy < h->mb.i_mb_width * h->mb.i_mb_height; mb_xy++ )
{
if( h->mb.type[mb_xy] < X264_MBTYPE_MAX && h->mb.type[mb_xy] >= 0 )
fprintf( stderr, "%c ", mb_chars[ h->mb.type[mb_xy] ] );
else
fprintf( stderr, "? " );
- if( (mb_xy+1) % h->sps->i_mb_width == 0 )
+ if( (mb_xy+1) % h->mb.i_mb_width == 0 )
fprintf( stderr, "\n" );
}
}
/* Slices used and PSNR */
for( int i = 0; i < 5; i++ )
{
- static const int slice_order[] = { SLICE_TYPE_I, SLICE_TYPE_SI, SLICE_TYPE_P, SLICE_TYPE_SP, SLICE_TYPE_B };
- static const char *slice_name[] = { "P", "B", "I", "SP", "SI" };
+ static const uint8_t slice_order[] = { SLICE_TYPE_I, SLICE_TYPE_SI, SLICE_TYPE_P, SLICE_TYPE_SP, SLICE_TYPE_B };
+ static const char * const slice_name[] = { "P", "B", "I", "SP", "SI" };
int i_slice = slice_order[i];
if( h->stat.i_frame_count[i_slice] > 0 )
if( h->param.analyse.b_ssim )
{
- x264_log( h, X264_LOG_INFO,
- "SSIM Mean Y:%.7f\n",
- SUM3( h->stat.f_ssim_mean_y ) / i_count );
+ float ssim = SUM3( h->stat.f_ssim_mean_y ) / i_count;
+ x264_log( h, X264_LOG_INFO, "SSIM Mean Y:%.7f (%6.3fdb)\n", ssim, x264_ssim( ssim ) );
}
if( h->param.analyse.b_psnr )
{