G_MODULE_EXPORT void
x264_use_advanced_options_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
ghb_widget_to_setting(ud->settings, widget);
if (ghb_dict_get_bool(ud->prefs, "HideAdvancedVideoSettings") &&
ghb_dict_get_bool(ud->settings, "x264UseAdvancedOptions"))
{
ghb_ui_update(ud, "x264UseAdvancedOptions", ghb_boolean_value(FALSE));
return;
}
if (ghb_dict_get_bool(ud->settings, "x264UseAdvancedOptions"))
{
ghb_ui_update(ud, "VideoPresetSlider", ghb_int_value(5));
ghb_ui_update(ud, "VideoTune", ghb_string_value("none"));
ghb_ui_update(ud, "VideoProfile", ghb_string_value("auto"));
ghb_ui_update(ud, "VideoLevel", ghb_string_value("auto"));
const char *options = ghb_dict_get_string(ud->settings, "x264Option");
ghb_ui_update(ud, "VideoOptionExtra", ghb_string_value(options));
}
ghb_check_dependency(ud, widget, NULL);
ghb_clear_presets_selection(ud);
}
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;
}
gboolean
ghb_background_refresh_x264Option(signal_user_data_t *ud)
{
const char *opt;
opt = ghb_dict_get_string(ud->settings, "x264Option");
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter start, end;
gchar *str;
widget = GHB_WIDGET(ud->builder, "x264Option");
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_get_bounds(buffer, &start, &end);
str = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
// If the value has changed, then update it
if (opt != NULL)
{
if (str == NULL || strcmp(str, opt))
{
ud->dont_clear_presets = 1;
ghb_ui_update(ud, "x264Option", ghb_string_value(opt));
ud->dont_clear_presets = 0;
}
}
free(str);
return FALSE;
}
G_MODULE_EXPORT void
gain_widget_changed_cb(GtkWidget *widget, gdouble gain, signal_user_data_t *ud)
{
GValue *asettings;
g_debug("gain_widget_changed_cb ()");
ghb_check_dependency(ud, widget, NULL);
if (block_updates) return;
asettings = get_selected_asettings(ud);
char *s_gain;
if ( gain >= 21.0 )
s_gain = g_strdup_printf("*11*");
else
s_gain = g_strdup_printf("%ddB", (int)gain);
ghb_ui_update( ud, "AudioTrackGainValue", ghb_string_value(s_gain));
g_free(s_gain);
if (asettings != NULL)
{
ghb_widget_to_setting(asettings, widget);
ghb_audio_list_refresh_selected(ud);
}
ghb_live_reset(ud);
}
G_MODULE_EXPORT void
drc_widget_changed_cb(GtkWidget *widget, gdouble drc, signal_user_data_t *ud)
{
GValue *asettings;
g_debug("drc_widget_changed_cb ()");
ghb_check_dependency(ud, widget, NULL);
if (block_updates) return;
char *s_drc;
if (drc < 0.99)
s_drc = g_strdup("Off");
else
s_drc = g_strdup_printf("%.1f", drc);
ghb_ui_update( ud, "AudioTrackDRCValue", ghb_string_value(s_drc));
g_free(s_drc);
asettings = get_selected_asettings(ud);
if (asettings != NULL)
{
ghb_widget_to_setting(asettings, widget);
ghb_audio_list_refresh_selected(ud);
}
ghb_live_reset(ud);
}
G_MODULE_EXPORT void
quality_widget_changed_cb(GtkWidget *widget, gdouble quality, signal_user_data_t *ud)
{
GValue *asettings;
g_debug("quality_widget_changed_cb ()");
ghb_check_dependency(ud, widget, NULL);
float low, high, gran;
int dir;
int codec = ghb_settings_combo_int(ud->settings, "AudioEncoderActual");
hb_audio_quality_get_limits(codec, &low, &high, &gran, &dir);
if (dir)
{
// Quality values are inverted
quality = high - quality + low;
}
char *s_quality = ghb_format_quality("", codec, quality);
ghb_ui_update( ud, "AudioTrackQualityValue", ghb_string_value(s_quality));
g_free(s_quality);
if (block_updates) return;
asettings = get_selected_asettings(ud);
if (asettings != NULL)
{
ghb_settings_set_double(asettings, "AudioTrackQuality", quality);
ghb_audio_list_refresh_selected(ud);
}
ghb_live_reset(ud);
}
static void
IoRedirect(signal_user_data_t *ud)
{
GIOChannel *channel;
gint pfd[2];
gchar *config, *path, *str;
pid_t pid;
// I'm opening a pipe and attaching the writer end to stderr
// The reader end will be polled by main event loop and I'll get
// a callback when there is data available.
if (pipe( pfd ) < 0)
{
g_warning("Failed to redirect IO. Logging impaired\n");
return;
}
clean_old_logs();
// Open activity log.
config = ghb_get_user_config_dir(NULL);
pid = getpid();
path = g_strdup_printf("%s/Activity.log.%d", config, pid);
ud->activity_log = g_io_channel_new_file (path, "w", NULL);
ud->job_activity_log = NULL;
str = g_strdup_printf("<big><b>%s</b></big>", path);
ghb_ui_update(ud, "activity_location", ghb_string_value(str));
g_free(str);
g_free(path);
g_free(config);
// Set encoding to raw.
g_io_channel_set_encoding(ud->activity_log, NULL, NULL);
// redirect stderr to the writer end of the pipe
#if defined(_WIN32)
_dup2(pfd[1], _fileno(stderr));
#else
dup2(pfd[1], STDERR_FILENO);
#endif
setvbuf(stderr, NULL, _IONBF, 0);
#if defined(_WIN32)
channel = g_io_channel_win32_new_fd(pfd[0]);
#else
channel = g_io_channel_unix_new(pfd[0]);
#endif
// I was getting an this error:
// "Invalid byte sequence in conversion input"
// Set disable encoding on the channel.
g_io_channel_set_encoding(channel, NULL, NULL);
g_io_add_watch(channel, G_IO_IN, ghb_log_cb, (gpointer)ud );
}
G_MODULE_EXPORT void
vcodec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
float val, vqmin, vqmax, step, page;
int inverted, digits;
ghb_widget_to_setting(ud->settings, widget);
ghb_check_dependency(ud, widget, NULL);
ghb_show_container_options(ud);
ghb_update_summary_info(ud);
ghb_clear_presets_selection(ud);
ghb_live_reset(ud);
// Set the range of the video quality slider
val = ghb_vquality_default(ud);
ghb_vquality_range(ud, &vqmin, &vqmax, &step, &page, &digits, &inverted);
ghb_scale_configure(ud, "VideoQualitySlider", val, vqmin, vqmax,
step, page, digits, inverted);
ghb_update_ui_combo_box(ud, "VideoTune", NULL, FALSE);
ghb_update_ui_combo_box(ud, "VideoProfile", NULL, FALSE);
ghb_update_ui_combo_box(ud, "VideoLevel", NULL, FALSE);
ghb_ui_update(ud, "VideoTune", ghb_int_value(0));
ghb_ui_update(ud, "VideoProfile", ghb_int_value(0));
ghb_ui_update(ud, "VideoLevel", ghb_int_value(0));
ghb_ui_update(ud, "VideoOptionExtra", ghb_string_value(""));
// Set the range of the preset slider
int encoder = ghb_get_video_encoder(ud->settings);
GtkWidget *presetSlider = GHB_WIDGET(ud->builder, "VideoPresetSlider");
GtkWidget *presetLabel = GHB_WIDGET(ud->builder, "VideoPresetLabel");
const char * const *video_presets;
int count = 0;
video_presets = hb_video_encoder_get_presets(encoder);
while (video_presets && video_presets[count]) count++;
gtk_widget_set_visible(presetSlider, count > 0);
gtk_widget_set_visible(presetLabel, count > 0);
if (count)
{
gtk_range_set_range(GTK_RANGE(presetSlider), 0, count-1);
}
ghb_set_video_preset(ud->settings, encoder, "medium");
GhbValue *gval = ghb_dict_get_value(ud->settings, "VideoPresetSlider");
ghb_ui_settings_update(ud, ud->settings, "VideoPresetSlider", gval);
// Advanced options are only for x264
if (!(encoder & HB_VCODEC_X264_MASK))
{
ghb_ui_update(ud, "x264UseAdvancedOptions", ghb_boolean_value(FALSE));
}
}
G_MODULE_EXPORT void
x264_entry_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
g_debug("x264_entry_changed_cb ()");
static char *tt = NULL;
if (tt == NULL)
{
GtkWidget *eo = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264OptionExtra"));
tt = gtk_widget_get_tooltip_text(eo);
}
if (!ignore_options_update)
{
GtkWidget *textview;
gchar *options;
textview = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264Option"));
ghb_widget_to_setting(ud->settings, textview);
options = ghb_settings_get_string(ud->settings, "x264Option");
ignore_options_update = TRUE;
ghb_x264_parse_options(ud, options);
if (!gtk_widget_has_focus(textview))
{
gchar *sopts;
sopts = sanitize_x264opts(ud, options);
ghb_ui_update(ud, "x264Option", ghb_string_value(sopts));
ghb_x264_parse_options(ud, sopts);
GtkWidget *eo = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264OptionExtra"));
char * new_tt;
if (sopts)
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"%s\"", tt, sopts);
else
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"\"", tt);
gtk_widget_set_tooltip_text(eo, new_tt);
g_free(new_tt);
g_free(options);
options = sopts;
}
g_free(options);
ignore_options_update = FALSE;
}
}
G_MODULE_EXPORT gboolean
x264_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
signal_user_data_t *ud)
{
const gchar *options;
gchar *sopts;
ghb_widget_to_setting(ud->settings, widget);
options = ghb_dict_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(sopts);
ignore_options_update = FALSE;
return FALSE;
}
void
ghb_queue_buttons_grey(signal_user_data_t *ud)
{
GtkWidget *widget;
GtkAction *action;
gint queue_count;
gint titleindex;
gint queue_state, scan_state;
gboolean show_start, show_stop, paused;
queue_count = ghb_array_len(ud->queue);
titleindex = ghb_settings_combo_int(ud->settings, "title");
queue_state = ghb_get_queue_state();
scan_state = ghb_get_scan_state();
show_stop = queue_state &
(GHB_STATE_WORKING | GHB_STATE_SEARCHING |
GHB_STATE_SCANNING | GHB_STATE_MUXING);
show_start = !(scan_state & GHB_STATE_SCANNING) &&
(titleindex >= 0 || queue_count > 0);
paused = queue_state & GHB_STATE_PAUSED;
widget = GHB_WIDGET(ud->builder, "queue_add");
gtk_widget_set_sensitive(widget, show_start);
action = GHB_ACTION(ud->builder, "queue_add_menu");
gtk_action_set_sensitive(action, show_start);
action = GHB_ACTION(ud->builder, "queue_add_all_menu");
gtk_action_set_sensitive(action, show_start);
widget = GHB_WIDGET (ud->builder, "queue_start1");
if (show_stop)
{
gtk_widget_set_sensitive (widget, TRUE);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-stop");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Stop");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Stop Encoding");
}
else
{
gtk_widget_set_sensitive (widget, show_start);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-start");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Start");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Start Encoding");
}
widget = GHB_WIDGET (ud->builder, "queue_start2");
if (show_stop)
{
gtk_widget_set_sensitive (widget, TRUE);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-stop");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Stop");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Stop Encoding");
}
else
{
gtk_widget_set_sensitive (widget, show_start);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-start");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Start");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Start Encoding");
}
widget = GHB_WIDGET (ud->builder, "queue_pause1");
if (paused)
{
gtk_widget_set_sensitive (widget, show_stop);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-start");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Resume");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Resume Encoding");
}
else
{
gtk_widget_set_sensitive (widget, show_stop);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-pause");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Pause");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Pause Encoding");
}
widget = GHB_WIDGET (ud->builder, "queue_pause2");
if (paused)
{
gtk_widget_set_sensitive (widget, show_stop);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-start");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Resume");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Resume Encoding");
}
else
{
gtk_widget_set_sensitive (widget, show_stop);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(widget), "hb-pause");
gtk_tool_button_set_label(GTK_TOOL_BUTTON(widget), "Pause");
gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(widget), "Pause Encoding");
}
action = GHB_ACTION (ud->builder, "queue_start_menu");
if (show_stop)
{
gtk_action_set_sensitive (action, TRUE);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_action_set_icon_name(action, "hb-stop");
gtk_action_set_label(action, "S_top Queue");
gtk_action_set_tooltip(action, "Stop Encoding");
#else
g_object_set_property(G_OBJECT(action), "icon-name",
ghb_string_value("hb-stop"));
g_object_set_property(G_OBJECT(action), "label",
ghb_string_value("S_top Queue"));
g_object_set_property(G_OBJECT(action), "tooltip",
ghb_string_value("Stop Encoding"));
#endif
}
else
{
gtk_action_set_sensitive (action, show_start);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_action_set_icon_name(action, "hb-start");
gtk_action_set_label(action, "_Start Queue");
gtk_action_set_tooltip(action, "Start Encoding");
#else
g_object_set_property(G_OBJECT(action), "icon-name",
ghb_string_value("hb-start"));
g_object_set_property(G_OBJECT(action), "label",
ghb_string_value("_Start Queue"));
g_object_set_property(G_OBJECT(action), "tooltip",
ghb_string_value("Start Encoding"));
#endif
}
action = GHB_ACTION (ud->builder, "queue_pause_menu");
if (paused)
{
gtk_action_set_sensitive (action, show_start);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_action_set_icon_name(action, "hb-start");
gtk_action_set_label(action, "_Resume Queue");
gtk_action_set_tooltip(action, "Resume Encoding");
#else
g_object_set_property(G_OBJECT(action), "icon-name",
ghb_string_value("hb-start"));
g_object_set_property(G_OBJECT(action), "label",
ghb_string_value("_Resume Queue"));
g_object_set_property(G_OBJECT(action), "tooltip",
ghb_string_value("Resume Encoding"));
#endif
}
else
{
gtk_action_set_sensitive (action, show_stop);
#if GTK_CHECK_VERSION(2, 16, 0)
gtk_action_set_icon_name(action, "hb-pause");
gtk_action_set_label(action, "_Pause Queue");
gtk_action_set_tooltip(action, "Pause Encoding");
#else
g_object_set_property(G_OBJECT(action), "icon-name",
ghb_string_value("hb-pause"));
g_object_set_property(G_OBJECT(action), "label",
ghb_string_value("_Pause Queue"));
g_object_set_property(G_OBJECT(action), "tooltip",
ghb_string_value("Pause Encoding"));
#endif
}
}
static void
x264_opt_update(signal_user_data_t *ud, GtkWidget *widget)
{
gint jj;
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++)
{
if (strcmp(name, x264_opt_map[jj].name) == 0)
{
// found the options that needs updating
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;
}
}
if (opt_syns != NULL)
{
GString *x264opts = g_string_new("");
gchar *options;
gchar **split = NULL;
gint ii;
gboolean foundit = FALSE;
options = ghb_settings_get_string(ud->settings, "x264Option");
if (options)
{
split = g_strsplit(options, ":", -1);
g_free(options);
}
for (ii = 0; split && split[ii] != NULL; ii++)
{
gint syn;
gchar *val = NULL;
gchar *pos = strchr(split[ii], '=');
if (pos != NULL)
{
val = pos + 1;
*pos = 0;
}
syn = find_syn_match(split[ii], opt_syns);
if (syn >= 0)
{ // Updating this option
gchar *val;
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;
gval = ghb_widget_value(widget);
if (G_VALUE_TYPE(gval) == G_TYPE_BOOLEAN)
{
if (ghb_value_boolean(gval))
val = g_strdup("1");
else
val = g_strdup("0");
}
else
{
val = ghb_widget_string(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);
}
g_free(val);
}
else if (val != NULL)
g_string_append_printf(x264opts, "%s=%s:", split[ii], val);
else
g_string_append_printf(x264opts, "%s:", split[ii]);
}
if (split) g_strfreev(split);
if (!foundit)
{
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;
gval = ghb_widget_value(widget);
if (G_VALUE_TYPE(gval) == G_TYPE_BOOLEAN)
{
if (ghb_value_boolean(gval))
val = g_strdup("1");
else
val = g_strdup("0");
}
else
{
val = ghb_widget_string(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);
}
g_free(val);
}
// Update the options value
// strip the trailing ":"
gchar *result;
gint len;
result = g_string_free(x264opts, FALSE);
len = strlen(result);
if (len > 0) result[len - 1] = 0;
gchar *sopts;
sopts = sanitize_x264opts(ud, result);
ghb_ui_update(ud, "x264Option", ghb_string_value(sopts));
ghb_x264_parse_options(ud, sopts);
g_free(sopts);
g_free(result);
}
}
G_MODULE_EXPORT void
x264_setting_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
static char *tt = NULL;
if (tt == NULL)
{
GtkWidget *eo = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264OptionExtra"));
tt = gtk_widget_get_tooltip_text(eo);
}
ghb_widget_to_setting(ud->settings, widget);
int x264Preset = ghb_settings_get_int(ud->settings, "x264PresetSlider");
const char *preset;
preset = hb_video_encoder_get_presets(HB_VCODEC_X264)[x264Preset];
ghb_settings_set_string(ud->settings, "x264Preset", preset);
if (!ghb_settings_get_boolean(ud->settings, "x264UseAdvancedOptions"))
{
GString *str = g_string_new("");
char *preset;
char *tune;
char *profile;
char *level;
char *opts;
char *tunes;
preset = ghb_settings_get_string(ud->settings, "x264Preset");
tune = ghb_settings_get_string(ud->settings, "x264Tune");
profile = ghb_settings_get_string(ud->settings, "h264Profile");
level = ghb_settings_get_string(ud->settings, "h264Level");
opts = ghb_settings_get_string(ud->settings, "x264OptionExtra");
if (tune[0] && strcmp(tune, "none"))
{
g_string_append_printf(str, "%s", tune);
}
if (ghb_settings_get_boolean(ud->settings, "x264FastDecode"))
{
g_string_append_printf(str, "%s%s", str->str[0] ? "," : "", "fastdecode");
}
if (ghb_settings_get_boolean(ud->settings, "x264ZeroLatency"))
{
g_string_append_printf(str, "%s%s", str->str[0] ? "," : "", "zerolatency");
}
tunes = g_string_free(str, FALSE);
char * new_opts;
int w = ghb_settings_get_int(ud->settings, "scale_width");
int h = ghb_settings_get_int(ud->settings, "scale_height");
if (w == 0 || h == 0)
{
if (!ghb_settings_get_boolean(ud->settings, "autoscale"))
{
w = ghb_settings_get_int(ud->settings, "PictureWidth");
h = ghb_settings_get_int(ud->settings, "PictureHeight");
if (h == 0 && w != 0)
{
h = w * 9 / 16;
}
if (w == 0 && h != 0)
{
w = h * 16 / 9;
}
}
if (w == 0 || h == 0)
{
w = 1280;
h = 720;
}
}
if (!strcasecmp(profile, "auto"))
{
profile[0] = 0;
}
if (!strcasecmp(level, "auto"))
{
level[0] = 0;
}
new_opts = hb_x264_param_unparse(
preset, tunes, opts, profile, level, w, h);
if (new_opts)
ghb_ui_update(ud, "x264Option", ghb_string_value(new_opts));
else
ghb_ui_update(ud, "x264Option", ghb_string_value(""));
GtkWidget *eo = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264OptionExtra"));
char * new_tt;
if (new_opts)
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"%s\"", tt, new_opts);
else
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"\"", tt);
gtk_widget_set_tooltip_text(eo, new_tt);
g_free(new_tt);
g_free(new_opts);
g_free(preset);
g_free(tune);
g_free(profile);
g_free(level);
g_free(opts);
g_free(tunes);
}
else
{
char *opts = ghb_settings_get_string(ud->settings, "x264Option");
GtkWidget *eo = GTK_WIDGET(GHB_WIDGET(ud->builder, "x264OptionExtra"));
char * new_tt;
if (opts)
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"%s\"", tt, opts);
else
new_tt = g_strdup_printf("%s\n\nExpanded Options:\n\"\"", tt);
gtk_widget_set_tooltip_text(eo, new_tt);
g_free(new_tt);
g_free(opts);
}
ghb_check_dependency(ud, widget, NULL);
ghb_clear_presets_selection(ud);
}
int
main(gint argc, gchar *argv[])
{
gint ii, jj;
GValue *top;
gint count = sizeof(dep_map) / sizeof(dependency_t);
g_type_init();
top = ghb_dict_value_new();
for (ii = 0; ii < count; ii++)
{
const gchar *name;
GValue *array;
name = dep_map[ii].widget_name;
if (ghb_dict_lookup(top, name))
continue;
array = ghb_array_value_new(8);
for (jj = 0; jj < count; jj++)
{
if (strcmp(name, dep_map[jj].widget_name) == 0)
{
ghb_array_append(array,
ghb_value_dup(ghb_string_value(dep_map[jj].dep_name)));
}
}
ghb_dict_insert(top, g_strdup(name), array);
}
ghb_plist_write_file("widget.deps", top);
// reverse map
top = ghb_dict_value_new();
for (ii = 0; ii < count; ii++)
{
const gchar *name;
GValue *array;
name = dep_map[ii].dep_name;
if (ghb_dict_lookup(top, name))
continue;
array = ghb_array_value_new(8);
for (jj = 0; jj < count; jj++)
{
if (strcmp(name, dep_map[jj].dep_name) == 0)
{
GValue *data;
data = ghb_array_value_new(3);
ghb_array_append(data, ghb_value_dup(
ghb_string_value(dep_map[jj].widget_name)));
ghb_array_append(data, ghb_value_dup(
ghb_string_value(dep_map[jj].enable_value)));
ghb_array_append(data, ghb_value_dup(
ghb_boolean_value(dep_map[jj].disable_if_equal)));
ghb_array_append(data, ghb_value_dup(
ghb_boolean_value(dep_map[jj].hide)));
ghb_array_append(array, data);
}
}
ghb_dict_insert(top, g_strdup(name), array);
}
ghb_plist_write_file("widget_reverse.deps", top);
return 0;
}
