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