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