X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fx264handler.c;h=72883d85a7cb002daa23958649a149ffe373eb1b;hb=4b72a63eb61a01275493c4bfb51ba02152d1c5e1;hp=4a75520f0368990bbb40240c9cb27d40d4b1e2db;hpb=465945016bd546a8eb524e0e6fcc61361f76b36d;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/x264handler.c b/gtk/src/x264handler.c index 4a75520f..72883d85 100644 --- a/gtk/src/x264handler.c +++ b/gtk/src/x264handler.c @@ -16,15 +16,18 @@ #include "settings.h" #include "values.h" #include "callbacks.h" +#include "presets.h" +#include "hb-backend.h" #include "x264handler.h" +gint ghb_lookup_bframes(const gchar *options); static void x264_opt_update(signal_user_data_t *ud, GtkWidget *widget); static gchar* sanitize_x264opts(signal_user_data_t *ud, const gchar *options); // Flag needed to prevent x264 options processing from chasing its tail static gboolean ignore_options_update = FALSE; -void +G_MODULE_EXPORT void x264_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud) { ghb_widget_to_setting(ud->settings, widget); @@ -34,11 +37,71 @@ x264_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud) x264_opt_update(ud, widget); ignore_options_update = FALSE; } - ghb_check_dependency(ud, widget); + ghb_check_dependency(ud, widget, NULL); ghb_clear_presets_selection(ud); } -void +G_MODULE_EXPORT void +x264_slider_changed_cb(GtkWidget *widget, signal_user_data_t *ud) +{ + ghb_widget_to_setting(ud->settings, widget); + + // Lock slider values to multiples of step_increment + GtkAdjustment * adj = gtk_range_get_adjustment(GTK_RANGE(widget)); + gdouble step = gtk_adjustment_get_step_increment(adj); + gdouble val = gtk_range_get_value(GTK_RANGE(widget)); + gdouble new_val = ((int)((val + step / 2) / step)) * step; + gdouble diff = val - new_val; + if ( diff > 0.0001 || diff < -0.0001 ) + { + gtk_range_set_value(GTK_RANGE(widget), new_val); + } + else if (!ignore_options_update) + { + ignore_options_update = TRUE; + x264_opt_update(ud, widget); + ignore_options_update = FALSE; + } + ghb_check_dependency(ud, widget, NULL); + ghb_clear_presets_selection(ud); +} + +G_MODULE_EXPORT gchar* +x264_format_slider_cb(GtkScale *scale, gdouble val, signal_user_data_t *ud) +{ + return g_strdup_printf("%-6.6g", val); +} + + +G_MODULE_EXPORT void +x264_me_changed_cb(GtkWidget *widget, signal_user_data_t *ud) +{ + gint me; + + ghb_widget_to_setting(ud->settings, widget); + if (!ignore_options_update) + { + ignore_options_update = TRUE; + x264_opt_update(ud, widget); + ignore_options_update = FALSE; + } + ghb_check_dependency(ud, widget, NULL); + ghb_clear_presets_selection(ud); + widget = GHB_WIDGET(ud->builder, "x264_merange"); + me = ghb_settings_combo_int(ud->settings, "x264_me"); + if (me < 2) + { // me < umh + // me_range 4 - 16 + gtk_spin_button_set_range(GTK_SPIN_BUTTON(widget), 4, 16); + } + else + { + // me_range 4 - 64 + gtk_spin_button_set_range(GTK_SPIN_BUTTON(widget), 4, 64); + } +} + +G_MODULE_EXPORT void x264_entry_changed_cb(GtkWidget *widget, signal_user_data_t *ud) { g_debug("x264_entry_changed_cb ()"); @@ -47,9 +110,9 @@ x264_entry_changed_cb(GtkWidget *widget, signal_user_data_t *ud) GtkWidget *textview; gchar *options; - textview = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264_options")); + textview = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264Option")); ghb_widget_to_setting(ud->settings, textview); - options = ghb_settings_get_string(ud->settings, "x264_options"); + options = ghb_settings_get_string(ud->settings, "x264Option"); ignore_options_update = TRUE; ghb_x264_parse_options(ud, options); if (!GTK_WIDGET_HAS_FOCUS(textview)) @@ -57,7 +120,7 @@ x264_entry_changed_cb(GtkWidget *widget, signal_user_data_t *ud) gchar *sopts; sopts = sanitize_x264opts(ud, options); - ghb_ui_update(ud, "x264_options", ghb_string_value(sopts)); + ghb_ui_update(ud, "x264Option", ghb_string_value(sopts)); ghb_x264_parse_options(ud, sopts); g_free(sopts); } @@ -66,19 +129,19 @@ x264_entry_changed_cb(GtkWidget *widget, signal_user_data_t *ud) } } -gboolean +G_MODULE_EXPORT gboolean x264_focus_out_cb(GtkWidget *widget, GdkEventFocus *event, signal_user_data_t *ud) { gchar *options, *sopts; ghb_widget_to_setting(ud->settings, widget); - options = ghb_settings_get_string(ud->settings, "x264_options"); + options = ghb_settings_get_string(ud->settings, "x264Option"); sopts = sanitize_x264opts(ud, options); ignore_options_update = TRUE; - if (sopts != NULL) + if (sopts != NULL && strcmp(sopts, options) != 0) { - ghb_ui_update(ud, "x264_options", ghb_string_value(sopts)); + ghb_ui_update(ud, "x264Option", ghb_string_value(sopts)); ghb_x264_parse_options(ud, sopts); } g_free(options); @@ -89,38 +152,95 @@ x264_focus_out_cb(GtkWidget *widget, GdkEventFocus *event, enum { + X264_OPT_NONE, + X264_OPT_BOOL_NONE, + X264_OPT_INT_NONE, X264_OPT_DEBLOCK, + X264_OPT_PSY, X264_OPT_INT, + X264_OPT_DOUBLE, X264_OPT_COMBO, X264_OPT_BOOL, + X264_OPT_TRANS, }; +typedef struct +{ + gchar *x264_val; + char *ui_val; +} trans_entry_t; + +typedef struct +{ + gint count; + gint x264_type; + gint ui_type; + trans_entry_t *map; +} trans_table_t; + +static gchar * +trans_x264_val(trans_table_t *trans, char *val) +{ + int ii; + + if (val == NULL) + return NULL; + for (ii = 0; ii < trans->count; ii++) + { + if (strcmp(val, trans->map[ii].x264_val) == 0) + { + return trans->map[ii].ui_val; + } + } + return NULL; +} + +static gchar * +trans_ui_val(trans_table_t *trans, char *val) +{ + int ii; + + if (val == NULL) + return NULL; + for (ii = 0; ii < trans->count; ii++) + { + if (strcmp(val, trans->map[ii].ui_val) == 0) + { + return trans->map[ii].x264_val; + } + } + return NULL; +} + struct x264_opt_map_s { gchar **opt_syns; gchar *name; gchar *def_val; gint type; + trans_table_t *translation; gboolean found; }; static gchar *x264_ref_syns[] = {"ref", "frameref", NULL}; -static gchar *x264_mixed_syns[] = {"mixed-refs", "mixed_refs", NULL}; static gchar *x264_bframes_syns[] = {"bframes", NULL}; +static gchar *x264_badapt_syns[] = {"b-adapt", "b_adapt", NULL}; static gchar *x264_direct_syns[] = {"direct", "direct-pred", "direct_pred", NULL}; -static gchar *x264_weightb_syns[] = {"weightb", "weight-b", "weight_b", NULL}; -static gchar *x264_brdo_syns[] = {"brdo", "b-rdo", "b_rdo", NULL}; -static gchar *x264_bime_syns[] = {"bime", NULL}; +static gchar *x264_weightp_syns[] = {"weightp", NULL}; static gchar *x264_bpyramid_syns[] = {"b-pyramid", "b_pyramid", NULL}; static gchar *x264_me_syns[] = {"me", NULL}; static gchar *x264_merange_syns[] = {"merange", "me-range", "me_range", NULL}; static gchar *x264_subme_syns[] = {"subme", "subq", NULL}; -static gchar *x264_analyse_syns[] = {"analyse", "partitions", NULL}; +static gchar *x264_aqmode_syns[] = {"aq-mode", NULL}; +static gchar *x264_analyse_syns[] = {"partitions", "analyse", NULL}; static gchar *x264_8x8dct_syns[] = {"8x8dct", NULL}; static gchar *x264_deblock_syns[] = {"deblock", "filter", NULL}; static gchar *x264_trellis_syns[] = {"trellis", NULL}; static gchar *x264_pskip_syns[] = {"no-fast-pskip", "no_fast_pskip", NULL}; +static gchar *x264_psy_syns[] = {"psy-rd", "psy_rd", NULL}; +static gchar *x264_aq_strength_syns[] = {"aq-strength", "aq_strength", NULL}; +static gchar *x264_mbtree_syns[] = {"mbtree", NULL}; static gchar *x264_decimate_syns[] = {"no-dct-decimate", "no_dct_decimate", NULL}; static gchar *x264_cabac_syns[] = {"cabac", NULL}; @@ -139,25 +259,28 @@ find_syn_match(const gchar *opt, gchar **syns) struct x264_opt_map_s x264_opt_map[] = { - {x264_ref_syns, "x264_refs", "1", X264_OPT_INT}, - {x264_mixed_syns, "x264_mixed_refs", "0", X264_OPT_BOOL}, - {x264_bframes_syns, "x264_bframes", "0", X264_OPT_INT}, + {x264_ref_syns, "x264_refs", "3", X264_OPT_INT}, + {x264_bframes_syns, "x264_bframes", "3", X264_OPT_INT}, {x264_direct_syns, "x264_direct", "spatial", X264_OPT_COMBO}, - {x264_weightb_syns, "x264_weighted_bframes", "0", X264_OPT_BOOL}, - {x264_brdo_syns, "x264_brdo", "0", X264_OPT_BOOL}, - {x264_bime_syns, "x264_bime", "0", X264_OPT_BOOL}, - {x264_bpyramid_syns, "x264_bpyramid", "0", X264_OPT_BOOL}, + {x264_badapt_syns, "x264_b_adapt", "1", X264_OPT_COMBO}, + {x264_weightp_syns, "x264_weighted_pframes", "2", X264_OPT_COMBO}, + {x264_bpyramid_syns, "x264_bpyramid", "normal", X264_OPT_COMBO}, {x264_me_syns, "x264_me", "hex", X264_OPT_COMBO}, {x264_merange_syns, "x264_merange", "16", X264_OPT_INT}, - {x264_subme_syns, "x264_subme", "6", X264_OPT_COMBO}, - {x264_analyse_syns, "x264_analyse", "some", X264_OPT_COMBO}, - {x264_8x8dct_syns, "x264_8x8dct", "0", X264_OPT_BOOL}, + {x264_subme_syns, "x264_subme", "7", X264_OPT_COMBO}, + {x264_aqmode_syns, "x264_aqmode", "1", X264_OPT_INT_NONE}, + {x264_analyse_syns, "x264_analyse", "p8x8,b8x8,i8x8,i4x4", X264_OPT_COMBO}, + {x264_8x8dct_syns, "x264_8x8dct", "1", X264_OPT_BOOL}, {x264_deblock_syns, "x264_deblock_alpha", "0,0", X264_OPT_DEBLOCK}, {x264_deblock_syns, "x264_deblock_beta", "0,0", X264_OPT_DEBLOCK}, - {x264_trellis_syns, "x264_trellis", "0", X264_OPT_COMBO}, + {x264_trellis_syns, "x264_trellis", "1", X264_OPT_COMBO}, {x264_pskip_syns, "x264_no_fast_pskip", "0", X264_OPT_BOOL}, {x264_decimate_syns, "x264_no_dct_decimate", "0", X264_OPT_BOOL}, {x264_cabac_syns, "x264_cabac", "1", X264_OPT_BOOL}, + {x264_aq_strength_syns, "x264_aq_strength", "1", X264_OPT_DOUBLE}, + {x264_psy_syns, "x264_psy_rd", "1,0", X264_OPT_PSY}, + {x264_psy_syns, "x264_psy_trell", "1,0", X264_OPT_PSY}, + {x264_mbtree_syns, "x264_mbtree", "1", X264_OPT_BOOL_NONE}, }; #define X264_OPT_MAP_SIZE (sizeof(x264_opt_map)/sizeof(struct x264_opt_map_s)) @@ -176,6 +299,16 @@ x264_opt_get_default(const gchar *opt) } static void +x264_update_double(signal_user_data_t *ud, const gchar *name, const gchar *val) +{ + gdouble dval; + + if (val == NULL) return; + dval = g_strtod (val, NULL); + ghb_ui_update(ud, name, ghb_double_value(dval)); +} + +static void x264_update_int(signal_user_data_t *ud, const gchar *name, const gchar *val) { gint ival; @@ -185,6 +318,17 @@ x264_update_int(signal_user_data_t *ud, const gchar *name, const gchar *val) ghb_ui_update(ud, name, ghb_int64_value(ival)); } +static void +x264_update_int_setting(signal_user_data_t *ud, const gchar *name, const gchar *val) +{ + gint ival; + + if (val == NULL) return; + ival = g_strtod (val, NULL); + ghb_settings_set_value(ud->settings, name, ghb_int64_value(ival)); + ghb_check_dependency(ud, NULL, name); +} + static gchar *true_str[] = { "true", @@ -215,12 +359,23 @@ x264_update_bool(signal_user_data_t *ud, const gchar *name, const gchar *val) } static void +x264_update_bool_setting(signal_user_data_t *ud, const gchar *name, const gchar *val) +{ + if (val == NULL) + ghb_settings_set_value(ud->settings, name, ghb_boolean_value(1)); + else + ghb_settings_set_value(ud->settings, name, ghb_boolean_value(str_is_true(val))); + + ghb_check_dependency(ud, NULL, name); +} + +static void x264_update_combo(signal_user_data_t *ud, const gchar *name, const gchar *val) { GtkTreeModel *store; GtkTreeIter iter; gchar *shortOpt; - gint ivalue; + gdouble ivalue; gboolean foundit = FALSE; GtkWidget *widget; @@ -301,6 +456,67 @@ x264_update_deblock(signal_user_data_t *ud, const gchar *xval) ghb_ui_update(ud, "x264_deblock_beta", ghb_int64_value(bvalue)); } +static void +x264_parse_psy(const gchar *psy, gdouble *psy_rd, gdouble *psy_trell) +{ + gchar *val; + gchar *trell_val = NULL; + gchar *end; + + *psy_rd = 0.; + *psy_trell = 0.; + if (psy == NULL) return; + val = g_strdup(psy); + gchar *pos = strchr(val, ','); + if (pos != NULL) + { + trell_val = pos + 1; + *pos = 0; + } + *psy_rd = g_strtod (val, &end); + if (trell_val != NULL) + { + *psy_trell = g_strtod (trell_val, &end); + } + g_free(val); +} + +static void +x264_update_psy(signal_user_data_t *ud, const gchar *xval) +{ + gdouble rd_value, trell_value; + + if (xval == NULL) return; + x264_parse_psy(xval, &rd_value, &trell_value); + ghb_ui_update(ud, "x264_psy_rd", ghb_double_value(rd_value)); + ghb_ui_update(ud, "x264_psy_trell", ghb_double_value(trell_value)); +} + +static void do_update(signal_user_data_t *ud, char *name, gint type, char *val) +{ + switch(type) + { + case X264_OPT_INT: + x264_update_int(ud, name, val); + break; + case X264_OPT_DOUBLE: + x264_update_double(ud, name, val); + break; + case X264_OPT_BOOL: + x264_update_bool(ud, name, val); + break; + case X264_OPT_COMBO: + x264_update_combo(ud, name, val); + break; + case X264_OPT_BOOL_NONE: + x264_update_bool_setting(ud, name, val); + break; + case X264_OPT_INT_NONE: + x264_update_int_setting(ud, name, val); + break; + } +} + void ghb_x264_parse_options(signal_user_data_t *ud, const gchar *options) { @@ -332,6 +548,9 @@ ghb_x264_parse_options(signal_user_data_t *ud, const gchar *options) case X264_OPT_INT: x264_update_int(ud, x264_opt_map[jj].name, val); break; + case X264_OPT_DOUBLE: + x264_update_double(ud, x264_opt_map[jj].name, val); + break; case X264_OPT_BOOL: x264_update_bool(ud, x264_opt_map[jj].name, val); break; @@ -343,6 +562,32 @@ ghb_x264_parse_options(signal_user_data_t *ud, const gchar *options) x264_opt_map[jj+1].found = TRUE; x264_update_deblock(ud, val); break; + case X264_OPT_PSY: + // dirty little hack. mark psy_trell found as well + x264_opt_map[jj+1].found = TRUE; + x264_update_psy(ud, val); + break; + case X264_OPT_BOOL_NONE: + x264_update_bool_setting(ud, x264_opt_map[jj].name, val); + break; + case X264_OPT_INT_NONE: + x264_update_int_setting(ud, x264_opt_map[jj].name, val); + break; + case X264_OPT_TRANS: + if (x264_opt_map[jj].translation == NULL) + break; + val = trans_x264_val(x264_opt_map[jj].translation, val); + if (val != NULL) + { + do_update(ud, x264_opt_map[jj].name, + x264_opt_map[jj].translation->ui_type, val); + // TODO un-grey the ui control + } + else + { + // TODO grey out the ui control + } + break; } break; } @@ -360,6 +605,9 @@ ghb_x264_parse_options(signal_user_data_t *ud, const gchar *options) case X264_OPT_INT: x264_update_int(ud, x264_opt_map[jj].name, val); break; + case X264_OPT_DOUBLE: + x264_update_double(ud, x264_opt_map[jj].name, val); + break; case X264_OPT_BOOL: x264_update_bool(ud, x264_opt_map[jj].name, val); break; @@ -369,6 +617,30 @@ ghb_x264_parse_options(signal_user_data_t *ud, const gchar *options) case X264_OPT_DEBLOCK: x264_update_deblock(ud, val); break; + case X264_OPT_PSY: + x264_update_psy(ud, val); + break; + case X264_OPT_BOOL_NONE: + x264_update_bool_setting(ud, x264_opt_map[jj].name, val); + break; + case X264_OPT_INT_NONE: + x264_update_int_setting(ud, x264_opt_map[jj].name, val); + break; + case X264_OPT_TRANS: + if (x264_opt_map[jj].translation == NULL) + break; + val = g_strdup(trans_x264_val(x264_opt_map[jj].translation, val)); + if (val != NULL) + { + do_update(ud, x264_opt_map[jj].name, + x264_opt_map[jj].translation->ui_type, val); + // TODO un-grey the ui control + } + else + { + // TODO grey out the ui control + } + break; } x264_opt_map[jj].found = TRUE; g_free(val); @@ -390,14 +662,26 @@ get_deblock_val(signal_user_data_t *ud) return result; } +gchar* +get_psy_val(signal_user_data_t *ud) +{ + gdouble rd, trell; + gchar *result; + rd = ghb_settings_get_double(ud->settings, "x264_psy_rd"); + trell = ghb_settings_get_double(ud->settings, "x264_psy_trell"); + result = g_strdup_printf("%g,%g", rd, trell); + return result; +} + static void x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) { gint jj; - const gchar *name = gtk_widget_get_name(widget); + const gchar *name = ghb_get_setting_key(widget); gchar **opt_syns = NULL; const gchar *def_val = NULL; gint type; + trans_table_t *trans; for (jj = 0; jj < X264_OPT_MAP_SIZE; jj++) { @@ -407,6 +691,7 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) opt_syns = x264_opt_map[jj].opt_syns; def_val = x264_opt_map[jj].def_val; type = x264_opt_map[jj].type; + trans = x264_opt_map[jj].translation; break; } } @@ -418,7 +703,7 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) gint ii; gboolean foundit = FALSE; - options = ghb_settings_get_string(ud->settings, "x264_options"); + options = ghb_settings_get_string(ud->settings, "x264Option"); if (options) { split = g_strsplit(options, ":", -1); @@ -441,6 +726,8 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) foundit = TRUE; if (type == X264_OPT_DEBLOCK) val = get_deblock_val(ud); + else if (type == X264_OPT_PSY) + val = get_psy_val(ud); else { GValue *gval; @@ -458,6 +745,16 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) } ghb_value_free(gval); } + if (type == X264_OPT_TRANS) + { + gchar *tmp; + tmp = g_strdup(trans_ui_val(trans, val)); + if (tmp) + { + g_free(val); + val = tmp; + } + } if (strcmp(def_val, val) != 0) { g_string_append_printf(x264opts, "%s=%s:", opt_syns[syn], val); @@ -476,6 +773,8 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) gchar *val; if (type == X264_OPT_DEBLOCK) val = get_deblock_val(ud); + else if (type == X264_OPT_PSY) + val = get_psy_val(ud); else { GValue *gval; @@ -493,6 +792,16 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) } ghb_value_free(gval); } + if (type == X264_OPT_TRANS) + { + gchar *tmp; + tmp = g_strdup(trans_ui_val(trans, val)); + if (tmp) + { + g_free(val); + val = tmp; + } + } if (strcmp(def_val, val) != 0) { g_string_append_printf(x264opts, "%s=%s:", opt_syns[0], val); @@ -508,13 +817,36 @@ x264_opt_update(signal_user_data_t *ud, GtkWidget *widget) if (len > 0) result[len - 1] = 0; gchar *sopts; sopts = sanitize_x264opts(ud, result); - ghb_ui_update(ud, "x264_options", ghb_string_value(sopts)); + ghb_ui_update(ud, "x264Option", ghb_string_value(sopts)); ghb_x264_parse_options(ud, sopts); g_free(sopts); g_free(result); } } +static gint +x264_find_opt(gchar **opts, gchar **opt_syns) +{ + gint ii; + for (ii = 0; opts[ii] != NULL; ii++) + { + gchar *opt; + opt = g_strdup(opts[ii]); + gchar *pos = strchr(opt, '='); + if (pos != NULL) + { + *pos = 0; + } + if (find_syn_match(opt, opt_syns) >= 0) + { + g_free(opt); + return ii; + } + g_free(opt); + } + return -1; +} + static void x264_remove_opt(gchar **opts, gchar **opt_syns) { @@ -537,6 +869,122 @@ x264_remove_opt(gchar **opts, gchar **opt_syns) } } +static gchar* +x264_lookup_value(gchar **opts, gchar **opt_syns) +{ + gchar *ret = NULL; + gint pos; + + const gchar *def_val = x264_opt_get_default(opt_syns[0]); + + pos = x264_find_opt(opts, opt_syns); + if (pos >= 0) + { + gchar *cpos = strchr(opts[pos], '='); + if (cpos != NULL) + { + ret = g_strdup(cpos+1); + } + else + { + ret = g_strdup(""); + } + } + else if (def_val != NULL) + { + ret = g_strdup(def_val); + } + return ret; +} + +gint +ghb_lookup_badapt(const gchar *options) +{ + gint ret = 0; + gchar *result; + gchar **split; + + if (options == NULL) + options = ""; + + split = g_strsplit(options, ":", -1); + + result = x264_lookup_value(split, x264_badapt_syns); + g_strfreev(split); + if (result != NULL) + { + ret = g_strtod(result, NULL); + g_free(result); + } + return ret; +} + +gint +ghb_lookup_aqmode(const gchar *options) +{ + gint ret = 0; + gchar *result; + gchar **split; + + if (options == NULL) + options = ""; + + split = g_strsplit(options, ":", -1); + + result = x264_lookup_value(split, x264_aqmode_syns); + g_strfreev(split); + if (result != NULL) + { + ret = g_strtod(result, NULL); + g_free(result); + } + return ret; +} + +gint +ghb_lookup_bframes(const gchar *options) +{ + gint ret = 0; + gchar *result; + gchar **split; + + if (options == NULL) + options = ""; + + split = g_strsplit(options, ":", -1); + + result = x264_lookup_value(split, x264_bframes_syns); + g_strfreev(split); + if (result != NULL) + { + ret = g_strtod(result, NULL); + g_free(result); + } + return ret; +} + +gint +ghb_lookup_mbtree(const gchar *options) +{ + gint ret = ghb_lookup_bframes(options) != 0; + gchar *result; + gchar **split; + + if (options == NULL) + options = ""; + + split = g_strsplit(options, ":", -1); + + result = x264_lookup_value(split, x264_mbtree_syns); + g_strfreev(split); + if (result != NULL) + { + ret = g_strtod(result, NULL); + g_free(result); + } + return ret; +} + // Construct the x264 options string // The result is allocated, so someone must free it at some point. static gchar* @@ -544,9 +992,53 @@ sanitize_x264opts(signal_user_data_t *ud, const gchar *options) { GString *x264opts = g_string_new(""); gchar **split = g_strsplit(options, ":", -1); + gint ii; + + // Fix up option dependencies + gint subme = ghb_settings_combo_int(ud->settings, "x264_subme"); + if (subme < 6) + { + x264_remove_opt(split, x264_psy_syns); + } + gint trell = ghb_settings_combo_int(ud->settings, "x264_trellis"); + if (subme == 10) + { + gint aqmode = ghb_lookup_aqmode(options); + if (trell != 2 || aqmode == 0) + { + gint pos = x264_find_opt(split, x264_subme_syns); + g_free(split[pos]); + split[pos] = g_strdup_printf("subme=9"); + } + } + if (trell < 1) + { + gint psy; + gdouble psy_rd = 0., psy_trell; + psy = x264_find_opt(split, x264_psy_syns); + if (psy >= 0) + { + gchar *pos = strchr(split[psy], '='); + if (pos != NULL) + { + x264_parse_psy(pos+1, &psy_rd, &psy_trell); + } + g_free(split[psy]); + split[psy] = g_strdup_printf("psy-rd=%g,0", psy_rd); + } + } + gint bframes = ghb_settings_get_int(ud->settings, "x264_bframes"); + if (bframes == 0) + { + x264_remove_opt(split, x264_direct_syns); + x264_remove_opt(split, x264_badapt_syns); + } + if (bframes <= 1) + { + x264_remove_opt(split, x264_bpyramid_syns); + } // Remove entries that match the defaults - gint ii; for (ii = 0; split[ii] != NULL; ii++) { gchar *val = NULL; @@ -561,7 +1053,8 @@ sanitize_x264opts(signal_user_data_t *ud, const gchar *options) { val = "1"; } - const gchar *def_val = x264_opt_get_default(opt); + const gchar *def_val; + def_val = x264_opt_get_default(opt); if (strcmp(val, def_val) == 0) { // Matches the default, so remove it @@ -569,40 +1062,6 @@ sanitize_x264opts(signal_user_data_t *ud, const gchar *options) } g_free(opt); } - gint refs = ghb_settings_get_int(ud->settings, "x264_refs"); - if (refs <= 1) - { - x264_remove_opt(split, x264_mixed_syns); - } - gint subme; - - subme = ghb_settings_combo_int(ud->settings, "x264_subme"); - if (subme < 6) - { - x264_remove_opt(split, x264_brdo_syns); - } - gint bframes = ghb_settings_get_int(ud->settings, "x264_bframes"); - if (bframes == 0) - { - x264_remove_opt(split, x264_weightb_syns); - x264_remove_opt(split, x264_brdo_syns); - x264_remove_opt(split, x264_bime_syns); - x264_remove_opt(split, x264_direct_syns); - } - if (bframes <= 1) - { - x264_remove_opt(split, x264_bpyramid_syns); - } - gchar *me = ghb_settings_get_string(ud->settings, "x264_me"); - if (!(strcmp(me, "umh") == 0 || strcmp(me, "esa") == 0)) - { - x264_remove_opt(split, x264_merange_syns); - } - g_free(me); - if (!ghb_settings_get_boolean(ud->settings, "x264_cabac")) - { - x264_remove_opt(split, x264_trellis_syns); - } for (ii = 0; split[ii] != NULL; ii++) { if (split[ii][0] != 0)