audio_dialog.cpp

网络MPEG4IP流媒体开发源代码

/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 * 
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 * 
 * The Original Code is MPEG4IP.
 * 
 * The Initial Developer of the Original Code is Cisco Systems Inc.
 * Portions created by Cisco Systems Inc. are
 * Copyright (C) Cisco Systems Inc. 2001.  All Rights Reserved.
 * 
 * Contributor(s): 
 *		Dave Mackie		[e-mail]
 *		Bill May 		[e-mail]
 */

#define __STDC_LIMIT_MACROS
#include "mp4live.h"
#include "mp4live_gui.h"
#include "audio_oss_source.h"
#include "audio_lame.h"

static GtkWidget *dialog;

static char* source_type;
static char* source_name;
static GtkWidget *source_combo;
static GtkWidget *source_entry;
static GtkWidget *source_list;
static bool source_modified;
static GtkWidget *browse_button;
static GtkWidget *input_label;
static GtkWidget *input_menu;
static GtkWidget *track_label;
static GtkWidget *track_menu;
static GtkWidget *channel_menu;
static GtkWidget *encoding_menu;
static GtkWidget *sampling_rate_menu;
static GtkWidget *bit_rate_menu;

static CAudioCapabilities* pAudioCaps;

static char* inputValues[] = {
	"cd", "line", "mic", "mix"
};
static char* inputNames[] = {
	"CD", "Line In", "Microphone", "Via Mixer"
};
static u_int8_t inputIndex;

static u_int32_t trackIndex;
static u_int32_t trackNumber;	// how many tracks total
static u_int32_t* trackValues = NULL;

static u_int8_t channelValues[] = {
	1, 2
};
static char* channelNames[] = {
	"1 - Mono", "2 - Stereo"
};
static u_int8_t channelIndex;

static char* encodingNames[] = {
  AUDIO_ENCODING_MP3,
  AUDIO_ENCODING_AAC,
};
static u_int8_t encodingIndex;

static char** samplingRateNames = NULL;
static u_int32_t* samplingRateValues = NULL;
static u_int8_t samplingRateIndex;
static u_int8_t samplingRateNumber = 0;	// how many sampling rates

// union of valid sampling rates for MP3 and AAC
static const u_int32_t samplingRateAllValues[] = {
	7350, 8000, 11025, 12000, 16000, 22050, 
	24000, 32000, 44100, 48000, 64000, 88200, 96000
};

// union of valid bit rates for MP3 and AAC
static const u_int32_t bitRateAllValues[] = {
	8000, 16000, 24000, 32000, 40000, 48000, 
	56000, 64000, 80000, 96000, 112000, 128000, 
	144000, 160000, 192000, 224000, 256000, 320000
};
static const u_int8_t bitRateAllNumber =
	sizeof(bitRateAllValues) / sizeof(bitRateAllValues[0]);

static u_int32_t bitRateValues[bitRateAllNumber];
static char* bitRateNames[bitRateAllNumber];
static u_int8_t bitRateIndex;
static u_int8_t bitRateNumber = 0; // how many bit rates

// forward function declarations
static void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps);
static void CreateBitRateMenu();
static void SetSamplingRate(u_int32_t samplingRate);

#define ENCODING_IDX_MP3 0
#define ENCODING_IDX_AAC 1

static void on_destroy_dialog (GtkWidget *widget, gpointer *data)
{
	gtk_grab_remove(dialog);
	gtk_widget_destroy(dialog);
	dialog = NULL;
} 

static bool SourceIsDevice()
{
	const char* source_name =
		gtk_entry_get_text(GTK_ENTRY(source_entry));
	return !strncmp(source_name, "/dev/", 5);
}

static void ShowSourceSpecificSettings()
{
	if (SourceIsDevice()) {
		gtk_widget_show(input_label);
		gtk_widget_show(input_menu);

		gtk_widget_hide(track_label);
		gtk_widget_hide(track_menu);
	} else {
		gtk_widget_hide(input_label);
		gtk_widget_hide(input_menu);

		gtk_widget_show(track_label);
		gtk_widget_show(track_menu);
	}
}

static void SourceOssDevice()
{
	const gchar *newSourceName =
		gtk_entry_get_text(GTK_ENTRY(source_entry));

	// don't probe the already open device!
	if (!strcmp(newSourceName, 
	  MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME))) {
		return;
	}

	// probe new device
	CAudioCapabilities* pNewAudioCaps = 
		new CAudioCapabilities(newSourceName);
	
	// check for errors
	if (!pNewAudioCaps->IsValid()) {
		ShowMessage("Change Audio Source",
			"Specified audio source can't be opened, check name");
		delete pNewAudioCaps;
		return;
	}

	if (pAudioCaps != MyConfig->m_audioCapabilities) {
		delete pAudioCaps;
	}
	pAudioCaps = pNewAudioCaps;

	// change sampling rate menu
	CreateSamplingRateMenu(pNewAudioCaps);

	// change bit rate menu
	CreateBitRateMenu();
}

static void ChangeSource()
{
	const gchar* new_source_name =
		gtk_entry_get_text(GTK_ENTRY(source_entry));

	if (!strcmp(new_source_name, source_name)) {
		source_modified = false;
		return;
	}

	free(source_name);
	source_name = stralloc(new_source_name);

	if (SourceIsDevice()) {
		source_type = AUDIO_SOURCE_OSS;
	
		SourceOssDevice();

	} else {
		if (pAudioCaps != MyConfig->m_audioCapabilities) {
			delete pAudioCaps;
		}
		pAudioCaps = NULL;

		if (IsUrl(source_name)) {
			source_type = URL_SOURCE;
		} else {
			if (access(source_name, R_OK) != 0) {
				ShowMessage("Change Audio Source",
					"Specified audio source can't be opened, check name");
			}
			source_type = FILE_SOURCE;
		}
	}

	track_menu = CreateTrackMenu(
		track_menu,
		'A',
		gtk_entry_get_text(GTK_ENTRY(source_entry)),
		&trackIndex,
		&trackNumber,
		&trackValues);

	ShowSourceSpecificSettings();

	source_modified = false;
}

static void on_source_browse_button (GtkWidget *widget, gpointer *data)
{
	FileBrowser(source_entry, GTK_SIGNAL_FUNC(ChangeSource));
}

static void on_source_entry_changed(GtkWidget *widget, gpointer *data)
{
	if (widget == source_entry) {
		source_modified = true;
	}
}

static int on_source_leave(GtkWidget *widget, gpointer *data)
{
	if (source_modified) {
		ChangeSource();
	}
	return FALSE;
}

static void on_source_list_changed(GtkWidget *widget, gpointer *data)
{
	if (widget == source_list) {
		ChangeSource();
	}
}

static void on_input_menu_activate (GtkWidget *widget, gpointer data)
{
	inputIndex = (unsigned int)data & 0xFF;
}

static void on_channel_menu_activate (GtkWidget *widget, gpointer data)
{
	channelIndex = (unsigned int)data & 0xFF;
}

static void on_encoding_menu_activate (GtkWidget *widget, gpointer data)
{
	encodingIndex = (unsigned int)data & 0xFF;

	CreateSamplingRateMenu(pAudioCaps);
	CreateBitRateMenu();
}

static void on_sampling_rate_menu_activate (GtkWidget *widget, gpointer data)
{
	samplingRateIndex = (unsigned int)data & 0xFF;

	CreateBitRateMenu();
}

static void on_bit_rate_menu_activate (GtkWidget *widget, gpointer data)
{
	bitRateIndex = (unsigned int)data & 0xFF;
}

void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps)
{
	// remember current sampling rate
	u_int32_t oldSamplingRate = 0;
	if (samplingRateValues) {
		oldSamplingRate = samplingRateValues[samplingRateIndex];
	}

	// invalidate index, will fix up below
	samplingRateIndex = 255;

	u_int8_t maxSamplingRateNumber;
	const u_int32_t* samplingRates = NULL;

	if (pNewAudioCaps) {
		maxSamplingRateNumber = pNewAudioCaps->m_numSamplingRates;
		samplingRates = &pNewAudioCaps->m_samplingRates[0];
	} else {
		maxSamplingRateNumber = 
			sizeof(samplingRateAllValues) / sizeof(u_int32_t);
		samplingRates = &samplingRateAllValues[0];
	}

	// create new menu item names and values
	char** newSamplingRateNames = 
		(char**)malloc(sizeof(char*) * maxSamplingRateNumber);
	u_int32_t* newSamplingRateValues =
		(u_int32_t*)malloc(sizeof(u_int32_t) * maxSamplingRateNumber);

	u_int8_t i;
	u_int8_t newSamplingRateNumber = 0;

	for (i = 0; i < maxSamplingRateNumber; i++) {

	  switch (encodingIndex) {
	  case ENCODING_IDX_MP3:
		// MP3 can't use all the possible sampling rates
			// skip the ones it can't handle
			// MP3 can't handle anything less than 8000
			// LAME MP3 encoder has additional lower bound at 16000
			if (samplingRates[i] < 11025 || samplingRates[i] > 48000) {
				continue;
			}
			break;
		}

		char buf[64];
		snprintf(buf, sizeof(buf), "%u", samplingRates[i]);
		newSamplingRateNames[newSamplingRateNumber] = 
			stralloc(buf);

		newSamplingRateValues[newSamplingRateNumber] = 
			samplingRates[i];

		if (oldSamplingRate == newSamplingRateValues[newSamplingRateNumber]) {
			samplingRateIndex = newSamplingRateNumber;
		}

		newSamplingRateNumber++;
	}

	if (samplingRateIndex >= newSamplingRateNumber) {
		samplingRateIndex = newSamplingRateNumber - 1; 
	}

	// (re)create the menu
	sampling_rate_menu = CreateOptionMenu(
		sampling_rate_menu,
		newSamplingRateNames, 
		newSamplingRateNumber,
		samplingRateIndex,
		GTK_SIGNAL_FUNC(on_sampling_rate_menu_activate));

	// free up old names
	for (i = 0; i < samplingRateNumber; i++) {
		free(samplingRateNames[i]);
	}
	free(samplingRateNames);
	samplingRateNames = newSamplingRateNames;
	samplingRateValues = newSamplingRateValues;
	samplingRateNumber = newSamplingRateNumber;
}

static void SetSamplingRate(u_int32_t samplingRate)
{
	u_int8_t i;
	for (i = 0; i < samplingRateNumber; i++) {
		if (samplingRate == samplingRateValues[i]) {
			samplingRateIndex = i;
			break;
		}
	}
	if (i == samplingRateNumber) {
		debug_message("invalid sampling rate %u\n", samplingRate);
	}

	gtk_option_menu_set_history(
		GTK_OPTION_MENU(sampling_rate_menu), samplingRateIndex);
}

void CreateBitRateMenu()
{
	u_int8_t i;