#include "settings.h"
#include "callbacks.h"
#include "audiohandler.h"
+#include "subtitlehandler.h"
#include "hb-backend.h"
#include "plist.h"
#include "resources.h"
// pointer will break strict-aliasing rules"
while (g_hash_table_iter_next(
&iter, (gpointer*)(void*)&key, (gpointer*)(void*)&gval))
- {
+ {
const GValue *value = NULL;
if (dict)
value = ghb_dict_lookup(dict, key);
if (value == NULL)
value = gval;
ghb_settings_set_value(ud->settings, key, value);
- }
+ }
internal = plist_get_dict(internalPlist, "Preferences");
ghb_dict_iter_init(&iter, internal);
// 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))
- {
- value = ghb_settings_get_value(settings, key);
- if (value != NULL)
- {
+ {
+ value = ghb_settings_get_value(settings, key);
+ if (value != NULL)
+ {
ghb_dict_insert(pref_dict, g_strdup(key), ghb_value_dup(value));
- }
+ }
}
store_prefs();
prefs_modified = FALSE;
prefsPlist = ghb_dict_value_new();
dict = plist_get_dict(prefsPlist, "Preferences");
internal = plist_get_dict(internalPlist, "Preferences");
- if (dict == NULL && internal)
- {
+ if (dict == NULL && internal)
+ {
dict = ghb_dict_value_new();
ghb_dict_insert(prefsPlist, g_strdup("Preferences"), dict);
- // Get defaults from internal defaults
+ // Get defaults from internal defaults
ghb_dict_iter_init(&iter, internal);
// 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*)&gval))
- {
+ {
ghb_dict_insert(dict, g_strdup(key), ghb_value_dup(gval));
- }
+ }
const gchar *dir = g_get_user_special_dir (G_USER_DIRECTORY_VIDEOS);
if (dir == NULL)
{
g_free(source);
#endif
store_prefs();
- }
+ }
// Read legacy default_preset preference and update accordingly
path = ghb_dict_lookup(dict, "default_preset");
if (path)
gval = export_value_xlat2(denoise_xlat, lin_val, G_TYPE_INT);
if (gval)
ghb_dict_insert(dict, g_strdup(key), gval);
- key = "Subtitles";
- lin_val = ghb_dict_lookup(dict, key);
- gval = export_subtitle_xlat2(lin_val);
- if (gval)
- ghb_dict_insert(dict, g_strdup(key), gval);
+
+ GValue *slist;
+ GValue *sdict;
+ gint count, ii;
+
+ slist = ghb_dict_lookup(dict, "SubtitleList");
+ count = ghb_array_len(slist);
+ for (ii = 0; ii < count; ii++)
+ {
+ sdict = ghb_array_get_nth(slist, ii);
+ key = "SubtitleLanguage";
+ lin_val = ghb_dict_lookup(sdict, key);
+ gval = export_subtitle_xlat2(lin_val);
+ if (gval)
+ ghb_dict_insert(sdict, g_strdup(key), gval);
+ }
GValue *alist;
GValue *adict;
- gint count, ii;
alist = ghb_dict_lookup(dict, "AudioList");
count = ghb_array_len(alist);
return gval;
}
}
- //g_warning("Can't map value: (%s)", str);
g_free(str);
}
else
{
- g_warning("Bad key: (%s)", key);
- return NULL;
+ gint ii;
+ gchar *str;
+ GValue *sval;
+
+ str = ghb_value_string(mac_val);
+ for (ii = 0; value_map[ii].mac_val; ii++)
+ {
+ if (strcmp(str, value_map[ii].mac_val) == 0)
+ {
+ sval = ghb_string_value_new(value_map[ii].lin_val);
+ g_free(str);
+ gval = ghb_value_new(G_VALUE_TYPE(mac_val));
+ if (!g_value_transform(sval, gval))
+ {
+ g_warning("can't transform");
+ ghb_value_free(gval);
+ ghb_value_free(sval);
+ return NULL;
+ }
+ ghb_value_free(sval);
+ return gval;
+ }
+ }
+ g_free(str);
}
return NULL;
}
gval = import_value_xlat2(defaults, denoise_xlat, key, mac_val);
if (gval)
ghb_dict_insert(dict, g_strdup(key), gval);
- key = "Subtitles";
- mac_val = ghb_dict_lookup(dict, key);
- gval = import_subtitle_xlat2(mac_val);
- if (gval)
- ghb_dict_insert(dict, g_strdup(key), gval);
+
+ GValue *sdeflist;
+ GValue *sdefaults;
+ GValue *slist;
+ GValue *sdict;
+ gint count, ii;
+
+ sdeflist = ghb_dict_lookup(defaults, "SubtitleList");
+ if (sdeflist)
+ {
+ slist = ghb_dict_lookup(dict, "SubtitleList");
+ if (slist)
+ {
+ sdefaults = ghb_array_get_nth(sdeflist, 0);
+ count = ghb_array_len(slist);
+ for (ii = 0; ii < count; ii++)
+ {
+ sdict = ghb_array_get_nth(slist, ii);
+ key = "SubtitleLanguage";
+ mac_val = ghb_dict_lookup(sdict, key);
+ gval = import_subtitle_xlat2(mac_val);
+ if (gval)
+ ghb_dict_insert(sdict, g_strdup(key), gval);
+ }
+
+ }
+ else
+ {
+ key = "Subtitles";
+ mac_val = ghb_dict_lookup(dict, key);
+ if (mac_val)
+ {
+ gchar *lang;
+
+ gval = import_subtitle_xlat2(mac_val);
+ lang = ghb_value_string(gval);
+ if (lang && strcmp(lang, "none") != 0 && !slist)
+ {
+ slist = ghb_array_value_new(8);
+ sdict = ghb_dict_value_new();
+ ghb_dict_insert(dict, g_strdup("SubtitleList"), slist);
+ ghb_array_append(slist, sdict);
+ ghb_dict_insert(sdict, g_strdup("SubtitleLanguage"), gval);
+ gval = ghb_dict_lookup(dict, "SubtitlesForced");
+ if (gval != NULL)
+ {
+ ghb_dict_insert(sdict, g_strdup("SubtitleForced"),
+ ghb_value_dup(gval));
+ }
+ else
+ {
+ ghb_dict_insert(sdict, g_strdup("SubtitleForced"),
+ ghb_boolean_value_new(FALSE));
+ }
+ ghb_dict_insert(sdict, g_strdup("SubtitleBurned"),
+ ghb_boolean_value_new(TRUE));
+ }
+ else
+ {
+ ghb_value_free(gval);
+ }
+ if (lang)
+ g_free(lang);
+ }
+ }
+ }
+ ghb_dict_remove(dict, "Subtitles");
+ ghb_dict_remove(dict, "SubtitlesForced");
+
GValue *alist;
GValue *adict;
GValue *adefaults;
GValue *adeflist;
- gint count, ii;
- adeflist = ghb_dict_lookup(dict, "AudioList");
+ adeflist = ghb_dict_lookup(defaults, "AudioList");
if (adeflist)
{
adefaults = ghb_array_get_nth(adeflist, 0);
vquality = 51. - vquality * 51.;
} break;
- case HB_VCODEC_XVID:
case HB_VCODEC_FFMPEG:
{
vquality = 31. - vquality * 30.;
if (std_presets == NULL) return;
remove_std_presets(ud);
- indices = presets_find_default(presetsPlist, &len);
+ indices = presets_find_default(presetsPlist, &len);
if (indices)
{
presets_clear_default(std_presets);
std_dict = ghb_array_get_nth(std_presets, ii);
copy_dict = ghb_value_dup(std_dict);
+ ghb_dict_insert(copy_dict, g_strdup("PresetBuildNumber"),
+ ghb_int64_value_new(hb_get_build(NULL)));
ghb_presets_insert(presetsPlist, copy_dict, &indices, 1);
presets_list_insert(ud, &indices, 1);
}
return FALSE;
}
+static void
+replace_standard_presets()
+{
+ GValue *std_presets;
+ int *indices, len;
+ gint count, ii;
+
+ count = ghb_array_len(presetsPlist);
+ for (ii = count-1; ii >= 0; ii--)
+ {
+ GValue *dict;
+ gint ptype;
+
+ dict = ghb_array_get_nth(presetsPlist, ii);
+ ptype = ghb_value_int(preset_dict_get_value(dict, "Type"));
+ if (ptype == PRESETS_BUILTIN)
+ {
+ gint indices = 0;
+ ghb_presets_remove(presetsPlist, &indices, 1);
+ }
+ }
+
+ std_presets = ghb_resource_get("standard-presets");
+ if (std_presets == NULL) return;
+
+ 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;
+ gint indices = 0;
+
+ std_dict = ghb_array_get_nth(std_presets, ii);
+ copy_dict = ghb_value_dup(std_dict);
+ ghb_dict_insert(copy_dict, g_strdup("PresetBuildNumber"),
+ ghb_int64_value_new(hb_get_build(NULL)));
+ ghb_presets_insert(presetsPlist, copy_dict, &indices, 1);
+ }
+ import_xlat_presets(presetsPlist);
+ store_presets();
+}
+
+static void
+update_standard_presets(signal_user_data_t *ud)
+{
+ gint count, ii;
+
+ count = ghb_array_len(presetsPlist);
+ for (ii = count-1; ii >= 0; ii--)
+ {
+ GValue *dict;
+ const GValue *gval;
+ gint64 build;
+ gint type;
+
+ dict = ghb_array_get_nth(presetsPlist, ii);
+ gval = ghb_dict_lookup(dict, "Type");
+ if (gval == NULL)
+ {
+ // Old preset that doesn't have a Type
+ replace_standard_presets();
+ return;
+ }
+
+ type = ghb_value_int(gval);
+ if (type == 0)
+ {
+ gval = ghb_dict_lookup(dict, "PresetBuildNumber");
+ if (gval == NULL)
+ {
+ // Old preset that doesn't have a build number
+ replace_standard_presets();
+ return;
+ }
+
+ build = ghb_value_int64(gval);
+ if (build != hb_get_build(NULL))
+ {
+ // Build number does not match
+ replace_standard_presets();
+ return;
+ }
+ }
+ }
+ return;
+}
+
void
-ghb_presets_load()
+ghb_presets_load(signal_user_data_t *ud)
{
presetsPlist = load_plist("presets");
if (presetsPlist == NULL)
import_xlat_presets(presetsPlist);
store_presets();
}
+ update_standard_presets(ud);
import_xlat_presets(presetsPlist);
}
current_preset = dict;
autoscale = ghb_settings_get_boolean(ud->settings, "autoscale");
ghb_settings_set_int64(ud->settings, "Type", PRESETS_CUSTOM);
+ ghb_settings_set_int64(ud->settings, "PresetBuildNumber", hb_get_build(NULL));
internal = plist_get_dict(internalPlist, "Presets");
ghb_dict_iter_init(&iter, internal);
ghb_settings_set_value(ud->settings, "AudioList", audio_list);
}
+static void
+update_subtitle_presets(signal_user_data_t *ud)
+{
+ g_debug("update_subtitle_presets");
+ const GValue *subtitle_list, *subtitle;
+ GValue *slist, *dict;
+ gint count, ii;
+
+ subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
+ slist = ghb_array_value_new(8);
+ count = ghb_array_len(subtitle_list);
+ for (ii = 0; ii < count; ii++)
+ {
+ subtitle = ghb_array_get_nth(subtitle_list, ii);
+ if (ghb_settings_get_boolean(subtitle, "SubtitleEnabled"))
+ {
+ dict = ghb_value_dup(subtitle);
+ ghb_array_append(slist, dict);
+ }
+ }
+ ghb_settings_set_value(ud->settings, "SubtitleList", slist);
+}
+
void
enforce_preset_type(signal_user_data_t *ud, const GValue *path)
{
{
// Construct the audio settings presets from the current audio list
update_audio_presets(ud);
+ update_subtitle_presets(ud);
settings_save(ud, dest);
}
ghb_value_free(dest);
gboolean src_folder, dst_folder;
GValue *preset;
gint tree_depth, ii;
+ GtkWidget *widget;
+
+ widget = gtk_drag_get_source_widget(ctx);
+ if (widget == NULL || widget != GTK_WIDGET(tv))
+ return TRUE;
// Get the type of the object being dragged
srctv = GTK_TREE_VIEW(gtk_drag_get_source_widget(ctx));
gint titleindex;
titleindex = ghb_settings_combo_int(ud->settings, "title");
ghb_set_pref_audio(titleindex, ud);
+ ghb_set_pref_subtitle(titleindex, ud);
ghb_settings_set_boolean(ud->settings, "preset_modified", FALSE);
if (ghb_get_title_info (&tinfo, titleindex))
{
OSDN Git Service
