1 /* $Id: encx264.c,v 1.21 2005/11/04 13:09:41 titer Exp $
3 This file is part of the HandBrake source code.
4 Homepage: <http://handbrake.m0k.org/>.
5 It may be used under the terms of the GNU General Public License. */
13 int encx264Init( hb_work_object_t *, hb_job_t * );
14 int encx264Work( hb_work_object_t *, hb_buffer_t **, hb_buffer_t ** );
15 void encx264Close( hb_work_object_t * );
17 hb_work_object_t hb_encx264 =
20 "H.264/AVC encoder (libx264)",
26 #define DTS_BUFFER_SIZE 32
28 struct hb_work_private_s
32 x264_picture_t pic_in;
33 uint8_t *x264_allocated_pic;
35 // Internal queue of DTS start/stop values.
36 int64_t dts_start[DTS_BUFFER_SIZE];
37 int64_t dts_stop[DTS_BUFFER_SIZE];
39 int64_t dts_write_index;
40 int64_t dts_read_index;
46 /***********************************************************************
47 * hb_work_encx264_init
48 ***********************************************************************
50 **********************************************************************/
51 int encx264Init( hb_work_object_t * w, hb_job_t * job )
57 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
62 memset( pv->filename, 0, 1024 );
63 hb_get_tempory_filename( job->h, pv->filename, "x264.log" );
65 x264_param_default( ¶m );
67 param.i_threads = ( hb_get_cpu_count() * 3 / 2 );
68 param.i_width = job->width;
69 param.i_height = job->height;
70 param.i_fps_num = job->vrate;
71 param.i_fps_den = job->vrate_base;
73 if (job->vrate_base != 1080000)
75 /* If the fps isn't 25, adjust the key intervals. Add 1 because
76 we want 24, not 23 with a truncated remainder. */
77 param.i_keyint_min = (job->vrate / job->vrate_base) + 1;
78 param.i_keyint_max = (10 * job->vrate / job->vrate_base) + 1;
79 hb_log("encx264: keyint-min: %i, keyint-max: %i", param.i_keyint_min, param.i_keyint_max);
82 param.i_log_level = X264_LOG_INFO;
86 param.i_level_idc = job->h264_level;
87 hb_log( "encx264: encoding at level %i",
91 /* Slightly faster with minimal quality lost */
92 param.analyse.i_subpel_refine = 4;
95 This section passes the string x264opts to libx264 for parsing into
96 parameter names and values.
98 The string is set up like this:
99 option1=value1:option2=value 2
101 So, you have to iterate through based on the colons, and then put
102 the left side of the equals sign in "name" and the right side into
103 "value." Then you hand those strings off to x264 for interpretation.
105 This is all based on the universal x264 option handling Loren
106 Merritt implemented in the Mplayer/Mencoder project.
109 if( job->x264opts != NULL && *job->x264opts != '\0' )
111 char *x264opts, *x264opts_start;
113 x264opts = x264opts_start = strdup(job->x264opts);
115 while( x264opts_start && *x264opts )
117 char *name = x264opts;
121 x264opts += strcspn( x264opts, ":" );
128 value = strchr( name, '=' );
136 When B-frames are enabled, the max frame count increments
137 by 1 (regardless of the number of B-frames). If you don't
138 change the duration of the video track when you mux, libmp4
139 barfs. So, check if the x264opts are using B-frames, and
140 when they are, set the boolean job->areBframes as true.
143 if( !( strcmp( name, "bframes" ) ) )
145 if( atoi( value ) > 0 )
151 /* Note b-pyramid here, so the initial delay can be doubled */
152 if( !( strcmp( name, "b-pyramid" ) ) )
156 if( atoi( value ) > 0 )
167 /* Here's where the strings are passed to libx264 for parsing. */
168 ret = x264_param_parse( ¶m, name, value );
170 /* Let x264 sanity check the options for us*/
171 if( ret == X264_PARAM_BAD_NAME )
172 hb_log( "x264 options: Unknown suboption %s", name );
173 if( ret == X264_PARAM_BAD_VALUE )
174 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
176 free(x264opts_start);
180 if( job->pixel_ratio )
182 param.vui.i_sar_width = job->pixel_aspect_width;
183 param.vui.i_sar_height = job->pixel_aspect_height;
185 hb_log( "encx264: encoding with stored aspect %d/%d",
186 param.vui.i_sar_width, param.vui.i_sar_height );
190 if( job->vquality >= 0.0 && job->vquality <= 1.0 )
196 param.rc.i_rc_method = X264_RC_CRF;
197 param.rc.f_rf_constant = 51 - job->vquality * 51;
198 hb_log( "encx264: Encoding at constant RF %f",
199 param.rc.f_rf_constant );
204 param.rc.i_rc_method = X264_RC_CQP;
205 param.rc.i_qp_constant = 51 - job->vquality * 51;
206 hb_log( "encx264: encoding at constant QP %d",
207 param.rc.i_qp_constant );
214 param.rc.i_rc_method = X264_RC_ABR;
215 param.rc.i_bitrate = job->vbitrate;
219 param.rc.b_stat_write = 1;
220 param.rc.psz_stat_out = pv->filename;
223 param.rc.b_stat_read = 1;
224 param.rc.psz_stat_in = pv->filename;
229 hb_log( "encx264: opening libx264 (pass %d)", job->pass );
230 pv->x264 = x264_encoder_open( ¶m );
232 x264_encoder_headers( pv->x264, &nal, &nal_count );
234 /* Sequence Parameter Set */
235 w->config->h264.sps_length = 1 + nal[1].i_payload;
236 w->config->h264.sps[0] = 0x67;
237 memcpy( &w->config->h264.sps[1], nal[1].p_payload, nal[1].i_payload );
239 /* Picture Parameter Set */
240 w->config->h264.pps_length = 1 + nal[2].i_payload;
241 w->config->h264.pps[0] = 0x68;
242 memcpy( &w->config->h264.pps[1], nal[2].p_payload, nal[2].i_payload );
244 x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
245 job->width, job->height );
247 pv->x264_allocated_pic = pv->pic_in.img.plane[0];
249 pv->dts_write_index = 0;
250 pv->dts_read_index = 0;
256 void encx264Close( hb_work_object_t * w )
258 hb_work_private_t * pv = w->private_data;
260 * Patch the x264 allocated data back in so that x264 can free it
261 * we have been using our own buffers during the encode to avoid copying.
263 pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
264 x264_picture_clean( &pv->pic_in );
265 x264_encoder_close( pv->x264 );
267 w->private_data = NULL;
272 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
273 hb_buffer_t ** buf_out )
275 hb_work_private_t * pv = w->private_data;
276 hb_job_t * job = pv->job;
277 hb_buffer_t * in = *buf_in, * buf;
278 x264_picture_t pic_out;
286 * Point x264 at our current buffers Y(UV) data.
288 pv->pic_in.img.plane[0] = in->data;
292 /* XXX x264 has currently no option for grayscale encoding */
293 memset( pv->pic_in.img.plane[1], 0x80, job->width * job->height / 4 );
294 memset( pv->pic_in.img.plane[2], 0x80, job->width * job->height / 4 );
299 * Point x264 at our buffers (Y)UV data
301 pv->pic_in.img.plane[1] = in->data + job->width * job->height;
302 pv->pic_in.img.plane[2] = in->data + 5 * job->width *
306 if( in->new_chap && job->chapter_markers )
308 /* chapters have to start with an IDR frame so request that this
309 frame be coded as IDR. Since there may be up to 16 frames
310 currently buffered in the encoder remember the timestamp so
311 when this frame finally pops out of the encoder we'll mark
312 its buffer as the start of a chapter. */
313 pv->pic_in.i_type = X264_TYPE_IDR;
314 if( pv->next_chap == 0 )
316 pv->next_chap = in->start;
318 /* don't let 'work_loop' put a chapter mark on the wrong buffer */
323 pv->pic_in.i_type = X264_TYPE_AUTO;
325 pv->pic_in.i_qpplus1 = 0;
327 // Remember current PTS value, use as DTS later
328 pv->dts_start[pv->dts_write_index & (DTS_BUFFER_SIZE-1)] = in->start;
329 pv->dts_stop[pv->dts_write_index & (DTS_BUFFER_SIZE-1)] = in->stop;
330 pv->dts_write_index++;
332 /* Feed the input DTS to x264 so it can figure out proper output PTS */
333 pv->pic_in.i_pts = in->start;
335 x264_encoder_encode( pv->x264, &nal, &i_nal,
336 &pv->pic_in, &pic_out );
340 x264_encoder_encode( pv->x264, &nal, &i_nal,
342 /* No more delayed B frames */
350 /* Since we output at least one more frame, drop another empty
351 one onto our input fifo. We'll keep doing this automatically
352 until we stop getting frames out of the encoder. */
353 hb_fifo_push(w->fifo_in, hb_buffer_init(0));
359 /* Should be way too large */
360 buf = hb_buffer_init( 3 * job->width * job->height / 2 );
362 buf->start = in->start;
363 buf->stop = in->stop;
366 int64_t dts_start, dts_stop;
368 /* Get next DTS value to use */
369 dts_start = pv->dts_start[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
370 dts_stop = pv->dts_stop[pv->dts_read_index & (DTS_BUFFER_SIZE-1)];
371 pv->dts_read_index++;
373 for( i = 0; i < i_nal; i++ )
377 data = buf->alloc - buf->size;
378 if( ( size = x264_nal_encode( buf->data + buf->size, &data,
384 if( job->mux & HB_MUX_AVI )
386 if( nal[i].i_ref_idc == NAL_PRIORITY_HIGHEST )
388 buf->frametype = HB_FRAME_KEY;
395 switch( buf->data[buf->size+4] & 0x1f )
403 /* H.264 in mp4 (stolen from mp4creator) */
404 buf->data[buf->size+0] = ( ( size - 4 ) >> 24 ) & 0xFF;
405 buf->data[buf->size+1] = ( ( size - 4 ) >> 16 ) & 0xFF;
406 buf->data[buf->size+2] = ( ( size - 4 ) >> 8 ) & 0xFF;
407 buf->data[buf->size+3] = ( ( size - 4 ) >> 0 ) & 0xFF;
408 switch( pic_out.i_type )
410 /* Decide what type of frame we have. */
412 buf->frametype = HB_FRAME_IDR;
413 /* if we have a chapter marker pending and this
414 frame's presentation time stamp is at or after
415 the marker's time stamp, use this as the
417 if( pv->next_chap != 0 && pv->next_chap <= pic_out.i_pts )
424 buf->frametype = HB_FRAME_I;
427 buf->frametype = HB_FRAME_P;
430 buf->frametype = HB_FRAME_B;
432 /* This is for b-pyramid, which has reference b-frames
433 However, it doesn't seem to ever be used... */
435 buf->frametype = HB_FRAME_BREF;
437 /* If it isn't the above, what type of frame is it?? */
443 /* Store the output presentation time stamp
444 from x264 for use by muxmp4 in off-setting
445 b-frames with the CTTS atom.
446 For now, just add 1000000 to the offset so that the
447 value is pretty much guaranteed to be positive. The
448 muxing code will minimize the renderOffset at the end. */
450 buf->renderOffset = pic_out.i_pts - dts_start + 1000000;
452 /* Send out the next dts values */
453 buf->start = dts_start;
454 buf->stop = dts_stop;