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.fr/>.
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
29 * The frame info struct remembers information about each frame across calls
30 * to x264_encoder_encode. Since frames are uniquely identified by their
31 * timestamp, we use some bits of the timestamp as an index. The LSB is
32 * chosen so that two successive frames will have different values in the
33 * bits over any plausible range of frame rates. (Starting with bit 8 allows
34 * any frame rate slower than 352fps.) The MSB determines the size of the array.
35 * It is chosen so that two frames can't use the same slot during the
36 * encoder's max frame delay (set by the standard as 16 frames) and so
37 * that, up to some minimum frame rate, frames are guaranteed to map to
38 * different slots. (An MSB of 17 which is 2^(17-8+1) = 1024 slots guarantees
39 * no collisions down to a rate of .7 fps).
41 #define FRAME_INFO_MAX2 (8) // 2^8 = 256; 90000/256 = 352 frames/sec
42 #define FRAME_INFO_MIN2 (17) // 2^17 = 128K; 90000/131072 = 1.4 frames/sec
43 #define FRAME_INFO_SIZE (1 << (FRAME_INFO_MIN2 - FRAME_INFO_MAX2 + 1))
44 #define FRAME_INFO_MASK (FRAME_INFO_SIZE - 1)
46 struct hb_work_private_s
50 x264_picture_t pic_in;
55 uint32_t frames_split; // number of frames we had to split
56 int chap_mark; // saved chap mark when we're propagating it
57 int64_t last_stop; // Debugging - stop time of previous input frame
62 } frame_info[FRAME_INFO_SIZE];
67 /***********************************************************************
68 * hb_work_encx264_init
69 ***********************************************************************
71 **********************************************************************/
72 int encx264Init( hb_work_object_t * w, hb_job_t * job )
78 hb_work_private_t * pv = calloc( 1, sizeof( hb_work_private_t ) );
83 memset( pv->filename, 0, 1024 );
84 hb_get_tempory_filename( job->h, pv->filename, "x264.log" );
86 x264_param_default( ¶m );
89 param.analyse.b_psnr = 1;
90 param.analyse.b_ssim = 1;
92 /* QuickTime has trouble with very low QPs (resulting in visual artifacts).
93 * Known to affect QuickTime 7, QuickTime X and iTunes.
94 * Testing shows that a qpmin of 3 works.
96 param.rc.i_qp_min = 3;
98 param.i_threads = ( hb_get_cpu_count() * 3 / 2 );
99 param.i_width = job->width;
100 param.i_height = job->height;
101 param.i_fps_num = job->vrate;
102 param.i_fps_den = job->vrate_base;
105 param.i_timebase_num = 0;
106 param.i_timebase_den = 0;
107 param.b_vfr_input = 0;
111 param.i_timebase_num = 1;
112 param.i_timebase_den = 90000;
115 /* Disable annexb. Inserts size into nal header instead of start code */
118 /* Set min:max key intervals ratio to 1:10 of fps.
119 * This section is skipped if fps=25 (default).
121 if (job->vrate_base != 1080000)
123 if (job->pass == 2 && !job->cfr )
125 /* Even though the framerate might be different due to VFR,
126 we still want the same keyframe intervals as the 1st pass,
127 so the 1st pass stats won't conflict on frame decisions. */
128 hb_interjob_t * interjob = hb_interjob_get( job->h );
129 param.i_keyint_max = 10 * (int)( (double)interjob->vrate / (double)interjob->vrate_base + 0.5 );
133 /* adjust +0.5 for when fps has remainder to bump
134 { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */
135 param.i_keyint_max = 10 * (int)( (double)job->vrate / (double)job->vrate_base + 0.5 );
139 param.i_log_level = X264_LOG_INFO;
142 This section passes the string x264opts to libx264 for parsing into
143 parameter names and values.
145 The string is set up like this:
146 option1=value1:option2=value 2
148 So, you have to iterate through based on the colons, and then put
149 the left side of the equals sign in "name" and the right side into
150 "value." Then you hand those strings off to x264 for interpretation.
152 This is all based on the universal x264 option handling Loren
153 Merritt implemented in the Mplayer/Mencoder project.
156 if( job->x264opts != NULL && *job->x264opts != '\0' )
158 char *x264opts, *x264opts_start;
160 x264opts = x264opts_start = strdup(job->x264opts);
162 while( x264opts_start && *x264opts )
164 char *name = x264opts;
168 x264opts += strcspn( x264opts, ":" );
175 value = strchr( name, '=' );
182 /* Here's where the strings are passed to libx264 for parsing. */
183 ret = x264_param_parse( ¶m, name, value );
185 /* Let x264 sanity check the options for us*/
186 if( ret == X264_PARAM_BAD_NAME )
187 hb_log( "x264 options: Unknown suboption %s", name );
188 if( ret == X264_PARAM_BAD_VALUE )
189 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
191 free(x264opts_start);
194 /* B-frames are on by default.*/
197 if( param.i_bframe && param.i_bframe_pyramid )
199 /* Note b-pyramid here, so the initial delay can be doubled */
202 else if( !param.i_bframe )
205 When B-frames are enabled, the max frame count increments
206 by 1 (regardless of the number of B-frames). If you don't
207 change the duration of the video track when you mux, libmp4
208 barfs. So, check if the x264opts aren't using B-frames, and
209 when they aren't, set the boolean job->areBframes as false.
214 if( param.i_keyint_min != X264_KEYINT_MIN_AUTO || param.i_keyint_max != 250 )
218 if ( param.i_fps_num / param.i_fps_den < param.i_keyint_max / 10 )
219 min_auto = param.i_fps_num / param.i_fps_den;
221 min_auto = param.i_keyint_max / 10;
223 char min[40], max[40];
224 param.i_keyint_min == X264_KEYINT_MIN_AUTO ?
225 snprintf( min, 40, "auto (%d)", min_auto ) :
226 snprintf( min, 40, "%d", param.i_keyint_min );
228 param.i_keyint_max == X264_KEYINT_MAX_INFINITE ?
229 snprintf( max, 40, "infinite" ) :
230 snprintf( max, 40, "%d", param.i_keyint_max );
232 hb_log( "encx264: min-keyint: %s, keyint: %s", min, max );
235 /* set up the VUI color model & gamma to match what the COLR atom
236 * set in muxmp4.c says. See libhb/muxmp4.c for notes. */
237 if( job->color_matrix == 1 )
239 // ITU BT.601 DVD or SD TV content
240 param.vui.i_colorprim = 6;
241 param.vui.i_transfer = 1;
242 param.vui.i_colmatrix = 6;
244 else if( job->color_matrix == 2 )
246 // ITU BT.709 HD content
247 param.vui.i_colorprim = 1;
248 param.vui.i_transfer = 1;
249 param.vui.i_colmatrix = 1;
251 else if ( job->title->width >= 1280 || job->title->height >= 720 )
253 // we guess that 720p or above is ITU BT.709 HD content
254 param.vui.i_colorprim = 1;
255 param.vui.i_transfer = 1;
256 param.vui.i_colmatrix = 1;
260 // ITU BT.601 DVD or SD TV content
261 param.vui.i_colorprim = 6;
262 param.vui.i_transfer = 1;
263 param.vui.i_colmatrix = 6;
266 if( job->anamorphic.mode )
268 param.vui.i_sar_width = job->anamorphic.par_width;
269 param.vui.i_sar_height = job->anamorphic.par_height;
271 hb_log( "encx264: encoding with stored aspect %d/%d",
272 param.vui.i_sar_width, param.vui.i_sar_height );
276 if( job->vquality > 0.0 && job->vquality < 1.0 )
279 param.rc.i_rc_method = X264_RC_CRF;
280 param.rc.f_rf_constant = 51 - job->vquality * 51;
281 hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
283 else if( job->vquality == 0 || job->vquality >= 1.0 )
285 /* Use the vquality as a raw RF or QP
286 instead of treating it like a percentage. */
288 param.rc.i_rc_method = X264_RC_CRF;
289 param.rc.f_rf_constant = job->vquality;
290 hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
295 param.rc.i_rc_method = X264_RC_ABR;
296 param.rc.i_bitrate = job->vbitrate;
300 param.rc.b_stat_write = 1;
301 param.rc.psz_stat_out = pv->filename;
304 param.rc.b_stat_read = 1;
305 param.rc.psz_stat_in = pv->filename;
310 hb_deep_log( 2, "encx264: opening libx264 (pass %d)", job->pass );
311 pv->x264 = x264_encoder_open( ¶m );
313 x264_encoder_headers( pv->x264, &nal, &nal_count );
315 /* Sequence Parameter Set */
316 memcpy(w->config->h264.sps, nal[0].p_payload + 4, nal[0].i_payload - 4);
317 w->config->h264.sps_length = nal[0].i_payload - 4;
319 /* Picture Parameter Set */
320 memcpy(w->config->h264.pps, nal[1].p_payload + 4, nal[1].i_payload - 4);
321 w->config->h264.pps_length = nal[1].i_payload - 4;
323 x264_picture_init( &pv->pic_in );
325 pv->pic_in.img.i_csp = X264_CSP_I420;
326 pv->pic_in.img.i_plane = 3;
327 pv->pic_in.img.i_stride[0] = job->width;
328 pv->pic_in.img.i_stride[2] = pv->pic_in.img.i_stride[1] = ( ( job->width + 1 ) >> 1 );
332 int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 );
333 pv->grey_data = malloc( uvsize );
334 memset( pv->grey_data, 0x80, uvsize );
335 pv->pic_in.img.plane[1] = pv->pic_in.img.plane[2] = pv->grey_data;
341 void encx264Close( hb_work_object_t * w )
343 hb_work_private_t * pv = w->private_data;
345 if ( pv->frames_split )
347 hb_log( "encx264: %u frames had to be split (%u in, %u out)",
348 pv->frames_split, pv->frames_in, pv->frames_out );
350 free( pv->grey_data );
351 x264_encoder_close( pv->x264 );
353 w->private_data = NULL;
359 * see comments in definition of 'frame_info' in pv struct for description
360 * of what these routines are doing.
362 static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
364 int i = (in->start >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
365 pv->frame_info[i].duration = in->stop - in->start;
368 static int64_t get_frame_duration( hb_work_private_t * pv, int64_t pts )
370 int i = (pts >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
371 return pv->frame_info[i].duration;
374 static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out,
375 int i_nal, x264_nal_t *nal )
377 hb_buffer_t *buf = NULL;
378 hb_work_private_t *pv = w->private_data;
379 hb_job_t *job = pv->job;
381 /* Should be way too large */
382 buf = hb_video_buffer_init( job->width, job->height );
386 // use the pts to get the original frame's duration.
387 int64_t duration = get_frame_duration( pv, pic_out->i_pts );
388 buf->start = pic_out->i_pts;
389 buf->stop = pic_out->i_pts + duration;
390 buf->renderOffset = pic_out->i_dts;
391 if ( !w->config->h264.init_delay && pic_out->i_dts < 0 )
393 w->config->h264.init_delay = -pic_out->i_dts;
396 /* Encode all the NALs we were given into buf.
397 NOTE: This code assumes one video frame per NAL (but there can
398 be other stuff like SPS and/or PPS). If there are multiple
399 frames we only get the duration of the first which will
400 eventually screw up the muxer & decoder. */
402 for( i = 0; i < i_nal; i++ )
404 int size = nal[i].i_payload;
405 memcpy(buf->data + buf->size, nal[i].p_payload, size);
411 /* H.264 in .mp4 or .mkv */
412 switch( nal[i].i_type )
414 /* Sequence Parameter Set & Program Parameter Set go in the
415 * mp4 header so skip them here
428 /* Decide what type of frame we have. */
429 switch( pic_out->i_type )
432 buf->frametype = HB_FRAME_IDR;
433 /* if we have a chapter marker pending and this
434 frame's presentation time stamp is at or after
435 the marker's time stamp, use this as the
437 if( pv->next_chap != 0 && pv->next_chap <= pic_out->i_pts )
440 buf->new_chap = pv->chap_mark;
445 buf->frametype = HB_FRAME_I;
449 buf->frametype = HB_FRAME_P;
453 buf->frametype = HB_FRAME_B;
456 /* This is for b-pyramid, which has reference b-frames
457 However, it doesn't seem to ever be used... */
459 buf->frametype = HB_FRAME_BREF;
462 // If it isn't the above, what type of frame is it??
468 /* Since libx264 doesn't tell us when b-frames are
469 themselves reference frames, figure it out on our own. */
470 if( (buf->frametype == HB_FRAME_B) &&
471 (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) )
472 buf->frametype = HB_FRAME_BREF;
474 /* Expose disposable bit to muxer. */
475 if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE )
476 buf->flags &= ~HB_FRAME_REF;
478 buf->flags |= HB_FRAME_REF;
482 // make sure we found at least one video frame
483 if ( buf->size <= 0 )
485 // no video - discard the buf
486 hb_buffer_close( &buf );
491 static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in )
493 hb_work_private_t *pv = w->private_data;
494 hb_job_t *job = pv->job;
496 /* Point x264 at our current buffers Y(UV) data. */
497 pv->pic_in.img.plane[0] = in->data;
499 int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 );
500 if( !job->grayscale )
502 /* Point x264 at our buffers (Y)UV data */
503 pv->pic_in.img.plane[1] = in->data + job->width * job->height;
504 pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize;
506 if( in->new_chap && job->chapter_markers )
508 /* chapters have to start with an IDR frame so request that this
509 frame be coded as IDR. Since there may be up to 16 frames
510 currently buffered in the encoder remember the timestamp so
511 when this frame finally pops out of the encoder we'll mark
512 its buffer as the start of a chapter. */
513 pv->pic_in.i_type = X264_TYPE_IDR;
514 if( pv->next_chap == 0 )
516 pv->next_chap = in->start;
517 pv->chap_mark = in->new_chap;
519 /* don't let 'work_loop' put a chapter mark on the wrong buffer */
524 pv->pic_in.i_type = X264_TYPE_AUTO;
527 /* XXX this is temporary debugging code to check that the upstream
528 * modules (render & sync) have generated a continuous, self-consistent
529 * frame stream with the current frame's start time equal to the
530 * previous frame's stop time.
532 if( pv->last_stop != in->start )
534 hb_log("encx264 input continuity err: last stop %"PRId64" start %"PRId64,
535 pv->last_stop, in->start);
537 pv->last_stop = in->stop;
539 // Remember info about this frame that we need to pass across
540 // the x264_encoder_encode call (since it reorders frames).
541 save_frame_info( pv, in );
543 /* Feed the input PTS to x264 so it can figure out proper output PTS */
544 pv->pic_in.i_pts = in->start;
546 x264_picture_t pic_out;
550 x264_encoder_encode( pv->x264, &nal, &i_nal, &pv->pic_in, &pic_out );
553 return nal_encode( w, &pic_out, i_nal, nal );
558 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
559 hb_buffer_t ** buf_out )
561 hb_work_private_t *pv = w->private_data;
562 hb_buffer_t *in = *buf_in;
568 // EOF on input. Flush any frames still in the decoder then
569 // send the eof downstream to tell the muxer we're done.
570 x264_picture_t pic_out;
573 hb_buffer_t *last_buf = NULL;
575 while ( x264_encoder_delayed_frames( pv->x264 ) )
577 x264_encoder_encode( pv->x264, &nal, &i_nal, NULL, &pic_out );
583 hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal );
587 if ( last_buf == NULL )
590 last_buf->next = buf;
594 // Flushed everything - add the eof to the end of the chain.
595 if ( last_buf == NULL )
604 // Not EOF - encode the packet & wrap it in a NAL
607 *buf_out = x264_encode( w, in );