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