X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fencx264.c;h=5e3fbc03c67029a80b647a4fe9939a600daae516;hb=d75166de2b31bb7743e7345e0105507656ce81fe;hp=caeccb646f8332309cfa851073c4387600d56310;hpb=1d9c122201261c9f3098a417ed140106e0d6ba0d;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/encx264.c b/libhb/encx264.c index caeccb64..5e3fbc03 100644 --- a/libhb/encx264.c +++ b/libhb/encx264.c @@ -50,11 +50,12 @@ 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 dts_next; // DTS start time value for next output frame int64_t last_stop; // Debugging - stop time of previous input frame int64_t init_delay; - int64_t max_delay; // if init_delay too small, delay really needed int64_t next_chap; struct { @@ -85,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); } @@ -110,9 +136,6 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) param.i_level_idc ); } - /* Slightly faster with minimal quality lost */ - param.analyse.i_subpel_refine = 4; - /* This section passes the string x264opts to libx264 for parsing into parameter names and values. @@ -200,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; @@ -216,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 ); @@ -288,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 ); @@ -304,11 +340,9 @@ 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]; - pv->dts_next = -1; - pv->next_chap = 0; - if (job->areBframes) { /* Basic initDelay value is the clockrate divided by the FPS @@ -332,15 +366,20 @@ 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. */ pv->init_delay *= job->areBframes; } + w->config->h264.init_delay = pv->init_delay; return 0; } @@ -348,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. @@ -384,34 +429,15 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, hb_work_private_t *pv = w->private_data; hb_job_t *job = pv->job; - /* Get next DTS value to use */ - int64_t dts_start = pv->dts_next; - - /* compute the stop time based on the original frame's duration */ - int64_t dts_stop = dts_start + get_frame_duration( pv, pic_out->i_pts ); - pv->dts_next = dts_stop; - /* 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; - buf->start = dts_start; - buf->stop = dts_stop; - /* Store the output presentation time stamp from x264 for use by muxmp4 - in off-setting b-frames with the CTTS atom. */ - buf->renderOffset = pic_out->i_pts - dts_start + pv->init_delay; - if ( buf->renderOffset < 0 ) - { - if ( dts_start - pic_out->i_pts > pv->max_delay ) - { - pv->max_delay = dts_start - pic_out->i_pts; - hb_log( "encx264: init_delay too small: " - "is %lld need %lld", pv->init_delay, - pv->max_delay ); - } - buf->renderOffset = 0; - } + // use the pts to get the original frame's duration. + int64_t duration = get_frame_duration( pv, pic_out->i_pts ); + buf->start = pic_out->i_pts; + buf->stop = pic_out->i_pts + duration; /* Encode all the NALs we were given into buf. NOTE: This code assumes one video frame per NAL (but there can @@ -439,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) */ @@ -499,13 +533,18 @@ 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 if ( buf->size <= 0 ) { - // no video: back up the output time stamp then free the buf - pv->dts_next = buf->start; + // no video - discard the buf hb_buffer_close( &buf ); } return buf; @@ -519,28 +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; - } - - if( pv->dts_next == -1 ) - { - /* we don't have a start time yet so use the first frame's - * start. All other frame times will be determined by the - * sum of the prior output frame durations in *DTS* order - * (not by the order they arrive here). This timing change is - * essential for VFR with b-frames but a complete nop otherwise. - */ - pv->dts_next = in->start; + pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize; } if( in->new_chap && job->chapter_markers ) { @@ -571,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; @@ -580,7 +609,7 @@ static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in ) // the x264_encoder_encode call (since it reorders frames). save_frame_info( pv, in ); - /* Feed the input DTS to x264 so it can figure out proper output PTS */ + /* Feed the input PTS to x264 so it can figure out proper output PTS */ pv->pic_in.i_pts = in->start; x264_picture_t pic_out; @@ -601,6 +630,8 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, hb_work_private_t *pv = w->private_data; hb_buffer_t *in = *buf_in; + *buf_out = NULL; + if( in->size <= 0 ) { // EOF on input. Flush any frames still in the decoder then @@ -617,11 +648,15 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, break; hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal ); - if ( last_buf == NULL ) - *buf_out = buf; - else - last_buf->next = buf; - last_buf = buf; + if ( buf ) + { + ++pv->frames_out; + if ( last_buf == NULL ) + *buf_out = buf; + else + last_buf->next = buf; + last_buf = buf; + } } // Flushed everything - add the eof to the end of the chain. if ( last_buf == NULL ) @@ -634,6 +669,9 @@ 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 ) { // This frame's duration is larger than the time allotted for b-frame @@ -647,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; @@ -671,16 +710,21 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, new_stop = orig_stop; in->stop = new_stop; hb_buffer_t *buf = x264_encode( w, in ); - if ( last_buf == NULL ) - *buf_out = buf; - else - last_buf->next = buf; - last_buf = buf; + if ( buf ) + { + ++pv->frames_out; + if ( last_buf == NULL ) + *buf_out = buf; + else + last_buf->next = buf; + last_buf = buf; + } in->start = new_stop; } } else { + ++pv->frames_out; *buf_out = x264_encode( w, in ); } return HB_WORK_OK;