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 "audiohandler.h"
  21
  22 void
  23 ghb_adjust_audio_rate_combos(signal_user_data_t *ud)
  24 {
  25         gint titleindex, audioindex, acodec, mix;
  26         ghb_audio_info_t ainfo;
  27         GtkWidget *widget;
  28         GValue *gval;
  29
  30         g_debug("ghb_adjust_audio_rate_combos ()");
  31         titleindex = ghb_settings_combo_int(ud->settings, "title");
  32
  33         widget = GHB_WIDGET(ud->builder, "AudioTrack");
  34         gval = ghb_widget_value(widget);
  35         audioindex = ghb_lookup_combo_int("AudioTrack", gval);
  36         ghb_value_free(gval);
  37
  38         widget = GHB_WIDGET(ud->builder, "AudioEncoder");
  39         gval = ghb_widget_value(widget);
  40         acodec = ghb_lookup_combo_int("AudioEncoder", gval);
  41         ghb_value_free(gval);
  42         widget = GHB_WIDGET(ud->builder, "AudioMixdown");
  43         gval = ghb_widget_value(widget);
  44         mix = ghb_lookup_combo_int("AudioMixdown", gval);
  45         ghb_value_free(gval);
  46
  47         if (ghb_audio_is_passthru (acodec))
  48         {
  49                 ghb_set_default_bitrate_opts (ud->builder, -1);
  50                 if (ghb_get_audio_info (&ainfo, titleindex, audioindex))
  51                 {
  52                         gint br = ainfo.bitrate / 1000;
  53                         // Set the values for bitrate and samplerate to the input rates
  54                         ghb_set_passthru_bitrate_opts (ud->builder, br);
  55                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(br));
  56                         ghb_ui_update(ud, "AudioSamplerate", ghb_int64_value(0));
  57                         ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(0));
  58                 }
  59                 else
  60                 {
  61                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(384));
  62                         ghb_ui_update(ud, "AudioSamplerate", ghb_int64_value(0));
  63                         ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(0));
  64                 }
  65         }
  66         else if (acodec == HB_ACODEC_FAAC && mix != HB_AMIXDOWN_6CH)
  67         {
  68                 gint br;
  69
  70                 widget = GHB_WIDGET(ud->builder, "AudioBitrate");
  71                 gval = ghb_widget_value(widget);
  72                 br = ghb_lookup_combo_int("AudioBitrate", gval);
  73                 ghb_value_free(gval);
  74                 if (br > 160)
  75                         ghb_ui_update(ud, "AudioBitrate", ghb_int64_value(160));
  76                 ghb_set_default_bitrate_opts (ud->builder, 160);
  77         }
  78         else
  79         {
  80                 ghb_set_default_bitrate_opts (ud->builder, -1);
  81         }
  82 }
  83
  84 void
  85 ghb_set_pref_audio(gint titleindex, signal_user_data_t *ud)
  86 {
  87         gint acodec_code, mix_code, track;
  88         gchar *source_lang;
  89         GtkWidget *button;
  90         ghb_audio_info_t ainfo;
  91         gint index;
  92         GHashTable *track_indicies;
  93         gint *iptr;
  94
  95         GValue *pref_audio;
  96         GValue *audio, *acodec, *bitrate, *rate, *mix, *drc;
  97         gint count, ii, list_count;
  98
  99         g_debug("set_pref_audio");
 100         track_indicies = g_hash_table_new(g_int_hash, g_int_equal);
 101         // Clear the audio list
 102         ghb_clear_audio_list(ud);
 103         // Find "best" audio based on audio preferences
 104         button = GHB_WIDGET (ud->builder, "audio_add");
 105         source_lang = ghb_settings_get_string(ud->settings, "SourceAudioLang");
 106
 107         pref_audio = ghb_settings_get_value(ud->settings, "AudioList");
 108
 109         list_count = 0;
 110         count = ghb_array_len(pref_audio);
 111         for (ii = 0; ii < count; ii++)
 112         {
 113                 audio = ghb_array_get_nth(pref_audio, ii);
 114                 acodec = ghb_settings_get_value(audio, "AudioEncoder");
 115                 bitrate = ghb_settings_get_value(audio, "AudioBitrate");
 116                 rate = ghb_settings_get_value(audio, "AudioSamplerate");
 117                 mix = ghb_settings_get_value(audio, "AudioMixdown");
 118                 drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
 119                 acodec_code = ghb_lookup_combo_int("AudioEncoder", acodec);
 120                 // If there are multiple audios using the same codec, then
 121                 // select sequential tracks for each.  This hash keeps track
 122                 // of the last used track for each codec.
 123                 iptr = g_hash_table_lookup(track_indicies, &acodec_code);
 124                 if (iptr == NULL)
 125                         index = 0;
 126                 else
 127                         index = *(gint*)iptr;
 128
 129                 track = ghb_find_audio_track(titleindex, source_lang, index);
 130                 // Check to see if:
 131                 // 1. pref codec is ac3
 132                 // 2. source codec is not ac3
 133                 // 3. next pref is enabled
 134                 if (ghb_get_audio_info (&ainfo, titleindex, track) &&
 135                         ghb_audio_is_passthru (acodec_code))
 136                 {
 137                         if (!ghb_audio_is_passthru(ainfo.codec))
 138                         {
 139                                 acodec_code = ghb_get_default_acodec();
 140                                 // If there's more audio to process, or we've already
 141                                 // placed one in the list, then we can skip this one
 142                                 if ((ii + 1 < count) || (list_count != 0))
 143                                 {
 144                                         // Skip this audio
 145                                         acodec_code = 0;
 146                                 }
 147                         }
 148                 }
 149                 if (titleindex >= 0 && track < 0)
 150                         acodec_code = 0;
 151                 if (acodec_code != 0)
 152                 {
 153                         // Add to audio list
 154                         g_signal_emit_by_name(button, "clicked", ud);
 155                         list_count++;
 156                         ghb_ui_update(ud, "AudioTrack", ghb_int64_value(track));
 157                         ghb_ui_update(ud, "AudioEncoder", acodec);
 158                         if (!ghb_audio_is_passthru (acodec_code))
 159                         {
 160                                 // This gets set autimatically if the codec is passthru
 161                                 ghb_ui_update(ud, "AudioBitrate", bitrate);
 162                                 ghb_ui_update(ud, "AudioSamplerate", rate);
 163                                 mix_code = ghb_lookup_combo_int("AudioMixdown", mix);
 164                                 mix_code = ghb_get_best_mix(
 165                                         titleindex, track, acodec_code, mix_code);
 166                                 ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(mix_code));
 167                         }
 168                         ghb_ui_update(ud, "AudioTrackDRCSlider", drc);
 169                         index++;
 170                         g_hash_table_insert(track_indicies, &acodec_code, &index);
 171                 }
 172         }
 173         g_free(source_lang);
 174         g_hash_table_destroy(track_indicies);
 175 }
 176
 177 static GValue*
 178 get_selected_asettings(signal_user_data_t *ud)
 179 {
 180         GtkTreeView *treeview;
 181         GtkTreePath *treepath;
 182         GtkTreeSelection *selection;
 183         GtkTreeModel *store;
 184         GtkTreeIter iter;
 185         gint *indices;
 186         gint row;
 187         GValue *asettings = NULL;
 188         const GValue *audio_list;
 189
 190         g_debug("get_selected_asettings ()");
 191         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 192         selection = gtk_tree_view_get_selection (treeview);
 193         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 194         {
 195                 // Get the row number
 196                 treepath = gtk_tree_model_get_path (store, &iter);
 197                 indices = gtk_tree_path_get_indices (treepath);
 198                 row = indices[0];
 199                 gtk_tree_path_free(treepath);
 200                 // find audio settings
 201                 if (row < 0) return NULL;
 202                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 203                 if (row >= ghb_array_len(audio_list))
 204                         return NULL;
 205                 asettings = ghb_array_get_nth(audio_list, row);
 206         }
 207         return asettings;
 208 }
 209
 210 static void
 211 audio_list_refresh_selected(signal_user_data_t *ud)
 212 {
 213         GtkTreeView *treeview;
 214         GtkTreePath *treepath;
 215         GtkTreeSelection *selection;
 216         GtkTreeModel *store;
 217         GtkTreeIter iter;
 218         gint *indices;
 219         gint row;
 220         GValue *asettings = NULL;
 221         const GValue *audio_list;
 222
 223         g_debug("audio_list_refresh_selected ()");
 224         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 225         selection = gtk_tree_view_get_selection (treeview);
 226         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 227         {
 228                 const gchar *track, *codec, *br, *sr, *mix;
 229                 gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
 230                 gdouble s_drc;
 231                 // Get the row number
 232                 treepath = gtk_tree_model_get_path (store, &iter);
 233                 indices = gtk_tree_path_get_indices (treepath);
 234                 row = indices[0];
 235                 gtk_tree_path_free(treepath);
 236                 // find audio settings
 237                 if (row < 0) return;
 238                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 239                 if (row >= ghb_array_len(audio_list))
 240                         return;
 241                 asettings = ghb_array_get_nth(audio_list, row);
 242
 243                 track = ghb_settings_combo_option(asettings, "AudioTrack");
 244                 codec = ghb_settings_combo_option(asettings, "AudioEncoder");
 245                 br = ghb_settings_combo_option(asettings, "AudioBitrate");
 246                 sr = ghb_settings_combo_option(asettings, "AudioSamplerate");
 247                 mix = ghb_settings_combo_option(asettings, "AudioMixdown");
 248                 drc = ghb_settings_get_string(asettings, "AudioTrackDRCSlider");
 249
 250                 s_track = ghb_settings_get_string(asettings, "AudioTrack");
 251                 s_codec = ghb_settings_get_string(asettings, "AudioEncoder");
 252                 s_br = ghb_settings_get_string(asettings, "AudioBitrate");
 253                 s_sr = ghb_settings_get_string(asettings, "AudioSamplerate");
 254                 s_mix = ghb_settings_get_string(asettings, "AudioMixdown");
 255                 s_drc = ghb_settings_get_double(asettings, "AudioTrackDRCSlider");
 256
 257                 gtk_list_store_set(GTK_LIST_STORE(store), &iter,
 258                         // These are displayed in list
 259                         0, track,
 260                         1, codec,
 261                         2, br,
 262                         3, sr,
 263                         4, mix,
 264                         // These are used to set combo values when a list item is selected
 265                         5, drc,
 266                         6, s_track,
 267                         7, s_codec,
 268                         8, s_br,
 269                         9, s_sr,
 270                         10, s_mix,
 271                         11, s_drc,
 272                         -1);
 273                 g_free(drc);
 274                 g_free(s_track);
 275                 g_free(s_codec);
 276                 g_free(s_br);
 277                 g_free(s_sr);
 278                 g_free(s_mix);
 279         }
 280 }
 281
 282 void
 283 audio_codec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 284 {
 285         static gint prev_acodec = 0;
 286         gint acodec_code, mix_code;
 287         GValue *asettings, *gval;
 288
 289         g_debug("audio_codec_changed_cb ()");
 290         gval = ghb_widget_value(widget);
 291         acodec_code = ghb_lookup_combo_int("AudioEncoder", gval);
 292         ghb_value_free(gval);
 293         if (ghb_audio_is_passthru (prev_acodec) &&
 294                 !ghb_audio_is_passthru (acodec_code))
 295         {
 296                 // Transition from passthru to not, put some audio settings back to
 297                 // pref settings
 298                 gint titleindex;
 299                 gint track;
 300
 301                 titleindex = ghb_settings_combo_int(ud->settings, "title");
 302                 track = ghb_settings_combo_int(ud->settings, "AudioTrack");
 303
 304                 ghb_ui_update(ud, "AudioBitrate", ghb_string_value("160"));
 305                 ghb_ui_update(ud, "AudioSamplerate", ghb_string_value("source"));
 306                 mix_code = ghb_lookup_combo_int("AudioMixdown", ghb_string_value("dpl2"));
 307                 mix_code = ghb_get_best_mix( titleindex, track, acodec_code, mix_code);
 308                 ghb_ui_update(ud, "AudioMixdown", ghb_int64_value(mix_code));
 309                 ghb_ui_update(ud, "AudioTrackDRCSlider", ghb_double_value(1.0));
 310         }
 311         ghb_adjust_audio_rate_combos(ud);
 312         ghb_grey_combo_options (ud->builder);
 313         ghb_check_dependency(ud, widget);
 314         prev_acodec = acodec_code;
 315         asettings = get_selected_asettings(ud);
 316         if (asettings != NULL)
 317         {
 318                 ghb_widget_to_setting(asettings, widget);
 319                 audio_list_refresh_selected(ud);
 320         }
 321
 322         const GValue *audio_list;
 323         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 324         if (ghb_ac3_in_audio_list (audio_list))
 325         {
 326                 gchar *container;
 327
 328                 container = ghb_settings_get_string(ud->settings, "FileFormat");
 329                 if (strcmp(container, "mp4") == 0)
 330                 {
 331                         ghb_ui_update(ud, "FileFormat", ghb_string_value("m4v"));
 332                 }
 333                 g_free(container);
 334         }
 335 }
 336
 337 void
 338 audio_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 339 {
 340         GValue *asettings;
 341
 342         g_debug("audio_track_changed_cb ()");
 343         ghb_adjust_audio_rate_combos(ud);
 344         ghb_check_dependency(ud, widget);
 345         ghb_grey_combo_options(ud->builder);
 346         asettings = get_selected_asettings(ud);
 347         if (asettings != NULL)
 348         {
 349                 const gchar *track;
 350
 351                 ghb_widget_to_setting(asettings, widget);
 352                 audio_list_refresh_selected(ud);
 353                 track = ghb_settings_combo_option(asettings, "AudioTrack");
 354                 ghb_settings_set_string(asettings, "AudioTrackDescription", track);
 355         }
 356 }
 357
 358 void
 359 audio_mix_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 360 {
 361         GValue *asettings;
 362
 363         g_debug("audio_widget_changed_cb ()");
 364         ghb_adjust_audio_rate_combos(ud);
 365         ghb_check_dependency(ud, widget);
 366         asettings = get_selected_asettings(ud);
 367         if (asettings != NULL)
 368         {
 369                 ghb_widget_to_setting(asettings, widget);
 370                 audio_list_refresh_selected(ud);
 371         }
 372 }
 373
 374 void
 375 audio_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 376 {
 377         GValue *asettings;
 378
 379         g_debug("audio_widget_changed_cb ()");
 380         ghb_check_dependency(ud, widget);
 381         asettings = get_selected_asettings(ud);
 382         if (asettings != NULL)
 383         {
 384                 ghb_widget_to_setting(asettings, widget);
 385                 audio_list_refresh_selected(ud);
 386         }
 387 }
 388
 389 // subtitles differ from other settings in that
 390 // the selection is updated automaitcally when the title
 391 // changes.  I don't want the preset selection changed as
 392 // would happen for regular settings.
 393 void
 394 subtitle_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
 395 {
 396         const gchar *name = gtk_widget_get_name(widget);
 397         g_debug("subtitle_changed_cb () %s", name);
 398         ghb_widget_to_setting(ud->settings, widget);
 399         ghb_check_dependency(ud, widget);
 400 }
 401
 402 void
 403 ghb_clear_audio_list(signal_user_data_t *ud)
 404 {
 405         GtkTreeView *treeview;
 406         GtkListStore *store;
 407         GValue *audio_list;
 408
 409         g_debug("clear_audio_list ()");
 410         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 411         if (audio_list == NULL)
 412         {
 413                 audio_list = ghb_array_value_new(8);
 414                 ghb_settings_set_value(ud->settings, "audio_list", audio_list);
 415         }
 416         else
 417                 ghb_array_value_reset(audio_list, 8);
 418         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 419         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 420         gtk_list_store_clear (store);
 421 }
 422
 423 static void
 424 add_to_audio_list(signal_user_data_t *ud, GValue *settings)
 425 {
 426         GtkTreeView *treeview;
 427         GtkTreeIter iter;
 428         GtkListStore *store;
 429         GtkTreeSelection *selection;
 430         const gchar *track, *codec, *br, *sr, *mix;
 431         gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
 432         gdouble s_drc;
 433
 434         g_debug("add_to_audio_list ()");
 435         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 436         selection = gtk_tree_view_get_selection (treeview);
 437         store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
 438
 439         track = ghb_settings_combo_option(settings, "AudioTrack");
 440         codec = ghb_settings_combo_option(settings, "AudioEncoder");
 441         br = ghb_settings_combo_option(settings, "AudioBitrate");
 442         sr = ghb_settings_combo_option(settings, "AudioSamplerate");
 443         mix = ghb_settings_combo_option(settings, "AudioMixdown");
 444         drc = ghb_settings_get_string(settings, "AudioTrackDRCSlider");
 445
 446         s_track = ghb_settings_get_string(settings, "AudioTrack");
 447         s_codec = ghb_settings_get_string(settings, "AudioEncoder");
 448         s_br = ghb_settings_get_string(settings, "AudioBitrate");
 449         s_sr = ghb_settings_get_string(settings, "AudioSamplerate");
 450         s_mix = ghb_settings_get_string(settings, "AudioMixdown");
 451         s_drc = ghb_settings_get_double(settings, "AudioTrackDRCSlider");
 452
 453         gtk_list_store_append(store, &iter);
 454         gtk_list_store_set(store, &iter,
 455                 // These are displayed in list
 456                 0, track,
 457                 1, codec,
 458                 2, br,
 459                 3, sr,
 460                 4, mix,
 461                 // These are used to set combo box values when a list item is selected
 462                 5, drc,
 463                 6, s_track,
 464                 7, s_codec,
 465                 8, s_br,
 466                 9, s_sr,
 467                 10, s_mix,
 468                 11, s_drc,
 469                 -1);
 470         gtk_tree_selection_select_iter(selection, &iter);
 471         g_free(drc);
 472         g_free(s_track);
 473         g_free(s_codec);
 474         g_free(s_br);
 475         g_free(s_sr);
 476         g_free(s_mix);
 477 }
 478
 479 void
 480 audio_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
 481 {
 482         GtkTreeModel *store;
 483         GtkTreeIter iter;
 484         GtkWidget *widget;
 485
 486         g_debug("audio_list_selection_changed_cb ()");
 487         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 488         {
 489                 const gchar *track, *codec, *bitrate, *sample_rate, *mix;
 490                 gdouble drc;
 491
 492                 gtk_tree_model_get(store, &iter,
 493                                                    6, &track,
 494                                                    7, &codec,
 495                                                    8, &bitrate,
 496                                                    9, &sample_rate,
 497                                                    10, &mix,
 498                                                    11, &drc,
 499                                                    -1);
 500                 ghb_ui_update(ud, "AudioTrack", ghb_string_value(track));
 501                 ghb_ui_update(ud, "AudioEncoder", ghb_string_value(codec));
 502                 ghb_ui_update(ud, "AudioBitrate", ghb_string_value(bitrate));
 503                 ghb_ui_update(ud, "AudioSamplerate", ghb_string_value(sample_rate));
 504                 ghb_ui_update(ud, "AudioMixdown", ghb_string_value(mix));
 505                 ghb_ui_update(ud, "AudioTrackDRCSlider", ghb_double_value(drc));
 506                 widget = GHB_WIDGET (ud->builder, "audio_remove");
 507                 gtk_widget_set_sensitive(widget, TRUE);
 508                 //widget = GHB_WIDGET (ud->builder, "audio_update");
 509                 //gtk_widget_set_sensitive(widget, TRUE);
 510         }
 511         else
 512         {
 513                 widget = GHB_WIDGET (ud->builder, "audio_remove");
 514                 gtk_widget_set_sensitive(widget, FALSE);
 515                 //widget = GHB_WIDGET (ud->builder, "audio_update");
 516                 //gtk_widget_set_sensitive(widget, FALSE);
 517         }
 518 }
 519
 520 void
 521 audio_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
 522 {
 523         // Add the current audio settings to the list.
 524         GValue *asettings;
 525         GtkWidget *widget;
 526         gint count;
 527         GValue *audio_list;
 528         const gchar *track;
 529
 530         g_debug("audio_add_clicked_cb ()");
 531         asettings = ghb_dict_value_new();
 532         // Only allow up to 8 audio entries
 533         widget = GHB_WIDGET(ud->builder, "AudioTrack");
 534         ghb_settings_take_value(asettings, "AudioTrack", ghb_widget_value(widget));
 535         widget = GHB_WIDGET(ud->builder, "AudioEncoder");
 536         ghb_settings_take_value(asettings, "AudioEncoder", ghb_widget_value(widget));
 537         widget = GHB_WIDGET(ud->builder, "AudioBitrate");
 538         ghb_settings_take_value(asettings, "AudioBitrate", ghb_widget_value(widget));
 539         widget = GHB_WIDGET(ud->builder, "AudioSamplerate");
 540         ghb_settings_take_value(asettings, "AudioSamplerate", ghb_widget_value(widget));
 541         widget = GHB_WIDGET(ud->builder, "AudioMixdown");
 542         ghb_settings_take_value(asettings, "AudioMixdown", ghb_widget_value(widget));
 543         widget = GHB_WIDGET(ud->builder, "AudioTrackDRCSlider");
 544         ghb_settings_take_value(asettings, "AudioTrackDRCSlider", ghb_widget_value(widget));
 545         track = ghb_settings_combo_option(asettings, "AudioTrack");
 546         ghb_settings_set_string(asettings, "AudioTrackDescription", track);
 547
 548         audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 549         if (audio_list == NULL)
 550         {
 551                 audio_list = ghb_array_value_new(8);
 552                 ghb_settings_set_value(ud->settings, "audio_list", audio_list);
 553         }
 554         ghb_array_append(audio_list, asettings);
 555         add_to_audio_list(ud, asettings);
 556         count = ghb_array_len(audio_list);
 557         if (count >= 8)
 558         {
 559                 gtk_widget_set_sensitive(xwidget, FALSE);
 560         }
 561 }
 562
 563 void
 564 audio_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
 565 {
 566         GtkTreeView *treeview;
 567         GtkTreePath *treepath;
 568         GtkTreeSelection *selection;
 569         GtkTreeModel *store;
 570         GtkTreeIter iter, nextIter;
 571         gint *indices;
 572         gint row;
 573         GValue *audio_list;
 574
 575         g_debug("audio_remove_clicked_cb ()");
 576         treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
 577         selection = gtk_tree_view_get_selection (treeview);
 578         if (gtk_tree_selection_get_selected(selection, &store, &iter))
 579         {
 580                 nextIter = iter;
 581                 if (!gtk_tree_model_iter_next(store, &nextIter))
 582                 {
 583                         nextIter = iter;
 584                         if (gtk_tree_model_get_iter_first(store, &nextIter))
 585                         {
 586                                 gtk_tree_selection_select_iter (selection, &nextIter);
 587                         }
 588                 }
 589                 else
 590                 {
 591                         gtk_tree_selection_select_iter (selection, &nextIter);
 592                 }
 593                 // Get the row number
 594                 treepath = gtk_tree_model_get_path (store, &iter);
 595                 indices = gtk_tree_path_get_indices (treepath);
 596                 row = indices[0];
 597                 gtk_tree_path_free(treepath);
 598                 // Remove the selected item
 599                 gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
 600                 // remove from audio settings list
 601                 if (row < 0) return;
 602                 widget = GHB_WIDGET (ud->builder, "audio_add");
 603                 gtk_widget_set_sensitive(widget, TRUE);
 604                 audio_list = ghb_settings_get_value(ud->settings, "audio_list");
 605                 if (row >= ghb_array_len(audio_list))
 606                         return;
 607                 GValue *old = ghb_array_get_nth(audio_list, row);
 608                 ghb_value_free(old);
 609                 ghb_array_remove(audio_list, row);
 610         }
 611 }
 612
 613 void
 614 ghb_set_audio(signal_user_data_t *ud, GValue *settings)
 615 {
 616         gint acodec_code;
 617         GtkWidget *button;
 618
 619         GValue *alist;
 620         GValue *track, *audio, *acodec, *bitrate, *rate, *mix, *drc;
 621         gint count, ii;
 622
 623         g_debug("set_audio");
 624         // Clear the audio list
 625         ghb_clear_audio_list(ud);
 626         button = GHB_WIDGET (ud->builder, "audio_add");
 627         alist = ghb_settings_get_value(settings, "audio_list");
 628
 629         count = ghb_array_len(alist);
 630         for (ii = 0; ii < count; ii++)
 631         {
 632                 audio = ghb_array_get_nth(alist, ii);
 633                 track = ghb_settings_get_value(audio, "AudioTrack");
 634                 acodec = ghb_settings_get_value(audio, "AudioEncoder");
 635                 bitrate = ghb_settings_get_value(audio, "AudioBitrate");
 636                 rate = ghb_settings_get_value(audio, "AudioSamplerate");
 637                 mix = ghb_settings_get_value(audio, "AudioMixdown");
 638                 drc = ghb_settings_get_value(audio, "AudioTrackDRCSlider");
 639                 acodec_code = ghb_lookup_combo_int("AudioEncoder", acodec);
 640
 641                 if (acodec_code != 0)
 642                 {
 643                         // Add to audio list
 644                         g_signal_emit_by_name(button, "clicked", ud);
 645                         ghb_ui_update(ud, "AudioTrack", track);
 646                         ghb_ui_update(ud, "AudioEncoder", acodec);
 647                         if (!ghb_audio_is_passthru (acodec_code))
 648                         {
 649                                 // This gets set autimatically if the codec is passthru
 650                                 ghb_ui_update(ud, "AudioBitrate", bitrate);
 651                                 ghb_ui_update(ud, "AudioSamplerate", rate);
 652                                 ghb_ui_update(ud, "AudioMixdown", mix);
 653                         }
 654                         ghb_ui_update(ud, "AudioTrackDRCSlider", drc);
 655                 }
 656         }
 657 }
 658