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;
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;
+ 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);
}
param.vui.i_transfer = 1;
param.vui.i_colmatrix = 1;
}
- else if ( job->title->width >= 1280 || job->title->width >= 720 )
+ 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;
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 );
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)
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. */
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.
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;
}
/* 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) */
(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
/* 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 )
{
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
}
// 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 )
// 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;
hb_buffer_t *buf = x264_encode( w, in );
if ( buf )
{
+ ++pv->frames_out;
if ( last_buf == NULL )
*buf_out = buf;
else
}
else
{
+ ++pv->frames_out;
*buf_out = x264_encode( w, in );
}
return HB_WORK_OK;
OSDN Git Service
