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, GValue *settings)
44 if (ghb_settings_combo_int(ud->settings, "FileFormat") == HB_MUX_MP4)
46 // MP4 can only handle burned vobsubs. make sure there isn't
47 // already something burned in the list
48 if (ghb_settings_get_int(settings, "SubtitleSource") == VOBSUB)
57 ghb_soft_in_subtitle_list(GValue *subtitle_list)
62 count = ghb_array_len(subtitle_list);
63 for (ii = 0; ii < count; ii++)
65 settings = ghb_array_get_nth(subtitle_list, ii);
66 if (!ghb_settings_get_boolean(settings, "SubtitleBurned"))
75 ghb_subtitle_exclusive_burn(signal_user_data_t *ud, gint index)
77 GValue *subtitle_list;
85 g_debug("ghb_subtitle_exclusive_burn");
86 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
87 count = ghb_array_len(subtitle_list);
88 for (ii = 0; ii < count; ii++)
90 settings = ghb_array_get_nth(subtitle_list, ii);
91 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
93 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
94 g_return_if_fail(tv != NULL);
95 tm = gtk_tree_view_get_model(tv);
96 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
97 if (burned && ii != index && !mustBurn(ud, settings))
99 ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
100 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
106 ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index)
108 GValue *subtitle_list;
116 g_debug("ghb_subtitle_exclusive_default");
117 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
118 count = ghb_array_len(subtitle_list);
119 for (ii = 0; ii < count; ii++)
121 settings = ghb_array_get_nth(subtitle_list, ii);
122 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
124 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
125 g_return_if_fail(tv != NULL);
126 tm = gtk_tree_view_get_model(tv);
127 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
128 if (def && ii != index)
131 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
132 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, FALSE, -1);
138 ghb_add_srt(signal_user_data_t *ud, GValue *settings)
140 // Add the current subtitle settings to the list.
141 GValue *subtitle_list;
145 g_debug("ghb_add_srt ()");
147 ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
148 // Add the long track description so the queue can access it
149 // when a different title is selected.
150 lang = ghb_settings_combo_option(settings, "SrtLanguage");
151 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
153 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
154 if (subtitle_list == NULL)
156 subtitle_list = ghb_array_value_new(8);
157 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
159 count = ghb_array_len(subtitle_list);
161 // Don't allow more than 99
162 // This is a had limit imposed by libhb/sync.c:GetFifoForId()
165 ghb_value_free(settings);
169 ghb_array_append(subtitle_list, settings);
170 add_to_srt_list(ud, settings);
175 widget = GHB_WIDGET (ud->builder, "subtitle_add");
176 gtk_widget_set_sensitive(widget, FALSE);
177 widget = GHB_WIDGET (ud->builder, "srt_add");
178 gtk_widget_set_sensitive(widget, FALSE);
180 ghb_update_destination_extension(ud);
185 ghb_add_subtitle(signal_user_data_t *ud, GValue *settings)
187 // Add the current subtitle settings to the list.
188 GValue *subtitle_list;
194 g_debug("ghb_add_subtitle ()");
196 // Add the long track description so the queue can access it
197 // when a different title is selected.
198 track = ghb_settings_combo_option(settings, "SubtitleTrack");
199 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
201 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
202 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
204 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
205 if (subtitle_list == NULL)
207 subtitle_list = ghb_array_value_new(8);
208 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
210 count = ghb_array_len(subtitle_list);
212 // Don't allow more than 99
213 // This is a had limit imposed by libhb/sync.c:GetFifoForId()
216 ghb_value_free(settings);
220 ghb_array_append(subtitle_list, settings);
221 add_to_subtitle_list(ud, settings);
223 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
225 ghb_subtitle_exclusive_burn(ud, count);
229 widget = GHB_WIDGET (ud->builder, "subtitle_add");
230 gtk_widget_set_sensitive(widget, FALSE);
231 widget = GHB_WIDGET (ud->builder, "srt_add");
232 gtk_widget_set_sensitive(widget, FALSE);
234 ghb_update_destination_extension(ud);
239 add_all_pref_subtitles(signal_user_data_t *ud)
241 const GValue *pref_subtitle;
243 gint count, ii, track;
246 pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
247 count = ghb_array_len(pref_subtitle);
248 for (ii = 0; ii < count; ii++)
250 subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
251 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
252 // If there are multiple subtitles using the same language, then
253 // select sequential tracks for each. The hash keeps track
254 // of the tracks used for each language.
255 track = ghb_find_pref_subtitle_track(lang);
261 // Add to subtitle list
262 ghb_settings_set_int(subtitle, "SubtitleTrack", track);
263 source = ghb_subtitle_track_source(ud, track);
264 ghb_settings_set_int(subtitle, "SubtitleSource", source);
265 ghb_add_subtitle(ud, subtitle);
271 ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud)
274 GHashTable *track_indices;
275 gchar *lang, *pref_lang = NULL;
277 gint foreign_lang_index = -1;
278 gboolean found_cc = FALSE;
280 const GValue *pref_subtitle;
284 g_debug("ghb_set_pref_subtitle %d", titleindex);
286 // Check to see if we need to add a subtitle track for foreign audio
287 // language films. A subtitle track will be added if:
289 // The first (default) audio track language does NOT match the users
290 // chosen Preferred Language AND the Preferred Language is NOT Any (und).
292 audio_lang = ghb_get_user_audio_lang(ud, titleindex, 0);
293 pref_lang = ghb_settings_get_string(ud->settings, "PreferredLanguage");
295 if (audio_lang != NULL && pref_lang != NULL &&
296 (strcmp(audio_lang, pref_lang) == 0 || strcmp("und", pref_lang) == 0))
302 track_indices = g_hash_table_new_full(g_str_hash, g_str_equal,
303 free_subtitle_key, free_subtitle_index_list);
305 ghb_ui_update(ud, "SubtitleTrack", ghb_int_value(0));
307 // Clear the subtitle list
308 ghb_clear_subtitle_list(ud);
311 add_all_pref_subtitles(ud);
315 // Find "best" subtitle based on subtitle preferences
316 pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
318 count = ghb_array_len(pref_subtitle);
320 for (ii = 0; ii < count; ii++)
323 gboolean force, burn;
325 subtitle = ghb_array_get_nth(pref_subtitle, ii);
326 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
327 source = ghb_settings_get_int(subtitle, "SubtitleSource");
328 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
329 force = ghb_settings_get_boolean(subtitle, "SubtitleForced");
330 // If there are multiple subtitles using the same language, then
331 // select sequential tracks for each. The hash keeps track
332 // of the tracks used for each language.
333 track = ghb_find_subtitle_track(titleindex, lang, burn,
334 force, source, track_indices);
338 GValue *dup = ghb_value_dup(subtitle);
339 lang = ghb_subtitle_track_lang(ud, track);
340 ghb_settings_set_int(dup, "SubtitleTrack", track);
341 if (foreign_lang_index < 0 && pref_lang != NULL &&
342 strcmp(lang, pref_lang) == 0)
344 foreign_lang_index = jj;
345 ghb_settings_take_value(dup, "SubtitleForced",
346 ghb_boolean_value_new(FALSE));
347 ghb_settings_take_value(dup, "SubtitleDefaultTrack",
348 ghb_boolean_value_new(TRUE));
350 source = ghb_subtitle_track_source(ud, track);
351 ghb_settings_set_int(dup, "SubtitleSource", source);
352 if (source == CC608SUB || source == CC708SUB)
354 ghb_add_subtitle(ud, dup);
359 if (foreign_lang_index < 0 && pref_lang != NULL)
361 // Subtitle for foreign language audio not added yet
365 track = ghb_find_subtitle_track(titleindex, pref_lang, FALSE, FALSE, VOBSUB, track_indices);
370 settings = ghb_dict_value_new();
371 ghb_settings_set_int(settings, "SubtitleTrack", track);
372 source = ghb_subtitle_track_source(ud, track);
373 ghb_settings_set_int(settings, "SubtitleSource", source);
374 burn = mustBurn(ud, settings);
375 ghb_settings_take_value(settings, "SubtitleForced",
376 ghb_boolean_value_new(FALSE));
377 ghb_settings_take_value(settings, "SubtitleBurned",
378 ghb_boolean_value_new(burn));
379 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
380 ghb_boolean_value_new(TRUE));
382 ghb_add_subtitle(ud, settings);
383 foreign_lang_index = jj;
386 if (foreign_lang_index >= 0)
388 GValue *subtitle_list;
391 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
392 subtitle = ghb_array_get_nth(subtitle_list, foreign_lang_index);
394 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
395 def = ghb_settings_get_boolean(subtitle, "SubtitleDefaultTrack");
397 ghb_subtitle_exclusive_burn(ud, foreign_lang_index);
399 ghb_subtitle_exclusive_default(ud, foreign_lang_index);
400 ghb_log("adding subtitle for foreign language audio: %s", audio_lang);
402 if (ghb_settings_get_boolean(ud->settings, "AddCC") && !found_cc)
404 // Subtitle for foreign language audio not added yet
407 track = ghb_find_cc_track(titleindex);
412 settings = ghb_dict_value_new();
413 ghb_settings_set_int(settings, "SubtitleTrack", track);
414 source = ghb_subtitle_track_source(ud, track);
415 ghb_settings_set_int(settings, "SubtitleSource", source);
416 ghb_settings_take_value(settings, "SubtitleForced",
417 ghb_boolean_value_new(FALSE));
418 ghb_settings_take_value(settings, "SubtitleBurned",
419 ghb_boolean_value_new(FALSE));
420 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
421 ghb_boolean_value_new(FALSE));
423 ghb_add_subtitle(ud, settings);
424 ghb_log("adding Closed Captions: %s", audio_lang);
427 if (pref_lang != NULL)
429 if (audio_lang != NULL)
431 g_hash_table_destroy(track_indices);
435 ghb_selected_subtitle_row(signal_user_data_t *ud)
437 GtkTreeView *treeview;
438 GtkTreePath *treepath;
439 GtkTreeSelection *selection;
445 g_debug("ghb_selected_subtitle_row ()");
446 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
447 selection = gtk_tree_view_get_selection (treeview);
448 if (gtk_tree_selection_get_selected(selection, &store, &iter))
450 // Get the row number
451 treepath = gtk_tree_model_get_path (store, &iter);
452 indices = gtk_tree_path_get_indices (treepath);
454 gtk_tree_path_free(treepath);
460 ghb_selected_subtitle_settings(signal_user_data_t *ud)
462 GtkTreeView *treeview;
463 GtkTreePath *treepath;
464 GtkTreeSelection *selection;
469 GValue *settings = NULL;
470 const GValue *subtitle_list;
472 g_debug("get_selected_settings ()");
473 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
474 selection = gtk_tree_view_get_selection (treeview);
475 if (gtk_tree_selection_get_selected(selection, &store, &iter))
477 // Get the row number
478 treepath = gtk_tree_model_get_path (store, &iter);
479 indices = gtk_tree_path_get_indices (treepath);
481 gtk_tree_path_free(treepath);
482 // find subtitle settings
483 if (row < 0) return NULL;
484 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
485 if (row >= ghb_array_len(subtitle_list))
487 settings = ghb_array_get_nth(subtitle_list, row);
493 subtitle_forced_toggled_cb(
494 GtkCellRendererToggle *cell,
496 signal_user_data_t *ud)
505 GValue *subtitle_list, *settings;
508 g_debug("forced toggled");
509 tp = gtk_tree_path_new_from_string (path);
510 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
511 g_return_if_fail(tv != NULL);
512 tm = gtk_tree_view_get_model(tv);
513 g_return_if_fail(tm != NULL);
514 gtk_tree_model_get_iter(tm, &ti, tp);
515 gtk_tree_model_get(tm, &ti, 1, &active, -1);
518 // Get the row number
519 indices = gtk_tree_path_get_indices (tp);
521 gtk_tree_path_free(tp);
523 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
525 if (row < 0 || row >= ghb_array_len(subtitle_list))
528 settings = ghb_array_get_nth(subtitle_list, row);
530 source = ghb_settings_get_int(settings, "SubtitleSource");
531 if (source != VOBSUB)
534 ghb_settings_set_boolean(settings, "SubtitleForced", active);
535 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
540 subtitle_burned_toggled_cb(
541 GtkCellRendererToggle *cell,
543 signal_user_data_t *ud)
552 GValue *subtitle_list;
557 g_debug("burned toggled");
558 tp = gtk_tree_path_new_from_string (path);
559 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
560 g_return_if_fail(tv != NULL);
561 tm = gtk_tree_view_get_model(tv);
562 g_return_if_fail(tm != NULL);
563 gtk_tree_model_get_iter(tm, &ti, tp);
564 gtk_tree_model_get(tm, &ti, 2, &active, -1);
567 // Get the row number
568 indices = gtk_tree_path_get_indices (tp);
570 gtk_tree_path_free(tp);
572 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
573 count = ghb_array_len(subtitle_list);
574 if (row < 0 || row >= count)
577 settings = ghb_array_get_nth(subtitle_list, row);
578 source = ghb_settings_get_int(settings, "SubtitleSource");
579 if (source != VOBSUB)
581 if (!active && mustBurn(ud, settings))
584 ghb_settings_set_boolean(settings, "SubtitleBurned", active);
585 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, active, -1);
589 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", !active);
590 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, !active, -1);
595 ghb_subtitle_exclusive_burn(ud, row);
596 ghb_update_destination_extension(ud);
601 subtitle_default_toggled_cb(
602 GtkCellRendererToggle *cell,
604 signal_user_data_t *ud)
613 GValue *subtitle_list;
618 g_debug("default toggled");
619 tp = gtk_tree_path_new_from_string (path);
620 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
621 g_return_if_fail(tv != NULL);
622 tm = gtk_tree_view_get_model(tv);
623 g_return_if_fail(tm != NULL);
624 gtk_tree_model_get_iter(tm, &ti, tp);
625 gtk_tree_model_get(tm, &ti, 3, &active, -1);
628 // Get the row number
629 indices = gtk_tree_path_get_indices (tp);
631 gtk_tree_path_free(tp);
633 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
634 count = ghb_array_len(subtitle_list);
635 if (row < 0 || row >= count)
638 settings = ghb_array_get_nth(subtitle_list, row);
639 if (active && mustBurn(ud, settings))
642 ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
643 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
647 ghb_settings_set_boolean(settings, "SubtitleBurned", !active);
648 gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, !active, -1);
650 // allow only one default
651 ghb_subtitle_exclusive_default(ud, row);
656 subtitle_source_name(gint source)
680 subtitle_list_refresh_selected(signal_user_data_t *ud)
682 GtkTreeView *treeview;
683 GtkTreePath *treepath;
684 GtkTreeSelection *selection;
689 GValue *settings = NULL;
690 const GValue *subtitle_list;
692 g_debug("subtitle_list_refresh_selected ()");
693 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
694 selection = gtk_tree_view_get_selection (treeview);
695 if (gtk_tree_selection_get_selected(selection, &store, &iter))
697 gchar *track, *source;
698 gboolean forced, burned, def;
702 // Get the row number
703 treepath = gtk_tree_model_get_path (store, &iter);
704 indices = gtk_tree_path_get_indices (treepath);
706 gtk_tree_path_free(treepath);
708 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
709 if (row >= ghb_array_len(subtitle_list))
711 settings = ghb_array_get_nth(subtitle_list, row);
713 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
716 i_source = ghb_settings_get_int(settings, "SubtitleSource");
717 if (i_source != VOBSUB)
719 // Force and burn only apply to VOBSUBS
722 ghb_settings_set_boolean(settings, "SubtitleForced", forced);
723 ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
726 if (i_source == SRTSUB)
731 lang = ghb_settings_combo_option(settings, "SrtLanguage");
732 code = ghb_settings_get_string(settings, "SrtCodeset");
733 track = g_strdup_printf("%s (%s)", lang, code);
736 s_track = ghb_settings_get_string(settings, "SrtFile");
737 if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR))
741 basename = g_path_get_basename(s_track);
742 source = g_strdup_printf("SRT (%s)", basename);
747 source = g_strdup_printf("SRT (none)");
749 offset = ghb_settings_get_int(settings, "SrtOffset");
757 ghb_settings_combo_option(settings, "SubtitleTrack"));
758 source = g_strdup(subtitle_source_name(i_source));
759 s_track = ghb_settings_get_string(settings, "SubtitleTrack");
761 forced = ghb_settings_get_boolean(settings, "SubtitleForced");
762 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
765 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
766 // These are displayed in list
773 // These are used to set combo box values when a list item is selected
781 ghb_subtitle_exclusive_burn(ud, row);
786 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
790 g_debug("subtitle_track_changed_cb ()");
791 ghb_check_dependency(ud, widget, NULL);
792 ghb_widget_to_setting(ud->settings, widget);
793 settings = ghb_selected_subtitle_settings(ud);
794 if (settings != NULL)
796 const gchar *track, *lang;
799 ghb_widget_to_setting(settings, widget);
800 track = ghb_settings_combo_option(settings, "SubtitleTrack");
801 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
802 tt = ghb_settings_get_int(settings, "SubtitleTrack");
803 source = ghb_subtitle_track_source(ud, tt);
804 ghb_settings_set_int(settings, "SubtitleSource", source);
805 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
806 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
807 subtitle_list_refresh_selected(ud);
814 srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
818 g_debug("srt_changed_cb ()");
819 ghb_check_dependency(ud, widget, NULL);
820 ghb_widget_to_setting(ud->settings, widget);
821 settings = ghb_selected_subtitle_settings(ud);
822 if (settings != NULL)
824 ghb_widget_to_setting(settings, widget);
825 subtitle_list_refresh_selected(ud);
832 srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
836 g_debug("srt_file_changed_cb ()");
837 ghb_check_dependency(ud, widget, NULL);
838 ghb_widget_to_setting(ud->settings, widget);
839 settings = ghb_selected_subtitle_settings(ud);
840 if (settings != NULL)
842 gchar *filename, *dirname;
844 ghb_widget_to_setting(settings, widget);
845 subtitle_list_refresh_selected(ud);
849 filename = ghb_settings_get_string(settings, "SrtFile");
850 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
852 ghb_settings_set_string(ud->settings, "SrtDir", filename);
856 dirname = g_path_get_dirname(filename);
857 ghb_settings_set_string(ud->settings, "SrtDir", dirname);
860 ghb_pref_save(ud->settings, "SrtDir");
866 srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
870 g_debug("srt_lang_changed_cb ()");
871 ghb_check_dependency(ud, widget, NULL);
872 ghb_widget_to_setting(ud->settings, widget);
873 settings = ghb_selected_subtitle_settings(ud);
874 if (settings != NULL)
878 ghb_widget_to_setting(settings, widget);
879 subtitle_list_refresh_selected(ud);
883 lang = ghb_settings_combo_option(settings, "SrtLanguage");
884 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
889 ghb_clear_subtitle_list(signal_user_data_t *ud)
891 GtkTreeView *treeview;
893 GValue *subtitle_list;
895 g_debug("clear_subtitle_list ()");
896 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
897 if (subtitle_list == NULL)
899 subtitle_list = ghb_array_value_new(8);
900 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
903 ghb_array_value_reset(subtitle_list, 8);
904 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
905 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
906 gtk_list_store_clear (store);
910 add_to_subtitle_list(
911 signal_user_data_t *ud,
914 GtkTreeView *treeview;
917 GtkTreeSelection *selection;
918 const gchar *track, *source;
919 gboolean forced, burned, def;
923 g_debug("add_to_subtitle_list ()");
924 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
925 selection = gtk_tree_view_get_selection (treeview);
926 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
928 track = ghb_settings_combo_option(settings, "SubtitleTrack");
929 forced = ghb_settings_get_boolean(settings, "SubtitleForced");
930 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
931 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
933 s_track = ghb_settings_get_string(settings, "SubtitleTrack");
934 i_source = ghb_settings_get_int(settings, "SubtitleSource");
935 source = subtitle_source_name(i_source);
937 gtk_list_store_append(store, &iter);
938 gtk_list_store_set(store, &iter,
939 // These are displayed in list
945 // These are used to set combo box values when a list item is selected
952 gtk_tree_selection_select_iter(selection, &iter);
958 signal_user_data_t *ud,
961 GtkTreeView *treeview;
964 GtkTreeSelection *selection;
966 gboolean forced, burned, def;
967 gchar *filename, *code, *track, *source;
968 gint i_source, offset;
970 g_debug("add_to_srt_list ()");
971 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
972 selection = gtk_tree_view_get_selection (treeview);
973 store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
975 lang = ghb_settings_combo_option(settings, "SrtLanguage");
976 code = ghb_settings_get_string(settings, "SrtCodeset");
977 track = g_strdup_printf("%s (%s)", lang, code);
980 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
982 filename = ghb_settings_get_string(settings, "SrtFile");
983 if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
987 basename = g_path_get_basename(filename);
988 source = g_strdup_printf("SRT (%s)", basename);
993 source = g_strdup_printf("SRT (none)");
996 offset = ghb_settings_get_int(settings, "SrtOffset");
998 gtk_list_store_append(store, &iter);
999 gtk_list_store_set(store, &iter,
1000 // These are displayed in list
1007 // These are used to set combo box values when a list item is selected
1014 gtk_tree_selection_select_iter(selection, &iter);
1021 G_MODULE_EXPORT void
1022 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
1024 GtkTreeModel *store;
1028 g_debug("subtitle_list_selection_changed_cb ()");
1029 if (gtk_tree_selection_get_selected(selection, &store, &iter))
1032 GtkTreePath *treepath;
1034 GValue *subtitle_list, *settings;
1036 treepath = gtk_tree_model_get_path (store, &iter);
1037 indices = gtk_tree_path_get_indices (treepath);
1039 gtk_tree_path_free(treepath);
1041 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1042 if (row >= ghb_array_len(subtitle_list))
1045 settings = ghb_array_get_nth(subtitle_list, row);
1047 source = ghb_settings_get_int(settings, "SubtitleSource");
1048 if (source == SRTSUB)
1053 str = ghb_settings_get_string(settings, "SrtLanguage");
1054 ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str));
1057 str = ghb_settings_get_string(settings, "SrtCodeset");
1058 ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str));
1061 str = ghb_settings_get_string(settings, "SrtFile");
1062 ghb_ui_update(ud, "SrtFile", ghb_string_value(str));
1065 offset = ghb_settings_get_int(settings, "SrtOffset");
1066 ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset));
1068 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1069 gtk_widget_hide(widget);
1070 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1071 gtk_widget_hide(widget);
1072 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1073 gtk_widget_show(widget);
1074 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1075 gtk_widget_show(widget);
1076 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1077 gtk_widget_show(widget);
1078 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1079 gtk_widget_show(widget);
1080 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1081 gtk_widget_show(widget);
1082 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1083 gtk_widget_show(widget);
1084 widget = GHB_WIDGET(ud->builder, "SrtFile");
1085 gtk_widget_show(widget);
1086 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1087 gtk_widget_show(widget);
1093 track = ghb_settings_get_string(settings, "SubtitleTrack");
1094 ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
1097 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1098 gtk_widget_hide(widget);
1099 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1100 gtk_widget_hide(widget);
1101 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1102 gtk_widget_hide(widget);
1103 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1104 gtk_widget_hide(widget);
1105 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1106 gtk_widget_hide(widget);
1107 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1108 gtk_widget_hide(widget);
1109 widget = GHB_WIDGET(ud->builder, "SrtFile");
1110 gtk_widget_hide(widget);
1111 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1112 gtk_widget_hide(widget);
1113 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1114 gtk_widget_show(widget);
1115 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1116 gtk_widget_show(widget);
1118 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
1119 gtk_widget_set_sensitive(widget, TRUE);
1123 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1124 gtk_widget_hide(widget);
1125 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1126 gtk_widget_hide(widget);
1127 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1128 gtk_widget_hide(widget);
1129 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1130 gtk_widget_hide(widget);
1131 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1132 gtk_widget_hide(widget);
1133 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1134 gtk_widget_hide(widget);
1135 widget = GHB_WIDGET(ud->builder, "SrtFile");
1136 gtk_widget_hide(widget);
1137 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1138 gtk_widget_hide(widget);
1139 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1140 gtk_widget_show(widget);
1141 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1142 gtk_widget_show(widget);
1146 G_MODULE_EXPORT void
1147 srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1149 // Add the current subtitle settings to the list.
1151 gchar *dir, *filename;
1153 g_debug("subtitle_add_clicked_cb ()");
1155 settings = ghb_dict_value_new();
1156 ghb_settings_set_int(settings, "SubtitleSource", SRTSUB);
1157 ghb_settings_set_string(settings, "SrtLanguage", "und");
1158 ghb_settings_set_string(settings, "SrtCodeset", "UTF-8");
1160 dir = ghb_settings_get_string(ud->settings, "SrtDir");
1161 filename = g_strdup_printf("%s/none", dir);
1162 ghb_settings_set_string(settings, "SrtFile", filename);
1166 ghb_settings_set_int(settings, "SrtOffset", 0);
1167 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1168 ghb_boolean_value_new(FALSE));
1170 ghb_add_srt(ud, settings);
1173 G_MODULE_EXPORT void
1174 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1176 // Add the current subtitle settings to the list.
1178 gboolean burned = FALSE;
1181 g_debug("subtitle_add_clicked_cb ()");
1183 track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1185 settings = ghb_dict_value_new();
1186 ghb_settings_set_int(settings, "SubtitleTrack", track);
1187 source = ghb_subtitle_track_source(ud, track);
1188 ghb_settings_set_int(settings, "SubtitleSource", source);
1189 if (mustBurn(ud, settings))
1193 ghb_settings_take_value(settings, "SubtitleForced",
1194 ghb_boolean_value_new(FALSE));
1195 ghb_settings_take_value(settings, "SubtitleBurned",
1196 ghb_boolean_value_new(burned));
1197 ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1198 ghb_boolean_value_new(FALSE));
1200 ghb_add_subtitle(ud, settings);
1203 G_MODULE_EXPORT void
1204 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
1206 GtkTreeView *treeview;
1207 GtkTreePath *treepath;
1208 GtkTreeSelection *selection;
1209 GtkTreeModel *store;
1210 GtkTreeIter iter, nextIter;
1213 GValue *subtitle_list;
1215 g_debug("subtitle_remove_clicked_cb ()");
1216 treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1217 selection = gtk_tree_view_get_selection (treeview);
1218 if (gtk_tree_selection_get_selected(selection, &store, &iter))
1221 if (!gtk_tree_model_iter_next(store, &nextIter))
1224 if (gtk_tree_model_get_iter_first(store, &nextIter))
1226 gtk_tree_selection_select_iter (selection, &nextIter);
1231 gtk_tree_selection_select_iter (selection, &nextIter);
1233 // Get the row number
1234 treepath = gtk_tree_model_get_path (store, &iter);
1235 indices = gtk_tree_path_get_indices (treepath);
1237 gtk_tree_path_free(treepath);
1238 // Remove the selected item
1239 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
1240 // remove from subtitle settings list
1241 if (row < 0) return;
1242 widget = GHB_WIDGET (ud->builder, "subtitle_add");
1243 gtk_widget_set_sensitive(widget, TRUE);
1244 widget = GHB_WIDGET (ud->builder, "srt_add");
1245 gtk_widget_set_sensitive(widget, TRUE);
1246 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1247 if (row >= ghb_array_len(subtitle_list))
1249 GValue *old = ghb_array_get_nth(subtitle_list, row);
1250 ghb_value_free(old);
1251 ghb_array_remove(subtitle_list, row);
1257 ghb_subtitle_prune(signal_user_data_t *ud)
1262 GValue *subtitle_list;
1264 gint first_track = 0, one_burned = 0;
1266 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1267 if (subtitle_list == NULL)
1269 count = ghb_array_len(subtitle_list);
1271 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1272 g_return_if_fail(tv != NULL);
1273 tm = gtk_tree_view_get_model(tv);
1274 for (ii = count-1; ii >= 0; ii--)
1279 settings = ghb_array_get_nth(subtitle_list, ii);
1280 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
1281 if (!burned && mustBurn(ud, settings))
1283 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
1284 gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
1285 ghb_array_remove(subtitle_list, ii);
1295 ghb_subtitle_exclusive_burn(ud, first_track);
1300 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
1307 g_debug("ghb_reset_subtitles");
1308 ghb_clear_subtitle_list(ud);
1309 titleindex = ghb_settings_combo_int(ud->settings, "title");
1313 slist = ghb_settings_get_value(settings, "subtitle_list");
1314 count = ghb_array_len(slist);
1315 for (ii = 0; ii < count; ii++)
1319 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
1320 source = ghb_settings_get_int(subtitle, "SubtitleSource");
1321 if (source == SRTSUB)
1322 ghb_add_srt(ud, subtitle);
1324 ghb_add_subtitle(ud, subtitle);