X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=libhb%2Fencx264.c;h=91b53f7646d6222eed947c102e8d41da70e5cae2;hb=55b0015a8c50106e553bc2f48336cc2a1c495459;hp=d237d913d6a444007fb705868d030ef77aa49979;hpb=46975e3e5b6a295fdddb7a86aa2db0c75d2c5856;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/libhb/encx264.c b/libhb/encx264.c index d237d913..91b53f76 100644 --- a/libhb/encx264.c +++ b/libhb/encx264.c @@ -55,7 +55,6 @@ struct hb_work_private_s 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; int64_t next_chap; struct { @@ -124,6 +123,9 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) } } + /* Temporary hack to use old b-pyramid default */ + param.i_bframe_pyramid = X264_B_PYRAMID_NONE; + /* Enable metrics */ param.analyse.b_psnr = 1; param.analyse.b_ssim = 1; @@ -133,6 +135,17 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) param.i_height = job->height; param.i_fps_num = job->vrate; param.i_fps_den = job->vrate_base; + if ( job->cfr == 1 ) + { + param.i_timebase_num = 0; + param.i_timebase_den = 0; + param.b_vfr_input = 0; + } + else + { + param.i_timebase_num = 1; + param.i_timebase_den = 90000; + } /* Disable annexb. Inserts size into nal header instead of start code */ param.b_annexb = 0; @@ -148,20 +161,13 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) 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; + param.i_keyint_max = ( ( 10 * (double)interjob->vrate / (double)interjob->vrate_base ) + 0.5 ); } else { - int fps = job->vrate / job->vrate_base; - - /* adjust +1 when fps has remainder to bump + /* adjust +0.5 for 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; + param.i_keyint_max = ( ( 10 * (double)job->vrate / (double)job->vrate_base ) + 0.5 ); } } @@ -242,12 +248,12 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) /* B-frames are on by default.*/ job->areBframes = 1; - if(!param.rc.b_mb_tree && param.i_bframe && param.i_bframe_pyramid) + if( param.i_bframe && param.i_bframe_pyramid ) { /* Note b-pyramid here, so the initial delay can be doubled */ job->areBframes = 2; } - else if (!param.i_bframe) + else if( !param.i_bframe ) { /* When B-frames are enabled, the max frame count increments @@ -259,8 +265,9 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) job->areBframes = 0; } - if (param.i_keyint_min != 25 || param.i_keyint_max != 250) - hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max); + if( param.i_keyint_min != X264_KEYINT_MIN_AUTO || param.i_keyint_max != 250 ) + hb_log("encx264: min-keyint: %i, keyint: %i", param.i_keyint_min == X264_KEYINT_MIN_AUTO ? param.i_keyint_max / 10 : param.i_keyint_min, + param.i_keyint_max); /* set up the VUI color model & gamma to match what the COLR atom * set in muxmp4.c says. See libhb/muxmp4.c for notes. */ @@ -343,12 +350,12 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) x264_encoder_headers( pv->x264, &nal, &nal_count ); /* Sequence Parameter Set */ - memcpy(w->config->h264.sps, nal[1].p_payload + 4, nal[1].i_payload - 4); - w->config->h264.sps_length = nal[1].i_payload - 4; + memcpy(w->config->h264.sps, nal[0].p_payload + 4, nal[0].i_payload - 4); + w->config->h264.sps_length = nal[0].i_payload - 4; /* Picture Parameter Set */ - memcpy(w->config->h264.pps, nal[2].p_payload + 4, nal[2].i_payload - 4); - w->config->h264.pps_length = nal[2].i_payload - 4; + memcpy(w->config->h264.pps, nal[1].p_payload + 4, nal[1].i_payload - 4); + w->config->h264.pps_length = nal[1].i_payload - 4; x264_picture_alloc( &pv->pic_in, X264_CSP_I420, job->width, job->height ); @@ -356,44 +363,6 @@ int encx264Init( hb_work_object_t * w, hb_job_t * job ) 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) - { - /* Basic initDelay value is the clockrate divided by the FPS - -- the length of one frame in clockticks. */ - pv->init_delay = 90000. / ((double)job->vrate / (double)job->vrate_base); - - /* 23.976-length frames are 3753.75 ticks long on average but the DVD - creates that average rate by repeating 59.95 fields so the max - frame size is actually 4504.5 (3 field times). The field durations - are computed based on quantized times (see below) so we need an extra - two ticks to account for the rounding. */ - if (pv->init_delay == 3753) - pv->init_delay = 4507; - - /* frame rates are not exact in the DVD 90KHz PTS clock (they are - exact in the DVD 27MHz system clock but we never see that) so the - rates computed above are all +-1 due to quantization. Worst case - is when a clock-rounded-down frame is adjacent to a rounded-up frame - which makes one of the frames 2 ticks longer than the nominal - frame time. */ - 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. - 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 *= 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; } @@ -451,6 +420,11 @@ static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out, int64_t duration = get_frame_duration( pv, pic_out->i_pts ); buf->start = pic_out->i_pts; buf->stop = pic_out->i_pts + duration; + buf->renderOffset = pic_out->i_dts; + if ( !w->config->h264.init_delay && pic_out->i_dts < 0 ) + { + w->config->h264.init_delay = -pic_out->i_dts; + } /* Encode all the NALs we were given into buf. NOTE: This code assumes one video frame per NAL (but there can @@ -648,10 +622,12 @@ int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in, x264_nal_t *nal; hb_buffer_t *last_buf = NULL; - while (1) + while ( x264_encoder_delayed_frames( pv->x264 ) ) { x264_encoder_encode( pv->x264, &nal, &i_nal, NULL, &pic_out ); - if ( i_nal <= 0 ) + if ( i_nal == 0 ) + continue; + if ( i_nal < 0 ) break; hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal ); @@ -677,62 +653,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 ) - { - // This frame's duration is larger than the time allotted for b-frame - // reordering. That means that if it's used as a reference the decoder - // won't be able to move it early enough to render it in correct - // sequence & the playback will have odd jumps & twitches. To make - // sure this doesn't happen we pretend this frame is multiple - // frames, each with duration <= init_delay. Since each of these - // new frames contains the same image the visual effect is identical - // to the original but the resulting stream can now be coded without - // 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; - - // We want to spread the new frames uniformly over the total time - // so that we don't end up with a very short frame at the end. - // In the number of pieces calculation we add in init_delay-1 to - // round up but not add an extra piece if the frame duration is - // a multiple of init_delay. The final increment of frame_dur is - // to restore the bits that got truncated by the divide on the - // previous line. If we don't do this we end up with an extra tiny - // frame at the end whose duration is npieces-1. - int64_t frame_dur = orig_stop - new_stop; - int64_t npieces = ( frame_dur + pv->init_delay - 1 ) / pv->init_delay; - frame_dur /= npieces; - ++frame_dur; - - while ( in->start < orig_stop ) - { - new_stop += frame_dur; - if ( new_stop > orig_stop ) - new_stop = orig_stop; - in->stop = new_stop; - hb_buffer_t *buf = x264_encode( w, in ); - 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 ); - } + ++pv->frames_out; + *buf_out = x264_encode( w, in ); return HB_WORK_OK; }