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