X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fpresets.c;h=c17a902d4e22fd96e92e645a324d03da6ccff72e;hb=47f681558afcfa3032c64a73f605b1d73812bfc7;hp=35f7b9c4b9cb1f0e1dab311920705da0027c2618;hpb=e2cd98f3e71232b518b7165705d25d965ab9d9f3;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/presets.c b/gtk/src/presets.c index 35f7b9c4..c17a902d 100644 --- a/gtk/src/presets.c +++ b/gtk/src/presets.c @@ -1133,14 +1133,14 @@ ghb_prefs_to_ui(signal_user_data_t *ud) // 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 @@ -1203,12 +1203,12 @@ ghb_prefs_save(GValue *settings) // 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; @@ -1371,20 +1371,20 @@ ghb_prefs_load(signal_user_data_t *ud) 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) { @@ -1392,6 +1392,8 @@ ghb_prefs_load(signal_user_data_t *ud) } 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; @@ -1405,7 +1407,7 @@ ghb_prefs_load(signal_user_data_t *ud) g_free(source); #endif store_prefs(); - } + } // Read legacy default_preset preference and update accordingly path = ghb_dict_lookup(dict, "default_preset"); if (path) @@ -1753,6 +1755,7 @@ static value_map_t vcodec_xlat[] = static value_map_t acodec_xlat[] = { {"AAC (faac)", "faac"}, + {"AAC (CoreAudio)", "faac"}, {"AC3 Passthru", "ac3"}, {"MP3 (lame)", "lame"}, {"Vorbis (vorbis)", "vorbis"}, @@ -1762,7 +1765,7 @@ static value_map_t acodec_xlat[] = value_map_t container_xlat[] = { {"MP4 file", "mp4"}, - {"M4V file", "m4v"}, + {"M4V file", "mp4"}, {"MKV file", "mkv"}, {"AVI file", "mkv"}, {"OGM file", "mkv"}, @@ -2218,6 +2221,7 @@ import_value_xlat(GValue *dict) if (gval) ghb_dict_insert(dict, g_strdup(key), gval); + GValue *sdeflist; GValue *sdefaults; GValue *slist; @@ -2247,17 +2251,17 @@ import_value_xlat(GValue *dict) { 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"); @@ -2273,6 +2277,8 @@ import_value_xlat(GValue *dict) } 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 { @@ -2321,6 +2327,18 @@ import_value_xlat(GValue *dict) 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)); + } + } } } } @@ -2330,7 +2348,7 @@ import_xlat_preset(GValue *dict) { gboolean uses_max; gint uses_pic; - gint par, par_width, par_height; + gint par; gint vqtype; g_debug("import_xlat_preset ()"); @@ -2340,12 +2358,6 @@ import_xlat_preset(GValue *dict) 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) { @@ -2437,7 +2449,6 @@ import_xlat_preset(GValue *dict) vquality = 51. - vquality * 51.; } break; - case HB_VCODEC_XVID: case HB_VCODEC_FFMPEG: { vquality = 31. - vquality * 30.; @@ -2490,7 +2501,6 @@ static void 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")); @@ -2500,10 +2510,6 @@ export_xlat_preset(GValue *dict) 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"), @@ -2528,17 +2534,31 @@ export_xlat_preset(GValue *dict) 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); } @@ -2618,7 +2638,7 @@ ghb_presets_reload(signal_user_data_t *ud) 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); @@ -2634,6 +2654,8 @@ ghb_presets_reload(signal_user_data_t *ud) 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); } @@ -2660,8 +2682,102 @@ check_old_presets() 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) @@ -2684,6 +2800,7 @@ ghb_presets_load() import_xlat_presets(presetsPlist); store_presets(); } + update_standard_presets(ud); import_xlat_presets(presetsPlist); } @@ -2739,6 +2856,7 @@ settings_save(signal_user_data_t *ud, const GValue *path) 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); @@ -2946,10 +3064,24 @@ static void 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