encx264Close
};
-// 16 is probably overkill but it's also the maximum for h.264 reference frames
-#define MAX_INFLIGHT_FRAMES 16
+#define DTS_BUFFER_SIZE 32
struct hb_work_private_s
{
hb_job_t * job;
x264_t * x264;
x264_picture_t pic_in;
+ uint8_t *x264_allocated_pic;
// Internal queue of DTS start/stop values.
- int64_t dts_start[MAX_INFLIGHT_FRAMES];
- int64_t dts_stop[MAX_INFLIGHT_FRAMES];
+ int64_t dts_start[DTS_BUFFER_SIZE];
+ int64_t dts_stop[DTS_BUFFER_SIZE];
+ int64_t init_delay;
int64_t dts_write_index;
int64_t dts_read_index;
+ int64_t next_chap;
char filename[1024];
};
param.i_height = job->height;
param.i_fps_num = job->vrate;
param.i_fps_den = job->vrate_base;
- param.i_keyint_max = 20 * job->vrate / job->vrate_base;
+
+ 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;
+ hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max);
+ }
+
param.i_log_level = X264_LOG_INFO;
if( job->h264_level )
{
Merritt implemented in the Mplayer/Mencoder project.
*/
- char *x264opts = job->x264opts;
- if( x264opts != NULL && *x264opts != '\0' )
+ if( job->x264opts != NULL && *job->x264opts != '\0' )
{
- while( *x264opts )
+ char *x264opts, *x264opts_start;
+
+ x264opts = x264opts_start = strdup(job->x264opts);
+
+ while( x264opts_start && *x264opts )
{
char *name = x264opts;
char *value;
if( ret == X264_PARAM_BAD_VALUE )
hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
}
+ free(x264opts_start);
}
memcpy( &w->config->h264.pps[1], nal[2].p_payload, nal[2].i_payload );
x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
- job->width, job->height );
+ job->width, job->height );
+
+ pv->x264_allocated_pic = pv->pic_in.img.plane[0];
pv->dts_write_index = 0;
pv->dts_read_index = 0;
+ pv->next_chap = 0;
+
+ if (job->areBframes)
+ {
+ /* Basic initDelay value is the clockrate divided by the FPS
+ -- the length of one frame in clockticks. */
+ pv->init_delay = (float)90000 / (float)((float)job->vrate / (float)job->vrate_base);
+
+ /* 23.976-length frames are 3753.75 ticks long. That means 25%
+ will come out as 3753, 75% will be 3754. The delay has to be
+ the longest possible frame duration, 3754. However, 3753.75
+ gets truncated to 3753, so if that's what it is, ++ it. */
+ if (pv->init_delay == 3753)
+ pv->init_delay++;
+
+ /* 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)
+ {
+ pv->init_delay = 3754;
+ }
+
+ /* The delay is 2 frames for regular b-frames, 3 for b-pyramid.
+ Since job->areBframes is 1 for b-frames and 2 for b-pyramid,
+ add one to it and use it as a multiplier. */
+ pv->init_delay *= ( job->areBframes + 1);
+ }
return 0;
}
void encx264Close( hb_work_object_t * w )
{
hb_work_private_t * pv = w->private_data;
+ /*
+ * 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.
+ */
+ pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
x264_picture_clean( &pv->pic_in );
x264_encoder_close( pv->x264 );
free( pv );
if( in->data )
{
- /* XXX avoid this memcpy ? */
- memcpy( pv->pic_in.img.plane[0], in->data, job->width * job->height );
+ /*
+ * Point x264 at our current buffers Y(UV) data.
+ */
+ pv->pic_in.img.plane[0] = in->data;
+
if( job->grayscale )
{
/* XXX x264 has currently no option for grayscale encoding */
}
else
{
- memcpy( pv->pic_in.img.plane[1], in->data + job->width * job->height,
- job->width * job->height / 4 );
- memcpy( pv->pic_in.img.plane[2], in->data + 5 * job->width *
- job->height / 4, job->width * job->height / 4 );
+ /*
+ * 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.i_type = X264_TYPE_AUTO;
+ if( in->new_chap && job->chapter_markers )
+ {
+ /* chapters have to start with an IDR frame so request that this
+ frame be coded as IDR. Since there may be up to 16 frames
+ currently buffered in the encoder remember the timestamp so
+ when this frame finally pops out of the encoder we'll mark
+ its buffer as the start of a chapter. */
+ pv->pic_in.i_type = X264_TYPE_IDR;
+ if( pv->next_chap == 0 )
+ {
+ pv->next_chap = in->start;
+ }
+ /* don't let 'work_loop' put a chapter mark on the wrong buffer */
+ in->new_chap = 0;
+ }
+ else
+ {
+ pv->pic_in.i_type = X264_TYPE_AUTO;
+ }
pv->pic_in.i_qpplus1 = 0;
// Remember current PTS value, use as DTS later
- pv->dts_start[pv->dts_write_index & (MAX_INFLIGHT_FRAMES-1)] = in->start;
- pv->dts_stop[pv->dts_write_index & (MAX_INFLIGHT_FRAMES-1)] = in->stop;
+ pv->dts_start[pv->dts_write_index & (DTS_BUFFER_SIZE-1)] = in->start;
+ pv->dts_stop[pv->dts_write_index & (DTS_BUFFER_SIZE-1)] = in->stop;
pv->dts_write_index++;
/* Feed the input DTS to x264 so it can figure out proper output PTS */
int64_t dts_start, dts_stop;
/* Get next DTS value to use */
- dts_start = pv->dts_start[pv->dts_read_index & (MAX_INFLIGHT_FRAMES-1)];
- dts_stop = pv->dts_stop[pv->dts_read_index & (MAX_INFLIGHT_FRAMES-1)];
+ dts_start = pv->dts_start[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
+ dts_stop = pv->dts_stop[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
pv->dts_read_index++;
for( i = 0; i < i_nal; i++ )
/* Decide what type of frame we have. */
case X264_TYPE_IDR:
buf->frametype = HB_FRAME_IDR;
+ /* if we have a chapter marker pending and this
+ frame's presentation time stamp is at or after
+ the marker's time stamp, use this as the
+ chapter start. */
+ if( pv->next_chap != 0 && pv->next_chap <= pic_out.i_pts )
+ {
+ pv->next_chap = 0;
+ buf->new_chap = 1;
+ }
break;
case X264_TYPE_I:
buf->frametype = HB_FRAME_I;
value is pretty much guaranteed to be positive. The
muxing code will minimize the renderOffset at the end. */
- buf->renderOffset = pic_out.i_pts - dts_start + 1000000;
+ buf->renderOffset = pic_out.i_pts - dts_start + pv->init_delay;
/* Send out the next dts values */
buf->start = dts_start;
OSDN Git Service
