presets_remove_nth(folder, indices[len-1]);
else
{
- g_warning("ghb_presets_remove ()");
- g_warning("internal preset lookup error");
+ g_warning("ghb_presets_remove (): internal preset lookup error");
return FALSE;
}
return TRUE;
ghb_array_replace(folder, indices[len-1], dict);
else
{
- g_warning("ghb_presets_replace ()");
- g_warning("internal preset lookup error");
+ g_warning("ghb_presets_replace (): internal preset lookup error");
}
}
ghb_array_insert(folder, indices[len-1], dict);
else
{
- g_warning("ghb_presets_insert ()");
- g_warning("internal preset lookup error");
+ g_warning("ghb_presets_insert (): internal preset lookup error");
}
}
return ghb_value_boolean(val);
}
+static void
+presets_clear_default(GValue *presets)
+{
+ gint count, ii;
+
+ count = ghb_array_len(presets);
+ for (ii = 0; ii < count; ii++)
+ {
+ GValue *dict;
+ gboolean folder;
+
+ dict = ghb_array_get_nth(presets, ii);
+ folder = ghb_value_boolean(preset_dict_get_value(dict, "Folder"));
+ if (folder)
+ {
+ GValue *nested;
+
+ nested = ghb_dict_lookup(dict, "ChildrenArray");
+ presets_clear_default(nested);
+ }
+ else
+ {
+ if (preset_is_default(dict))
+ {
+ ghb_dict_insert(dict, g_strdup("Default"),
+ ghb_boolean_value_new(FALSE));
+ }
+ }
+ }
+}
+
static gint*
presets_find_default2(GValue *presets, gint *len)
{
{
if (preset_is_default(dict))
{
- indices = malloc(MAX_NESTED_PRESET * sizeof(gint));
+ indices = g_malloc(MAX_NESTED_PRESET * sizeof(gint));
indices[*len] = ii;
(*len)++;
return indices;
}
static gint*
-presets_find_default(gint *len)
+presets_find_default(GValue *presets, gint *len)
{
*len = 0;
- return presets_find_default2(presetsPlist, len);
+ return presets_find_default2(presets, len);
}
gint*
}
else
{
- g_warning("ghb_presets_get_type ()");
- g_warning("internal preset lookup error");
+ g_warning("ghb_presets_get_type (): internal preset lookup error");
}
return type;
}
}
else
{
- g_warning("ghb_presets_get_folder ()");
- g_warning("internal preset lookup error");
+ g_warning("ghb_presets_get_folder (): internal preset lookup error");
}
return folder;
}
presets_set_default(gint *indices, gint len)
{
GValue *dict;
- gint *curr_indices, curr_len;
g_debug("presets_set_default ()");
- curr_indices = presets_find_default(&curr_len);
- if (curr_indices)
- {
- dict = presets_get_dict(presetsPlist, curr_indices, curr_len);
- if (dict)
- {
- ghb_dict_insert(dict, g_strdup("Default"),
- ghb_boolean_value_new(FALSE));
- }
- }
+ presets_clear_default(presetsPlist);
dict = presets_get_dict(presetsPlist, indices, len);
if (dict)
{
init_settings_from_dict(ud->settings, hidden, dict);
init_ui_from_dict(ud, internal, dict);
init_ui_from_dict(ud, hidden, dict);
-
- if (ghb_settings_get_boolean(ud->settings, "allow_tweaks"))
- {
- const GValue *gval;
- gval = preset_dict_get_value(dict, "PictureDeinterlace");
- if (gval)
- {
- ghb_ui_update(ud, "tweak_PictureDeinterlace", gval);
- }
- gval = preset_dict_get_value(dict, "PictureDenoise");
- if (gval)
- {
- ghb_ui_update(ud, "tweak_PictureDenoise", gval);
- }
- }
}
void
static GValue *current_preset = NULL;
+gboolean
+ghb_preset_is_custom()
+{
+ const GValue *val;
+
+ if (current_preset == NULL) return FALSE;
+ val = preset_dict_get_value(current_preset, "Type");
+ return (ghb_value_int(val) == 1);
+}
+
void
ghb_set_preset_from_indices(signal_user_data_t *ud, gint *indices, gint len)
{
gint *indices, len;
g_debug("ghb_select_default_preset()");
- indices = presets_find_default(&len);
+ indices = presets_find_default(presetsPlist, &len);
if (indices)
{
ghb_select_preset2(builder, indices, len);
}
gchar*
-ghb_get_user_config_dir()
+ghb_get_user_config_dir(gchar *subdir)
{
const gchar *dir;
gchar *config;
if (!g_file_test(config, G_FILE_TEST_IS_DIR))
g_mkdir (config, 0755);
}
+ if (subdir)
+ {
+ gchar **split;
+ gint ii;
+
+ split = g_strsplit(subdir, "/", -1);
+ for (ii = 0; split[ii] != NULL; ii++)
+ {
+ gchar *tmp;
+
+ tmp = g_strdup_printf ("%s/%s", config, split[ii]);
+ g_free(config);
+ config = tmp;
+ if (!g_file_test(config, G_FILE_TEST_IS_DIR))
+ g_mkdir (config, 0755);
+ }
+ }
return config;
}
gchar *config, *path;
FILE *file;
- config = ghb_get_user_config_dir();
+ config = ghb_get_user_config_dir(NULL);
path = g_strdup_printf ("%s/%s", config, name);
file = g_fopen(path, "w");
g_free(config);
gchar *config, *path;
GValue *plist = NULL;
- config = ghb_get_user_config_dir();
+ config = ghb_get_user_config_dir(NULL);
path = g_strdup_printf ("%s/%s", config, name);
if (g_file_test(path, G_FILE_TEST_IS_REGULAR))
{
{
gchar *config, *path;
- config = ghb_get_user_config_dir();
+ config = ghb_get_user_config_dir(NULL);
path = g_strdup_printf ("%s/%s", config, name);
if (g_file_test(path, G_FILE_TEST_IS_REGULAR))
{
}
gval = ghb_settings_get_value(ud->settings, "default_source");
ghb_settings_set_value (ud->settings, "source", gval);
+
str = ghb_settings_get_string(ud->settings, "destination_dir");
+ ghb_ui_update(ud, "dest_dir", ghb_string_value(str));
- gchar *path = g_strdup_printf ("%s/new_video.mp4", str);
- ghb_ui_update(ud, "destination", ghb_string_value(path));
+ gchar *file = g_strdup_printf ("new_video.mp4");
+ ghb_ui_update(ud, "dest_file", ghb_string_value(file));
g_free(str);
- g_free(path);
+ g_free(file);
prefs_initializing = FALSE;
}
value_map_t deint_xlat[] =
{
{"0", "none"},
- {"1", "fast"},
- {"2", "slow"},
- {"3", "slower"},
+ {"1", "custom"},
+ {"2", "fast"},
+ {"3", "slow"},
+ {"4", "slower"},
{NULL, NULL}
};
value_map_t denoise_xlat[] =
{
{"0", "none"},
- {"1", "weak"},
- {"2", "medium"},
- {"3", "strong"},
+ {"1", "custom"},
+ {"2", "weak"},
+ {"3", "medium"},
+ {"4", "strong"},
+ {NULL, NULL}
+};
+
+value_map_t detel_xlat[] =
+{
+ {"0", "none"},
+ {"1", "custom"},
+ {"2", "default"},
+ {NULL, NULL}
+};
+
+value_map_t decomb_xlat[] =
+{
+ {"0", "none"},
+ {"1", "custom"},
+ {"2", "default"},
{NULL, NULL}
};
gchar *str;
GValue *gval;
+ if (lin_val == NULL) return NULL;
str = ghb_value_string(lin_val);
if (strcmp(str, "none") == 0)
{
gchar *str;
GValue *gval;
+ if (mac_val == NULL) return NULL;
str = ghb_value_string(mac_val);
if (strcmp(str, "None") == 0)
{
gchar *str;
GValue *gval = NULL;
+ if (lin_val == NULL) return NULL;
str = ghb_value_string(lin_val);
if (strcmp(str, "none") == 0)
{
gchar *str;
GValue *gval;
+ if (mac_val == NULL) return NULL;
val = ghb_value_int(mac_val);
if (val <= 0)
{
gval = export_value_xlat2(framerate_xlat, lin_val, G_TYPE_STRING);
if (gval)
ghb_dict_insert(dict, g_strdup(key), gval);
+ key = "PictureDetelecine";
+ lin_val = ghb_dict_lookup(dict, key);
+ gval = export_value_xlat2(detel_xlat, lin_val, G_TYPE_INT);
+ if (gval)
+ ghb_dict_insert(dict, g_strdup(key), gval);
+ else
+ ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(lin_val));
+ key = "PictureDecomb";
+ lin_val = ghb_dict_lookup(dict, key);
+ gval = export_value_xlat2(decomb_xlat, lin_val, G_TYPE_INT);
+ if (gval)
+ ghb_dict_insert(dict, g_strdup(key), gval);
+ else
+ ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(lin_val));
key = "PictureDeinterlace";
lin_val = ghb_dict_lookup(dict, key);
gval = export_value_xlat2(deint_xlat, lin_val, G_TYPE_INT);
gval = import_value_xlat2(defaults, framerate_xlat, key, mac_val);
if (gval)
ghb_dict_insert(dict, g_strdup(key), gval);
+ key = "PictureDetelecine";
+ mac_val = ghb_dict_lookup(dict, key);
+ gval = import_value_xlat2(defaults, detel_xlat, key, mac_val);
+ if (gval)
+ ghb_dict_insert(dict, g_strdup(key), gval);
+ key = "PictureDecomb";
+ mac_val = ghb_dict_lookup(dict, key);
+ gval = import_value_xlat2(defaults, decomb_xlat, key, mac_val);
+ if (gval)
+ ghb_dict_insert(dict, g_strdup(key), gval);
key = "PictureDeinterlace";
mac_val = ghb_dict_lookup(dict, key);
gval = import_value_xlat2(defaults, deint_xlat, key, mac_val);
ghb_dict_insert(dict, g_strdup("VideoQualityType"),
ghb_int_value_new(2));
}
+ ghb_dict_remove(dict, "UsesMaxPictureSettings");
ghb_dict_remove(dict, "autoscale");
ghb_dict_remove(dict, "anamorphic");
ghb_dict_remove(dict, "vquality_type_target");
{
GValue *std_presets;
gint count, ii;
+ int *indices, len;
g_debug("ghb_presets_reload()\n");
std_presets = ghb_resource_get("standard-presets");
if (std_presets == NULL) return;
remove_std_presets(ud);
+ indices = presets_find_default(presetsPlist, &len);
+ if (indices)
+ {
+ presets_clear_default(std_presets);
+ g_free(indices);
+ }
// Merge the keyfile contents into our presets
count = ghb_array_len(std_presets);
for (ii = count-1; ii >= 0; ii--)
{
GValue *std_dict;
GValue *copy_dict;
- GHashTableIter iter;
- gchar *key;
- GValue *value;
gint indices = 0;
std_dict = ghb_array_get_nth(std_presets, ii);
- copy_dict = ghb_dict_value_new();
+ copy_dict = ghb_value_dup(std_dict);
ghb_presets_insert(presetsPlist, copy_dict, &indices, 1);
- ghb_dict_iter_init(&iter, std_dict);
- // middle (void*) cast prevents gcc warning "defreferencing
- // type-punned pointer will break strict-aliasing rules"
- while (g_hash_table_iter_next(
- &iter, (gpointer*)(void*)&key, (gpointer*)(void*)&value))
- {
- ghb_dict_insert(copy_dict, g_strdup(key), ghb_value_dup(value));
- }
presets_list_insert(ud, &indices, 1);
}
import_xlat_presets(presetsPlist);
store_presets();
}
+static gboolean
+check_old_presets()
+{
+ gint count, ii;
+
+ count = ghb_array_len(presetsPlist);
+ for (ii = count-1; ii >= 0; ii--)
+ {
+ GValue *dict;
+ GValue *type;
+
+ dict = ghb_array_get_nth(presetsPlist, ii);
+ type = ghb_dict_lookup(dict, "Type");
+ if (type == NULL)
+ return TRUE;
+ }
+ return FALSE;
+}
+
void
ghb_presets_load()
{
if (presetsPlist == NULL)
{
presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets"));
+ import_xlat_presets(presetsPlist);
store_presets();
}
else if (G_VALUE_TYPE(presetsPlist) == ghb_dict_get_type())
{ // Presets is older dictionary format. Convert to array
ghb_value_free(presetsPlist);
presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets"));
+ import_xlat_presets(presetsPlist);
+ store_presets();
+ }
+ else if (check_old_presets())
+ {
+ ghb_value_free(presetsPlist);
+ presetsPlist = ghb_value_dup(ghb_resource_get("standard-presets"));
+ import_xlat_presets(presetsPlist);
store_presets();
}
import_xlat_presets(presetsPlist);
return;
}
}
-
- if (ghb_settings_get_boolean(ud->settings, "allow_tweaks"))
- {
- gchar *str;
- str = ghb_settings_get_string(ud->settings, "tweak_PictureDeinterlace");
- if (str)
- {
- ghb_settings_set_string(ud->settings, "PictureDeinterlace", str);
- g_free(str);
- }
- str = ghb_settings_get_string(ud->settings, "tweak_PictureDenoise");
- if (str)
- {
- ghb_settings_set_string(ud->settings, "PictureDenoise", str);
- g_free(str);
- }
- }
+ current_preset = dict;
autoscale = ghb_settings_get_boolean(ud->settings, "autoscale");
ghb_settings_set_int64(ud->settings, "Type", PRESETS_CUSTOM);
g_debug("ghb_presets_list_default ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list"));
store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
- indices = presets_find_default(&len);
+ indices = presets_find_default(presetsPlist, &len);
if (indices == NULL) return;
treepath = ghb_tree_path_new_from_indices(indices, len);
if (treepath)
g_debug("ghb_presets_list_clear_default ()");
treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "presets_list"));
store = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
- indices = presets_find_default(&len);
+ indices = presets_find_default(presetsPlist, &len);
if (indices == NULL) return;
treepath = ghb_tree_path_new_from_indices(indices, len);
if (treepath)
OSDN Git Service
