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;
51 uint8_t *x264_allocated_pic;
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 );
88 /* Default weightp to off for baseline,
89 overridable through x264 option strings. */
90 if( job->x264opts != NULL && *job->x264opts != '\0' )
92 char *x264opts, *x264opts_start;
94 x264opts = x264opts_start = strdup(job->x264opts);
96 while( x264opts_start && *x264opts )
98 char *name = x264opts;
101 x264opts += strcspn( x264opts, ":" );
108 value = strchr( name, '=' );
115 if( !( strcmp( name, "bframes" ) ) )
117 if( atoi( value ) == 0 )
119 param.analyse.i_weighted_pred = X264_WEIGHTP_NONE;
120 hb_log("encx264: no bframes, disabling weight-p unless told otherwise");
126 /* Temporary hack to use old b-pyramid default */
127 param.i_bframe_pyramid = X264_B_PYRAMID_NONE;
130 param.analyse.b_psnr = 1;
131 param.analyse.b_ssim = 1;
133 param.i_threads = ( hb_get_cpu_count() * 3 / 2 );
134 param.i_width = job->width;
135 param.i_height = job->height;
136 param.i_fps_num = job->vrate;
137 param.i_fps_den = job->vrate_base;
140 param.i_timebase_num = 0;
141 param.i_timebase_den = 0;
142 param.b_vfr_input = 0;
146 param.i_timebase_num = 1;
147 param.i_timebase_den = 90000;
150 /* Disable annexb. Inserts size into nal header instead of start code */
153 /* Set min:max key intervals ratio to 1:10 of fps.
154 * This section is skipped if fps=25 (default).
156 if (job->vrate_base != 1080000)
158 if (job->pass == 2 && !job->cfr )
160 /* Even though the framerate might be different due to VFR,
161 we still want the same keyframe intervals as the 1st pass,
162 so the 1st pass stats won't conflict on frame decisions. */
163 hb_interjob_t * interjob = hb_interjob_get( job->h );
164 param.i_keyint_max = ( ( 10 * (double)interjob->vrate / (double)interjob->vrate_base ) + 0.5 );
168 /* adjust +0.5 for when fps has remainder to bump
169 { 23.976, 29.976, 59.94 } to { 24, 30, 60 } */
170 param.i_keyint_max = ( ( 10 * (double)job->vrate / (double)job->vrate_base ) + 0.5 );
174 param.i_log_level = X264_LOG_INFO;
175 if( job->h264_level )
178 param.i_level_idc = job->h264_level;
179 hb_log( "encx264: encoding at level %i",
184 This section passes the string x264opts to libx264 for parsing into
185 parameter names and values.
187 The string is set up like this:
188 option1=value1:option2=value 2
190 So, you have to iterate through based on the colons, and then put
191 the left side of the equals sign in "name" and the right side into
192 "value." Then you hand those strings off to x264 for interpretation.
194 This is all based on the universal x264 option handling Loren
195 Merritt implemented in the Mplayer/Mencoder project.
198 if( job->x264opts != NULL && *job->x264opts != '\0' )
200 char *x264opts, *x264opts_start;
202 x264opts = x264opts_start = strdup(job->x264opts);
204 while( x264opts_start && *x264opts )
206 char *name = x264opts;
210 x264opts += strcspn( x264opts, ":" );
217 value = strchr( name, '=' );
224 if( !( strcmp( name, "b-pyramid" ) ) )
226 if( value == NULL || !strcmp( value, "1" ) )
230 else if( !strcmp( value, "0" ) )
236 /* Here's where the strings are passed to libx264 for parsing. */
237 ret = x264_param_parse( ¶m, name, value );
239 /* Let x264 sanity check the options for us*/
240 if( ret == X264_PARAM_BAD_NAME )
241 hb_log( "x264 options: Unknown suboption %s", name );
242 if( ret == X264_PARAM_BAD_VALUE )
243 hb_log( "x264 options: Bad argument %s=%s", name, value ? value : "(null)" );
245 free(x264opts_start);
248 /* B-frames are on by default.*/
251 if( param.i_bframe && param.i_bframe_pyramid )
253 /* Note b-pyramid here, so the initial delay can be doubled */
256 else if( !param.i_bframe )
259 When B-frames are enabled, the max frame count increments
260 by 1 (regardless of the number of B-frames). If you don't
261 change the duration of the video track when you mux, libmp4
262 barfs. So, check if the x264opts aren't using B-frames, and
263 when they aren't, set the boolean job->areBframes as false.
268 if( param.i_keyint_min != X264_KEYINT_MIN_AUTO || param.i_keyint_max != 250 )
269 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,
272 /* set up the VUI color model & gamma to match what the COLR atom
273 * set in muxmp4.c says. See libhb/muxmp4.c for notes. */
274 if( job->color_matrix == 1 )
276 // ITU BT.601 DVD or SD TV content
277 param.vui.i_colorprim = 6;
278 param.vui.i_transfer = 1;
279 param.vui.i_colmatrix = 6;
281 else if( job->color_matrix == 2 )
283 // ITU BT.709 HD content
284 param.vui.i_colorprim = 1;
285 param.vui.i_transfer = 1;
286 param.vui.i_colmatrix = 1;
288 else if ( job->title->width >= 1280 || job->title->height >= 720 )
290 // we guess that 720p or above is ITU BT.709 HD content
291 param.vui.i_colorprim = 1;
292 param.vui.i_transfer = 1;
293 param.vui.i_colmatrix = 1;
297 // ITU BT.601 DVD or SD TV content
298 param.vui.i_colorprim = 6;
299 param.vui.i_transfer = 1;
300 param.vui.i_colmatrix = 6;
303 if( job->anamorphic.mode )
305 param.vui.i_sar_width = job->anamorphic.par_width;
306 param.vui.i_sar_height = job->anamorphic.par_height;
308 hb_log( "encx264: encoding with stored aspect %d/%d",
309 param.vui.i_sar_width, param.vui.i_sar_height );
313 if( job->vquality > 0.0 && job->vquality < 1.0 )
316 param.rc.i_rc_method = X264_RC_CRF;
317 param.rc.f_rf_constant = 51 - job->vquality * 51;
318 hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
320 else if( job->vquality == 0 || job->vquality >= 1.0 )
322 /* Use the vquality as a raw RF or QP
323 instead of treating it like a percentage. */
325 param.rc.i_rc_method = X264_RC_CRF;
326 param.rc.f_rf_constant = job->vquality;
327 hb_log( "encx264: Encoding at constant RF %f", param.rc.f_rf_constant );
332 param.rc.i_rc_method = X264_RC_ABR;
333 param.rc.i_bitrate = job->vbitrate;
337 param.rc.b_stat_write = 1;
338 param.rc.psz_stat_out = pv->filename;
341 param.rc.b_stat_read = 1;
342 param.rc.psz_stat_in = pv->filename;
347 hb_deep_log( 2, "encx264: opening libx264 (pass %d)", job->pass );
348 pv->x264 = x264_encoder_open( ¶m );
350 x264_encoder_headers( pv->x264, &nal, &nal_count );
352 /* Sequence Parameter Set */
353 memcpy(w->config->h264.sps, nal[0].p_payload + 4, nal[0].i_payload - 4);
354 w->config->h264.sps_length = nal[0].i_payload - 4;
356 /* Picture Parameter Set */
357 memcpy(w->config->h264.pps, nal[1].p_payload + 4, nal[1].i_payload - 4);
358 w->config->h264.pps_length = nal[1].i_payload - 4;
360 x264_picture_alloc( &pv->pic_in, X264_CSP_I420,
361 job->width, job->height );
363 pv->pic_in.img.i_stride[2] = pv->pic_in.img.i_stride[1] = ( ( job->width + 1 ) >> 1 );
364 pv->x264_allocated_pic = pv->pic_in.img.plane[0];
369 void encx264Close( hb_work_object_t * w )
371 hb_work_private_t * pv = w->private_data;
373 if ( pv->frames_split )
375 hb_log( "encx264: %u frames had to be split (%u in, %u out)",
376 pv->frames_split, pv->frames_in, pv->frames_out );
379 * Patch the x264 allocated data back in so that x264 can free it
380 * we have been using our own buffers during the encode to avoid copying.
382 pv->pic_in.img.plane[0] = pv->x264_allocated_pic;
383 x264_picture_clean( &pv->pic_in );
384 x264_encoder_close( pv->x264 );
386 w->private_data = NULL;
392 * see comments in definition of 'frame_info' in pv struct for description
393 * of what these routines are doing.
395 static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
397 int i = (in->start >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
398 pv->frame_info[i].duration = in->stop - in->start;
401 static int64_t get_frame_duration( hb_work_private_t * pv, int64_t pts )
403 int i = (pts >> FRAME_INFO_MAX2) & FRAME_INFO_MASK;
404 return pv->frame_info[i].duration;
407 static hb_buffer_t *nal_encode( hb_work_object_t *w, x264_picture_t *pic_out,
408 int i_nal, x264_nal_t *nal )
410 hb_buffer_t *buf = NULL;
411 hb_work_private_t *pv = w->private_data;
412 hb_job_t *job = pv->job;
414 /* Should be way too large */
415 buf = hb_video_buffer_init( job->width, job->height );
419 // use the pts to get the original frame's duration.
420 int64_t duration = get_frame_duration( pv, pic_out->i_pts );
421 buf->start = pic_out->i_pts;
422 buf->stop = pic_out->i_pts + duration;
423 buf->renderOffset = pic_out->i_dts;
424 if ( !w->config->h264.init_delay && pic_out->i_dts < 0 )
426 w->config->h264.init_delay = -pic_out->i_dts;
429 /* Encode all the NALs we were given into buf.
430 NOTE: This code assumes one video frame per NAL (but there can
431 be other stuff like SPS and/or PPS). If there are multiple
432 frames we only get the duration of the first which will
433 eventually screw up the muxer & decoder. */
435 for( i = 0; i < i_nal; i++ )
437 int size = nal[i].i_payload;
438 memcpy(buf->data + buf->size, nal[i].p_payload, size);
444 if( job->mux & HB_MUX_AVI )
446 if( nal[i].i_ref_idc == NAL_PRIORITY_HIGHEST )
448 buf->frametype = HB_FRAME_KEY;
454 /* H.264 in .mp4 or .mkv */
455 switch( nal[i].i_type )
457 /* Sequence Parameter Set & Program Parameter Set go in the
458 * mp4 header so skip them here
471 /* Decide what type of frame we have. */
472 switch( pic_out->i_type )
475 buf->frametype = HB_FRAME_IDR;
476 /* if we have a chapter marker pending and this
477 frame's presentation time stamp is at or after
478 the marker's time stamp, use this as the
480 if( pv->next_chap != 0 && pv->next_chap <= pic_out->i_pts )
483 buf->new_chap = pv->chap_mark;
488 buf->frametype = HB_FRAME_I;
492 buf->frametype = HB_FRAME_P;
496 buf->frametype = HB_FRAME_B;
499 /* This is for b-pyramid, which has reference b-frames
500 However, it doesn't seem to ever be used... */
502 buf->frametype = HB_FRAME_BREF;
505 // If it isn't the above, what type of frame is it??
511 /* Since libx264 doesn't tell us when b-frames are
512 themselves reference frames, figure it out on our own. */
513 if( (buf->frametype == HB_FRAME_B) &&
514 (nal[i].i_ref_idc != NAL_PRIORITY_DISPOSABLE) )
515 buf->frametype = HB_FRAME_BREF;
517 /* Expose disposable bit to muxer. */
518 if( nal[i].i_ref_idc == NAL_PRIORITY_DISPOSABLE )
519 buf->flags &= ~HB_FRAME_REF;
521 buf->flags |= HB_FRAME_REF;
525 // make sure we found at least one video frame
526 if ( buf->size <= 0 )
528 // no video - discard the buf
529 hb_buffer_close( &buf );
534 static hb_buffer_t *x264_encode( hb_work_object_t *w, hb_buffer_t *in )
536 hb_work_private_t *pv = w->private_data;
537 hb_job_t *job = pv->job;
539 /* Point x264 at our current buffers Y(UV) data. */
540 pv->pic_in.img.plane[0] = in->data;
542 int uvsize = ( (job->width + 1) >> 1 ) * ( (job->height + 1) >> 1 );
545 /* XXX x264 has currently no option for grayscale encoding */
546 memset( pv->pic_in.img.plane[1], 0x80, uvsize );
547 memset( pv->pic_in.img.plane[2], 0x80, uvsize );
551 /* Point x264 at our buffers (Y)UV data */
552 pv->pic_in.img.plane[1] = in->data + job->width * job->height;
553 pv->pic_in.img.plane[2] = pv->pic_in.img.plane[1] + uvsize;
555 if( in->new_chap && job->chapter_markers )
557 /* chapters have to start with an IDR frame so request that this
558 frame be coded as IDR. Since there may be up to 16 frames
559 currently buffered in the encoder remember the timestamp so
560 when this frame finally pops out of the encoder we'll mark
561 its buffer as the start of a chapter. */
562 pv->pic_in.i_type = X264_TYPE_IDR;
563 if( pv->next_chap == 0 )
565 pv->next_chap = in->start;
566 pv->chap_mark = in->new_chap;
568 /* don't let 'work_loop' put a chapter mark on the wrong buffer */
573 pv->pic_in.i_type = X264_TYPE_AUTO;
575 pv->pic_in.i_qpplus1 = 0;
577 /* XXX this is temporary debugging code to check that the upstream
578 * modules (render & sync) have generated a continuous, self-consistent
579 * frame stream with the current frame's start time equal to the
580 * previous frame's stop time.
582 if( pv->last_stop != in->start )
584 hb_log("encx264 input continuity err: last stop %"PRId64" start %"PRId64,
585 pv->last_stop, in->start);
587 pv->last_stop = in->stop;
589 // Remember info about this frame that we need to pass across
590 // the x264_encoder_encode call (since it reorders frames).
591 save_frame_info( pv, in );
593 /* Feed the input PTS to x264 so it can figure out proper output PTS */
594 pv->pic_in.i_pts = in->start;
596 x264_picture_t pic_out;
600 x264_encoder_encode( pv->x264, &nal, &i_nal, &pv->pic_in, &pic_out );
603 return nal_encode( w, &pic_out, i_nal, nal );
608 int encx264Work( hb_work_object_t * w, hb_buffer_t ** buf_in,
609 hb_buffer_t ** buf_out )
611 hb_work_private_t *pv = w->private_data;
612 hb_buffer_t *in = *buf_in;
618 // EOF on input. Flush any frames still in the decoder then
619 // send the eof downstream to tell the muxer we're done.
620 x264_picture_t pic_out;
623 hb_buffer_t *last_buf = NULL;
625 while ( x264_encoder_delayed_frames( pv->x264 ) )
627 x264_encoder_encode( pv->x264, &nal, &i_nal, NULL, &pic_out );
633 hb_buffer_t *buf = nal_encode( w, &pic_out, i_nal, nal );
637 if ( last_buf == NULL )
640 last_buf->next = buf;
644 // Flushed everything - add the eof to the end of the chain.
645 if ( last_buf == NULL )
654 // Not EOF - encode the packet & wrap it in a NAL
657 *buf_out = x264_encode( w, in );