// 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)
{
}
ghb_dict_insert(dict,
g_strdup("destination_dir"), ghb_value_dup(ghb_string_value(dir)));
+ ghb_dict_insert(dict,
+ g_strdup("SrtDir"), ghb_value_dup(ghb_string_value(dir)));
#if defined(_WIN32)
gchar *source;
g_free(source);
#endif
store_prefs();
- }
+ }
// Read legacy default_preset preference and update accordingly
path = ghb_dict_lookup(dict, "default_preset");
if (path)
static value_map_t acodec_xlat[] =
{
{"AAC (faac)", "faac"},
+ {"AAC (CoreAudio)", "faac"},
{"AC3 Passthru", "ac3"},
{"MP3 (lame)", "lame"},
{"Vorbis (vorbis)", "vorbis"},
value_map_t container_xlat[] =
{
{"MP4 file", "mp4"},
- {"M4V file", "m4v"},
+ {"M4V file", "mp4"},
{"MKV file", "mkv"},
{"AVI file", "mkv"},
{"OGM file", "mkv"},
if (gval)
ghb_dict_insert(dict, g_strdup(key), gval);
+
GValue *sdeflist;
GValue *sdefaults;
GValue *slist;
{
key = "Subtitles";
mac_val = ghb_dict_lookup(dict, key);
+ slist = ghb_array_value_new(8);
+ ghb_dict_insert(dict, g_strdup("SubtitleList"), slist);
if (mac_val)
{
gchar *lang;
gval = import_subtitle_xlat2(mac_val);
lang = ghb_value_string(gval);
- if (lang && strcmp(lang, "none") != 0 && !slist)
+ if (lang && strcasecmp(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");
}
ghb_dict_insert(sdict, g_strdup("SubtitleBurned"),
ghb_boolean_value_new(TRUE));
+ ghb_dict_insert(sdict, g_strdup("SubtitleDefaultTrack"),
+ ghb_boolean_value_new(FALSE));
}
else
{
gval = import_value_xlat2(adefaults, mix_xlat, key, mac_val);
if (gval)
ghb_dict_insert(adict, g_strdup(key), gval);
+
+ mac_val = ghb_dict_lookup(adict, "AudioTrackDRCSlider");
+ if (mac_val != NULL)
+ {
+ gdouble drc;
+ drc = ghb_value_double(mac_val);
+ if (drc < 1.0 && drc > 0.0)
+ {
+ ghb_dict_insert(adict, g_strdup("AudioTrackDRCSlider"),
+ ghb_double_value_new(0.0));
+ }
+ }
}
}
}
{
gboolean uses_max;
gint uses_pic;
- gint par, par_width, par_height;
+ gint par;
gint vqtype;
g_debug("import_xlat_preset ()");
preset_dict_get_value(dict, "UsesPictureSettings"));
par = ghb_value_int(preset_dict_get_value(dict, "PicturePAR"));
vqtype = ghb_value_int(preset_dict_get_value(dict, "VideoQualityType"));
- par_width = ghb_value_int(preset_dict_get_value(dict, "PicturePARWidth"));
- par_height = ghb_value_int(preset_dict_get_value(dict, "PicturePARHeight"));
- ghb_dict_insert(dict, g_strdup("par_width"),
- ghb_int_value_new(par_width));
- ghb_dict_insert(dict, g_strdup("par_height"),
- ghb_int_value_new(par_height));
if (uses_max || uses_pic == 2)
{
vquality = 51. - vquality * 51.;
} break;
- case HB_VCODEC_XVID:
case HB_VCODEC_FFMPEG:
{
vquality = 31. - vquality * 30.;
export_xlat_preset(GValue *dict)
{
gboolean autoscale, target, br, constant;
- gint par_width, par_height;
g_debug("export_xlat_prest ()");
autoscale = ghb_value_boolean(preset_dict_get_value(dict, "autoscale"));
preset_dict_get_value(dict, "vquality_type_bitrate"));
constant = ghb_value_boolean(
preset_dict_get_value(dict, "vquality_type_constant"));
- par_width = ghb_value_int(
- preset_dict_get_value(dict, "par_width"));
- par_height = ghb_value_int(
- preset_dict_get_value(dict, "par_height"));
if (autoscale)
ghb_dict_insert(dict, g_strdup("UsesPictureSettings"),
ghb_dict_insert(dict, g_strdup("VideoQualityType"),
ghb_int_value_new(2));
}
- ghb_dict_insert(dict, g_strdup("PicturePARWidth"),
- ghb_int_value_new(par_width));
- ghb_dict_insert(dict, g_strdup("PicturePARHeight"),
- ghb_int_value_new(par_height));
+
+ GValue *alist, *adict;
+ gint count, ii;
+
+ alist = ghb_dict_lookup(dict, "AudioList");
+ count = ghb_array_len(alist);
+ for (ii = 0; ii < count; ii++)
+ {
+ gdouble drc;
+
+ adict = ghb_array_get_nth(alist, ii);
+ drc = ghb_value_double(
+ preset_dict_get_value(adict, "AudioTrackDRCSlider"));
+ if (drc < 1.0 && drc > 0.0)
+ {
+ ghb_dict_insert(adict, g_strdup("AudioTrackDRCSlider"),
+ ghb_double_value_new(0.0));
+ }
+ }
+
ghb_dict_remove(dict, "UsesMaxPictureSettings");
ghb_dict_remove(dict, "autoscale");
ghb_dict_remove(dict, "vquality_type_target");
ghb_dict_remove(dict, "vquality_type_bitrate");
ghb_dict_remove(dict, "vquality_type_constant");
- ghb_dict_remove(dict, "par_width");
- ghb_dict_remove(dict, "par_height");
export_value_xlat(dict);
}
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);
update_subtitle_presets(signal_user_data_t *ud)
{
g_debug("update_subtitle_presets");
- const GValue *subtitle_list;
+ const GValue *subtitle_list, *subtitle;
+ GValue *slist, *dict;
+ gint count, ii, source;
subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
- ghb_settings_set_value(ud->settings, "SubtitleList", 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);
+ source = ghb_settings_get_int(subtitle, "SubtitleSource");
+ if (source != SRTSUB)
+ {
+ dict = ghb_value_dup(subtitle);
+ ghb_array_append(slist, dict);
+ }
+ }
+ ghb_settings_take_value(ud->settings, "SubtitleList", slist);
}
void
OSDN Git Service
