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