gtk/src/subtitlehandler.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * subtitlehandler.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * subtitlehandler.c is free software.
   7  *
   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)
  11  * any later version.
  12  */
  13
  14 #include <gtk/gtk.h>
  15 #include "hb.h"
  16 #include "settings.h"
  17 #include "hb-backend.h"
  18 #include "values.h"
  19 #include "callbacks.h"
  20 #include "preview.h"
  21 #include "presets.h"
  22 #include "audiohandler.h"
  23 #include "subtitlehandler.h"
  24
  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);
  27
  28 static void
  29 free_subtitle_index_list(gpointer data)
  30 {
  31         g_free(data);
  32 }
  33
  34 static void
  35 free_subtitle_key(gpointer data)
  36 {
  37         if (data != NULL)
  38                 g_free(data);
  39 }
  40
  41 static gboolean
  42 mustBurn(signal_user_data_t *ud, gint track)
  43 {
  44         gint mux;
  45
  46         mux = ghb_settings_combo_int(ud->settings, "FileFormat");
  47         if (mux == HB_MUX_MP4)
  48         {
  49                 gint source;
  50
  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);
  54                 if (source == VOBSUB)
  55                 {
  56                         return TRUE;
  57                 }
  58         }
  59         return FALSE;
  60 }
  61
  62 gboolean
  63 ghb_soft_in_subtitle_list(GValue *subtitle_list)
  64 {
  65         gint count, ii;
  66         GValue *settings;
  67
  68         count = ghb_array_len(subtitle_list);
  69         for (ii = 0; ii < count; ii++)
  70         {
  71                 settings = ghb_array_get_nth(subtitle_list, ii);
  72                 if (!ghb_settings_get_boolean(settings, "SubtitleBurned"))
  73                 {
  74                         return TRUE;
  75                 }
  76         }
  77         return FALSE;
  78 }
  79
  80 void
  81 ghb_subtitle_exclusive_burn(signal_user_data_t *ud, gint index)
  82 {
  83         GValue *subtitle_list;
  84         GValue *settings;
  85         gint ii, count, tt;
  86         GtkTreeView  *tv;
  87         GtkTreeModel *tm;
  88         GtkTreeIter   ti;
  89         gboolean burned;
  90
  91         g_debug("ghb_subtitle_exclusive_burn");
  92         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
  93         count = ghb_array_len(subtitle_list);
  94         for (ii = 0; ii < count; ii++)
  95         {
  96                 settings = ghb_array_get_nth(subtitle_list, ii);
  97                 tt = ghb_settings_combo_int(settings, "SubtitleTrack");
  98                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
  99
 100                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 101                 g_return_if_fail(tv != NULL);
 102                 tm = gtk_tree_view_get_model(tv);
 103                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
 104                 if (burned && ii != index && !mustBurn(ud, tt))
 105                 {
 106                         ghb_settings_set_boolean(settings, "SubtitleBurned", FALSE);
 107                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, FALSE, -1);
 108                 }
 109         }
 110 }
 111
 112 void
 113 ghb_subtitle_exclusive_default(signal_user_data_t *ud, gint index)
 114 {
 115         GValue *subtitle_list;
 116         GValue *settings;
 117         gint ii, count;
 118         GtkTreeView  *tv;
 119         GtkTreeModel *tm;
 120         GtkTreeIter   ti;
 121         gboolean def;
 122
 123         g_debug("ghb_subtitle_exclusive_default");
 124         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 125         count = ghb_array_len(subtitle_list);
 126         for (ii = 0; ii < count; ii++)
 127         {
 128                 settings = ghb_array_get_nth(subtitle_list, ii);
 129                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 130
 131                 tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 132                 g_return_if_fail(tv != NULL);
 133                 tm = gtk_tree_view_get_model(tv);
 134                 gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
 135                 if (def && ii != index)
 136                 {
 137
 138                         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", FALSE);
 139                         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, FALSE, -1);
 140                 }
 141         }
 142 }
 143
 144 void
 145 ghb_add_srt(signal_user_data_t *ud, GValue *settings)
 146 {
 147         // Add the current subtitle settings to the list.
 148         GValue *subtitle_list;
 149         gint count;
 150         const gchar *lang;
 151
 152         g_debug("ghb_add_srt ()");
 153
 154         // Add the long track description so the queue can access it
 155         // when a different title is selected.
 156         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 157         ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
 158
 159         ghb_settings_set_int(settings, "SubtitleSource", SRTSUB);
 160
 161         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 162         if (subtitle_list == NULL)
 163         {
 164                 subtitle_list = ghb_array_value_new(8);
 165                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 166         }
 167         count = ghb_array_len(subtitle_list);
 168
 169         // Don't allow more than 99
 170         // This is a had limit imposed by libhb/sync.c:GetFifoForId()
 171         if (count >= 99)
 172         {
 173                 ghb_value_free(settings);
 174                 return;
 175         }
 176
 177         ghb_array_append(subtitle_list, settings);
 178         add_to_srt_list(ud, settings);
 179
 180         if (count == 98)
 181         {
 182                 GtkWidget *widget;
 183                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 184                 gtk_widget_set_sensitive(widget, FALSE);
 185                 widget = GHB_WIDGET (ud->builder, "srt_add");
 186                 gtk_widget_set_sensitive(widget, FALSE);
 187         }
 188         ghb_update_destination_extension(ud);
 189         ghb_live_reset(ud);
 190 }
 191
 192 void
 193 ghb_add_subtitle(signal_user_data_t *ud, GValue *settings)
 194 {
 195         // Add the current subtitle settings to the list.
 196         GValue *subtitle_list;
 197         gint count;
 198         gboolean burned;
 199         const gchar *track;
 200         const gchar *lang;
 201         gint tt, source;
 202
 203         g_debug("ghb_add_subtitle ()");
 204
 205         // Add the long track description so the queue can access it
 206         // when a different title is selected.
 207         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 208         ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
 209
 210         lang = ghb_settings_combo_string(settings, "SubtitleTrack");
 211         ghb_settings_set_string(settings, "SubtitleLanguage", lang);
 212
 213         tt = ghb_settings_get_int(settings, "SubtitleTrack");
 214         source = ghb_subtitle_track_source(ud, tt);
 215         ghb_settings_set_int(settings, "SubtitleSource", source);
 216
 217         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 218         if (subtitle_list == NULL)
 219         {
 220                 subtitle_list = ghb_array_value_new(8);
 221                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 222         }
 223         count = ghb_array_len(subtitle_list);
 224
 225         // Don't allow more than 99
 226         // This is a had limit imposed by libhb/sync.c:GetFifoForId()
 227         if (count >= 99)
 228         {
 229                 ghb_value_free(settings);
 230                 return;
 231         }
 232
 233         ghb_array_append(subtitle_list, settings);
 234         add_to_subtitle_list(ud, settings);
 235
 236         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 237         if (burned)
 238                 ghb_subtitle_exclusive_burn(ud, count);
 239         if (count == 98)
 240         {
 241                 GtkWidget *widget;
 242                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
 243                 gtk_widget_set_sensitive(widget, FALSE);
 244                 widget = GHB_WIDGET (ud->builder, "srt_add");
 245                 gtk_widget_set_sensitive(widget, FALSE);
 246         }
 247         ghb_update_destination_extension(ud);
 248         ghb_live_reset(ud);
 249 }
 250
 251 static void
 252 add_all_pref_subtitles(signal_user_data_t *ud)
 253 {
 254         const GValue *pref_subtitle;
 255         GValue *subtitle;
 256         gint count, ii, track;
 257         char *lang;
 258
 259         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 260         count = ghb_array_len(pref_subtitle);
 261         for (ii = 0; ii < count; ii++)
 262         {
 263                 subtitle = ghb_value_dup(ghb_array_get_nth(pref_subtitle, ii));
 264                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 265                 // If there are multiple subtitles using the same language, then
 266                 // select sequential tracks for each.  The hash keeps track
 267                 // of the tracks used for each language.
 268                 track = ghb_find_pref_subtitle_track(lang);
 269                 g_free(lang);
 270                 if (track >= -1)
 271                 {
 272                         // Add to subtitle list
 273                         ghb_settings_set_int(subtitle, "SubtitleTrack", track);
 274                         ghb_add_subtitle(ud, subtitle);
 275                 }
 276         }
 277 }
 278
 279 void
 280 ghb_set_pref_subtitle(gint titleindex, signal_user_data_t *ud)
 281 {
 282         gint track;
 283         GHashTable *track_indices;
 284         gchar *lang, *pref_lang = NULL;
 285         gchar *audio_lang;
 286         gint foreign_lang_index = -1;
 287         gboolean found_cc = FALSE;
 288
 289         const GValue *pref_subtitle;
 290         GValue *subtitle;
 291         gint count, ii, jj;
 292
 293         g_debug("ghb_set_pref_subtitle %d", titleindex);
 294
 295         // Check to see if we need to add a subtitle track for foreign audio
 296         // language films. A subtitle track will be added if:
 297         //
 298         // The first (default) audio track language does NOT match the users
 299         // chosen Preferred Language AND the Preferred Language is NOT Any (und).
 300         //
 301         audio_lang = ghb_get_user_audio_lang(ud, titleindex, 0);
 302         pref_lang = ghb_settings_get_string(ud->settings, "PreferredLanguage");
 303
 304         if (audio_lang != NULL && pref_lang != NULL &&
 305                 (strcmp(audio_lang, pref_lang) == 0 || strcmp("und", pref_lang) == 0))
 306         {
 307                 g_free(pref_lang);
 308                 pref_lang = NULL;
 309         }
 310
 311         track_indices = g_hash_table_new_full(g_str_hash, g_str_equal,
 312                                                                                         free_subtitle_key, free_subtitle_index_list);
 313
 314         ghb_ui_update(ud, "SubtitleTrack", ghb_int_value(0));
 315
 316         // Clear the subtitle list
 317         ghb_clear_subtitle_list(ud);
 318         if (titleindex < 0)
 319         {
 320                 add_all_pref_subtitles(ud);
 321                 return;
 322         }
 323
 324         // Find "best" subtitle based on subtitle preferences
 325         pref_subtitle = ghb_settings_get_value(ud->settings, "SubtitleList");
 326
 327         count = ghb_array_len(pref_subtitle);
 328         jj = 0;
 329         for (ii = 0; ii < count; ii++)
 330         {
 331                 subtitle = ghb_array_get_nth(pref_subtitle, ii);
 332                 lang = ghb_settings_get_string(subtitle, "SubtitleLanguage");
 333                 // If there are multiple subtitles using the same language, then
 334                 // select sequential tracks for each.  The hash keeps track
 335                 // of the tracks used for each language.
 336                 track = ghb_find_subtitle_track(titleindex, lang, track_indices);
 337                 g_free(lang);
 338                 if (track >= -1)
 339                 {
 340                         gint source;
 341                         GValue *dup = ghb_value_dup(subtitle);
 342                         lang = ghb_subtitle_track_lang(ud, track);
 343                         ghb_settings_set_int(dup, "SubtitleTrack", track);
 344                         if (foreign_lang_index < 0 && pref_lang != NULL &&
 345                                 strcmp(lang, pref_lang) == 0)
 346                         {
 347                                 foreign_lang_index = jj;
 348                                 ghb_settings_take_value(dup, "SubtitleForced",
 349                                                                 ghb_boolean_value_new(FALSE));
 350                                 ghb_settings_take_value(dup, "SubtitleDefaultTrack",
 351                                                                 ghb_boolean_value_new(TRUE));
 352                         }
 353                         source = ghb_subtitle_track_source(ud, track);
 354                         if (source == CC608SUB || source == CC708SUB)
 355                                 found_cc = TRUE;
 356                         ghb_add_subtitle(ud, dup);
 357                         jj++;
 358                         g_free(lang);
 359                 }
 360         }
 361         if (foreign_lang_index < 0 && pref_lang != NULL)
 362         {
 363                 // Subtitle for foreign language audio not added yet
 364                 GValue *settings;
 365                 gboolean burn;
 366
 367                 track = ghb_find_subtitle_track(titleindex, pref_lang, track_indices);
 368                 if (track >= -1)
 369                 {
 370                         burn = mustBurn(ud, track);
 371                         settings = ghb_dict_value_new();
 372                         ghb_settings_set_int(settings, "SubtitleTrack", track);
 373                         ghb_settings_take_value(settings, "SubtitleForced",
 374                                                         ghb_boolean_value_new(FALSE));
 375                         ghb_settings_take_value(settings, "SubtitleBurned",
 376                                                         ghb_boolean_value_new(burn));
 377                         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
 378                                                         ghb_boolean_value_new(TRUE));
 379
 380                         ghb_add_subtitle(ud, settings);
 381                         foreign_lang_index = jj;
 382                 }
 383         }
 384         if (foreign_lang_index >= 0)
 385         {
 386                 GValue *subtitle_list;
 387                 gboolean burn, def;
 388
 389                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 390                 subtitle = ghb_array_get_nth(subtitle_list, foreign_lang_index);
 391
 392                 burn = ghb_settings_get_boolean(subtitle, "SubtitleBurned");
 393                 def = ghb_settings_get_boolean(subtitle, "SubtitleDefaultTrack");
 394                 if (burn)
 395                         ghb_subtitle_exclusive_burn(ud, foreign_lang_index);
 396                 if (def)
 397                         ghb_subtitle_exclusive_default(ud, foreign_lang_index);
 398                 ghb_log("adding subtitle for foreign language audio: %s", audio_lang);
 399         }
 400         if (ghb_settings_get_boolean(ud->settings, "AddCC") && !found_cc)
 401         {
 402                 // Subtitle for foreign language audio not added yet
 403                 GValue *settings;
 404
 405                 track = ghb_find_cc_track(titleindex);
 406                 if (track >= 0)
 407                 {
 408                         settings = ghb_dict_value_new();
 409                         ghb_settings_set_int(settings, "SubtitleTrack", track);
 410                         ghb_settings_take_value(settings, "SubtitleForced",
 411                                                         ghb_boolean_value_new(FALSE));
 412                         ghb_settings_take_value(settings, "SubtitleBurned",
 413                                                         ghb_boolean_value_new(FALSE));
 414                         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
 415                                                         ghb_boolean_value_new(FALSE));
 416
 417                         ghb_add_subtitle(ud, settings);
 418                         ghb_log("adding Closed Captions: %s", audio_lang);
 419                 }
 420         }
 421         if (pref_lang != NULL)
 422                 g_free(pref_lang);
 423         if (audio_lang != NULL)
 424                 g_free(audio_lang);
 425         g_hash_table_destroy(track_indices);
 426 }
 427
 428 gint
 429 ghb_selected_subtitle_row(signal_user_data_t *ud)
 430 {
 431         GtkTreeView *treeview;
 432         GtkTreePath *treepath;
 433         GtkTreeSelection *selection;
 434         GtkTreeModel *store;
 435         GtkTreeIter iter;
 436         gint *indices;
 437         gint row = -1;
 438
 439         g_debug("ghb_selected_subtitle_row ()");
 440         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 441         selection = gtk_tree_view_get_selection (treeview);
 442         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 443         {
 444                 // Get the row number
 445                 treepath = gtk_tree_model_get_path (store, &iter);
 446                 indices = gtk_tree_path_get_indices (treepath);
 447                 row = indices[0];
 448                 gtk_tree_path_free(treepath);
 449         }
 450         return row;
 451 }
 452
 453 GValue*
 454 ghb_selected_subtitle_settings(signal_user_data_t *ud)
 455 {
 456         GtkTreeView *treeview;
 457         GtkTreePath *treepath;
 458         GtkTreeSelection *selection;
 459         GtkTreeModel *store;
 460         GtkTreeIter iter;
 461         gint *indices;
 462         gint row;
 463         GValue *settings = NULL;
 464         const GValue *subtitle_list;
 465
 466         g_debug("get_selected_settings ()");
 467         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 468         selection = gtk_tree_view_get_selection (treeview);
 469         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 470         {
 471                 // Get the row number
 472                 treepath = gtk_tree_model_get_path (store, &iter);
 473                 indices = gtk_tree_path_get_indices (treepath);
 474                 row = indices[0];
 475                 gtk_tree_path_free(treepath);
 476                 // find subtitle settings
 477                 if (row < 0) return NULL;
 478                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 479                 if (row >= ghb_array_len(subtitle_list))
 480                         return NULL;
 481                 settings = ghb_array_get_nth(subtitle_list, row);
 482         }
 483         return settings;
 484 }
 485
 486 G_MODULE_EXPORT void
 487 subtitle_forced_toggled_cb(
 488         GtkCellRendererToggle *cell,
 489         gchar                 *path,
 490         signal_user_data_t    *ud)
 491 {
 492         GtkTreeView  *tv;
 493         GtkTreeModel *tm;
 494         GtkTreeIter   ti;
 495         gboolean      active;
 496         gint          row;
 497         GtkTreePath  *tp;
 498         gint *indices;
 499         GValue *subtitle_list, *settings;
 500         gint source;
 501
 502         g_debug("forced toggled");
 503         tp = gtk_tree_path_new_from_string (path);
 504         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 505         g_return_if_fail(tv != NULL);
 506         tm = gtk_tree_view_get_model(tv);
 507         g_return_if_fail(tm != NULL);
 508         gtk_tree_model_get_iter(tm, &ti, tp);
 509         gtk_tree_model_get(tm, &ti, 1, &active, -1);
 510         active ^= 1;
 511
 512         // Get the row number
 513         indices = gtk_tree_path_get_indices (tp);
 514         row = indices[0];
 515         gtk_tree_path_free(tp);
 516
 517         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 518
 519         if (row < 0 || row >= ghb_array_len(subtitle_list))
 520                 return;
 521
 522         settings = ghb_array_get_nth(subtitle_list, row);
 523
 524         source = ghb_settings_get_int(settings, "SubtitleSource");
 525         if (source != VOBSUB)
 526                 return;
 527
 528         ghb_settings_set_boolean(settings, "SubtitleForced", active);
 529         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 1, active, -1);
 530         ghb_live_reset(ud);
 531 }
 532
 533 G_MODULE_EXPORT void
 534 subtitle_burned_toggled_cb(
 535         GtkCellRendererToggle *cell,
 536         gchar                 *path,
 537         signal_user_data_t    *ud)
 538 {
 539         GtkTreeView  *tv;
 540         GtkTreeModel *tm;
 541         GtkTreeIter   ti;
 542         GtkTreePath  *tp;
 543         gboolean      active;
 544         gint          row;
 545         gint *indices;
 546         GValue *subtitle_list;
 547         gint count, track, source;
 548         GValue *settings;
 549
 550         g_debug("burned toggled");
 551         tp = gtk_tree_path_new_from_string (path);
 552         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 553         g_return_if_fail(tv != NULL);
 554         tm = gtk_tree_view_get_model(tv);
 555         g_return_if_fail(tm != NULL);
 556         gtk_tree_model_get_iter(tm, &ti, tp);
 557         gtk_tree_model_get(tm, &ti, 2, &active, -1);
 558         active ^= 1;
 559
 560         // Get the row number
 561         indices = gtk_tree_path_get_indices (tp);
 562         row = indices[0];
 563         gtk_tree_path_free(tp);
 564
 565         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 566         count = ghb_array_len(subtitle_list);
 567         if (row < 0 || row >= count)
 568                 return;
 569
 570         settings = ghb_array_get_nth(subtitle_list, row);
 571
 572         source = ghb_settings_get_int(settings, "SubtitleSource");
 573         if (source != VOBSUB)
 574                 return;
 575
 576         track = ghb_settings_combo_int(settings, "SubtitleTrack");
 577         if (!active && mustBurn(ud, track))
 578                 return;
 579
 580         ghb_settings_set_boolean(settings, "SubtitleBurned", active);
 581
 582         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 2, active, -1);
 583         // Unburn the rest
 584         if (active)
 585                 ghb_subtitle_exclusive_burn(ud, row);
 586         ghb_update_destination_extension(ud);
 587         ghb_live_reset(ud);
 588 }
 589
 590 G_MODULE_EXPORT void
 591 subtitle_default_toggled_cb(
 592         GtkCellRendererToggle *cell,
 593         gchar                 *path,
 594         signal_user_data_t    *ud)
 595 {
 596         GtkTreeView  *tv;
 597         GtkTreeModel *tm;
 598         GtkTreeIter   ti;
 599         GtkTreePath  *tp;
 600         gboolean      active;
 601         gint          row;
 602         gint *indices;
 603         GValue *subtitle_list;
 604         gint count;
 605         GValue *settings;
 606
 607         g_debug("default toggled");
 608         tp = gtk_tree_path_new_from_string (path);
 609         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 610         g_return_if_fail(tv != NULL);
 611         tm = gtk_tree_view_get_model(tv);
 612         g_return_if_fail(tm != NULL);
 613         gtk_tree_model_get_iter(tm, &ti, tp);
 614         gtk_tree_model_get(tm, &ti, 3, &active, -1);
 615         active ^= 1;
 616
 617         // Get the row number
 618         indices = gtk_tree_path_get_indices (tp);
 619         row = indices[0];
 620         gtk_tree_path_free(tp);
 621
 622         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 623         count = ghb_array_len(subtitle_list);
 624         if (row < 0 || row >= count)
 625                 return;
 626
 627         settings = ghb_array_get_nth(subtitle_list, row);
 628
 629         ghb_settings_set_boolean(settings, "SubtitleDefaultTrack", active);
 630
 631         gtk_list_store_set(GTK_LIST_STORE(tm), &ti, 3, active, -1);
 632         // allow only one default
 633         ghb_subtitle_exclusive_default(ud, row);
 634         ghb_live_reset(ud);
 635 }
 636
 637 static const char*
 638 subtitle_source_name(gint source)
 639 {
 640         const gchar * name;
 641
 642         switch (source)
 643         {
 644                 case VOBSUB:
 645                         name = "Bitmap";
 646                         break;
 647                 case CC708SUB:
 648                 case CC608SUB:
 649                         name = "Text";
 650                         break;
 651                 case SRTSUB:
 652                         name = "SRT";
 653                         break;
 654                 default:
 655                         name = "Unknown";
 656                         break;
 657         }
 658         return name;
 659 }
 660
 661 static void
 662 subtitle_list_refresh_selected(signal_user_data_t *ud)
 663 {
 664         GtkTreeView *treeview;
 665         GtkTreePath *treepath;
 666         GtkTreeSelection *selection;
 667         GtkTreeModel *store;
 668         GtkTreeIter iter;
 669         gint *indices;
 670         gint row;
 671         GValue *settings = NULL;
 672         const GValue *subtitle_list;
 673
 674         g_debug("subtitle_list_refresh_selected ()");
 675         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 676         selection = gtk_tree_view_get_selection (treeview);
 677         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 678         {
 679                 gchar *track, *source;
 680                 gboolean forced, burned, def;
 681                 gchar *s_track;
 682                 gint offset = 0;
 683
 684                 // Get the row number
 685                 treepath = gtk_tree_model_get_path (store, &iter);
 686                 indices = gtk_tree_path_get_indices (treepath);
 687                 row = indices[0];
 688                 gtk_tree_path_free(treepath);
 689                 // find audio settings
 690                 if (row < 0) return;
 691                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 692                 if (row >= ghb_array_len(subtitle_list))
 693                         return;
 694                 settings = ghb_array_get_nth(subtitle_list, row);
 695
 696                 def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 697
 698                 gint i_source;
 699                 i_source = ghb_settings_get_int(settings, "SubtitleSource");
 700                 if (i_source != VOBSUB)
 701                 {
 702                         // Force and burn only apply to VOBSUBS
 703                         forced = FALSE;
 704                         burned = FALSE;
 705                         ghb_settings_set_boolean(settings, "SubtitleForced", forced);
 706                         ghb_settings_set_boolean(settings, "SubtitleBurned", burned);
 707                 }
 708
 709                 if (i_source == SRTSUB)
 710                 {
 711                         const gchar *lang;
 712                         gchar *code;
 713
 714                         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 715                         code = ghb_settings_get_string(settings, "SrtCodeset");
 716                         track = g_strdup_printf("%s (%s)", lang, code);
 717                         g_free(code);
 718
 719                         s_track = ghb_settings_get_string(settings, "SrtFile");
 720                         if (g_file_test(s_track, G_FILE_TEST_IS_REGULAR))
 721                         {
 722                                 gchar *basename;
 723
 724                                 basename = g_path_get_basename(s_track);
 725                                 source = g_strdup_printf("SRT (%s)", basename);
 726                                 g_free(basename);
 727                         }
 728                         else
 729                         {
 730                                 source = g_strdup_printf("SRT (none)");
 731                         }
 732                         offset = ghb_settings_get_int(settings, "SrtOffset");
 733
 734                         forced = FALSE;
 735                         burned = FALSE;
 736                 }
 737                 else
 738                 {
 739                         track = g_strdup(
 740                                 ghb_settings_combo_option(settings, "SubtitleTrack"));
 741                         source = g_strdup(subtitle_source_name(i_source));
 742                         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 743
 744                         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 745                         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 746                 }
 747
 748                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 749                         // These are displayed in list
 750                         0, track,
 751                         1, forced,
 752                         2, burned,
 753                         3, def,
 754                         4, source,
 755                         5, offset,
 756                         // These are used to set combo box values when a list item is selected
 757                         6, s_track,
 758                         7, i_source,
 759                         -1);
 760                 g_free(track);
 761                 g_free(source);
 762                 g_free(s_track);
 763                 if (burned)
 764                         ghb_subtitle_exclusive_burn(ud, row);
 765         }
 766 }
 767
 768 G_MODULE_EXPORT void
 769 subtitle_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 770 {
 771         GValue *settings;
 772
 773         g_debug("subtitle_track_changed_cb ()");
 774         ghb_check_dependency(ud, widget);
 775         ghb_widget_to_setting(ud->settings, widget);
 776         settings = ghb_selected_subtitle_settings(ud);
 777         if (settings != NULL)
 778         {
 779                 const gchar *track, *lang;
 780                 gint tt, source;
 781
 782                 ghb_widget_to_setting(settings, widget);
 783                 subtitle_list_refresh_selected(ud);
 784                 track = ghb_settings_combo_option(settings, "SubtitleTrack");
 785                 ghb_settings_set_string(settings, "SubtitleTrackDescription", track);
 786                 tt = ghb_settings_get_int(settings, "SubtitleTrack");
 787                 source = ghb_subtitle_track_source(ud, tt);
 788                 ghb_settings_set_int(settings, "SubtitleSource", source);
 789                 lang = ghb_settings_combo_string(settings, "SubtitleTrack");
 790                 ghb_settings_set_string(settings, "SubtitleLanguage", lang);
 791                 ghb_live_reset(ud);
 792         }
 793         ghb_live_reset(ud);
 794 }
 795
 796 G_MODULE_EXPORT void
 797 srt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 798 {
 799         GValue *settings;
 800
 801         g_debug("srt_changed_cb ()");
 802         ghb_check_dependency(ud, widget);
 803         ghb_widget_to_setting(ud->settings, widget);
 804         settings = ghb_selected_subtitle_settings(ud);
 805         if (settings != NULL)
 806         {
 807                 ghb_widget_to_setting(settings, widget);
 808                 subtitle_list_refresh_selected(ud);
 809
 810                 ghb_live_reset(ud);
 811         }
 812 }
 813
 814 G_MODULE_EXPORT void
 815 srt_file_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 816 {
 817         GValue *settings;
 818
 819         g_debug("srt_changed_cb ()");
 820         ghb_check_dependency(ud, widget);
 821         ghb_widget_to_setting(ud->settings, widget);
 822         settings = ghb_selected_subtitle_settings(ud);
 823         if (settings != NULL)
 824         {
 825                 gchar *filename, *dirname;
 826
 827                 ghb_widget_to_setting(settings, widget);
 828                 subtitle_list_refresh_selected(ud);
 829
 830                 ghb_live_reset(ud);
 831
 832                 filename = ghb_settings_get_string(settings, "SrtFile");
 833                 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
 834                 {
 835                         ghb_settings_set_string(ud->settings, "SrtDir", filename);
 836                 }
 837                 else
 838                 {
 839                         dirname = g_path_get_dirname(filename);
 840                         ghb_settings_set_string(ud->settings, "SrtDir", dirname);
 841                         g_free(dirname);
 842                 }
 843                 ghb_pref_save(ud->settings, "SrtDir");
 844                 g_free(filename);
 845         }
 846 }
 847
 848 G_MODULE_EXPORT void
 849 srt_lang_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 850 {
 851         GValue *settings;
 852
 853         g_debug("srt_lang_changed_cb ()");
 854         ghb_check_dependency(ud, widget);
 855         ghb_widget_to_setting(ud->settings, widget);
 856         settings = ghb_selected_subtitle_settings(ud);
 857         if (settings != NULL)
 858         {
 859                 const gchar *lang;
 860
 861                 ghb_widget_to_setting(settings, widget);
 862                 subtitle_list_refresh_selected(ud);
 863
 864                 ghb_live_reset(ud);
 865
 866                 lang = ghb_settings_combo_option(settings, "SrtLanguage");
 867                 ghb_settings_set_string(settings, "SubtitleTrackDescription", lang);
 868         }
 869 }
 870
 871 void
 872 ghb_clear_subtitle_list(signal_user_data_t *ud)
 873 {
 874         GtkTreeView *treeview;
 875         GtkListStore *store;
 876         GValue *subtitle_list;
 877
 878         g_debug("clear_subtitle_list ()");
 879         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
 880         if (subtitle_list == NULL)
 881         {
 882                 subtitle_list = ghb_array_value_new(8);
 883                 ghb_settings_set_value(ud->settings, "subtitle_list", subtitle_list);
 884         }
 885         else
 886                 ghb_array_value_reset(subtitle_list, 8);
 887         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 888         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 889         gtk_list_store_clear (store);
 890 }
 891
 892 static void
 893 add_to_subtitle_list(
 894         signal_user_data_t *ud,
 895         GValue *settings)
 896 {
 897         GtkTreeView *treeview;
 898         GtkTreeIter iter;
 899         GtkListStore *store;
 900         GtkTreeSelection *selection;
 901         const gchar *track, *source;
 902         gboolean forced, burned, def;
 903         gchar *s_track;
 904         gint i_source;
 905
 906         g_debug("add_to_subtitle_list ()");
 907         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 908         selection = gtk_tree_view_get_selection (treeview);
 909         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 910
 911         track = ghb_settings_combo_option(settings, "SubtitleTrack");
 912         forced = ghb_settings_get_boolean(settings, "SubtitleForced");
 913         burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
 914         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 915
 916         s_track = ghb_settings_get_string(settings, "SubtitleTrack");
 917         i_source = ghb_settings_get_int(settings, "SubtitleSource");
 918         source = subtitle_source_name(i_source);
 919
 920         gtk_list_store_append(store, &iter);
 921         gtk_list_store_set(store, &iter,
 922                 // These are displayed in list
 923                 0, track,
 924                 1, forced,
 925                 2, burned,
 926                 3, def,
 927                 4, source,
 928                 // These are used to set combo box values when a list item is selected
 929                 6, s_track,
 930                 7, i_source,
 931                 8, TRUE,
 932                 9, TRUE,
 933                 10, FALSE,
 934                 -1);
 935         gtk_tree_selection_select_iter(selection, &iter);
 936         g_free(s_track);
 937 }
 938
 939 static void
 940 add_to_srt_list(
 941         signal_user_data_t *ud,
 942         GValue *settings)
 943 {
 944         GtkTreeView *treeview;
 945         GtkTreeIter iter;
 946         GtkListStore *store;
 947         GtkTreeSelection *selection;
 948         const gchar *lang;
 949         gboolean forced, burned, def;
 950         gchar *filename, *code, *track, *source;
 951         gint i_source, offset;
 952
 953         g_debug("add_to_srt_list ()");
 954         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
 955         selection = gtk_tree_view_get_selection (treeview);
 956         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 957
 958         lang = ghb_settings_combo_option(settings, "SrtLanguage");
 959         code = ghb_settings_get_string(settings, "SrtCodeset");
 960         track = g_strdup_printf("%s (%s)", lang, code);
 961         forced = FALSE;
 962         burned = FALSE;
 963         def = ghb_settings_get_boolean(settings, "SubtitleDefaultTrack");
 964
 965         filename = ghb_settings_get_string(settings, "SrtFile");
 966         if (g_file_test(filename, G_FILE_TEST_IS_REGULAR))
 967         {
 968                 gchar *basename;
 969
 970                 basename = g_path_get_basename(filename);
 971                 source = g_strdup_printf("SRT (%s)", basename);
 972                 g_free(basename);
 973         }
 974         else
 975         {
 976                 source = g_strdup_printf("SRT (none)");
 977         }
 978         i_source = SRTSUB;
 979         offset = ghb_settings_get_int(settings, "SrtOffset");
 980
 981         gtk_list_store_append(store, &iter);
 982         gtk_list_store_set(store, &iter,
 983                 // These are displayed in list
 984                 0, track,
 985                 1, forced,
 986                 2, burned,
 987                 3, def,
 988                 4, source,
 989                 5, offset,
 990                 // These are used to set combo box values when a list item is selected
 991                 6, filename,
 992                 7, i_source,
 993                 8, FALSE,
 994                 9, FALSE,
 995                 10, TRUE,
 996                 -1);
 997         gtk_tree_selection_select_iter(selection, &iter);
 998         g_free(code);
 999         g_free(track);
1000         g_free(filename);
1001         g_free(source);
1002 }
1003
1004 G_MODULE_EXPORT void
1005 subtitle_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
1006 {
1007         GtkTreeModel *store;
1008         GtkTreeIter iter;
1009         GtkWidget *widget;
1010
1011         g_debug("subtitle_list_selection_changed_cb ()");
1012         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1013         {
1014                 gint source;
1015                 GtkTreePath *treepath;
1016                 gint *indices, row;
1017                 GValue *subtitle_list, *settings;
1018
1019                 treepath = gtk_tree_model_get_path (store, &iter);
1020                 indices = gtk_tree_path_get_indices (treepath);
1021                 row = indices[0];
1022                 gtk_tree_path_free(treepath);
1023
1024                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1025                 if (row >= ghb_array_len(subtitle_list))
1026                         return;
1027
1028                 settings = ghb_array_get_nth(subtitle_list, row);
1029
1030                 source = ghb_settings_get_int(settings, "SubtitleSource");
1031                 if (source == SRTSUB)
1032                 {
1033                         gchar *str;
1034                         gint offset;
1035
1036                         str = ghb_settings_get_string(settings, "SrtLanguage");
1037                         ghb_ui_update(ud, "SrtLanguage", ghb_string_value(str));
1038                         g_free(str);
1039
1040                         str = ghb_settings_get_string(settings, "SrtCodeset");
1041                         ghb_ui_update(ud, "SrtCodeset", ghb_string_value(str));
1042                         g_free(str);
1043
1044                         str = ghb_settings_get_string(settings, "SrtFile");
1045                         ghb_ui_update(ud, "SrtFile", ghb_string_value(str));
1046                         g_free(str);
1047
1048                         offset = ghb_settings_get_int(settings, "SrtOffset");
1049                         ghb_ui_update(ud, "SrtOffset", ghb_int_value(offset));
1050
1051                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1052                         gtk_widget_hide(widget);
1053                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1054                         gtk_widget_hide(widget);
1055                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1056                         gtk_widget_show(widget);
1057                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1058                         gtk_widget_show(widget);
1059                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1060                         gtk_widget_show(widget);
1061                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1062                         gtk_widget_show(widget);
1063                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1064                         gtk_widget_show(widget);
1065                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1066                         gtk_widget_show(widget);
1067                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1068                         gtk_widget_show(widget);
1069                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1070                         gtk_widget_show(widget);
1071                 }
1072                 else
1073                 {
1074                         gchar *track;
1075
1076                         track = ghb_settings_get_string(settings, "SubtitleTrack");
1077                         ghb_ui_update(ud, "SubtitleTrack", ghb_string_value(track));
1078                         g_free(track);
1079
1080                         widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1081                         gtk_widget_hide(widget);
1082                         widget = GHB_WIDGET(ud->builder, "srt_code_label");
1083                         gtk_widget_hide(widget);
1084                         widget = GHB_WIDGET(ud->builder, "srt_file_label");
1085                         gtk_widget_hide(widget);
1086                         widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1087                         gtk_widget_hide(widget);
1088                         widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1089                         gtk_widget_hide(widget);
1090                         widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1091                         gtk_widget_hide(widget);
1092                         widget = GHB_WIDGET(ud->builder, "SrtFile");
1093                         gtk_widget_hide(widget);
1094                         widget = GHB_WIDGET(ud->builder, "SrtOffset");
1095                         gtk_widget_hide(widget);
1096                         widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1097                         gtk_widget_show(widget);
1098                         widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1099                         gtk_widget_show(widget);
1100                 }
1101                 widget = GHB_WIDGET (ud->builder, "subtitle_remove");
1102                 gtk_widget_set_sensitive(widget, TRUE);
1103         }
1104         else
1105         {
1106                 widget = GHB_WIDGET(ud->builder, "srt_lang_label");
1107                 gtk_widget_hide(widget);
1108                 widget = GHB_WIDGET(ud->builder, "srt_code_label");
1109                 gtk_widget_hide(widget);
1110                 widget = GHB_WIDGET(ud->builder, "srt_file_label");
1111                 gtk_widget_hide(widget);
1112                 widget = GHB_WIDGET(ud->builder, "srt_offset_label");
1113                 gtk_widget_hide(widget);
1114                 widget = GHB_WIDGET(ud->builder, "SrtLanguage");
1115                 gtk_widget_hide(widget);
1116                 widget = GHB_WIDGET(ud->builder, "SrtCodeset");
1117                 gtk_widget_hide(widget);
1118                 widget = GHB_WIDGET(ud->builder, "SrtFile");
1119                 gtk_widget_hide(widget);
1120                 widget = GHB_WIDGET(ud->builder, "SrtOffset");
1121                 gtk_widget_hide(widget);
1122                 widget = GHB_WIDGET(ud->builder, "subtitle_track_label");
1123                 gtk_widget_show(widget);
1124                 widget = GHB_WIDGET(ud->builder, "SubtitleTrack");
1125                 gtk_widget_show(widget);
1126         }
1127 }
1128
1129 G_MODULE_EXPORT void
1130 srt_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1131 {
1132         // Add the current subtitle settings to the list.
1133         GValue *settings;
1134         gboolean burned = FALSE;
1135         gint track;
1136         gchar *dir, *filename;
1137
1138         g_debug("subtitle_add_clicked_cb ()");
1139
1140         track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1141         if (mustBurn(ud, track))
1142         {
1143                 burned = TRUE;
1144         }
1145         settings = ghb_dict_value_new();
1146         ghb_settings_set_string(settings, "SrtLanguage", "und");
1147         ghb_settings_set_string(settings, "SrtCodeset", "UTF-8");
1148
1149         dir = ghb_settings_get_string(ud->settings, "SrtDir");
1150         filename = g_strdup_printf("%s/none", dir);
1151         ghb_settings_set_string(settings, "SrtFile", filename);
1152         g_free(dir);
1153         g_free(filename);
1154
1155         ghb_settings_set_int(settings, "SrtOffset", 0);
1156         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1157                                                         ghb_boolean_value_new(FALSE));
1158
1159         ghb_add_srt(ud, settings);
1160 }
1161
1162 G_MODULE_EXPORT void
1163 subtitle_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
1164 {
1165         // Add the current subtitle settings to the list.
1166         GValue *settings;
1167         gboolean burned = FALSE;
1168         gint track;
1169
1170         g_debug("subtitle_add_clicked_cb ()");
1171
1172         track = ghb_settings_get_int(ud->settings, "SubtitleTrack");
1173         if (mustBurn(ud, track))
1174         {
1175                 burned = TRUE;
1176         }
1177         settings = ghb_dict_value_new();
1178         ghb_settings_set_int(settings, "SubtitleTrack", track);
1179         ghb_settings_take_value(settings, "SubtitleForced",
1180                                                         ghb_boolean_value_new(FALSE));
1181         ghb_settings_take_value(settings, "SubtitleBurned",
1182                                                         ghb_boolean_value_new(burned));
1183         ghb_settings_take_value(settings, "SubtitleDefaultTrack",
1184                                                         ghb_boolean_value_new(FALSE));
1185
1186         ghb_add_subtitle(ud, settings);
1187 }
1188
1189 G_MODULE_EXPORT void
1190 subtitle_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
1191 {
1192         GtkTreeView *treeview;
1193         GtkTreePath *treepath;
1194         GtkTreeSelection *selection;
1195         GtkTreeModel *store;
1196         GtkTreeIter iter, nextIter;
1197         gint *indices;
1198         gint row;
1199         GValue *subtitle_list;
1200
1201         g_debug("subtitle_remove_clicked_cb ()");
1202         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1203         selection = gtk_tree_view_get_selection (treeview);
1204         if (gtk_tree_selection_get_selected(selection, &store, &iter))
1205         {
1206                 nextIter = iter;
1207                 if (!gtk_tree_model_iter_next(store, &nextIter))
1208                 {
1209                         nextIter = iter;
1210                         if (gtk_tree_model_get_iter_first(store, &nextIter))
1211                         {
1212                                 gtk_tree_selection_select_iter (selection, &nextIter);
1213                         }
1214                 }
1215                 else
1216                 {
1217                         gtk_tree_selection_select_iter (selection, &nextIter);
1218                 }
1219                 // Get the row number
1220                 treepath = gtk_tree_model_get_path (store, &iter);
1221                 indices = gtk_tree_path_get_indices (treepath);
1222                 row = indices[0];
1223                 gtk_tree_path_free(treepath);
1224                 // Remove the selected item
1225                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
1226                 // remove from subtitle settings list
1227                 if (row < 0) return;
1228                 widget = GHB_WIDGET (ud->builder, "subtitle_add");
1229                 gtk_widget_set_sensitive(widget, TRUE);
1230                 widget = GHB_WIDGET (ud->builder, "srt_add");
1231                 gtk_widget_set_sensitive(widget, TRUE);
1232                 subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1233                 if (row >= ghb_array_len(subtitle_list))
1234                         return;
1235                 GValue *old = ghb_array_get_nth(subtitle_list, row);
1236                 ghb_value_free(old);
1237                 ghb_array_remove(subtitle_list, row);
1238                 ghb_live_reset(ud);
1239         }
1240 }
1241
1242 void
1243 ghb_subtitle_prune(signal_user_data_t *ud)
1244 {
1245         GtkTreeView  *tv;
1246         GtkTreeModel *tm;
1247         GtkTreeIter   ti;
1248         GValue *subtitle_list, *settings;
1249         gint count, ii, track;
1250         gboolean burned;
1251         gint first_track = 0, one_burned = 0;
1252
1253         subtitle_list = ghb_settings_get_value(ud->settings, "subtitle_list");
1254         if (subtitle_list == NULL)
1255                 return;
1256         count = ghb_array_len(subtitle_list);
1257
1258         tv = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "subtitle_list"));
1259         g_return_if_fail(tv != NULL);
1260         tm = gtk_tree_view_get_model(tv);
1261         for (ii = count-1; ii >= 0; ii--)
1262         {
1263                 settings = ghb_array_get_nth(subtitle_list, ii);
1264                 burned = ghb_settings_get_boolean(settings, "SubtitleBurned");
1265                 track = ghb_settings_combo_int(settings, "SubtitleTrack");
1266                 if (!burned && mustBurn(ud, track))
1267                 {
1268                         gtk_tree_model_iter_nth_child(tm, &ti, NULL, ii);
1269                         gtk_list_store_remove (GTK_LIST_STORE(tm), &ti);
1270                         ghb_array_remove(subtitle_list, ii);
1271                 }
1272                 if (burned)
1273                 {
1274                         first_track = ii;
1275                         one_burned++;
1276                 }
1277         }
1278         if (one_burned)
1279         {
1280                 ghb_subtitle_exclusive_burn(ud, first_track);
1281         }
1282 }
1283
1284 void
1285 ghb_reset_subtitles(signal_user_data_t *ud, GValue *settings)
1286 {
1287         GValue *slist;
1288         GValue *subtitle;
1289         gint count, ii;
1290         gint titleindex;
1291
1292         g_debug("ghb_reset_subtitles");
1293         ghb_clear_subtitle_list(ud);
1294         titleindex = ghb_settings_combo_int(ud->settings, "title");
1295         if (titleindex < 0)
1296                 return;
1297
1298         slist = ghb_settings_get_value(settings, "subtitle_list");
1299         count = ghb_array_len(slist);
1300         for (ii = 0; ii < count; ii++)
1301         {
1302                 subtitle = ghb_value_dup(ghb_array_get_nth(slist, ii));
1303                 ghb_add_subtitle(ud, subtitle);
1304         }
1305 }
1306