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