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 {
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;
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 );
}
}
value++;
}
- if( !( strcmp( name, "b-pyramid" ) ) )
- {
- if( value == NULL || !strcmp( value, "1" ) )
- {
- value = "normal";
- }
- else if( !strcmp( value, "0" ) )
- {
- value = "none";
- }
- }
-
/* Here's where the strings are passed to libx264 for parsing. */
ret = x264_param_parse( ¶m, name, value );
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. */
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 );
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;
}
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
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 );
// 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;
}
OSDN Git Service
