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