LinGui: continue callbacks.c reduction. move audio tab handling to separate

file.


git-svn-id: svn://svn.handbrake.fr/HandBrake/trunk@1772 b64f7644-9d1e-0410-96f1-a4d463321fa5

1 files changed, 601 insertions, 0 deletions

diff --git a/gtk/src/audiohandler.c b/gtk/src/audiohandler.c
new file mode 100644
index 000000000..e6085d304
--- /dev/null
+++ b/gtk/src/audiohandler.c
@@ -0,0 +1,601 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
+/*
+ * audiohandler.c
+ * Copyright (C) John Stebbins 2008 <stebbins@stebbins>
+ * 
+ * audiohandler.c is free software.
+ * 
+ * You may redistribute it and/or modify it under the terms of the
+ * GNU General Public License, as published by the Free Software
+ * Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <gtk/gtk.h>
+#include "hb.h"
+#include "settings.h"
+#include "hb-backend.h"
+#include "values.h"
+#include "callbacks.h"
+#include "audiohandler.h"
+
+void
+ghb_adjust_audio_rate_combos(signal_user_data_t *ud)
+{
+	gint titleindex, audioindex, acodec, mix;
+	ghb_audio_info_t ainfo;
+	GtkWidget *widget;
+	
+	g_debug("ghb_adjust_audio_rate_combos ()");
+	titleindex = ghb_settings_combo_int(ud->settings, "title");
+
+	widget = GHB_WIDGET(ud->builder, "audio_track");
+	audioindex = ghb_lookup_combo_int("audio_track", ghb_widget_value(widget));
+
+	widget = GHB_WIDGET(ud->builder, "audio_codec");
+	acodec = ghb_lookup_combo_int("audio_codec", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_mix");
+	mix = ghb_lookup_combo_int("audio_mix", ghb_widget_value(widget));
+
+	if (ghb_audio_is_passthru (acodec))
+	{
+		ghb_set_default_bitrate_opts (ud->builder, -1);
+		if (ghb_get_audio_info (&ainfo, titleindex, audioindex))
+		{
+			gint br = ainfo.bitrate / 1000;
+			// Set the values for bitrate and samplerate to the input rates
+			ghb_set_passthru_bitrate_opts (ud->builder, br);
+			ghb_ui_update(ud, "audio_bitrate", ghb_int64_value(br));
+			ghb_ui_update(ud, "audio_rate", ghb_int64_value(0));
+			ghb_ui_update(ud, "audio_mix", ghb_int64_value(0));
+		}
+		else
+		{
+			ghb_ui_update(ud, "audio_bitrate", ghb_int64_value(384));
+			ghb_ui_update(ud, "audio_rate", ghb_int64_value(0));
+			ghb_ui_update(ud, "audio_mix", ghb_int64_value(0));
+		}
+	}
+	else if (acodec == HB_ACODEC_FAAC && mix != HB_AMIXDOWN_6CH)
+	{
+		gint br;
+
+		widget = GHB_WIDGET(ud->builder, "audio_bitrate");
+		br = ghb_lookup_combo_int("audio_bitrate", ghb_widget_value(widget));
+		if (br > 160)
+			ghb_ui_update(ud, "audio_bitrate", ghb_int64_value(160));
+		ghb_set_default_bitrate_opts (ud->builder, 160);
+	}
+	else
+	{
+		ghb_set_default_bitrate_opts (ud->builder, -1);
+	}
+}
+
+void
+ghb_set_pref_audio(gint titleindex, signal_user_data_t *ud)
+{
+	gint acodec_code, mix_code, track;
+	gchar *source_lang;
+	GtkWidget *button;
+	ghb_audio_info_t ainfo;
+	gint index;
+	GHashTable *track_indicies;
+	gint *iptr;
+
+	GValue *pref_audio;
+	GValue *audio, *acodec, *bitrate, *rate, *mix, *drc;
+	gint count, ii, list_count;
+	
+	g_debug("set_pref_audio");
+	track_indicies = g_hash_table_new(g_int_hash, g_int_equal);
+	// Clear the audio list
+	ghb_clear_audio_list(ud);
+	// Find "best" audio based on audio preferences
+	button = GHB_WIDGET (ud->builder, "audio_add");
+	source_lang = ghb_settings_get_string(ud->settings, "source_audio_lang");
+
+	pref_audio = ghb_settings_get_value(ud->settings, "pref_audio_list");
+
+	list_count = 0;
+	count = ghb_array_len(pref_audio);
+	for (ii = 0; ii < count; ii++)
+	{
+		audio = ghb_array_get_nth(pref_audio, ii);
+		acodec = ghb_settings_get_value(audio, "audio_codec");
+		bitrate = ghb_settings_get_value(audio, "audio_bitrate");
+		rate = ghb_settings_get_value(audio, "audio_rate");
+		mix = ghb_settings_get_value(audio, "audio_mix");
+		drc = ghb_settings_get_value(audio, "audio_drc");
+		acodec_code = ghb_lookup_combo_int("audio_codec", acodec);
+		// If there are multiple audios using the same codec, then
+		// select sequential tracks for each.  This hash keeps track 
+		// of the last used track for each codec.
+		iptr = g_hash_table_lookup(track_indicies, &acodec_code);
+		if (iptr == NULL)
+			index = 0;
+		else
+			index = *(gint*)iptr;
+
+		track = ghb_find_audio_track(titleindex, source_lang, index);
+		// Check to see if:
+		// 1. pref codec is ac3
+		// 2. source codec is not ac3
+		// 3. next pref is enabled
+		if (ghb_get_audio_info (&ainfo, titleindex, track) && 
+			ghb_audio_is_passthru (acodec_code))
+		{
+			if (!ghb_audio_is_passthru(ainfo.codec))
+			{
+				acodec_code = ghb_get_default_acodec();
+				// If there's more audio to process, or we've already
+				// placed one in the list, then we can skip this one
+				if ((ii + 1 < count) || (list_count != 0))
+				{
+					// Skip this audio
+					acodec_code = 0;
+				}
+			}
+		}
+		if (titleindex >= 0 && track < 0)
+			acodec_code = 0;
+		if (acodec_code != 0)
+		{
+			// Add to audio list
+			g_signal_emit_by_name(button, "clicked", ud);
+			list_count++;
+			ghb_ui_update(ud, "audio_track", ghb_int64_value(track));
+			ghb_ui_update(ud, "audio_codec", acodec);
+			if (!ghb_audio_is_passthru (acodec_code))
+			{
+				// This gets set autimatically if the codec is passthru
+				ghb_ui_update(ud, "audio_bitrate", bitrate);
+				ghb_ui_update(ud, "audio_rate", rate);
+				mix_code = ghb_lookup_combo_int("audio_mix", mix);
+				mix_code = ghb_get_best_mix(
+					titleindex, track, acodec_code, mix_code);
+				ghb_ui_update(ud, "audio_mix", ghb_int64_value(mix_code));
+			}
+			ghb_ui_update(ud, "audio_drc", drc);
+			index++;
+			g_hash_table_insert(track_indicies, &acodec_code, &index);
+		}
+	}
+	g_free(source_lang);
+	g_hash_table_destroy(track_indicies);
+}
+
+static GValue*
+get_selected_asettings(signal_user_data_t *ud)
+{
+	GtkTreeView *treeview;
+	GtkTreePath *treepath;
+	GtkTreeSelection *selection;
+	GtkTreeModel *store;
+	GtkTreeIter iter;
+	gint *indices;
+	gint row;
+	GValue *asettings = NULL;
+	const GValue *audio_list;
+	
+	g_debug("get_selected_asettings ()");
+	treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
+	selection = gtk_tree_view_get_selection (treeview);
+	if (gtk_tree_selection_get_selected(selection, &store, &iter))
+	{
+		// Get the row number
+		treepath = gtk_tree_model_get_path (store, &iter);
+		indices = gtk_tree_path_get_indices (treepath);
+		row = indices[0];
+		gtk_tree_path_free(treepath);
+		// find audio settings
+		if (row < 0) return NULL;
+		audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+		if (row >= ghb_array_len(audio_list))
+			return NULL;
+		asettings = ghb_array_get_nth(audio_list, row);
+	}
+	return asettings;
+}
+
+static void
+audio_list_refresh_selected(signal_user_data_t *ud)
+{
+	GtkTreeView *treeview;
+	GtkTreePath *treepath;
+	GtkTreeSelection *selection;
+	GtkTreeModel *store;
+	GtkTreeIter iter;
+	gint *indices;
+	gint row;
+	GValue *asettings = NULL;
+	const GValue *audio_list;
+	
+	g_debug("audio_list_refresh_selected ()");
+	treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
+	selection = gtk_tree_view_get_selection (treeview);
+	if (gtk_tree_selection_get_selected(selection, &store, &iter))
+	{
+		const gchar *track, *codec, *br, *sr, *mix;
+		gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
+		gdouble s_drc;
+		// Get the row number
+		treepath = gtk_tree_model_get_path (store, &iter);
+		indices = gtk_tree_path_get_indices (treepath);
+		row = indices[0];
+		gtk_tree_path_free(treepath);
+		// find audio settings
+		if (row < 0) return;
+		audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+		if (row >= ghb_array_len(audio_list))
+			return;
+		asettings = ghb_array_get_nth(audio_list, row);
+
+		track = ghb_settings_combo_option(asettings, "audio_track");
+		codec = ghb_settings_combo_option(asettings, "audio_codec");
+		br = ghb_settings_combo_option(asettings, "audio_bitrate");
+		sr = ghb_settings_combo_option(asettings, "audio_rate");
+		mix = ghb_settings_combo_option(asettings, "audio_mix");
+		drc = ghb_settings_get_string(asettings, "audio_drc");
+
+		s_track = ghb_settings_get_string(asettings, "audio_track");
+		s_codec = ghb_settings_get_string(asettings, "audio_codec");
+		s_br = ghb_settings_get_string(asettings, "audio_bitrate");
+		s_sr = ghb_settings_get_string(asettings, "audio_rate");
+		s_mix = ghb_settings_get_string(asettings, "audio_mix");
+		s_drc = ghb_settings_get_double(asettings, "audio_drc");
+
+		gtk_list_store_set(GTK_LIST_STORE(store), &iter, 
+			// These are displayed in list
+			0, track,
+			1, codec,
+			2, br,
+			3, sr,
+			4, mix,
+			// These are used to set combo values when a list item is selected
+			5, drc,
+			6, s_track,
+			7, s_codec,
+			8, s_br,
+			9, s_sr,
+			10, s_mix,
+			11, s_drc,
+			-1);
+		g_free(drc);
+		g_free(s_track);
+		g_free(s_codec);
+		g_free(s_br);
+		g_free(s_sr);
+		g_free(s_mix);
+	}
+}
+
+void
+audio_codec_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	static gint prev_acodec = 0;
+	gint acodec_code, mix_code;
+	GValue *asettings;
+	
+	g_debug("audio_codec_changed_cb ()");
+	acodec_code = ghb_lookup_combo_int("audio_codec", ghb_widget_value(widget));
+	if (ghb_audio_is_passthru (prev_acodec) && 
+		!ghb_audio_is_passthru (acodec_code))
+	{
+		// Transition from passthru to not, put some audio settings back to 
+		// pref settings
+		gint titleindex;
+		gint track;
+
+		titleindex = ghb_settings_combo_int(ud->settings, "title");
+		track = ghb_settings_combo_int(ud->settings, "audio_track");
+
+		ghb_ui_update(ud, "audio_bitrate", ghb_string_value("160"));
+		ghb_ui_update(ud, "audio_rate", ghb_string_value("source"));
+		mix_code = ghb_lookup_combo_int("audio_mix", ghb_string_value("dpl2"));
+		mix_code = ghb_get_best_mix( titleindex, track, acodec_code, mix_code);
+		ghb_ui_update(ud, "audio_mix", ghb_int64_value(mix_code));
+		ghb_ui_update(ud, "audio_drc", ghb_double_value(1.0));
+	}
+	ghb_adjust_audio_rate_combos(ud);
+	ghb_grey_combo_options (ud->builder);
+	ghb_check_dependency(ud, widget);
+	prev_acodec = acodec_code;
+	asettings = get_selected_asettings(ud);
+	if (asettings != NULL)
+	{
+		ghb_widget_to_setting(asettings, widget);
+		audio_list_refresh_selected(ud);
+	}
+
+	const GValue *audio_list;
+	audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+	if (ghb_ac3_in_audio_list (audio_list))
+	{
+		gchar *container;
+
+		container = ghb_settings_get_string(ud->settings, "container");
+		if (strcmp(container, "mp4") == 0)
+		{
+			ghb_ui_update(ud, "container", ghb_string_value("m4v"));
+		}
+		g_free(container);
+	}
+}
+
+void
+audio_track_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	GValue *asettings;
+
+	g_debug("audio_track_changed_cb ()");
+	ghb_adjust_audio_rate_combos(ud);
+	ghb_check_dependency(ud, widget);
+	ghb_grey_combo_options(ud->builder);
+	asettings = get_selected_asettings(ud);
+	if (asettings != NULL)
+	{
+		const gchar *track;
+
+		ghb_widget_to_setting(asettings, widget);
+		audio_list_refresh_selected(ud);
+		track = ghb_settings_combo_option(asettings, "audio_track");
+		ghb_settings_set_string(asettings, "audio_track_long", track);
+	}
+}
+
+void
+audio_mix_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	GValue *asettings;
+
+	g_debug("audio_widget_changed_cb ()");
+	ghb_adjust_audio_rate_combos(ud);
+	ghb_check_dependency(ud, widget);
+	asettings = get_selected_asettings(ud);
+	if (asettings != NULL)
+	{
+		ghb_widget_to_setting(asettings, widget);
+		audio_list_refresh_selected(ud);
+	}
+}
+
+void
+audio_widget_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	GValue *asettings;
+
+	g_debug("audio_widget_changed_cb ()");
+	ghb_check_dependency(ud, widget);
+	asettings = get_selected_asettings(ud);
+	if (asettings != NULL)
+	{
+		ghb_widget_to_setting(asettings, widget);
+		audio_list_refresh_selected(ud);
+	}
+}
+
+// subtitles differ from other settings in that
+// the selection is updated automaitcally when the title
+// changes.  I don't want the preset selection changed as
+// would happen for regular settings.
+void
+subtitle_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	const gchar *name = gtk_widget_get_name(widget);
+	g_debug("subtitle_changed_cb () %s", name);
+	ghb_widget_to_setting(ud->settings, widget);
+	ghb_check_dependency(ud, widget);
+}
+
+void
+ghb_clear_audio_list(signal_user_data_t *ud)
+{
+	GtkTreeView *treeview;
+	GtkListStore *store;
+	GValue *audio_list;
+	
+	g_debug("clear_audio_list ()");
+	audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+	if (audio_list == NULL)
+	{
+		audio_list = ghb_array_value_new(8);
+		ghb_settings_set_value(ud->settings, "audio_list", audio_list);
+	}
+	else
+		ghb_array_value_reset(audio_list, 8);
+	treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
+	store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
+	gtk_list_store_clear (store);
+}
+
+static void
+add_to_audio_list(signal_user_data_t *ud, GValue *settings)
+{
+	GtkTreeView *treeview;
+	GtkTreeIter iter;
+	GtkListStore *store;
+	GtkTreeSelection *selection;
+	const gchar *track, *codec, *br, *sr, *mix;
+	gchar *drc, *s_track, *s_codec, *s_br, *s_sr, *s_mix;
+	gdouble s_drc;
+	
+	g_debug("add_to_audio_list ()");
+	treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
+	selection = gtk_tree_view_get_selection (treeview);
+	store = GTK_LIST_STORE(gtk_tree_view_get_model(treeview));
+
+	track = ghb_settings_combo_option(settings, "audio_track");
+	codec = ghb_settings_combo_option(settings, "audio_codec");
+	br = ghb_settings_combo_option(settings, "audio_bitrate");
+	sr = ghb_settings_combo_option(settings, "audio_rate");
+	mix = ghb_settings_combo_option(settings, "audio_mix");
+	drc = ghb_settings_get_string(settings, "audio_drc");
+
+	s_track = ghb_settings_get_string(settings, "audio_track");
+	s_codec = ghb_settings_get_string(settings, "audio_codec");
+	s_br = ghb_settings_get_string(settings, "audio_bitrate");
+	s_sr = ghb_settings_get_string(settings, "audio_rate");
+	s_mix = ghb_settings_get_string(settings, "audio_mix");
+	s_drc = ghb_settings_get_double(settings, "audio_drc");
+
+	gtk_list_store_append(store, &iter);
+	gtk_list_store_set(store, &iter, 
+		// These are displayed in list
+		0, track,
+		1, codec,
+		2, br,
+		3, sr,
+		4, mix,
+		// These are used to set combo box values when a list item is selected
+		5, drc,
+		6, s_track,
+		7, s_codec,
+		8, s_br,
+		9, s_sr,
+		10, s_mix,
+		11, s_drc,
+		-1);
+	gtk_tree_selection_select_iter(selection, &iter);
+	g_free(drc);
+	g_free(s_track);
+	g_free(s_codec);
+	g_free(s_br);
+	g_free(s_sr);
+	g_free(s_mix);
+}
+
+void
+audio_list_selection_changed_cb(GtkTreeSelection *selection, signal_user_data_t *ud)
+{
+	GtkTreeModel *store;
+	GtkTreeIter iter;
+	GtkWidget *widget;
+	
+	g_debug("audio_list_selection_changed_cb ()");
+	if (gtk_tree_selection_get_selected(selection, &store, &iter))
+	{
+		const gchar *track, *codec, *bitrate, *sample_rate, *mix;
+		gdouble drc;
+
+		gtk_tree_model_get(store, &iter,
+						   6, &track,
+						   7, &codec,
+						   8, &bitrate,
+						   9, &sample_rate,
+						   10, &mix,
+						   11, &drc,
+						   -1);
+		ghb_ui_update(ud, "audio_track", ghb_string_value(track));
+		ghb_ui_update(ud, "audio_codec", ghb_string_value(codec));
+		ghb_ui_update(ud, "audio_bitrate", ghb_string_value(bitrate));
+		ghb_ui_update(ud, "audio_rate", ghb_string_value(sample_rate));
+		ghb_ui_update(ud, "audio_mix", ghb_string_value(mix));
+		ghb_ui_update(ud, "audio_drc", ghb_double_value(drc));
+		widget = GHB_WIDGET (ud->builder, "audio_remove");
+		gtk_widget_set_sensitive(widget, TRUE);
+		//widget = GHB_WIDGET (ud->builder, "audio_update");
+		//gtk_widget_set_sensitive(widget, TRUE);
+	}
+	else
+	{
+		widget = GHB_WIDGET (ud->builder, "audio_remove");
+		gtk_widget_set_sensitive(widget, FALSE);
+		//widget = GHB_WIDGET (ud->builder, "audio_update");
+		//gtk_widget_set_sensitive(widget, FALSE);
+	}
+}
+
+void
+audio_add_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
+{
+	// Add the current audio settings to the list.
+	GValue *asettings;
+	GtkWidget *widget;
+	gint count;
+	GValue *audio_list;
+	const gchar *track;
+	
+	g_debug("audio_add_clicked_cb ()");
+	asettings = ghb_dict_value_new();
+	// Only allow up to 8 audio entries
+	widget = GHB_WIDGET(ud->builder, "audio_track");
+	ghb_settings_take_value(asettings, "audio_track", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_codec");
+	ghb_settings_take_value(asettings, "audio_codec", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_bitrate");
+	ghb_settings_take_value(asettings, "audio_bitrate", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_rate");
+	ghb_settings_take_value(asettings, "audio_rate", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_mix");
+	ghb_settings_take_value(asettings, "audio_mix", ghb_widget_value(widget));
+	widget = GHB_WIDGET(ud->builder, "audio_drc");
+	ghb_settings_take_value(asettings, "audio_drc", ghb_widget_value(widget));
+	track = ghb_settings_combo_option(asettings, "audio_track");
+	ghb_settings_set_string(asettings, "audio_track_long", track);
+
+	audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+	if (audio_list == NULL)
+	{
+		audio_list = ghb_array_value_new(8);
+		ghb_settings_set_value(ud->settings, "audio_list", audio_list);
+	}
+	ghb_array_append(audio_list, asettings);
+	add_to_audio_list(ud, asettings);
+	count = ghb_array_len(audio_list);
+	if (count >= 8)
+	{
+		gtk_widget_set_sensitive(xwidget, FALSE);
+	}
+}
+
+void
+audio_remove_clicked_cb(GtkWidget *widget, signal_user_data_t *ud)
+{
+	GtkTreeView *treeview;
+	GtkTreePath *treepath;
+	GtkTreeSelection *selection;
+	GtkTreeModel *store;
+	GtkTreeIter iter, nextIter;
+	gint *indices;
+	gint row;
+	GValue *audio_list;
+
+	g_debug("audio_remove_clicked_cb ()");
+	treeview = GTK_TREE_VIEW(GHB_WIDGET(ud->builder, "audio_list"));
+	selection = gtk_tree_view_get_selection (treeview);
+	if (gtk_tree_selection_get_selected(selection, &store, &iter))
+	{
+		nextIter = iter;
+		if (!gtk_tree_model_iter_next(store, &nextIter))
+		{
+			nextIter = iter;
+			if (gtk_tree_model_get_iter_first(store, &nextIter))
+			{
+				gtk_tree_selection_select_iter (selection, &nextIter);
+			}
+		}
+		else
+		{
+			gtk_tree_selection_select_iter (selection, &nextIter);
+		}
+		// Get the row number
+		treepath = gtk_tree_model_get_path (store, &iter);
+		indices = gtk_tree_path_get_indices (treepath);
+		row = indices[0];
+		gtk_tree_path_free(treepath);
+		// Remove the selected item
+		gtk_list_store_remove (GTK_LIST_STORE(store), &iter);
+		// remove from audio settings list
+		if (row < 0) return;
+		widget = GHB_WIDGET (ud->builder, "audio_add");
+		gtk_widget_set_sensitive(widget, TRUE);
+		audio_list = ghb_settings_get_value(ud->settings, "audio_list");
+		if (row >= ghb_array_len(audio_list))
+			return;
+		GValue *old = ghb_array_get_nth(audio_list, row);
+		ghb_value_free(old);
+		ghb_array_remove(audio_list, row);
+	}
+}
+