gtk/src/audiohandler.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * audiohandler.c
   4  * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
   5  *
   6  * audiohandler.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 "audiohandler.h"
  22
  23 void
  24 ghb_adjust_audio_rate_combos(signal_user_data_t *ud)
  25 {
  26         gint titleindex, audioindex, acodec, mix;
  27         ghb_audio_info_t ainfo;
  28         GtkWidget *widget;
  29         GValue *gval;
  30
  31         g_debug("ghb_adjust_audio_rate_combos ()");
  32         titleindex = ghb_settings_combo_int(ud->settings, "title");
  33
  34         widget = GHB_WIDGET(ud->builder, "AudioTrack");
  35         gval = ghb_widget_value(widget);
  36         audioindex = ghb_lookup_combo_int("AudioTrack", gval);
  37         ghb_value_free(gval);
  38
  39         widget = GHB_WIDGET(ud->builder, "AudioEncoder");
  40         gval = ghb_widget_value(widget);
  41         acodec = ghb_lookup_combo_int("AudioEncoder", gval);
  42         ghb_value_free(gval);
  43         widget = GHB_WIDGET(ud->builder, "AudioMixdown");
  44         gval = ghb_widget_value(widget);
  45         mix = ghb_lookup_combo_int("AudioMixdown", gval);
  46         ghb_value_free(gval);
  47
  48         if (ghb_audio_is_passthru (acodec))
  49         {
  50                 ghb_set_default_bitrate_opts (ud->builder, -1);
  51                 if (ghb_get_audio_info (&ainfo, titleindex, audioindex))
  52                 {
  53                         gint br = ainfo.bitrate / 1000;
  54                         // Set the values for bitrate and samplerate to the input rates
  55                         ghb_set_passthru_bitrate_opts (ud->builder, br);
  56                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(br));
  57                         ghb_ui_update(ud, "AudioSamplerate", ghb_int64_value(0));
  58                         ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(0));
  59                 }
  60                 else
  61                 {
  62                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(384));
  63                         ghb_ui_update(ud, "AudioSamplerate", ghb_int64_value(0));
  64                         ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(0));
  65                 }
  66         }
  67         else if (acodec == HB_ACODEC_FAAC && mix != HB_AMIXDOWN_6CH)
  68         {
  69                 gint br;
  70
  71                 widget = GHB_WIDGET(ud->builder, "AudioBitrate");
  72                 gval = ghb_widget_value(widget);
  73                 br = ghb_lookup_combo_int("AudioBitrate", gval);
  74                 ghb_value_free(gval);
  75                 if (br > 160)
  76                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(160));
  77                 ghb_set_default_bitrate_opts (ud->builder, 160);
  78         }
  79         else
  80         {
  81                 ghb_set_default_bitrate_opts (ud->builder, -1);
  82         }
  83 }
  84
  85 void
  86 free_audio_index_list(gpointer data)
  87 {
  88         g_free(data);
  89 }
  90
  91 void
  92 ghb_set_pref_audio(gint titleindex, signal_user_data_t *ud)
  93 {
  94         gint acodec_code, mix_code, track;
  95         gchar *source_lang;
  96         GtkWidget *button;
  97         ghb_audio_info_t ainfo;
  98         GHashTable *track_indices;
  99
 100         const GValue *pref_audio;
 101         const GValue *audio, *acodec, *bitrate, *rate, *mix, *drc;
 102         gint count, ii, list_count;
 103
 104         g_debug("set_pref_audio");
 105         track_indices = g_hash_table_new_full(g_int_hash, g_int_equal,
 106                                                                                         NULL, free_audio_index_list);
 107         // Clear the audio list
 108         ghb_clear_audio_list(ud);
 109         // Find "best" audio based on audio preferences
 110         button = GHB_WIDGET (ud->builder, "audio_add");
 111         source_lang = ghb_settings_get_string(ud->settings, "SourceAudioLang");
 112
 113         pref_audio = ghb_settings_get_value(ud->settings, "AudioList");
 114
 115         list_count = 0;
 116         count = ghb_array_len(pref_audio);
 117         for (ii = 0; ii < count; ii++)
 118         {
 119                 audio = ghb_array_get_nth(pref_audio, ii);
 120                 acodec = ghb_settings_get_value(audio, "AudioEncoder");
 121                 bitrate = ghb_settings_get_value(audio, "AudioBitrate");
 122                 rate = ghb_settings_get_value(audio, "AudioSamplerate");
 123                 mix = ghb_settings_get_value(audio, "AudioMixdown");
 124                 drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
 125                 acodec_code = ghb_lookup_combo_int("AudioEncoder", acodec);
 126                 // If there are multiple audios using the same codec, then
 127                 // select sequential tracks for each.  The hash keeps track
 128                 // of the tracks used for each codec.
 129                 track = ghb_find_audio_track(titleindex, source_lang,
 130                                                                         acodec_code, track_indices);
 131                 // Check to see if:
 132                 // 1. pref codec is ac3
 133                 // 2. source codec is not ac3
 134                 // 3. next pref is enabled
 135                 if (ghb_get_audio_info (&ainfo, titleindex, track) &&
 136                         ghb_audio_is_passthru (acodec_code))
 137                 {
 138                         if (ainfo.codec != acodec_code)
 139                         {
 140                                 acodec_code = ghb_get_default_acodec();
 141                                 // If there's more audio to process, or we've already
 142                                 // placed one in the list, then we can skip this one
 143                                 if ((ii + 1 < count) || (list_count != 0))
 144                                 {
 145                                         // Skip this audio
 146                                         acodec_code = 0;
 147                                 }
 148                         }
 149                 }
 150                 if (titleindex >= 0 && track < 0)
 151                         acodec_code = 0;
 152                 if (acodec_code != 0)
 153                 {
 154                         // Add to audio list
 155                         g_signal_emit_by_name(button, "clicked", ud);
 156                         list_count++;
 157                         ghb_ui_update(ud, "AudioTrack", ghb_int64_value(track));
 158                         ghb_ui_update(ud, "AudioEncoder", acodec);
 159                         if (!ghb_audio_is_passthru (acodec_code))
 160                         {
 161                                 // This gets set autimatically if the codec is passthru
 162                                 ghb_ui_update(ud, "AudioBitrate", bitrate);
 163                                 ghb_ui_update(ud, "AudioSamplerate", rate);
 164                                 mix_code = ghb_lookup_combo_int("AudioMixdown", mix);
 165                                 mix_code = ghb_get_best_mix(
 166                                         titleindex, track, acodec_code, mix_code);
 167                                 ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(mix_code));
 168                         }
 169                         ghb_ui_update(ud, "AudioTrackDRCSlider", drc);
 170                 }
 171         }
 172         g_free(source_lang);
 173         g_hash_table_destroy(track_indices);
 174 }
 175
 176 static GValue*
 177 get_selected_asettings(signal_user_data_t *ud)
 178 {
 179         GtkTreeView *treeview;
 180         GtkTreePath *treepath;
 181         GtkTreeSelection *selection;
 182         GtkTreeModel *store;
 183         GtkTreeIter iter;
 184         gint *indices;
 185         gint row;
 186         GValue *asettings = NULL;
 187         const GValue *audio_list;
 188
 189         g_debug("get_selected_asettings ()");
 190         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 191         selection = gtk_tree_view_get_selection (treeview);
 192         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 193         {
 194                 // Get the row number
 195                 treepath = gtk_tree_model_get_path (store, &iter);
 196                 indices = gtk_tree_path_get_indices (treepath);
 197                 row = indices[0];
 198                 gtk_tree_path_free(treepath);
 199                 // find audio settings
 200                 if (row < 0) return NULL;
 201                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 202                 if (row >= ghb_array_len(audio_list))
 203                         return NULL;
 204                 asettings = ghb_array_get_nth(audio_list, row);
 205         }
 206         return asettings;
 207 }
 208
 209 static void
 210 audio_list_refresh_selected(signal_user_data_t *ud)
 211 {
 212         GtkTreeView *treeview;
 213         GtkTreePath *treepath;
 214         GtkTreeSelection *selection;
 215         GtkTreeModel *store;
 216         GtkTreeIter iter;
 217         gint *indices;
 218         gint row;
 219         GValue *asettings = NULL;
 220         const GValue *audio_list;
 221
 222         g_debug("audio_list_refresh_selected ()");
 223         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 224         selection = gtk_tree_view_get_selection (treeview);
 225         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 226         {
 227                 const gchar *track, *codec, *br, *sr, *mix;
 228                 gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
 229                 gdouble s_drc;
 230                 // Get the row number
 231                 treepath = gtk_tree_model_get_path (store, &iter);
 232                 indices = gtk_tree_path_get_indices (treepath);
 233                 row = indices[0];
 234                 gtk_tree_path_free(treepath);
 235                 // find audio settings
 236                 if (row < 0) return;
 237                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 238                 if (row >= ghb_array_len(audio_list))
 239                         return;
 240                 asettings = ghb_array_get_nth(audio_list, row);
 241
 242                 track = ghb_settings_combo_option(asettings, "AudioTrack");
 243                 codec = ghb_settings_combo_option(asettings, "AudioEncoder");
 244                 br = ghb_settings_combo_option(asettings, "AudioBitrate");
 245                 sr = ghb_settings_combo_option(asettings, "AudioSamplerate");
 246                 mix = ghb_settings_combo_option(asettings, "AudioMixdown");
 247
 248                 s_track = ghb_settings_get_string(asettings, "AudioTrack");
 249                 s_codec = ghb_settings_get_string(asettings, "AudioEncoder");
 250                 s_br = ghb_settings_get_string(asettings, "AudioBitrate");
 251                 s_sr = ghb_settings_get_string(asettings, "AudioSamplerate");
 252                 s_mix = ghb_settings_get_string(asettings, "AudioMixdown");
 253                 s_drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider");
 254                 if (s_drc < 0.1)
 255                         drc = g_strdup("Off");
 256                 else
 257                         drc = g_strdup_printf("%.1f", s_drc);
 258
 259                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 260                         // These are displayed in list
 261                         0, track,
 262                         1, codec,
 263                         2, br,
 264                         3, sr,
 265                         4, mix,
 266                         5, drc,
 267                         // These are used to set combo values when a list item is selected
 268                         6, s_track,
 269                         7, s_codec,
 270                         8, s_br,
 271                         9, s_sr,
 272                         10, s_mix,
 273                         11, s_drc,
 274                         -1);
 275                 g_free(drc);
 276                 g_free(s_track);
 277                 g_free(s_codec);
 278                 g_free(s_br);
 279                 g_free(s_sr);
 280                 g_free(s_mix);
 281         }
 282 }
 283
 284 void
 285 audio_codec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 286 {
 287         static gint prev_acodec = 0;
 288         gint acodec_code, mix_code;
 289         GValue *asettings, *gval;
 290
 291         g_debug("audio_codec_changed_cb ()");
 292         gval = ghb_widget_value(widget);
 293         acodec_code = ghb_lookup_combo_int("AudioEncoder", gval);
 294         ghb_value_free(gval);
 295         if (ghb_audio_is_passthru (prev_acodec) &&
 296                 !ghb_audio_is_passthru (acodec_code))
 297         {
 298                 // Transition from passthru to not, put some audio settings back to
 299                 // pref settings
 300                 gint titleindex;
 301                 gint track;
 302
 303                 titleindex = ghb_settings_combo_int(ud->settings, "title");
 304                 track = ghb_settings_combo_int(ud->settings, "AudioTrack");
 305
 306                 ghb_ui_update(ud, "AudioBitrate", ghb_string_value("160"));
 307                 ghb_ui_update(ud, "AudioSamplerate", ghb_string_value("source"));
 308                 mix_code = ghb_lookup_combo_int("AudioMixdown", ghb_string_value("dpl2"));
 309                 mix_code = ghb_get_best_mix( titleindex, track, acodec_code, mix_code);
 310                 ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(mix_code));
 311                 ghb_ui_update(ud, "AudioTrackDRCSlider", ghb_double_value(1.0));
 312         }
 313         ghb_adjust_audio_rate_combos(ud);
 314         ghb_grey_combo_options (ud->builder);
 315         ghb_check_dependency(ud, widget);
 316         prev_acodec = acodec_code;
 317         asettings = get_selected_asettings(ud);
 318         if (asettings != NULL)
 319         {
 320                 ghb_widget_to_setting(asettings, widget);
 321                 audio_list_refresh_selected(ud);
 322         }
 323
 324         const GValue *audio_list;
 325         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 326         if (ghb_ac3_in_audio_list (audio_list))
 327         {
 328                 gchar *container;
 329
 330                 container = ghb_settings_get_string(ud->settings, "FileFormat");
 331                 if (strcmp(container, "mp4") == 0)
 332                 {
 333                         ghb_ui_update(ud, "FileFormat", ghb_string_value("m4v"));
 334                 }
 335                 g_free(container);
 336         }
 337         ghb_live_reset(ud);
 338 }
 339
 340 void
 341 audio_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 342 {
 343         GValue *asettings;
 344
 345         g_debug("audio_track_changed_cb ()");
 346         ghb_adjust_audio_rate_combos(ud);
 347         ghb_check_dependency(ud, widget);
 348         ghb_grey_combo_options(ud->builder);
 349         asettings = get_selected_asettings(ud);
 350         if (asettings != NULL)
 351         {
 352                 const gchar *track;
 353
 354                 ghb_widget_to_setting(asettings, widget);
 355                 audio_list_refresh_selected(ud);
 356                 track = ghb_settings_combo_option(asettings, "AudioTrack");
 357                 ghb_settings_set_string(asettings, "AudioTrackDescription", track);
 358         }
 359         ghb_live_reset(ud);
 360 }
 361
 362 void
 363 audio_mix_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 364 {
 365         GValue *asettings;
 366
 367         g_debug("audio_mix_changed_cb ()");
 368         ghb_adjust_audio_rate_combos(ud);
 369         ghb_check_dependency(ud, widget);
 370         asettings = get_selected_asettings(ud);
 371         if (asettings != NULL)
 372         {
 373                 ghb_widget_to_setting(asettings, widget);
 374                 audio_list_refresh_selected(ud);
 375         }
 376         ghb_live_reset(ud);
 377 }
 378
 379 void
 380 audio_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 381 {
 382         GValue *asettings;
 383
 384         g_debug("audio_widget_changed_cb ()");
 385         ghb_check_dependency(ud, widget);
 386         asettings = get_selected_asettings(ud);
 387         if (asettings != NULL)
 388         {
 389                 ghb_widget_to_setting(asettings, widget);
 390                 audio_list_refresh_selected(ud);
 391         }
 392         ghb_live_reset(ud);
 393 }
 394
 395 void
 396 drc_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 397 {
 398         GValue *asettings;
 399         gdouble val;
 400
 401         g_debug("drc_widget_changed_cb ()");
 402         val = gtk_range_get_value(GTK_RANGE(widget));
 403         if (val < 0.5)
 404                 gtk_range_set_value(GTK_RANGE(widget), 0.0);
 405         else if (val < 1.0)
 406                 gtk_range_set_value(GTK_RANGE(widget), 1.0);
 407         ghb_check_dependency(ud, widget);
 408         asettings = get_selected_asettings(ud);
 409         if (asettings != NULL)
 410         {
 411                 ghb_widget_to_setting(asettings, widget);
 412                 audio_list_refresh_selected(ud);
 413         }
 414         ghb_live_reset(ud);
 415 }
 416
 417 // subtitles differ from other settings in that
 418 // the selection is updated automaitcally when the title
 419 // changes.  I don't want the preset selection changed as
 420 // would happen for regular settings.
 421 void
 422 subtitle_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 423 {
 424         const gchar *name = gtk_widget_get_name(widget);
 425         g_debug("subtitle_changed_cb () %s", name);
 426         ghb_widget_to_setting(ud->settings, widget);
 427         ghb_check_dependency(ud, widget);
 428         ghb_live_reset(ud);
 429 }
 430
 431 void
 432 ghb_clear_audio_list(signal_user_data_t *ud)
 433 {
 434         GtkTreeView *treeview;
 435         GtkListStore *store;
 436         GValue *audio_list;
 437
 438         g_debug("clear_audio_list ()");
 439         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 440         if (audio_list == NULL)
 441         {
 442                 audio_list = ghb_array_value_new(8);
 443                 ghb_settings_set_value(ud->settings, "audio_list", audio_list);
 444         }
 445         else
 446                 ghb_array_value_reset(audio_list, 8);
 447         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 448         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 449         gtk_list_store_clear (store);
 450 }
 451
 452 static void
 453 add_to_audio_list(signal_user_data_t *ud, GValue *settings)
 454 {
 455         GtkTreeView *treeview;
 456         GtkTreeIter iter;
 457         GtkListStore *store;
 458         GtkTreeSelection *selection;
 459         const gchar *track, *codec, *br, *sr, *mix;
 460         gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
 461         gdouble s_drc;
 462
 463         g_debug("add_to_audio_list ()");
 464         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 465         selection = gtk_tree_view_get_selection (treeview);
 466         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 467
 468         track = ghb_settings_combo_option(settings, "AudioTrack");
 469         codec = ghb_settings_combo_option(settings, "AudioEncoder");
 470         br = ghb_settings_combo_option(settings, "AudioBitrate");
 471         sr = ghb_settings_combo_option(settings, "AudioSamplerate");
 472         mix = ghb_settings_combo_option(settings, "AudioMixdown");
 473
 474         s_track = ghb_settings_get_string(settings, "AudioTrack");
 475         s_codec = ghb_settings_get_string(settings, "AudioEncoder");
 476         s_br = ghb_settings_get_string(settings, "AudioBitrate");
 477         s_sr = ghb_settings_get_string(settings, "AudioSamplerate");
 478         s_mix = ghb_settings_get_string(settings, "AudioMixdown");
 479         s_drc = ghb_settings_get_double(settings, "AudioTrackDRCSlider");
 480         if (s_drc < 0.1)
 481                 drc = g_strdup("Off");
 482         else
 483                 drc = g_strdup_printf("%.1f", s_drc);
 484
 485         gtk_list_store_append(store, &iter);
 486         gtk_list_store_set(store, &iter,
 487                 // These are displayed in list
 488                 0, track,
 489                 1, codec,
 490                 2, br,
 491                 3, sr,
 492                 4, mix,
 493                 5, drc,
 494                 // These are used to set combo box values when a list item is selected
 495                 6, s_track,
 496                 7, s_codec,
 497                 8, s_br,
 498                 9, s_sr,
 499                 10, s_mix,
 500                 11, s_drc,
 501                 -1);
 502         gtk_tree_selection_select_iter(selection, &iter);
 503         g_free(drc);
 504         g_free(s_track);
 505         g_free(s_codec);
 506         g_free(s_br);
 507         g_free(s_sr);
 508         g_free(s_mix);
 509 }
 510
 511 void
 512 audio_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
 513 {
 514         GtkTreeModel *store;
 515         GtkTreeIter iter;
 516         GtkWidget *widget;
 517
 518         g_debug("audio_list_selection_changed_cb ()");
 519         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 520         {
 521                 const gchar *track, *codec, *bitrate, *sample_rate, *mix;
 522                 gdouble drc;
 523
 524                 gtk_tree_model_get(store, &iter,
 525                                                    6, &track,
 526                                                    7, &codec,
 527                                                    8, &bitrate,
 528                                                    9, &sample_rate,
 529                                                    10, &mix,
 530                                                    11, &drc,
 531                                                    -1);
 532                 ghb_ui_update(ud, "AudioTrack", ghb_string_value(track));
 533                 ghb_ui_update(ud, "AudioEncoder", ghb_string_value(codec));
 534                 ghb_ui_update(ud, "AudioBitrate", ghb_string_value(bitrate));
 535                 ghb_ui_update(ud, "AudioSamplerate", ghb_string_value(sample_rate));
 536                 ghb_ui_update(ud, "AudioMixdown", ghb_string_value(mix));
 537                 ghb_ui_update(ud, "AudioTrackDRCSlider", ghb_double_value(drc));
 538                 widget = GHB_WIDGET (ud->builder, "audio_remove");
 539                 gtk_widget_set_sensitive(widget, TRUE);
 540         }
 541         else
 542         {
 543                 widget = GHB_WIDGET (ud->builder, "audio_remove");
 544                 gtk_widget_set_sensitive(widget, FALSE);
 545         }
 546 }
 547
 548 void
 549 audio_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
 550 {
 551         // Add the current audio settings to the list.
 552         GValue *asettings;
 553         GtkWidget *widget;
 554         gint count;
 555         GValue *audio_list;
 556         const gchar *track;
 557
 558         g_debug("audio_add_clicked_cb ()");
 559         asettings = ghb_dict_value_new();
 560         // Only allow up to 8 audio entries
 561         widget = GHB_WIDGET(ud->builder, "AudioTrack");
 562         ghb_settings_take_value(asettings, "AudioTrack", ghb_widget_value(widget));
 563         widget = GHB_WIDGET(ud->builder, "AudioEncoder");
 564         ghb_settings_take_value(asettings, "AudioEncoder", ghb_widget_value(widget));
 565         widget = GHB_WIDGET(ud->builder, "AudioBitrate");
 566         ghb_settings_take_value(asettings, "AudioBitrate", ghb_widget_value(widget));
 567         widget = GHB_WIDGET(ud->builder, "AudioSamplerate");
 568         ghb_settings_take_value(asettings, "AudioSamplerate", ghb_widget_value(widget));
 569         widget = GHB_WIDGET(ud->builder, "AudioMixdown");
 570         ghb_settings_take_value(asettings, "AudioMixdown", ghb_widget_value(widget));
 571         widget = GHB_WIDGET(ud->builder, "AudioTrackDRCSlider");
 572         ghb_settings_take_value(asettings, "AudioTrackDRCSlider", ghb_widget_value(widget));
 573         track = ghb_settings_combo_option(asettings, "AudioTrack");
 574         ghb_settings_set_string(asettings, "AudioTrackDescription", track);
 575
 576         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 577         if (audio_list == NULL)
 578         {
 579                 audio_list = ghb_array_value_new(8);
 580                 ghb_settings_set_value(ud->settings, "audio_list", audio_list);
 581         }
 582         ghb_array_append(audio_list, asettings);
 583         add_to_audio_list(ud, asettings);
 584         count = ghb_array_len(audio_list);
 585         if (count >= 8)
 586         {
 587                 gtk_widget_set_sensitive(xwidget, FALSE);
 588         }
 589 }
 590
 591 void
 592 audio_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
 593 {
 594         GtkTreeView *treeview;
 595         GtkTreePath *treepath;
 596         GtkTreeSelection *selection;
 597         GtkTreeModel *store;
 598         GtkTreeIter iter, nextIter;
 599         gint *indices;
 600         gint row;
 601         GValue *audio_list;
 602
 603         g_debug("audio_remove_clicked_cb ()");
 604         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 605         selection = gtk_tree_view_get_selection (treeview);
 606         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 607         {
 608                 nextIter = iter;
 609                 if (!gtk_tree_model_iter_next(store, &nextIter))
 610                 {
 611                         nextIter = iter;
 612                         if (gtk_tree_model_get_iter_first(store, &nextIter))
 613                         {
 614                                 gtk_tree_selection_select_iter (selection, &nextIter);
 615                         }
 616                 }
 617                 else
 618                 {
 619                         gtk_tree_selection_select_iter (selection, &nextIter);
 620                 }
 621                 // Get the row number
 622                 treepath = gtk_tree_model_get_path (store, &iter);
 623                 indices = gtk_tree_path_get_indices (treepath);
 624                 row = indices[0];
 625                 gtk_tree_path_free(treepath);
 626                 // Remove the selected item
 627                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
 628                 // remove from audio settings list
 629                 if (row < 0) return;
 630                 widget = GHB_WIDGET (ud->builder, "audio_add");
 631                 gtk_widget_set_sensitive(widget, TRUE);
 632                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 633                 if (row >= ghb_array_len(audio_list))
 634                         return;
 635                 GValue *old = ghb_array_get_nth(audio_list, row);
 636                 ghb_value_free(old);
 637                 ghb_array_remove(audio_list, row);
 638         }
 639 }
 640
 641 void
 642 ghb_set_audio(signal_user_data_t *ud, GValue *settings)
 643 {
 644         gint acodec_code;
 645         GtkWidget *button;
 646
 647         GValue *alist;
 648         GValue *track, *audio, *acodec, *bitrate, *rate, *mix, *drc;
 649         gint count, ii;
 650
 651         g_debug("set_audio");
 652         // Clear the audio list
 653         ghb_clear_audio_list(ud);
 654         button = GHB_WIDGET (ud->builder, "audio_add");
 655         alist = ghb_settings_get_value(settings, "audio_list");
 656
 657         count = ghb_array_len(alist);
 658         for (ii = 0; ii < count; ii++)
 659         {
 660                 audio = ghb_array_get_nth(alist, ii);
 661                 track = ghb_settings_get_value(audio, "AudioTrack");
 662                 acodec = ghb_settings_get_value(audio, "AudioEncoder");
 663                 bitrate = ghb_settings_get_value(audio, "AudioBitrate");
 664                 rate = ghb_settings_get_value(audio, "AudioSamplerate");
 665                 mix = ghb_settings_get_value(audio, "AudioMixdown");
 666                 drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
 667                 acodec_code = ghb_lookup_combo_int("AudioEncoder", acodec);
 668
 669                 if (acodec_code != 0)
 670                 {
 671                         // Add to audio list
 672                         g_signal_emit_by_name(button, "clicked", ud);
 673                         ghb_ui_update(ud, "AudioTrack", track);
 674                         ghb_ui_update(ud, "AudioEncoder", acodec);
 675                         if (!ghb_audio_is_passthru (acodec_code))
 676                         {
 677                                 // This gets set autimatically if the codec is passthru
 678                                 ghb_ui_update(ud, "AudioBitrate", bitrate);
 679                                 ghb_ui_update(ud, "AudioSamplerate", rate);
 680                                 ghb_ui_update(ud, "AudioMixdown", mix);
 681                         }
 682                         ghb_ui_update(ud, "AudioTrackDRCSlider", drc);
 683                 }
 684         }
 685 }
 686