X-Git-Url: http://git.osdn.jp/view?a=blobdiff_plain;f=gtk%2Fsrc%2Fpresets.c;h=c17a902d4e22fd96e92e645a324d03da6ccff72e;hb=47f681558afcfa3032c64a73f605b1d73812bfc7;hp=fead949bf8f0db780aa116630ec156175bd89c69;hpb=8f2a86ad7122a8815f8d0bf8bdbaee24bbbaf2c0;p=handbrake-jp%2Fhandbrake-jp-git.git diff --git a/gtk/src/presets.c b/gtk/src/presets.c index fead949b..c17a902d 100644 --- a/gtk/src/presets.c +++ b/gtk/src/presets.c @@ -20,6 +20,7 @@ #include "settings.h" #include "callbacks.h" #include "audiohandler.h" +#include "subtitlehandler.h" #include "hb-backend.h" #include "plist.h" #include "resources.h" @@ -1132,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 @@ -1202,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; @@ -1370,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) { @@ -1391,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; @@ -1404,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) @@ -1752,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"}, @@ -1761,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"}, @@ -2057,15 +2061,25 @@ export_value_xlat(GValue *dict) 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); @@ -2132,13 +2146,34 @@ import_value_xlat2( 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; } @@ -2185,19 +2220,85 @@ import_value_xlat(GValue *dict) 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); + 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 && strcasecmp(lang, "none") != 0 && !slist) + { + sdict = ghb_dict_value_new(); + 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)); + ghb_dict_insert(sdict, g_strdup("SubtitleDefaultTrack"), + ghb_boolean_value_new(FALSE)); + } + 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); @@ -2226,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)); + } + } } } } @@ -2235,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 ()"); @@ -2245,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) { @@ -2342,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.; @@ -2395,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")); @@ -2405,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"), @@ -2433,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); } @@ -2523,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); @@ -2539,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); } @@ -2565,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) @@ -2589,6 +2800,7 @@ ghb_presets_load() import_xlat_presets(presetsPlist); store_presets(); } + update_standard_presets(ud); import_xlat_presets(presetsPlist); } @@ -2644,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); @@ -2847,6 +3060,30 @@ update_audio_presets(signal_user_data_t *ud) 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, source; + + 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); + 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 enforce_preset_type(signal_user_data_t *ud, const GValue *path) { @@ -2940,6 +3177,7 @@ presets_save_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud) { // 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); @@ -3071,6 +3309,11 @@ presets_drag_motion_cb( 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)); @@ -3430,6 +3673,7 @@ presets_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_ 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)) {