X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fencx264.c;h=5e3fbc03c67029a80b647a4fe9939a600daae516;hb=d75166de2b31bb7743e7345e0105507656ce81fe;hp=23afa424378441843bd6b7289442a4fc50623e71;hpb=91d83077b34825c1acd6e2b7236ac6c5152ce106;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/encx264.c b/libhb/encx264.c index 23afa424..5e3fbc03 100644 --- a/libhb/encx264.c +++ b/libhb/encx264.c @@ -50,6 +50,9 @@ struct hb_work_private_s x264_picture_t pic_in; uint8_t *x264_allocated_pic; + uint32_t frames_in; + uint32_t frames_out; + uint32_t frames_split; // number of frames we had to split int chap_mark; // saved chap mark when we're propagating it int64_t last_stop; // Debugging - stop time of previous input frame int64_t init_delay; @@ -83,19 +86,44 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) hb_get_tempory_filename( job->h, pv->filename, "x264.log" ); x264_param_default( ¶m ); - + + /* Enable metrics */ + param.analyse.b_psnr = 1; + param.analyse.b_ssim = 1; + param.i_threads = ( hb_get_cpu_count() * 3 / 2 ); param.i_width = job->width; param.i_height = job->height; param.i_fps_num = job->vrate; param.i_fps_den = job->vrate_base; + /* Set min:max key intervals ratio to 1:10 of fps. + * This section is skipped if fps=25 (default). + */ if (job->vrate_base != 1080000) { - /* If the fps isn't 25, adjust the key intervals. Add 1 because - we want 24, not 23 with a truncated remainder. */ - param.i_keyint_min = (job->vrate / job->vrate_base) + 1; - param.i_keyint_max = (10 * job->vrate / job->vrate_base) + 1; + if (job->pass == 2 && !job->cfr ) + { + /* Even though the framerate might be different due to VFR, + we still want the same keyframe intervals as the 1st pass, + so the 1st pass stats won't conflict on frame decisions. */ + hb_interjob_t * interjob = hb_interjob_get( job->h ); + param.i_keyint_min = ( interjob->vrate / interjob->vrate_base ) + 1; + param.i_keyint_max = ( 10 * interjob->vrate / interjob->vrate_base ) + 1; + } + else + { + int fps = job->vrate / job->vrate_base; + + /* adjust +1 when fps has remainder to bump + { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */ + if (job->vrate % job->vrate_base) + fps += 1; + + param.i_keyint_min = fps; + param.i_keyint_max = fps * 10; + } + hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max); } @@ -195,8 +223,21 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) /* set up the VUI color model & gamma to match what the COLR atom * set in muxmp4.c says. See libhb/muxmp4.c for notes. */ - - if ( job->title->height >= 720 ) + if( job->color_matrix == 1 ) + { + // ITU BT.601 DVD or SD TV content + param.vui.i_colorprim = 6; + param.vui.i_transfer = 1; + param.vui.i_colmatrix = 6; + } + else if( job->color_matrix == 2 ) + { + // ITU BT.709 HD content + param.vui.i_colorprim = 1; + param.vui.i_transfer = 1; + param.vui.i_colmatrix = 1; + } + else if ( job->title->width >= 1280 || job->title->height >= 720 ) { // we guess that 720p or above is ITU BT.709 HD content param.vui.i_colorprim = 1; @@ -211,10 +252,10 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) param.vui.i_colmatrix = 6; } - if( job->pixel_ratio ) + if( job->anamorphic.mode ) { - param.vui.i_sar_width = job->pixel_aspect_width; - param.vui.i_sar_height = job->pixel_aspect_height; + param.vui.i_sar_width = job->anamorphic.par_width; + param.vui.i_sar_height = job->anamorphic.par_height; hb_log( "encx264: encoding with stored aspect %d/%d", param.vui.i_sar_width, param.vui.i_sar_height ); @@ -283,7 +324,7 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) } } - hb_log( "encx264: opening libx264 (pass %d)", job->pass ); + hb_deep_log( 2, "encx264: opening libx264 (pass %d)", job->pass ); pv->x264 = x264_encoder_open( ¶m ); x264_encoder_headers( pv->x264, &nal, &nal_count ); @@ -299,6 +340,7 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) x264_picture_alloc( &pv->pic_in, X264_CSP_I420, job->width, job->height ); + pv->pic_in.img.i_stride[2] = pv->pic_in.img.i_stride[1] = ( ( job->width + 1 ) >> 1 ); pv->x264_allocated_pic = pv->pic_in.img.plane[0]; if (job->areBframes) @@ -324,10 +366,14 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) pv->init_delay += 2; /* For VFR, libhb sees the FPS as 29.97, but the longest frames - will use the duration of frames running at 23.976fps instead.. */ - if (job->vfr) + will use the duration of frames running at 23.976fps instead. + Since detelecine occasionally makes mistakes and since we have + to deal with some really horrible timing jitter from mkvs and + mp4s encoded with low resolution clocks, make the delay very + conservative if we're not doing CFR. */ + if ( job->cfr != 1 ) { - pv->init_delay = 7506; + pv->init_delay *= 2; } /* The delay is 1 frames for regular b-frames, 2 for b-pyramid. */ @@ -341,6 +387,12 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) void encx264Close( hb_work_object_t * w ) { hb_work_private_t * pv = w->private_data; + + if ( pv->frames_split ) + { + hb_log( "encx264: %u frames had to be split (%u in, %u out)", + pv->frames_split, pv->frames_in, pv->frames_out ); + } /* * Patch the x264 allocated data back in so that x264 can free it * we have been using our own buffers during the encode to avoid copying. @@ -378,7 +430,7 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, hb_job_t *job = pv->job; /* Should be way too large */ - buf = hb_buffer_init( 3 * job->width * job->height / 2 ); + buf = hb_video_buffer_init( job->width, job->height ); buf->size = 0; buf->frametype = 0; @@ -413,12 +465,20 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, } /* H.264 in .mp4 or .mkv */ - int naltype = buf->data[buf->size+4] & 0x1f; - if ( naltype == 0x7 || naltype == 0x8 ) + switch( nal[i].i_type ) { - // Sequence Parameter Set & Program Parameter Set go in the - // mp4 header so skip them here - continue; + /* Sequence Parameter Set & Program Parameter Set go in the + * mp4 header so skip them here + */ + case NAL_SPS: + case NAL_PPS: + continue; + + case NAL_SLICE: + case NAL_SLICE_IDR: + case NAL_SEI: + default: + break; } /* H.264 in mp4 (stolen from mp4creator) */ @@ -473,6 +533,12 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) ) buf->frametype = HB_FRAME_BREF; + /* Expose disposable bit to muxer. */ + if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE ) + buf->flags &= ~HB_FRAME_REF; + else + buf->flags |= HB_FRAME_REF; + buf->size += size; } // make sure we found at least one video frame @@ -492,17 +558,18 @@ static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in ) /* Point x264 at our current buffers Y(UV) data. */ pv->pic_in.img.plane[0] = in->data; + int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 ); if( job->grayscale ) { /* XXX x264 has currently no option for grayscale encoding */ - memset( pv->pic_in.img.plane[1], 0x80, job->width * job->height / 4 ); - memset( pv->pic_in.img.plane[2], 0x80, job->width * job->height / 4 ); + memset( pv->pic_in.img.plane[1], 0x80, uvsize ); + memset( pv->pic_in.img.plane[2], 0x80, uvsize ); } else { /* Point x264 at our buffers (Y)UV data */ pv->pic_in.img.plane[1] = in->data + job->width * job->height; - pv->pic_in.img.plane[2] = in->data + 5 * job->width * job->height / 4; + pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize; } if( in->new_chap && job->chapter_markers ) { @@ -533,7 +600,7 @@ static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in ) */ if( pv->last_stop != in->start ) { - hb_log("encx264 input continuity err: last stop %lld start %lld", + hb_log("encx264 input continuity err: last stop %"PRId64" start %"PRId64, pv->last_stop, in->start); } pv->last_stop = in->stop; @@ -583,6 +650,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal ); if ( buf ) { + ++pv->frames_out; if ( last_buf == NULL ) *buf_out = buf; else @@ -601,6 +669,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, } // Not EOF - encode the packet & wrap it in a NAL + ++pv->frames_in; // if we're re-ordering frames, check if this frame is too large to reorder if ( pv->init_delay && in->stop - in->start > pv->init_delay ) @@ -616,6 +685,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, // error. We take advantage of the fact that x264 buffers frame // data internally to feed the same image into the encoder multiple // times, just changing its start & stop times each time. + ++pv->frames_split; int64_t orig_stop = in->stop; int64_t new_stop = in->start; hb_buffer_t *last_buf = NULL; @@ -642,6 +712,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_buffer_t *buf = x264_encode( w, in ); if ( buf ) { + ++pv->frames_out; if ( last_buf == NULL ) *buf_out = buf; else @@ -653,6 +724,7 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, } else { + ++pv->frames_out; *buf_out = x264_encode( w, in ); } return HB_WORK_OK;