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