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