X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=encoder%2Fencoder.c;h=ebc86c75381ffe22994e23da8a26400c7b9edf62;hb=8060431f0d60f97a9b5274ceb230fbcdb3e2cffd;hp=e59e48b6815d077d458dcbbfd4675f2497b81d3b;hpb=22acdd610c9d9bdda31295c388a4d59d93b5d704;p=x264 diff --git a/encoder/encoder.c b/encoder/encoder.c index e59e48b6..ebc86c75 100644 --- a/encoder/encoder.c +++ b/encoder/encoder.c @@ -25,7 +25,6 @@ #include #include "common/common.h" -#include "common/cpu.h" #include "set.h" #include "analyse.h" @@ -33,7 +32,7 @@ #include "macroblock.h" #include "me.h" -#ifdef HAVE_VISUALIZE +#if HAVE_VISUALIZE #include "common/visualize.h" #endif @@ -59,6 +58,11 @@ static float x264_psnr( int64_t i_sqe, int64_t i_size ) 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" ); @@ -355,10 +359,16 @@ fail: 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; } @@ -388,7 +398,7 @@ static int x264_validate_parameters( x264_t *h ) 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 @@ -597,9 +607,10 @@ static int x264_validate_parameters( x264_t *h ) 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 @@ -779,6 +790,7 @@ static int x264_validate_parameters( x264_t *h ) 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 ); @@ -803,6 +815,7 @@ static void mbcmp_init( x264_t *h ) 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) ); @@ -920,10 +933,12 @@ x264_t *x264_encoder_open( x264_param_t *param ) 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; @@ -931,7 +946,6 @@ x264_t *x264_encoder_open( x264_param_t *param ) 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); @@ -980,6 +994,7 @@ x264_t *x264_encoder_open( x264_param_t *param ) 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 ); @@ -1022,7 +1037,7 @@ x264_t *x264_encoder_open( x264_param_t *param ) 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 @@ -1266,12 +1281,14 @@ static int x264_encoder_encapsulate_nals( x264_t *h, int start ) 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); } @@ -1410,8 +1427,8 @@ static void x264_weighted_pred_init( x264_t *h ) //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; @@ -1562,7 +1579,7 @@ static void x264_fdec_filter_row( x264_t *h, int mb_y, int b_inloop ) { 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 ) @@ -1571,7 +1588,7 @@ static void x264_fdec_filter_row( x264_t *h, int mb_y, int b_inloop ) 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 ) { @@ -1746,6 +1763,9 @@ static int x264_slice_write( x264_t *h ) 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 */ @@ -1757,7 +1777,7 @@ static int x264_slice_write( x264_t *h ) /* 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; @@ -1776,11 +1796,11 @@ static int x264_slice_write( x264_t *h ) 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 ) @@ -1876,7 +1896,7 @@ static int x264_slice_write( x264_t *h ) else h->mb.b_reencode_mb = 0; -#ifdef HAVE_VISUALIZE +#if HAVE_VISUALIZE if( h->param.b_visualize ) x264_visualize_mb( h ); #endif @@ -1885,11 +1905,11 @@ static int x264_slice_write( x264_t *h ) 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 ) @@ -1937,16 +1957,29 @@ static int x264_slice_write( x264_t *h ) } } + /* 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; @@ -1969,7 +2002,7 @@ static int x264_slice_write( x264_t *h ) 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) @@ -2014,13 +2047,13 @@ static void *x264_slices_write( x264_t *h ) 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; @@ -2036,8 +2069,8 @@ static void *x264_slices_write( x264_t *h ) 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; } @@ -2047,7 +2080,7 @@ static void *x264_slices_write( x264_t *h ) 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 ); @@ -2061,6 +2094,10 @@ static void *x264_slices_write( x264_t *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++ ) { @@ -2070,14 +2107,14 @@ static int x264_threaded_slices_write( x264_t *h ) 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 ); @@ -2098,7 +2135,11 @@ static int x264_threaded_slices_write( x264_t *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 ); @@ -2122,6 +2163,12 @@ static int x264_threaded_slices_write( x264_t *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 @@ -2180,8 +2227,8 @@ int x264_encoder_encode( x264_t *h, 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++; @@ -2210,20 +2257,19 @@ int x264_encoder_encode( x264_t *h, 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 ); @@ -2255,8 +2301,8 @@ int x264_encoder_encode( x264_t *h, /* ------------------- 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 ); @@ -2366,25 +2412,34 @@ int x264_encoder_encode( x264_t *h, 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 ) @@ -2422,7 +2477,7 @@ int x264_encoder_encode( x264_t *h, 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 ); @@ -2471,7 +2526,7 @@ int x264_encoder_encode( x264_t *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 ) ) @@ -2713,14 +2768,14 @@ static int x264_encoder_frame_end( x264_t *h, x264_t *thread_current, { 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" ); } } @@ -2792,8 +2847,8 @@ void x264_encoder_close ( x264_t *h ) /* 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 ) @@ -3021,9 +3076,8 @@ void x264_encoder_close ( x264_t *h ) 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 ) {