LinGui: Picture Filter enhancements

[handbrake-jp/handbrake-jp-git.git] / gtk / src / presets.c

diff --git a/gtk/src/presets.c b/gtk/src/presets.c
index 90bbe55..5cbab83 100644 (file)
--- a/gtk/src/presets.c
+++ b/gtk/src/presets.c
@@ -323,8 +323,7 @@ ghb_presets_remove(
                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;
@@ -344,8 +343,7 @@ ghb_presets_replace(
                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");
        }
 }
 
@@ -363,8 +361,7 @@ ghb_presets_insert(
                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");
        }
 }
 
@@ -558,7 +555,7 @@ 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;
@@ -637,8 +634,7 @@ ghb_presets_get_type(
        }
        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;
 }
@@ -659,8 +655,7 @@ ghb_presets_get_folder(
        }
        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;
 }
@@ -866,21 +861,6 @@ preset_to_ui(signal_user_data_t *ud, GValue *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
@@ -891,6 +871,16 @@ ghb_settings_to_ui(signal_user_data_t *ud, GValue *dict)
 
 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)
 {
@@ -1010,7 +1000,7 @@ ghb_select_default_preset(GtkBuilder *builder)
 }
 
 gchar*
-ghb_get_user_config_dir()
+ghb_get_user_config_dir(gchar *subdir)
 {
        const gchar *dir;
        gchar *config;
@@ -1029,6 +1019,23 @@ ghb_get_user_config_dir()
                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;
 }
 
@@ -1038,7 +1045,7 @@ store_plist(GValue *plist, const gchar *name)
        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);
@@ -1053,7 +1060,7 @@ load_plist(const gchar *name)
        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))
        {
@@ -1069,7 +1076,7 @@ remove_plist(const gchar *name)
 {
        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))
        {
@@ -1155,12 +1162,14 @@ ghb_prefs_to_ui(signal_user_data_t *ud)
        }
        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;
 }
@@ -1697,18 +1706,36 @@ value_map_t mix_xlat[] =
 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}
 };
 
@@ -1909,6 +1936,20 @@ export_value_xlat(GValue *dict)
        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);
@@ -2031,6 +2072,16 @@ import_value_xlat(GValue *dict)
        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);
@@ -2263,6 +2314,7 @@ export_xlat_preset(GValue *dict)
                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");
@@ -2370,18 +2422,21 @@ 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);
@@ -2435,23 +2490,7 @@ settings_save(signal_user_data_t *ud, const GValue *path)
                        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);