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