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