1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
4 * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
6 * subtitlehandler.c is free software.
8 * You may redistribute it and/or modify it under the terms of the
9 * GNU General Public License, as published by the Free Software
10 * Foundation; either version 2 of the License, or (at your option)
17 #include "hb-backend.h"
19 #include "callbacks.h"
22 #include "audiohandler.h"
23 #include "subtitlehandler.h"
25 static void add_to_subtitle_list(signal_user_data_t *ud, GValue *settings);
26 static void add_to_srt_list(signal_user_data_t *ud, GValue *settings);
29 free_subtitle_index_list(gpointer data)
35 free_subtitle_key(gpointer data)
42 mustBurn(signal_user_data_t *ud, gint track)
46 mux = ghb_settings_combo_int(ud->settings, "FileFormat");
47 if (mux == HB_MUX_MP4)
51 // MP4 can only handle burned vobsubs. make sure there isn't
52 // already something burned in the list
53 source = ghb_subtitle_track_source(ud, track);
63 ghb_subtitle_exclusive_burn(signal_user_data_t *ud, gint index)
65 GValue *subtitle_list;
73 g_debug("ghb_subtitle_exclusive_burn");
74 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
75 count = ghb_array_len(subtitle_list);
76 for (ii = 0; ii < count; ii++)
78 settings = ghb_array_get_nth(subtitle_list, ii);
79 tt = ghb_settings_combo_int(settings, "SubtitleTrack");
80 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
82 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
83 g_return_if_fail(tv != NULL);
84 tm = gtk_tree_view_get_model(tv);
85 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
86 if (burned && ii != index && !mustBurn(ud, tt))
88 ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
89 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
95 ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index)
97 GValue *subtitle_list;
105 g_debug("ghb_subtitle_exclusive_default");
106 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
107 count = ghb_array_len(subtitle_list);
108 for (ii = 0; ii < count; ii++)
110 settings = ghb_array_get_nth(subtitle_list, ii);
111 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
113 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
114 g_return_if_fail(tv != NULL);
115 tm = gtk_tree_view_get_model(tv);
116 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
117 if (def && ii != index)
120 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
121 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, FALSE, -1);
127 ghb_add_srt(signal_user_data_t *ud, GValue *settings)
129 // Add the current subtitle settings to the list.
130 GValue *subtitle_list;
134 g_debug("ghb_add_srt ()");
136 // Add the long track description so the queue can access it
137 // when a different title is selected.
138 lang = ghb_settings_combo_option(settings, "SrtLanguage");
139 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
141 ghb_settings_set_int(settings, "SubtitleSource", SRTSUB);
143 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
144 if (subtitle_list == NULL)
146 subtitle_list = ghb_array_value_new(8);
147 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
149 count = ghb_array_len(subtitle_list);
151 // Don't allow more than 99
152 // This is a had limit imposed by libhb/sync.c:GetFifoForId()
155 ghb_value_free(settings);
159 ghb_array_append(subtitle_list, settings);
160 add_to_srt_list(ud, settings);
165 widget = GHB_WIDGET (ud->builder, "subtitle_add");
166 gtk_widget_set_sensitive(widget, FALSE);
167 widget = GHB_WIDGET (ud->builder, "srt_add");
168 gtk_widget_set_sensitive(widget, FALSE);
174 ghb_add_subtitle(signal_user_data_t *ud, GValue *settings)
176 // Add the current subtitle settings to the list.
177 GValue *subtitle_list;
184 g_debug("ghb_add_subtitle ()");
186 // Add the long track description so the queue can access it
187 // when a different title is selected.
188 track = ghb_settings_combo_option(settings, "SubtitleTrack");
189 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
191 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
192 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
194 tt = ghb_settings_get_int(settings, "SubtitleTrack");
195 source = ghb_subtitle_track_source(ud, tt);
196 ghb_settings_set_int(settings, "SubtitleSource", source);
198 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
199 if (subtitle_list == NULL)
201 subtitle_list = ghb_array_value_new(8);
202 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
204 count = ghb_array_len(subtitle_list);
206 // Don't allow more than 99
207 // This is a had limit imposed by libhb/sync.c:GetFifoForId()
210 ghb_value_free(settings);
214 ghb_array_append(subtitle_list, settings);
215 add_to_subtitle_list(ud, settings);
217 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
219 ghb_subtitle_exclusive_burn(ud, count);
223 widget = GHB_WIDGET (ud->builder, "subtitle_add");
224 gtk_widget_set_sensitive(widget, FALSE);
225 widget = GHB_WIDGET (ud->builder, "srt_add");
226 gtk_widget_set_sensitive(widget, FALSE);
232 add_all_pref_subtitles(signal_user_data_t *ud)
234 const GValue *pref_subtitle;
236 gint count, ii, track;
239 pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
240 count = ghb_array_len(pref_subtitle);
241 for (ii = 0; ii < count; ii++)
243 subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
244 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
245 // If there are multiple subtitles using the same language, then
246 // select sequential tracks for each. The hash keeps track
247 // of the tracks used for each language.
248 track = ghb_find_pref_subtitle_track(lang);
252 // Add to subtitle list
253 ghb_settings_set_int(subtitle, "SubtitleTrack", track);
254 ghb_add_subtitle(ud, subtitle);
260 ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud)
263 GHashTable *track_indices;
264 gchar *lang, *pref_lang = NULL;
266 gint foreign_lang_index = -1;
267 gboolean found_cc = FALSE;
269 const GValue *pref_subtitle;
273 g_debug("ghb_set_pref_subtitle %d", titleindex);
275 // Check to see if we need to add a subtitle track for foreign audio
276 // language films. A subtitle track will be added if:
278 // The first (default) audio track language does NOT match the users
279 // chosen Preferred Language AND the Preferred Language is NOT Any (und).
281 audio_lang = ghb_get_user_audio_lang(ud, titleindex, 0);
282 pref_lang = ghb_settings_get_string(ud->settings, "PreferredLanguage");
284 if (audio_lang != NULL && pref_lang != NULL &&
285 (strcmp(audio_lang, pref_lang) == 0 || strcmp("und", pref_lang) == 0))
291 track_indices = g_hash_table_new_full(g_str_hash, g_str_equal,
292 free_subtitle_key, free_subtitle_index_list);
294 ghb_ui_update(ud, "SubtitleTrack", ghb_int_value(0));
296 // Clear the subtitle list
297 ghb_clear_subtitle_list(ud);
300 add_all_pref_subtitles(ud);
304 // Find "best" subtitle based on subtitle preferences
305 pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
307 count = ghb_array_len(pref_subtitle);
309 for (ii = 0; ii < count; ii++)
311 subtitle = ghb_array_get_nth(pref_subtitle, ii);
312 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
313 // If there are multiple subtitles using the same language, then
314 // select sequential tracks for each. The hash keeps track
315 // of the tracks used for each language.
316 track = ghb_find_subtitle_track(titleindex, lang, track_indices);
321 GValue *dup = ghb_value_dup(subtitle);
322 lang = ghb_subtitle_track_lang(ud, track);
323 ghb_settings_set_int(dup, "SubtitleTrack", track);
324 if (foreign_lang_index < 0 && pref_lang != NULL &&
325 strcmp(lang, pref_lang) == 0)
327 foreign_lang_index = jj;
328 ghb_settings_take_value(dup, "SubtitleForced",
329 ghb_boolean_value_new(FALSE));
330 ghb_settings_take_value(dup, "SubtitleDefaultTrack",
331 ghb_boolean_value_new(TRUE));
333 source = ghb_subtitle_track_source(ud, track);
334 if (source == CC608SUB || source == CC708SUB)
336 ghb_add_subtitle(ud, dup);
341 if (foreign_lang_index < 0 && pref_lang != NULL)
343 // Subtitle for foreign language audio not added yet
347 track = ghb_find_subtitle_track(titleindex, pref_lang, track_indices);
350 burn = mustBurn(ud, track);
351 settings = ghb_dict_value_new();
352 ghb_settings_set_int(settings, "SubtitleTrack", track);
353 ghb_settings_take_value(settings, "SubtitleForced",
354 ghb_boolean_value_new(FALSE));
355 ghb_settings_take_value(settings, "SubtitleBurned",
356 ghb_boolean_value_new(burn));
357 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
358 ghb_boolean_value_new(TRUE));
360 ghb_add_subtitle(ud, settings);
361 foreign_lang_index = jj;
364 if (foreign_lang_index >= 0)
366 GValue *subtitle_list;
369 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
370 subtitle = ghb_array_get_nth(subtitle_list, foreign_lang_index);
372 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
373 def = ghb_settings_get_boolean(subtitle, "SubtitleDefaultTrack");
375 ghb_subtitle_exclusive_burn(ud, foreign_lang_index);
377 ghb_subtitle_exclusive_default(ud, foreign_lang_index);
378 ghb_log("adding subtitle for foreign language audio: %s", audio_lang);
380 if (ghb_settings_get_boolean(ud->settings, "AddCC") && !found_cc)
382 // Subtitle for foreign language audio not added yet
385 track = ghb_find_cc_track(titleindex);
388 settings = ghb_dict_value_new();
389 ghb_settings_set_int(settings, "SubtitleTrack", track);
390 ghb_settings_take_value(settings, "SubtitleForced",
391 ghb_boolean_value_new(FALSE));
392 ghb_settings_take_value(settings, "SubtitleBurned",
393 ghb_boolean_value_new(FALSE));
394 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
395 ghb_boolean_value_new(FALSE));
397 ghb_add_subtitle(ud, settings);
398 ghb_log("adding Closed Captions: %s", audio_lang);
401 if (pref_lang != NULL)
403 if (audio_lang != NULL)
405 g_hash_table_destroy(track_indices);
409 ghb_selected_subtitle_row(signal_user_data_t *ud)
411 GtkTreeView *treeview;
412 GtkTreePath *treepath;
413 GtkTreeSelection *selection;
419 g_debug("ghb_selected_subtitle_row ()");
420 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
421 selection = gtk_tree_view_get_selection (treeview);
422 if (gtk_tree_selection_get_selected(selection, &store, &iter))
424 // Get the row number
425 treepath = gtk_tree_model_get_path (store, &iter);
426 indices = gtk_tree_path_get_indices (treepath);
428 gtk_tree_path_free(treepath);
434 ghb_selected_subtitle_settings(signal_user_data_t *ud)
436 GtkTreeView *treeview;
437 GtkTreePath *treepath;
438 GtkTreeSelection *selection;
443 GValue *settings = NULL;
444 const GValue *subtitle_list;
446 g_debug("get_selected_settings ()");
447 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
448 selection = gtk_tree_view_get_selection (treeview);
449 if (gtk_tree_selection_get_selected(selection, &store, &iter))
451 // Get the row number
452 treepath = gtk_tree_model_get_path (store, &iter);
453 indices = gtk_tree_path_get_indices (treepath);
455 gtk_tree_path_free(treepath);
456 // find subtitle settings
457 if (row < 0) return NULL;
458 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
459 if (row >= ghb_array_len(subtitle_list))
461 settings = ghb_array_get_nth(subtitle_list, row);
467 subtitle_forced_toggled_cb(
468 GtkCellRendererToggle *cell,
470 signal_user_data_t *ud)
479 GValue *subtitle_list, *settings;
482 g_debug("forced toggled");
483 tp = gtk_tree_path_new_from_string (path);
484 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
485 g_return_if_fail(tv != NULL);
486 tm = gtk_tree_view_get_model(tv);
487 g_return_if_fail(tm != NULL);
488 gtk_tree_model_get_iter(tm, &ti, tp);
489 gtk_tree_model_get(tm, &ti, 1, &active, -1);
492 // Get the row number
493 indices = gtk_tree_path_get_indices (tp);
495 gtk_tree_path_free(tp);
497 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
499 if (row < 0 || row >= ghb_array_len(subtitle_list))
502 settings = ghb_array_get_nth(subtitle_list, row);
504 source = ghb_settings_get_int(settings, "SubtitleSource");
505 if (source != VOBSUB)
508 ghb_settings_set_boolean(settings, "SubtitleForced", active);
509 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
514 subtitle_burned_toggled_cb(
515 GtkCellRendererToggle *cell,
517 signal_user_data_t *ud)
526 GValue *subtitle_list;
527 gint count, track, source;
530 g_debug("burned toggled");
531 tp = gtk_tree_path_new_from_string (path);
532 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
533 g_return_if_fail(tv != NULL);
534 tm = gtk_tree_view_get_model(tv);
535 g_return_if_fail(tm != NULL);
536 gtk_tree_model_get_iter(tm, &ti, tp);
537 gtk_tree_model_get(tm, &ti, 2, &active, -1);
540 // Get the row number
541 indices = gtk_tree_path_get_indices (tp);
543 gtk_tree_path_free(tp);
545 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
546 count = ghb_array_len(subtitle_list);
547 if (row < 0 || row >= count)
550 settings = ghb_array_get_nth(subtitle_list, row);
552 source = ghb_settings_get_int(settings, "SubtitleSource");
553 if (source != VOBSUB)
556 track = ghb_settings_combo_int(settings, "SubtitleTrack");
557 if (!active && mustBurn(ud, track))
560 ghb_settings_set_boolean(settings, "SubtitleBurned", active);
562 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, active, -1);
565 ghb_subtitle_exclusive_burn(ud, row);
570 subtitle_default_toggled_cb(
571 GtkCellRendererToggle *cell,
573 signal_user_data_t *ud)
582 GValue *subtitle_list;
586 g_debug("default toggled");
587 tp = gtk_tree_path_new_from_string (path);
588 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
589 g_return_if_fail(tv != NULL);
590 tm = gtk_tree_view_get_model(tv);
591 g_return_if_fail(tm != NULL);
592 gtk_tree_model_get_iter(tm, &ti, tp);
593 gtk_tree_model_get(tm, &ti, 3, &active, -1);
596 // Get the row number
597 indices = gtk_tree_path_get_indices (tp);
599 gtk_tree_path_free(tp);
601 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
602 count = ghb_array_len(subtitle_list);
603 if (row < 0 || row >= count)
606 settings = ghb_array_get_nth(subtitle_list, row);
608 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
610 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
611 // allow only one default
612 ghb_subtitle_exclusive_default(ud, row);
617 subtitle_source_name(gint source)
641 subtitle_list_refresh_selected(signal_user_data_t *ud)
643 GtkTreeView *treeview;
644 GtkTreePath *treepath;
645 GtkTreeSelection *selection;
650 GValue *settings = NULL;
651 const GValue *subtitle_list;
653 g_debug("subtitle_list_refresh_selected ()");
654 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
655 selection = gtk_tree_view_get_selection (treeview);
656 if (gtk_tree_selection_get_selected(selection, &store, &iter))
658 gchar *track, *source;
659 gboolean forced, burned, def;
663 // Get the row number
664 treepath = gtk_tree_model_get_path (store, &iter);
665 indices = gtk_tree_path_get_indices (treepath);
667 gtk_tree_path_free(treepath);
668 // find audio settings
670 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
671 if (row >= ghb_array_len(subtitle_list))
673 settings = ghb_array_get_nth(subtitle_list, row);
675 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
678 i_source = ghb_settings_get_int(settings, "SubtitleSource");
679 if (i_source != VOBSUB)
681 // Force and burn only apply to VOBSUBS
684 ghb_settings_set_boolean(settings, "SubtitleForced", forced);
685 ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
688 if (i_source == SRTSUB)
693 lang = ghb_settings_combo_option(settings, "SrtLanguage");
694 code = ghb_settings_get_string(settings, "SrtCodeset");
695 track = g_strdup_printf("%s (%s)", lang, code);
698 s_track = ghb_settings_get_string(settings, "SrtFile");
699 if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR))
703 basename = g_path_get_basename(s_track);
704 source = g_strdup_printf("SRT (%s)", basename);
709 source = g_strdup_printf("SRT (none)");
711 offset = ghb_settings_get_int(settings, "SrtOffset");
719 ghb_settings_combo_option(settings, "SubtitleTrack"));
720 source = g_strdup(subtitle_source_name(i_source));
721 s_track = ghb_settings_get_string(settings, "SubtitleTrack");
723 forced = ghb_settings_get_boolean(settings, "SubtitleForced");
724 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
727 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
728 // These are displayed in list
735 // These are used to set combo box values when a list item is selected
743 ghb_subtitle_exclusive_burn(ud, row);
748 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
752 g_debug("subtitle_track_changed_cb ()");
753 ghb_check_dependency(ud, widget);
754 ghb_widget_to_setting(ud->settings, widget);
755 settings = ghb_selected_subtitle_settings(ud);
756 if (settings != NULL)
758 const gchar *track, *lang;
761 ghb_widget_to_setting(settings, widget);
762 subtitle_list_refresh_selected(ud);
763 track = ghb_settings_combo_option(settings, "SubtitleTrack");
764 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
765 tt = ghb_settings_get_int(settings, "SubtitleTrack");
766 source = ghb_subtitle_track_source(ud, tt);
767 ghb_settings_set_int(settings, "SubtitleSource", source);
768 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
769 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
776 srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
780 g_debug("srt_changed_cb ()");
781 ghb_check_dependency(ud, widget);
782 ghb_widget_to_setting(ud->settings, widget);
783 settings = ghb_selected_subtitle_settings(ud);
784 if (settings != NULL)
786 ghb_widget_to_setting(settings, widget);
787 subtitle_list_refresh_selected(ud);
794 srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
798 g_debug("srt_changed_cb ()");
799 ghb_check_dependency(ud, widget);
800 ghb_widget_to_setting(ud->settings, widget);
801 settings = ghb_selected_subtitle_settings(ud);
802 if (settings != NULL)
804 gchar *filename, *dirname;
806 ghb_widget_to_setting(settings, widget);
807 subtitle_list_refresh_selected(ud);
811 filename = ghb_settings_get_string(settings, "SrtFile");
812 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
814 ghb_settings_set_string(ud->settings, "SrtDir", filename);
818 dirname = g_path_get_dirname(filename);
819 ghb_settings_set_string(ud->settings, "SrtDir", dirname);
822 ghb_pref_save(ud->settings, "SrtDir");
828 srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
832 g_debug("srt_lang_changed_cb ()");
833 ghb_check_dependency(ud, widget);
834 ghb_widget_to_setting(ud->settings, widget);
835 settings = ghb_selected_subtitle_settings(ud);
836 if (settings != NULL)
840 ghb_widget_to_setting(settings, widget);
841 subtitle_list_refresh_selected(ud);
845 lang = ghb_settings_combo_option(settings, "SrtLanguage");
846 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
851 ghb_clear_subtitle_list(signal_user_data_t *ud)
853 GtkTreeView *treeview;
855 GValue *subtitle_list;
857 g_debug("clear_subtitle_list ()");
858 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
859 if (subtitle_list == NULL)
861 subtitle_list = ghb_array_value_new(8);
862 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
865 ghb_array_value_reset(subtitle_list, 8);
866 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
867 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
868 gtk_list_store_clear (store);
872 add_to_subtitle_list(
873 signal_user_data_t *ud,
876 GtkTreeView *treeview;
879 GtkTreeSelection *selection;
880 const gchar *track, *source;
881 gboolean forced, burned, def;
885 g_debug("add_to_subtitle_list ()");
886 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
887 selection = gtk_tree_view_get_selection (treeview);
888 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
890 track = ghb_settings_combo_option(settings, "SubtitleTrack");
891 forced = ghb_settings_get_boolean(settings, "SubtitleForced");
892 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
893 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
895 s_track = ghb_settings_get_string(settings, "SubtitleTrack");
896 i_source = ghb_settings_get_int(settings, "SubtitleSource");
897 source = subtitle_source_name(i_source);
899 gtk_list_store_append(store, &iter);
900 gtk_list_store_set(store, &iter,
901 // These are displayed in list
907 // These are used to set combo box values when a list item is selected
914 gtk_tree_selection_select_iter(selection, &iter);
920 signal_user_data_t *ud,
923 GtkTreeView *treeview;
926 GtkTreeSelection *selection;
928 gboolean forced, burned, def;
929 gchar *filename, *code, *track, *source;
930 gint i_source, offset;
932 g_debug("add_to_srt_list ()");
933 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
934 selection = gtk_tree_view_get_selection (treeview);
935 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
937 lang = ghb_settings_combo_option(settings, "SrtLanguage");
938 code = ghb_settings_get_string(settings, "SrtCodeset");
939 track = g_strdup_printf("%s (%s)", lang, code);
942 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
944 filename = ghb_settings_get_string(settings, "SrtFile");
945 if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
949 basename = g_path_get_basename(filename);
950 source = g_strdup_printf("SRT (%s)", basename);
955 source = g_strdup_printf("SRT (none)");
958 offset = ghb_settings_get_int(settings, "SrtOffset");
960 gtk_list_store_append(store, &iter);
961 gtk_list_store_set(store, &iter,
962 // These are displayed in list
969 // These are used to set combo box values when a list item is selected
976 gtk_tree_selection_select_iter(selection, &iter);
984 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
990 g_debug("subtitle_list_selection_changed_cb ()");
991 if (gtk_tree_selection_get_selected(selection, &store, &iter))
994 GtkTreePath *treepath;
996 GValue *subtitle_list, *settings;
998 treepath = gtk_tree_model_get_path (store, &iter);
999 indices = gtk_tree_path_get_indices (treepath);
1001 gtk_tree_path_free(treepath);
1003 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1004 if (row >= ghb_array_len(subtitle_list))
1007 settings = ghb_array_get_nth(subtitle_list, row);
1009 source = ghb_settings_get_int(settings, "SubtitleSource");
1010 if (source == SRTSUB)
1015 str = ghb_settings_get_string(settings, "SrtLanguage");
1016 ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str));
1019 str = ghb_settings_get_string(settings, "SrtCodeset");
1020 ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str));
1023 str = ghb_settings_get_string(settings, "SrtFile");
1024 ghb_ui_update(ud, "SrtFile", ghb_string_value(str));
1027 offset = ghb_settings_get_int(settings, "SrtOffset");
1028 ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset));
1030 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1031 gtk_widget_hide(widget);
1032 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1033 gtk_widget_hide(widget);
1034 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1035 gtk_widget_show(widget);
1036 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1037 gtk_widget_show(widget);
1038 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1039 gtk_widget_show(widget);
1040 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1041 gtk_widget_show(widget);
1042 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1043 gtk_widget_show(widget);
1044 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1045 gtk_widget_show(widget);
1046 widget = GHB_WIDGET(ud->builder, "SrtFile");
1047 gtk_widget_show(widget);
1048 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1049 gtk_widget_show(widget);
1055 track = ghb_settings_get_string(settings, "SubtitleTrack");
1056 ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
1059 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1060 gtk_widget_hide(widget);
1061 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1062 gtk_widget_hide(widget);
1063 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1064 gtk_widget_hide(widget);
1065 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1066 gtk_widget_hide(widget);
1067 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1068 gtk_widget_hide(widget);
1069 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1070 gtk_widget_hide(widget);
1071 widget = GHB_WIDGET(ud->builder, "SrtFile");
1072 gtk_widget_hide(widget);
1073 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1074 gtk_widget_hide(widget);
1075 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1076 gtk_widget_show(widget);
1077 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1078 gtk_widget_show(widget);
1080 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
1081 gtk_widget_set_sensitive(widget, TRUE);
1085 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1086 gtk_widget_hide(widget);
1087 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1088 gtk_widget_hide(widget);
1089 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1090 gtk_widget_hide(widget);
1091 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1092 gtk_widget_hide(widget);
1093 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1094 gtk_widget_hide(widget);
1095 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1096 gtk_widget_hide(widget);
1097 widget = GHB_WIDGET(ud->builder, "SrtFile");
1098 gtk_widget_hide(widget);
1099 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1100 gtk_widget_hide(widget);
1101 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1102 gtk_widget_show(widget);
1103 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1104 gtk_widget_show(widget);
1108 G_MODULE_EXPORT void
1109 srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1111 // Add the current subtitle settings to the list.
1113 gboolean burned = FALSE;
1115 gchar *dir, *filename;
1117 g_debug("subtitle_add_clicked_cb ()");
1119 track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1120 if (mustBurn(ud, track))
1124 settings = ghb_dict_value_new();
1125 ghb_settings_set_string(settings, "SrtLanguage", "und");
1126 ghb_settings_set_string(settings, "SrtCodeset", "UTF-8");
1128 dir = ghb_settings_get_string(ud->settings, "SrtDir");
1129 filename = g_strdup_printf("%s/none", dir);
1130 ghb_settings_set_string(settings, "SrtFile", filename);
1134 ghb_settings_set_int(settings, "SrtOffset", 0);
1135 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1136 ghb_boolean_value_new(FALSE));
1138 ghb_add_srt(ud, settings);
1141 G_MODULE_EXPORT void
1142 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1144 // Add the current subtitle settings to the list.
1146 gboolean burned = FALSE;
1149 g_debug("subtitle_add_clicked_cb ()");
1151 track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1152 if (mustBurn(ud, track))
1156 settings = ghb_dict_value_new();
1157 ghb_settings_set_int(settings, "SubtitleTrack", track);
1158 ghb_settings_take_value(settings, "SubtitleForced",
1159 ghb_boolean_value_new(FALSE));
1160 ghb_settings_take_value(settings, "SubtitleBurned",
1161 ghb_boolean_value_new(burned));
1162 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1163 ghb_boolean_value_new(FALSE));
1165 ghb_add_subtitle(ud, settings);
1168 G_MODULE_EXPORT void
1169 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
1171 GtkTreeView *treeview;
1172 GtkTreePath *treepath;
1173 GtkTreeSelection *selection;
1174 GtkTreeModel *store;
1175 GtkTreeIter iter, nextIter;
1178 GValue *subtitle_list;
1180 g_debug("subtitle_remove_clicked_cb ()");
1181 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1182 selection = gtk_tree_view_get_selection (treeview);
1183 if (gtk_tree_selection_get_selected(selection, &store, &iter))
1186 if (!gtk_tree_model_iter_next(store, &nextIter))
1189 if (gtk_tree_model_get_iter_first(store, &nextIter))
1191 gtk_tree_selection_select_iter (selection, &nextIter);
1196 gtk_tree_selection_select_iter (selection, &nextIter);
1198 // Get the row number
1199 treepath = gtk_tree_model_get_path (store, &iter);
1200 indices = gtk_tree_path_get_indices (treepath);
1202 gtk_tree_path_free(treepath);
1203 // Remove the selected item
1204 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
1205 // remove from subtitle settings list
1206 if (row < 0) return;
1207 widget = GHB_WIDGET (ud->builder, "subtitle_add");
1208 gtk_widget_set_sensitive(widget, TRUE);
1209 widget = GHB_WIDGET (ud->builder, "srt_add");
1210 gtk_widget_set_sensitive(widget, TRUE);
1211 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1212 if (row >= ghb_array_len(subtitle_list))
1214 GValue *old = ghb_array_get_nth(subtitle_list, row);
1215 ghb_value_free(old);
1216 ghb_array_remove(subtitle_list, row);
1222 ghb_subtitle_prune(signal_user_data_t *ud)
1227 GValue *subtitle_list, *settings;
1228 gint count, ii, track;
1230 gint first_track = 0, one_burned = 0;
1232 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1233 if (subtitle_list == NULL)
1235 count = ghb_array_len(subtitle_list);
1237 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1238 g_return_if_fail(tv != NULL);
1239 tm = gtk_tree_view_get_model(tv);
1240 for (ii = count-1; ii >= 0; ii--)
1242 settings = ghb_array_get_nth(subtitle_list, ii);
1243 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
1244 track = ghb_settings_combo_int(settings, "SubtitleTrack");
1245 if (!burned && mustBurn(ud, track))
1247 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
1248 gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
1249 ghb_array_remove(subtitle_list, ii);
1259 ghb_subtitle_exclusive_burn(ud, first_track);
1264 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
1271 g_debug("ghb_reset_subtitles");
1272 ghb_clear_subtitle_list(ud);
1273 titleindex = ghb_settings_combo_int(ud->settings, "title");
1277 slist = ghb_settings_get_value(settings, "subtitle_list");
1278 count = ghb_array_len(slist);
1279 for (ii = 0; ii < count; ii++)
1281 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
1282 ghb_add_subtitle(ud, subtitle);