<object class="GtkWindow" id="hb_window">
<property name="visible">True</property>
- <property name="resizable">False</property>
+ <property name="resizable">True</property>
<property name="title" translatable="yes">HandBrake</property>
<property name="default_width">500</property>
<property name="default_height">400</property>
x264's scale is logarithmic and lower values coorespond to higher quality. So small decreases in value will result in progressively larger increases in the resulting file size. A value of 0 means lossless and will result in a file size that is larger than the original source, unless the source was also lossless.
-FFmpeg's and Theora's scale is more linear. These encoders do not have a lossless mode.</property>
+FFMpeg's and Theora's scale is more linear. These encoders do not have a lossless mode.</property>
<property name="adjustment">adjustment5</property>
<property name="digits">3</property>
<property name="value_pos">GTK_POS_TOP</property>
x264's scale is logarithmic and lower values coorespond to higher quality. So small decreases in value will result in progressively larger increases in the resulting file size. A value of 0 means lossless and will result in a file size that is larger than the original source, unless the source was also lossless.
-FFmpeg's and Theora's scale is more linear. These encoders do not have a lossless mode.</property>
+FFMpeg's and Theora's scale is more linear. These encoders do not have a lossless mode.</property>
<property name="label" translatable="yes">Constant Quality:</property>
<property name="active">True</property>
<property name="draw_indicator">True</property>
</packing>
</child>
<child>
+ <object class="GtkHBox" id="advanced_tab">
+ <property name="orientation">vertical</property>
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <child>
+
<object class="GtkVBox" id="x264_tab">
<property name="orientation">vertical</property>
<property name="visible">True</property>
</packing>
</child>
</object>
+ <packing>
+ <property name="expand">True</property>
+ <property name="fill">True</property>
+ <property name="padding">0</property>
+ <property name="position">0</property>
+ </packing>
+
+ </child>
+ <child>
+ <object class="GtkVBox" id="lavc_mpeg4_tab">
+ <property name="orientation">vertical</property>
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <child>
+ <object class="GtkHBox" id="hbox86">
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <property name="spacing">2</property>
+ </object>
+ <packing>
+ <property name="expand">True</property>
+ <property name="position">0</property>
+ </packing>
+ </child>
+ <child>
+ <object class="GtkFrame" id="frame18">
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <property name="label_xalign">0</property>
+ <property name="shadow_type">none</property>
+ <child>
+ <object class="GtkAlignment" id="alignment33">
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <property name="top_padding">6</property>
+ <property name="bottom_padding">2</property>
+ <property name="left_padding">12</property>
+ <property name="right_padding">2</property>
+ <child>
+ <object class="GtkScrolledWindow" id="scrolledwindow7">
+ <property name="height_request">40</property>
+ <property name="visible">True</property>
+ <property name="can_focus">True</property>
+ <property name="hscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+ <property name="vscrollbar_policy">GTK_POLICY_AUTOMATIC</property>
+ <property name="shadow_type">etched-in</property>
+ <child>
+ <object class="GtkTextView" id="lavcOption">
+ <property name="visible">True</property>
+ <property name="can_focus">True</property>
+ <property name="tooltip-text" translatable="yes">Your selected options will appear here.
+ You can edit these and add additional options.</property>
+ <property name="wrap_mode">GTK_WRAP_CHAR</property>
+ <property name="accepts_tab">False</property>
+ <signal handler="lavc_focus_out_cb" name="focus_out_event"/>
+ </object>
+ </child>
+ </object>
+ </child>
+ </object>
+ </child>
+ <child type="label">
+ <object class="GtkLabel" id="label75">
+ <property name="visible">True</property>
+ <property name="events">GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK</property>
+ <property name="label" translatable="yes"><small><b>Current FFMpeg MPEG-4 Advanced Option String</b></small></property>
+ <property name="use_markup">True</property>
+ </object>
+ </child>
+ </object>
+ <packing>
+ <property name="expand">False</property>
+ <property name="fill">True</property>
+ <property name="padding">2</property>
+ <property name="position">1</property>
+ </packing>
+ </child>
+ </object>
+ <packing>
+ <property name="expand">True</property>
+ <property name="fill">True</property>
+ <property name="padding">0</property>
+ <property name="position">1</property>
+ </packing>
+ </child>
+ </object>
<packing>
</packing>
</child>
<child type="tab">
- <object class="GtkLabel" id="x264_tab_label">
+ <object class="GtkLabel" id="advanced_tab_label">
<property name="visible">True</property>
- <property name="label" translatable="yes">H.264</property>
+ <property name="label" translatable="yes">Advanced</property>
</object>
<packing>
<property name="position">4</property>
</object>
<packing>
- <property name="expand">False</property>
+ <property name="expand">True</property>
<property name="position">1</property>
</packing>
</child>
</child>
</object>
<packing>
+ <property name="expand">False</property>
<property name="position">2</property>
</packing>
</child>
}
}
-static const char * turbo_opts =
+static const char * turbo_lavc_opts = "";
+
+static const char * turbo_x264_opts =
"ref=1:subme=2:me=dia:analyse=none:trellis=0:"
"no-fast-pskip=0:8x8dct=0";
-// Construct the x264 options string
+// Construct the advanced options string
// The result is allocated, so someone must free it at some point.
gchar*
-ghb_build_x264opts_string(GValue *settings)
+ghb_build_advanced_opts_string(GValue *settings)
{
gchar *result;
- gchar *opts = ghb_settings_get_string(settings, "x264Option");
- if (opts != NULL)
- {
- result = opts;
- }
- else
+
+ gint vcodec = ghb_settings_combo_int(settings, "VideoEncoder");
+
+ switch (vcodec)
{
- result = g_strdup("");
+ case HB_VCODEC_X264:
+ {
+ gchar *opts = ghb_settings_get_string(settings, "x264Option");
+ if (opts != NULL)
+ {
+ result = opts;
+ }
+ else
+ {
+ result = g_strdup("");
+ }
+ } break;
+
+ case HB_VCODEC_FFMPEG:
+ {
+ gchar *opts = ghb_settings_get_string(settings, "lavcOption");
+ if (opts != NULL)
+ {
+ result = opts;
+ }
+ else
+ {
+ result = g_strdup("");
+ }
+ } break;
+
+ case HB_VCODEC_THEORA:
+ default:
+ {
+ result = g_strdup("");
+ } break;
}
return result;
}
hb_list_t * list;
hb_title_t * title;
hb_job_t * job;
- static gchar *x264opts;
+ static gchar *advanced_opts;
gint sub_id = 0;
gboolean tweaks = FALSE;
gchar *detel_str = NULL;
}
}
- // TODO: libhb holds onto a reference to the x264opts and is not
+ // TODO: libhb holds onto a reference to the advanced_opts and is not
// finished with it until encoding the job is done. But I can't
// find a way to get at the job before it is removed in order to
// free up the memory I am allocating here.
// The short story is THIS LEAKS.
- x264opts = ghb_build_x264opts_string(js);
+ advanced_opts = ghb_build_advanced_opts_string(js);
- if( *x264opts == '\0' )
+ if( advanced_opts && *advanced_opts == '\0' )
{
- g_free(x264opts);
- x264opts = NULL;
+ g_free(advanced_opts);
+ advanced_opts = NULL;
}
if (job->indepth_scan == 1)
*/
job->pass = -1;
job->indepth_scan = 1;
- job->x264opts = NULL;
+ job->advanced_opts = NULL;
/*
* Add the pre-scan job
/*
* If turbo options have been selected then append them
- * to the x264opts now (size includes one ':' and the '\0')
+ * to the advanced_opts now (size includes one ':' and the '\0')
*/
if( ghb_settings_get_boolean(js, "VideoTurboTwoPass") )
{
- gchar *tmp_x264opts;
+ gchar *tmp_advanced_opts;
gchar *extra_opts;
- gint badapt;
- badapt = ghb_lookup_badapt(x264opts);
- if (badapt == 2)
+ if (job->vcodec == HB_VCODEC_X264)
{
- extra_opts = g_strdup_printf("%s", turbo_opts);
+ gint badapt;
+
+ badapt = ghb_lookup_badapt(advanced_opts);
+ if (badapt == 2)
+ {
+ extra_opts = g_strdup_printf("%s", turbo_x264_opts);
+ }
+ else
+ {
+ extra_opts = g_strdup_printf("%s:weightb=0", turbo_x264_opts);
+ }
+ }
+ else if (job->vcodec == HB_VCODEC_FFMPEG)
+ {
+ extra_opts = g_strdup_printf("%s", turbo_lavc_opts);
}
else
{
- extra_opts = g_strdup_printf("%s:weightb=0", turbo_opts);
+ extra_opts = g_strdup("");
}
-
- if ( x264opts )
+
+ if ( advanced_opts )
{
- tmp_x264opts = g_strdup_printf("%s:%s", x264opts, extra_opts);
+ tmp_advanced_opts = g_strdup_printf("%s:%s", advanced_opts, extra_opts);
}
else
{
/*
- * No x264opts to modify, but apply the turbo options
+ * No advanced_opts to modify, but apply the turbo options
* anyway as they may be modifying defaults
*/
- tmp_x264opts = g_strdup_printf("%s", extra_opts);
+ tmp_advanced_opts = g_strdup_printf("%s", extra_opts);
}
g_free(extra_opts);
- job->x264opts = tmp_x264opts;
+ job->advanced_opts = tmp_advanced_opts;
}
else
{
- job->x264opts = x264opts;
+ job->advanced_opts = advanced_opts;
}
job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24);
hb_add( h, job );
- //if (job->x264opts != NULL)
- // g_free(job->x264opts);
+ //if (job->advanced_opts != NULL)
+ // g_free(job->advanced_opts);
job->pass = 2;
/*
* attribute of the job).
*/
job->indepth_scan = 0;
- job->x264opts = x264opts;
+ job->advanced_opts = advanced_opts;
job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24);
hb_add( h, job );
- //if (job->x264opts != NULL)
- // g_free(job->x264opts);
+ //if (job->advanced_opts != NULL)
+ // g_free(job->advanced_opts);
}
else
{
- job->x264opts = x264opts;
+ job->advanced_opts = advanced_opts;
job->indepth_scan = 0;
job->pass = 0;
job->sequence_id = (unique_id & 0xFFFFFF) | (sub_id++ << 24);
hb_add( h, job );
- //if (job->x264opts != NULL)
- // g_free(job->x264opts);
+ //if (job->advanced_opts != NULL)
+ // g_free(job->advanced_opts);
}
// clean up audio list
gint ghb_pick_subtitle_track(signal_user_data_t *ud);
gint ghb_find_cc_track(gint titleindex);
gint ghb_longest_title(void);
-gchar* ghb_build_x264opts_string(GValue *settings);
+gchar* ghb_build_advanced_opts_string(GValue *settings);
GdkPixbuf* ghb_get_preview_image(
gint titleindex, gint index, signal_user_data_t *ud,
gint *width, gint *height);
<real>0.60</real>
<key>VideoTargetSize</key>
<integer>700</integer>
+ <key>lavcOption</key>
+ <string></string>
<key>x264Option</key>
<string></string>
</dict>
widget = GHB_WIDGET(ud->builder, "subtitle_table");
gtk_widget_set_size_request(widget, -1, height);
+ widget = GHB_WIDGET (ud->builder, "hb_window");
+
+ GdkGeometry geo = {
+ -1, -1, 1024, 768, 200, 200, 10, 10, 0, 0, GDK_GRAVITY_NORTH_WEST
+ };
+ GdkWindowHints geo_mask;
+ geo_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_BASE_SIZE;
+ gtk_window_set_geometry_hints( GTK_WINDOW(widget), widget, &geo, geo_mask);
+
// Everything should be go-to-go. Lets rock!
gtk_main ();
DepEntry("PictureAutoCrop", "PictureBottomCrop", "FALSE", False, False),
DepEntry("PictureAutoCrop", "PictureLeftCrop", "FALSE", False, False),
DepEntry("PictureAutoCrop", "PictureRightCrop", "FALSE", False, False),
- DepEntry("VideoEncoder", "x264_tab", "x264", False, False),
- DepEntry("VideoEncoder", "x264_tab_label", "x264", False, False),
+ DepEntry("VideoEncoder", "x264_tab", "x264", False, True),
+ DepEntry("VideoEncoder", "lavc_mpeg4_tab", "ffmpeg", False, True),
DepEntry("VideoEncoder", "Mp4iPodCompatible", "x264", False, False),
DepEntry("AudioEncoderActual", "AudioBitrate", "ac3pass|dtspass", True, False),
DepEntry("AudioEncoderActual", "AudioSamplerate", "ac3pass|dtspass", True, False),
vqvalue = ghb_settings_get_double(settings, "VideoQualitySlider");
vq_desc = "Constant Quality:";
vqstr = g_strdup_printf("%d", (gint)vqvalue);
- if (strcmp(vcodec_abbr, "x264") == 0)
- {
- vq_units = "(RF)";
- }
- else
- {
- vq_units = "(QP)";
- }
+ if (strcmp(vcodec_abbr, "x264") == 0)
+ {
+ vq_units = "(RF)";
+ }
+ else
+ {
+ vq_units = "(QP)";
+ }
}
fps = ghb_settings_get_string(settings, "VideoFramerate");
if (strcmp("source", fps) == 0)
{
g_string_append_printf(str, "<b>Turbo:</b> <small>On</small>\n");
}
- if (strcmp(vcodec_abbr, "x264") == 0)
+ if (strcmp(vcodec_abbr, "x264") == 0 ||
+ strcmp(vcodec_abbr, "ffmpeg") == 0)
{
- gchar *x264opts = ghb_build_x264opts_string(settings);
+ gchar *opts = ghb_build_advanced_opts_string(settings);
g_string_append_printf(str,
- "<b>x264 Options:</b> <small>%s</small>\n", x264opts);
- g_free(x264opts);
+ "<b>Advanced Options:</b> <small>%s</small>\n", opts);
+ g_free(opts);
}
// Add the audios
gint count, ii;
return result;
}
+G_MODULE_EXPORT gboolean
+lavc_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
+ signal_user_data_t *ud)
+{
+ ghb_widget_to_setting(ud->settings, widget);
+
+#if 0
+ gchar *options, *sopts;
+ ****************************************************************
+ When there are lavc widget in the future, this will be populated
+ ****************************************************************
+ options = ghb_settings_get_string(ud->settings, "x264Option");
+ sopts = sanitize_x264opts(ud, options);
+ ignore_options_update = TRUE;
+ if (sopts != NULL && strcmp(sopts, options) != 0)
+ {
+ ghb_ui_update(ud, "x264Option", ghb_string_value(sopts));
+ ghb_x264_parse_options(ud, sopts);
+ }
+ g_free(options);
+ g_free(sopts);
+ ignore_options_update = FALSE;
+#endif
+ return FALSE;
+}
+
vrate, vrate_base: output framerate is vrate / vrate_base
cfr: 0 (vfr), 1 (cfr), 2 (pfr) [see render.c]
pass: 0, 1 or 2 (or -1 for scan)
- x264opts: string of extra x264 options
- areBframes: boolean to note if b-frames are included in x264opts */
+ advanced_opts: string of extra advanced encoder options
+ areBframes: boolean to note if b-frames are included in advanced_opts */
#define HB_VCODEC_MASK 0x0000FF
#define HB_VCODEC_FFMPEG 0x000001
#define HB_VCODEC_X264 0x000002
int vfr;
int cfr;
int pass;
- char *x264opts;
+ char *advanced_opts;
int areBframes;
int color_matrix;
// if the packet has a timestamp use it if we don't have a timestamp yet
// or if there's been a timing discontinuity of more than 100ms.
- if ( in->start >= 0 &&
- ( pv->pts_next < 0 || ( in->start - pv->pts_next ) > 90*100 ) )
+ if ( in->start >= 0 )
{
pv->pts_next = in->start;
}
#include "hb.h"
#include "hbffmpeg.h"
+/*
+ * The frame info struct remembers information about each frame across calls
+ * to avcodec_encode_video. Since frames are uniquely identified by their
+ * frame number, we use this as an index.
+ *
+ * The size of the array is chosen so that two frames can't use the same
+ * slot during the encoder's max frame delay (set by the standard as 16
+ * frames) and so that, up to some minimum frame rate, frames are guaranteed
+ * to map to * different slots.
+ */
+#define FRAME_INFO_SIZE 32
+#define FRAME_INFO_MASK (FRAME_INFO_SIZE - 1)
+
struct hb_work_private_s
{
hb_job_t * job;
AVCodecContext * context;
FILE * file;
+
+ int frameno_in;
+ int frameno_out;
+ hb_buffer_t * delay_head;
+ hb_buffer_t * delay_tail;
+
+ int64_t dts_delay;
+
+ struct {
+ int64_t start;
+ int64_t stop;
+ int64_t renderOffset;
+ } frame_info[FRAME_INFO_SIZE];
};
int encavcodecInit( hb_work_object_t *, hb_job_t * );
hb_log( "hb_work_encavcodec_init: avcodec_find_encoder "
"failed" );
}
- context = avcodec_alloc_context();
- if( job->vquality < 0.0 )
- {
- /* Rate control */
- context->bit_rate = 1000 * job->vbitrate;
- context->bit_rate_tolerance = 10 * context->bit_rate;
- }
- else
- {
- /* Constant quantizer */
- // These settings produce better image quality than
- // what was previously used
- context->flags |= CODEC_FLAG_QSCALE;
- if (job->vquality < 1.0)
- {
- float vquality;
- vquality = 31 - job->vquality * 31;
- // A value of 0 has undefined behavior
- // and ffmpeg qp has integral increments
- if (vquality < 1.0)
- vquality = 1.0;
- context->global_quality = FF_QP2LAMBDA * vquality + 0.5;
- }
- else
- {
- context->global_quality = FF_QP2LAMBDA * job->vquality + 0.5;
- }
- context->mb_decision = 1;
- hb_log( "encavcodec: encoding at constant quantizer %d",
- context->global_quality );
- }
- context->width = job->width;
- context->height = job->height;
+ context = avcodec_alloc_context3( codec );
+
+ // Set things in context that we will allow the user to
+ // override with advanced settings.
+ context->thread_count = ( hb_get_cpu_count() * 3 / 2 );
if( job->pass == 2 )
{
rate_num = job->vrate_base;
rate_den = job->vrate;
}
+
+ // If the rate_den is 27000000, there's a good chance this is
+ // a standard rate that we have in our hb_video_rates table.
+ // Because of rounding errors and approximations made while
+ // measuring framerate, the actual value may not be exact. So
+ // we look for rates that are "close" and make an adjustment
+ // to rate_num.
if (rate_den == 27000000)
{
int ii;
}
context->time_base = (AVRational) { rate_num, rate_den };
context->gop_size = 10 * (int)( (double)job->vrate / (double)job->vrate_base + 0.5 );
+
+ /*
+ This section passes the string advanced_opts to avutil for parsing
+ into an AVCodecContext.
+
+ The string is set up like this:
+ option1=value1:option2=value2
+
+ So, you have to iterate through based on the colons, and then put
+ the left side of the equals sign in "name" and the right side into
+ "value." Then you hand those strings off to avutil for interpretation.
+ */
+ if( job->advanced_opts != NULL && *job->advanced_opts != '\0' )
+ {
+ char *opts, *opts_start;
+
+ opts = opts_start = strdup(job->advanced_opts);
+
+ if( opts_start )
+ {
+ while( *opts )
+ {
+ char *name = opts;
+ char *value;
+ int ret;
+
+ opts += strcspn( opts, ":" );
+ if( *opts )
+ {
+ *opts = 0;
+ opts++;
+ }
+
+ value = strchr( name, '=' );
+ if( value )
+ {
+ *value = 0;
+ value++;
+ }
+
+ /* Here's where the strings are passed to avutil for parsing. */
+ ret = av_set_string3( context, name, value, 1, NULL );
+
+ /* Let avutil sanity check the options for us*/
+ if( ret == AVERROR(ENOENT) )
+ hb_log( "avcodec options: Unknown option %s", name );
+ if( ret == AVERROR(EINVAL) )
+ hb_log( "avcodec options: Bad argument %s=%s", name, value ? value : "(null)" );
+ }
+ }
+ free(opts_start);
+ }
+
+ // Now set the things in context that we don't want to allow
+ // the user to override.
+ if( job->vquality < 0.0 )
+ {
+ /* Rate control */
+ context->bit_rate = 1000 * job->vbitrate;
+ context->bit_rate_tolerance = 10 * context->bit_rate;
+ }
+ else
+ {
+ /* Constant quantizer */
+ // These settings produce better image quality than
+ // what was previously used
+ context->flags |= CODEC_FLAG_QSCALE;
+ if (job->vquality < 1.0)
+ {
+ float vquality;
+ vquality = 31 - job->vquality * 31;
+ // A value of 0 has undefined behavior
+ // and ffmpeg qp has integral increments
+ if (vquality < 1.0)
+ vquality = 1.0;
+ context->global_quality = FF_QP2LAMBDA * vquality + 0.5;
+ }
+ else
+ {
+ context->global_quality = FF_QP2LAMBDA * job->vquality + 0.5;
+ }
+ hb_log( "encavcodec: encoding at constant quantizer %d",
+ context->global_quality );
+ }
+ context->width = job->width;
+ context->height = job->height;
context->pix_fmt = PIX_FMT_YUV420P;
if( job->anamorphic.mode )
}
pv->context = context;
+ if ( context->has_b_frames )
+ {
+ job->areBframes = 1;
+ }
if( ( job->mux & HB_MUX_MP4 ) && job->pass != 1 )
{
-#if 0
- /* Hem hem */
- w->config->mpeg4.length = 15;
- memcpy( w->config->mpeg4.bytes, context->extradata + 15, 15 );
-#else
w->config->mpeg4.length = context->extradata_size;
memcpy( w->config->mpeg4.bytes, context->extradata,
context->extradata_size );
-#endif
}
return 0;
w->private_data = NULL;
}
+/*
+ * see comments in definition of 'frame_info' in pv struct for description
+ * of what these routines are doing.
+ */
+static void save_frame_info( hb_work_private_t * pv, hb_buffer_t * in )
+{
+ int i = pv->frameno_in & FRAME_INFO_MASK;
+ pv->frame_info[i].start = in->start;
+ pv->frame_info[i].stop = in->stop;
+}
+
+static int64_t get_frame_start( hb_work_private_t * pv, int64_t frameno )
+{
+ int i = frameno & FRAME_INFO_MASK;
+ return pv->frame_info[i].start;
+}
+
+static int64_t get_frame_stop( hb_work_private_t * pv, int64_t frameno )
+{
+ int i = frameno & FRAME_INFO_MASK;
+ return pv->frame_info[i].stop;
+}
+
+static void compute_dts_offset( hb_work_private_t * pv, hb_buffer_t * buf )
+{
+ if ( pv->job->areBframes )
+ {
+ if ( ( pv->frameno_in - 1 ) == pv->job->areBframes )
+ {
+ pv->dts_delay = buf->start;
+ pv->job->config.h264.init_delay = pv->dts_delay;
+ }
+ }
+}
+
+// Generate DTS by rearranging PTS in this sequence:
+// pts0 - delay, pts1 - delay, pts2 - delay, pts1, pts2, pts3...
+//
+// Where pts0 - ptsN are in decoded monotonically increasing presentation
+// order and delay == pts1 (1 being the number of frames the decoder must
+// delay before it has suffecient information to decode). The number of
+// frames to delay is set by job->areBframes, so it is configurable.
+// This guarantees that DTS <= PTS for any frame.
+//
+// This is similar to how x264 generates DTS
+static hb_buffer_t * process_delay_list( hb_work_private_t * pv, hb_buffer_t * buf )
+{
+ if ( pv->job->areBframes )
+ {
+ // Has dts_delay been set yet?
+ if ( pv->frameno_in <= pv->job->areBframes )
+ {
+ // dts_delay not yet set. queue up buffers till it is set.
+ if ( pv->delay_tail == NULL )
+ {
+ pv->delay_head = pv->delay_tail = buf;
+ }
+ else
+ {
+ pv->delay_tail->next = buf;
+ pv->delay_tail = buf;
+ }
+ return NULL;
+ }
+
+ // We have dts_delay. Apply it to any queued buffers renderOffset
+ // and return all queued buffers.
+ if ( pv->delay_tail == NULL && buf != NULL )
+ {
+ pv->frameno_out++;
+ // Use the cached frame info to get the start time of Nth frame
+ // Note that start Nth frame != start time this buffer since the
+ // output buffers have rearranged start times.
+ int64_t start = get_frame_start( pv, pv->frameno_out );
+ buf->renderOffset = start - pv->dts_delay;
+ return buf;
+ }
+ else
+ {
+ pv->delay_tail->next = buf;
+ buf = pv->delay_head;
+ while ( buf )
+ {
+ pv->frameno_out++;
+ // Use the cached frame info to get the start time of Nth frame
+ // Note that start Nth frame != start time this buffer since the
+ // output buffers have rearranged start times.
+ int64_t start = get_frame_start( pv, pv->frameno_out );
+ buf->renderOffset = start - pv->dts_delay;
+ }
+ buf = pv->delay_head;
+ pv->delay_head = pv->delay_tail = NULL;
+ return buf;
+ }
+ }
+ else if ( buf )
+ {
+ buf->renderOffset = buf->start - pv->dts_delay;
+ return buf;
+ }
+ return NULL;
+}
+
/***********************************************************************
* Work
***********************************************************************
// doesn't do the trick. It must be set in the AVFrame.
frame->quality = pv->context->global_quality;
+ // Bizarro ffmpeg appears to require the input AVFrame.pts to be
+ // set to a frame number. Setting it to an actual pts causes
+ // jerky video.
+ // frame->pts = in->start;
+ frame->pts = ++pv->frameno_in;
+
+ // Remember info about this frame that we need to pass across
+ // the avcodec_encode_video call (since it reorders frames).
+ save_frame_info( pv, in );
+ compute_dts_offset( pv, in );
+
if ( pv->context->codec )
{
/* Should be way too large */
buf = hb_video_buffer_init( job->width, job->height );
buf->size = avcodec_encode_video( pv->context, buf->data, buf->alloc,
frame );
- buf->start = in->start;
- buf->stop = in->stop;
- buf->frametype = pv->context->coded_frame->key_frame ? HB_FRAME_KEY : HB_FRAME_REF;
+ if ( buf->size <= 0 )
+ {
+ hb_buffer_close( &buf );
+ }
+ else
+ {
+ int64_t frameno = pv->context->coded_frame->pts;
+ buf->start = get_frame_start( pv, frameno );
+ buf->stop = get_frame_stop( pv, frameno );
+ switch ( pv->context->coded_frame->pict_type )
+ {
+ case FF_P_TYPE:
+ {
+ buf->frametype = HB_FRAME_P;
+ } break;
+
+ case FF_B_TYPE:
+ {
+ buf->frametype = HB_FRAME_B;
+ } break;
+
+ case FF_S_TYPE:
+ {
+ buf->frametype = HB_FRAME_P;
+ } break;
+
+ case FF_SP_TYPE:
+ {
+ buf->frametype = HB_FRAME_P;
+ } break;
+
+ case FF_BI_TYPE:
+ case FF_SI_TYPE:
+ case FF_I_TYPE:
+ {
+ if ( pv->context->coded_frame->key_frame )
+ {
+ buf->frametype = HB_FRAME_IDR;
+ }
+ else
+ {
+ buf->frametype = HB_FRAME_I;
+ }
+ } break;
+
+ default:
+ {
+ if ( pv->context->coded_frame->key_frame )
+ buf->frametype = HB_FRAME_KEY;
+ else
+ buf->frametype = HB_FRAME_REF;
+ } break;
+ }
+ buf = process_delay_list( pv, buf );
+ }
}
else
{
param.i_log_level = X264_LOG_INFO;
/*
- This section passes the string x264opts to libx264 for parsing into
+ This section passes the string advanced_opts to libx264 for parsing into
parameter names and values.
The string is set up like this:
Merritt implemented in the Mplayer/Mencoder project.
*/
- if( job->x264opts != NULL && *job->x264opts != '\0' )
+ if( job->advanced_opts != NULL && *job->advanced_opts != '\0' )
{
char *x264opts, *x264opts_start;
- x264opts = x264opts_start = strdup(job->x264opts);
+ x264opts = x264opts_start = strdup(job->advanced_opts);
while( x264opts_start && *x264opts )
{
/* Here's where the strings are passed to libx264 for parsing. */
ret = x264_param_parse( ¶m, name, value );
- /* Let x264 sanity check the options for us*/
+ /* Let x264 sanity check the options for us*/
if( ret == X264_PARAM_BAD_NAME )
hb_log( "x264 options: Unknown suboption %s", name );
if( ret == X264_PARAM_BAD_VALUE )
Homepage: <http://handbrake.fr/>.
It may be used under the terms of the GNU General Public License. */
+#include "libavcodec/opt.h"
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
track->codecID = MK_VCODEC_MP4ASP;
track->codecPrivate = job->config.mpeg4.bytes;
track->codecPrivateSize = job->config.mpeg4.length;
+ if (job->areBframes)
+ track->minCache = 1;
break;
case HB_VCODEC_THEORA:
{
}
mk_addFrameData(m->file, mux_data->track, buf->data, buf->size);
mk_setFrameFlags(m->file, mux_data->track, timecode,
- ((job->vcodec == HB_VCODEC_X264 &&
+ (((job->vcodec == HB_VCODEC_X264 ||
+ job->vcodec == HB_VCODEC_FFMPEG) &&
mux_data == job->mux_data) ?
(buf->frametype == HB_FRAME_IDR) :
((buf->frametype & HB_FRAME_KEY) != 0)), 0 );
{
/* Video */
- if( job->vcodec == HB_VCODEC_X264 )
+ if( job->vcodec == HB_VCODEC_X264 ||
+ job->vcodec == HB_VCODEC_FFMPEG )
{
if ( buf && buf->start < buf->renderOffset )
{
if ( !buf )
return 0;
- if( job->vcodec == HB_VCODEC_X264 )
+ if( job->vcodec == HB_VCODEC_X264 ||
+ job->vcodec == HB_VCODEC_FFMPEG )
{
// x264 supplies us with DTS, so offset is PTS - DTS
offset = buf->start - buf->renderOffset;
}
}
- if( job->vcodec == HB_VCODEC_X264 )
+ if( job->vcodec == HB_VCODEC_X264 ||
+ job->vcodec == HB_VCODEC_FFMPEG )
{
// x264 supplies us with DTS
if ( m->delay_buf )
}
/* Here's where the sample actually gets muxed. */
- if( job->vcodec == HB_VCODEC_X264 && mux_data == job->mux_data )
+ if( ( job->vcodec == HB_VCODEC_X264 || job->vcodec == HB_VCODEC_FFMPEG )
+ && mux_data == job->mux_data )
{
/* Compute dependency flags.
*
case HB_VCODEC_X264:
hb_log( " + encoder: x264" );
- if( job->x264opts != NULL && *job->x264opts != '\0' )
- hb_log( " + options: %s", job->x264opts);
+ if( job->advanced_opts != NULL && *job->advanced_opts != '\0' )
+ hb_log( " + options: %s", job->advanced_opts);
break;
case HB_VCODEC_THEORA:
* which will determine which subtitles to enable, if any.
*/
job->pass = -1;
- x264opts_tmp = job->x264opts;
+ x264opts_tmp = job->advanced_opts;
- job->x264opts = NULL;
+ job->advanced_opts = NULL;
job->indepth_scan = 1;
* Add the pre-scan job
*/
hb_add( fQueueEncodeLibhb, job );
- job->x264opts = x264opts_tmp;
+ job->advanced_opts = x264opts_tmp;
}
job->pass = 2;
- job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
- strcpy(job->x264opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
+ job->advanced_opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
+ strcpy(job->advanced_opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
hb_add( fQueueEncodeLibhb, job );
/* Below Sends x264 options to the core library if x264 is selected*/
/* Lets use this as per Nyx, Thanks Nyx!*/
- job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
+ job->advanced_opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
/* For previews we ignore the turbo option for the first pass of two since we only use 1 pass */
- strcpy(job->x264opts, [[fAdvancedOptions optionsString] UTF8String]);
+ strcpy(job->advanced_opts, [[fAdvancedOptions optionsString] UTF8String]);
}
/* Below Sends x264 options to the core library if x264 is selected*/
/* Lets use this as per Nyx, Thanks Nyx!*/
- job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
+ job->advanced_opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
/* Turbo first pass if two pass and Turbo First pass is selected */
if( [[queueToApply objectForKey:@"VideoTwoPass"] intValue] == 1 && [[queueToApply objectForKey:@"VideoTurboTwoPass"] intValue] == 1 )
{
/* append the "Turbo" string variable to the existing opts string.
Note: the "Turbo" string must be appended, not prepended to work properly*/
NSString *firstPassOptStringCombined = [[queueToApply objectForKey:@"x264Option"] stringByAppendingString:firstPassOptStringTurbo];
- strcpy(job->x264opts, [firstPassOptStringCombined UTF8String]);
+ strcpy(job->advanced_opts, [firstPassOptStringCombined UTF8String]);
}
else
{
- strcpy(job->x264opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
+ strcpy(job->advanced_opts, [[queueToApply objectForKey:@"x264Option"] UTF8String]);
}
}
* which will determine which subtitles to enable, if any.
*/
job->pass = -1;
- x264opts_tmp = job->x264opts;
+ x264opts_tmp = job->advanced_opts;
- job->x264opts = NULL;
+ job->advanced_opts = NULL;
job->indepth_scan = 1;
/*
* Add the pre-scan job
*/
hb_add( fPreviewLibhb, job );
- job->x264opts = x264opts_tmp;
+ job->advanced_opts = x264opts_tmp;
}
/* Go ahead and perform the actual encoding preview scan */
job->indepth_scan = 0;
job->mux = [currentPreset muxer];
job->vcodec = [currentPreset videoCodec];
- job->x264opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
- strcpy(job->x264opts, [[currentPreset videoCodecOptions] UTF8String]);
+ job->advanced_opts = (char *)calloc(1024, 1); /* Fixme, this just leaks */
+ strcpy(job->advanced_opts, [[currentPreset videoCodecOptions] UTF8String]);
job->chapter_markers = 1;
job->vquality = -1.0;
if hash["VideoTwoPass"] == 1 then commandString << " -2" end
if hash["VideoTurboTwoPass"] == 1 then commandString << " -T" end
- #x264 Options
+ #Advanced Options
if hash["x264Option"] != ""
commandString << " -x "
commandString << hash["x264Option"]
if hash["VideoTwoPass"] == 1 then commandString << " -2" end
if hash["VideoTurboTwoPass"] == 1 then commandString << " -T" end
- #x264 Options
+ #Advanced Options
if hash["x264Option"] != ""
commandString << " -x "
commandString << hash["x264Option"]
end
end
- #x264 Options
+ #Advanced Options
if hash["x264Option"] != ""
- commandString << "if( !x264opts )\n "
+ commandString << "if( !advanced_opts )\n "
commandString << "{\n "
- commandString << " x264opts = strdup(\""
+ commandString << " advanced_opts = strdup(\""
commandString << hash["x264Option"] << "\");\n "
commandString << "}\n "
end
if hash["VideoTwoPass"] == 1 then commandString << " -2" end
if hash["VideoTurboTwoPass"] == 1 then commandString << " -T" end
- #x264 Options
+ #Advanced Options
if hash["x264Option"] != ""
commandString << " -x "
commandString << hash["x264Option"]
static int chapter_end = 0;
static int chapter_markers = 0;
static char * marker_file = NULL;
-static char *x264opts = NULL;
-static char *x264opts2 = NULL;
+static char *advanced_opts = NULL;
+static char *advanced_opts2 = NULL;
static int maxHeight = 0;
static int maxWidth = 0;
static int turbo_opts_enabled = 0;
if( acodecs ) free( acodecs );
if( anames ) free( anames );
if (native_language ) free (native_language );
- if( x264opts ) free (x264opts );
- if( x264opts2 ) free (x264opts2 );
+ if( advanced_opts ) free (advanced_opts );
+ if( advanced_opts2 ) free (advanced_opts2 );
if (preset_name) free (preset_name);
if( stop_at_string ) free( stop_at_string );
if( start_at_string ) free( start_at_string );
dynamic_range_compression = strdup("0.0,0.0");
}
maxWidth = 720;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("cabac=0:ref=2:me=umh:bframes=0:weightp=0:8x8dct=0:trellis=0:subme=6");
+ advanced_opts = strdup("cabac=0:ref=2:me=umh:bframes=0:weightp=0:8x8dct=0:trellis=0:subme=6");
}
if( !anamorphic_mode )
{
dynamic_range_compression = strdup("0.0");
}
maxWidth = 320;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("level=30:bframes=0:weightp=0:cabac=0:ref=1:vbv-maxrate=768:vbv-bufsize=2000:analyse=all:me=umh:no-fast-pskip=1:subme=6:8x8dct=0:trellis=0");
+ advanced_opts = strdup("level=30:bframes=0:weightp=0:cabac=0:ref=1:vbv-maxrate=768:vbv-bufsize=2000:analyse=all:me=umh:no-fast-pskip=1:subme=6:8x8dct=0:trellis=0");
}
job->chapter_markers = 1;
dynamic_range_compression = strdup("0.0");
}
maxWidth = 480;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("cabac=0:ref=2:me=umh:bframes=0:weightp=0:subme=6:8x8dct=0:trellis=0");
+ advanced_opts = strdup("cabac=0:ref=2:me=umh:bframes=0:weightp=0:subme=6:8x8dct=0:trellis=0");
}
job->chapter_markers = 1;
dynamic_range_compression = strdup("0.0,0.0");
}
maxWidth = 960;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("cabac=0:ref=2:me=umh:b-pyramid=none:b-adapt=2:weightb=0:trellis=0:weightp=0:vbv-maxrate=9500:vbv-bufsize=9500");
+ advanced_opts = strdup("cabac=0:ref=2:me=umh:b-pyramid=none:b-adapt=2:weightb=0:trellis=0:weightp=0:vbv-maxrate=9500:vbv-bufsize=9500");
}
if( !anamorphic_mode )
{
{
dynamic_range_compression = strdup("0.0");
}
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("ref=2:bframes=2:subme=6:mixed-refs=0:weightb=0:8x8dct=0:trellis=0");
+ advanced_opts = strdup("ref=2:bframes=2:subme=6:mixed-refs=0:weightb=0:8x8dct=0:trellis=0");
}
if( !anamorphic_mode )
{
{
dynamic_range_compression = strdup("0.0,0.0");
}
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("b-adapt=2:rc-lookahead=50");
+ advanced_opts = strdup("b-adapt=2:rc-lookahead=50");
}
detelecine = 1;
decomb = 1;
{
dynamic_range_compression = strdup("0.0,0.0");
}
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("ref=1:b-pyramid=none:weightp=0:subme=5:me=umh:no-fast-pskip=1:cabac=0:weightb=0:8x8dct=0:trellis=0");
+ advanced_opts = strdup("ref=1:b-pyramid=none:weightp=0:subme=5:me=umh:no-fast-pskip=1:cabac=0:weightb=0:8x8dct=0:trellis=0");
}
if( !anamorphic_mode )
{
dynamic_range_compression = strdup("0.0");
}
maxWidth = 480;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("level=30:cabac=0:ref=1:analyse=all:me=umh:no-fast-pskip=1:psy-rd=0,0:bframes=0:weightp=0:subme=6:8x8dct=0:trellis=0");
+ advanced_opts = strdup("level=30:cabac=0:ref=1:analyse=all:me=umh:no-fast-pskip=1:psy-rd=0,0:bframes=0:weightp=0:subme=6:8x8dct=0:trellis=0");
}
job->chapter_markers = 1;
dynamic_range_compression = strdup("0.0");
}
maxWidth = 640;
- if( !x264opts )
+ if( !advanced_opts )
{
- x264opts = strdup("level=30:bframes=0:weightp=0:cabac=0:ref=1:vbv-maxrate=1500:vbv-bufsize=2000:analyse=all:me=umh:no-fast-pskip=1:psy-rd=0,0:subme=6:8x8dct=0:trellis=0");
+ advanced_opts = strdup("level=30:bframes=0:weightp=0:cabac=0:ref=1:vbv-maxrate=1500:vbv-bufsize=2000:analyse=all:me=umh:no-fast-pskip=1:psy-rd=0,0:subme=6:8x8dct=0:trellis=0");
}
job->chapter_markers = 1;
job->color_matrix = color_matrix;
}
- if( x264opts != NULL && *x264opts != '\0' )
+ if( advanced_opts != NULL && *advanced_opts != '\0' )
{
- job->x264opts = x264opts;
+ job->advanced_opts = advanced_opts;
}
else /*avoids a bus error crash when options aren't specified*/
{
- job->x264opts = NULL;
+ job->advanced_opts = NULL;
}
if (maxWidth)
job->maxWidth = maxWidth;
if( subtitle_scan )
{
- char *x264opts_tmp;
+ char *advanced_opts_tmp;
/*
* When subtitle scan is enabled do a fast pre-scan job
*/
job->pass = -1;
- x264opts_tmp = job->x264opts;
+ advanced_opts_tmp = job->advanced_opts;
- job->x264opts = NULL;
+ job->advanced_opts = NULL;
job->indepth_scan = subtitle_scan;
fprintf( stderr, "Subtitle Scan Enabled - enabling "
*/
hb_add( h, job );
- job->x264opts = x264opts_tmp;
+ job->advanced_opts = advanced_opts_tmp;
}
if( twoPass )
job->indepth_scan = 0;
- if (x264opts)
+ if (advanced_opts)
{
- x264opts2 = strdup(x264opts);
+ advanced_opts2 = strdup(advanced_opts);
}
/*
* If turbo options have been selected then append them
- * to the x264opts now (size includes one ':' and the '\0')
+ * to the advanced_opts now (size includes one ':' and the '\0')
*/
if( turbo_opts_enabled )
{
- int size = (x264opts ? strlen(x264opts) : 0) + strlen(turbo_opts) + 2;
- char *tmp_x264opts;
+ int size = (advanced_opts ? strlen(advanced_opts) : 0) + strlen(turbo_opts) + 2;
+ char *tmp_advanced_opts;
- tmp_x264opts = malloc(size * sizeof(char));
- if( x264opts )
+ tmp_advanced_opts = malloc(size * sizeof(char));
+ if( advanced_opts )
{
- snprintf( tmp_x264opts, size, "%s:%s",
- x264opts, turbo_opts );
- free( x264opts );
+ snprintf( tmp_advanced_opts, size, "%s:%s",
+ advanced_opts, turbo_opts );
+ free( advanced_opts );
} else {
/*
- * No x264opts to modify, but apply the turbo options
+ * No advanced_opts to modify, but apply the turbo options
* anyway as they may be modifying defaults
*/
- snprintf( tmp_x264opts, size, "%s",
+ snprintf( tmp_advanced_opts, size, "%s",
turbo_opts );
}
- x264opts = tmp_x264opts;
+ advanced_opts = tmp_advanced_opts;
fprintf( stderr, "Modified x264 options for pass 1 to append turbo options: %s\n",
- x264opts );
+ advanced_opts );
- job->x264opts = x264opts;
+ job->advanced_opts = advanced_opts;
}
hb_add( h, job );
*/
job->indepth_scan = 0;
- job->x264opts = x264opts2;
+ job->advanced_opts = advanced_opts2;
hb_add( h, job );
}
"### Video Options------------------------------------------------------------\n\n"
" -e, --encoder <string> Set video library encoder (ffmpeg,x264,theora)\n"
" (default: ffmpeg)\n"
- " -x, --x264opts <string> Specify advanced x264 options in the\n"
- " same style as mencoder:\n"
+ " -x, --encopts <string> Specify advanced encoder options in the\n"
+ " same style as mencoder (x264 and ffmpeg only):\n"
" option1=value1:option2=value2\n"
" -q, --quality <number> Set video quality\n"
" -S, --size <MB> Set target size\n"
{ "ab", required_argument, NULL, 'B' },
{ "rate", required_argument, NULL, 'r' },
{ "arate", required_argument, NULL, 'R' },
- { "x264opts", required_argument, NULL, 'x' },
+ { "encopts", required_argument, NULL, 'x' },
{ "turbo", no_argument, NULL, 'T' },
{ "maxHeight", required_argument, NULL, 'Y' },
{ "maxWidth", required_argument, NULL, 'X' },
}
break;
case 'x':
- x264opts = strdup( optarg );
+ advanced_opts = strdup( optarg );
break;
case 'T':
turbo_opts_enabled = 1;
projects / handbrake / commitdiff