WebSVN – Games.Carmageddon – Blame – //src/S3/audio.c

Rev	Author	Line No.	Line
1	pmbaty	1	#include "audio.h"
		2	#include "resource.h"
		3
		4	#include "3d.h"
		5	#include "backends/backend.h"
		6	#include "harness/config.h"
		7	#include "harness/os.h"
		8	#include "harness/trace.h"
		9	#include "s3/s3.h"
		10	#include "s3cda.h"
		11	#include "s3music.h"
		12	#include "s3sound.h"
		13	#include <ctype.h>
		14	#include <errno.h>
		15	#include <stddef.h>
		16	#include <stdio.h>
		17	#include <stdlib.h>
		18	#include <string.h>
		19
		20	extern int PDGetTotalTime(void);
		21
		22	int gS3_enabled;
		23	int gS3_noutlets;
		24	int gS3_nsound_sources;
		25	int gS3_next_outlet_id;
		26	tS3_outlet* gS3_outlets;
		27	tS3_sound_source* gS3_sound_sources;
		28	tS3_descriptor* gS3_descriptors;
		29	tS3_descriptor* gS3_root_descriptor;
		30	int gS3_opened_output_devices;
		31	int gS3_last_service_time;
		32	int gS3_service_time_delta;
		33	tS3_channel* gS3_unbound_channels;
		34	tS3_channel* gS3_last_unbound_channel;
		35	int gS3_last_error;
		36	int gS3_default_pitch;
		37	tS3_hardware_info gS3_hardware_info;
		38	char* gS3_soundbank_buffer;
		39	int gS3_soundbank_buffer_len;
		40	int gS3_inside_cockpit;
		41
		42	tS3_channel gS3_channel_template;
		43	int gS3_tag_seed;
		44
		45	char gS3_directory_separator[4];
		46	char gS3_directory_name[8];
		47	int gS3_have_current_dir;
		48	char gS3_current_dir[260];
		49
		50	int dword_5216C0;
		51
		52	int S3Init(char* pPath, int pLow_memory_mode) {
		53	tS3_descriptor* root_descriptor;
		54
		55	gS3_noutlets = 0;
		56	gS3_nsound_sources = 0;
		57	gS3_next_outlet_id = 0;
		58	gS3_outlets = NULL;
		59	gS3_sound_sources = NULL;
		60	gS3_descriptors = NULL;
		61	gS3_root_descriptor = NULL;
		62
		63	S3Disable();
		64	S3DisableMIDI();
		65	S3DisableCDA();
		66	gS3_sample_filter_funcs_registered = 0;
		67	gS3_sample_filter_func = NULL;
		68	gS3_sample_filter_disable_func = NULL;
		69	if (S3OpenOutputDevices() == 0) {
		70	return 1;
		71	}
		72	gS3_opened_output_devices = 1;
		73	root_descriptor = S3MemAllocate(sizeof(tS3_descriptor), kMem_S3_sentinel);
		74	if (!root_descriptor) {
		75	return 3;
		76	}
		77	memset(root_descriptor, 0, sizeof(tS3_descriptor));
		78	root_descriptor->id = 2495081;
		79	gS3_root_descriptor = root_descriptor;
		80	gS3_descriptors = root_descriptor;
		81	if (S3LoadSoundbank(pPath, pLow_memory_mode)) {
		82	return 5;
		83	}
		84	gS3_last_service_time = PDGetTotalTime();
		85	gS3_unbound_channels = 0;
		86	gS3_last_unbound_channel = 0;
		87	return 0;
		88	}
		89
		90	void S3Shutdown(void) {
		91	tS3_outlet* outlet; // [esp+10h] [ebp-10h]
		92	tS3_outlet* next_outlet; // [esp+14h] [ebp-Ch]
		93	tS3_descriptor* next_descriptor; // [esp+18h] [ebp-8h]
		94	tS3_descriptor* descriptor; // [esp+1Ch] [ebp-4h]
		95
		96	S3StopAllOutletSounds();
		97	S3DisableMIDI();
		98	S3DisableCDA();
		99	if (gS3_enabled) {
		100	S3Disable();
		101	for (descriptor = gS3_descriptors; descriptor != NULL; descriptor = next_descriptor) {
		102	next_descriptor = descriptor->next;
		103	S3ReleaseSound(descriptor->id);
		104	S3MemFree(descriptor);
		105	}
		106	for (outlet = gS3_outlets; outlet != NULL; outlet = next_outlet) {
		107	next_outlet = outlet->next;
		108	S3ReleaseOutlet(outlet);
		109	}
		110	S3ReleaseUnboundChannels();
		111	}
		112	if (gS3_opened_output_devices) {
		113	S3CloseDevices();
		114	}
		115	}
		116
		117	void S3Enable(void) {
		118	gS3_enabled = 1;
		119	}
		120
		121	void S3Disable(void) {
		122	S3StopAllOutletSounds();
		123	gS3_enabled = 0;
		124	}
		125
		126	int S3OpenOutputDevices(void) {
		127
		128	// strcpy(gS3_directory_separator, "\\");
		129	strcpy(gS3_directory_separator, "/");
		130	strcpy(gS3_directory_name, "SOUND");
		131	memset(&gS3_hardware_info, 0, sizeof(gS3_hardware_info));
		132	if (S3OpenSampleDevice() == 0) {
		133	return 0;
		134	}
		135	S3OpenCDADevice();
		136	gS3_hardware_info.timer_installed = 0;
		137	gS3_hardware_info.device_installed = 1;
		138	gS3_hardware_info.independent_pitch = 0;
		139	return 1;
		140	}
		141
		142	int S3OpenSampleDevice(void) {
		143
		144	// if (DirectSoundCreate(0, &gS3_direct_sound_ptr, 0)) {
		145	// return 0;
		146	// }
		147	// if (gS3_direct_sound_ptr->lpVtbl->SetCooperativeLevel(gS3_direct_sound_ptr, gWin32_hwnd, 3)) {
		148	// return 0;
		149	// }
		150
		151	if (AudioBackend_Init() != eAB_success) {
		152	return 0;
		153	}
		154	S3Enable();
		155	return 1;
		156	}
		157
		158	// returns 0 on failure, 1 on success
		159	int S3OpenCDADevice(void) {
		160	// gS3_cda_device.lpstrDeviceType = (LPCSTR)516;
		161	// if (mciSendCommandA(0, 0x803u, 0x3000u, (DWORD_PTR)&gS3_cda_device)
		162	// && mciSendCommandA(0, 0x803u, 0x3100u, (DWORD_PTR)&gS3_cda_device)) {
		163	// return 0;
		164	// }
		165	// stru_550560.dwTimeFormat = 10; // MCI_FORMAT_TMSF
		166	// mciSendCommandA(gS3_cda_device.wDeviceID, 0x80Du, 0x400u, (DWORD_PTR)&stru_550560);
		167
		168	if (AudioBackend_InitCDA() != eAB_success) {
		169	return 0;
		170	}
		171
		172	S3EnableCDA();
		173	return 1;
		174	}
		175
		176	void S3CloseDevices(void) {
		177	if (gS3_hardware_info.device_installed) {
		178	// gS3_direct_sound_ptr->lpVtbl->Release(gS3_direct_sound_ptr);
		179	// gS3_direct_sound_ptr = NULL;
		180
		181	AudioBackend_UnInit();
		182	}
		183	// if (gS3_cda_device.wDeviceID) {
		184	// mciSendCommandA(gS3_cda_device.wDeviceID, 0x804u, 0, 0); // MCI_CLOSE
		185	// }
		186
		187	AudioBackend_UnInitCDA();
		188	}
		189
		190	int S3ReleaseSound(tS3_sound_id id) {
		191	tS3_channel* c; // [esp+Ch] [ebp-10h]
		192	tS3_outlet* o; // [esp+10h] [ebp-Ch]
		193	tS3_descriptor* desc; // [esp+14h] [ebp-8h]
		194	tS3_sample* sample_ptr;
		195
		196	if (!gS3_enabled) {
		197	return 0;
		198	}
		199
		200	desc = S3GetDescriptorByID(id);
		201	if (desc == NULL) {
		202	return eS3_error_bad_id;
		203	}
		204	if (desc->type == eS3_ST_midi) {
		205	for (o = gS3_outlets; o; o = o->next) {
		206	for (c = o->channel_list; c; c = c->next) {
		207	if (c->descriptor && c->descriptor->id == id) {
		208	S3ReleaseMIDI(c->tag);
		209	}
		210	}
		211	}
		212	} else if (desc->type == eS3_ST_sample) {
		213	sample_ptr = (tS3_sample*)desc->sound_data;
		214	if (sample_ptr == NULL) {
		215	return 0;
		216	}
		217	S3MemFree(sample_ptr->freeptr);
		218	S3MemFree(sample_ptr);
		219	desc->sound_data = NULL;
		220	}
		221	return 0;
		222	}
		223
		224	int S3LoadSoundbank(const char* pSoundbank_filename, int pLow_memory_mode) {
		225	char soundbank_filename[256]; // [esp+Ch] [ebp-218h] BYREF
		226	void* buffer; // [esp+10Ch] [ebp-118h]
		227	tS3_soundbank_read_ctx read_ctx; // [esp+110h] [ebp-114h] BYREF
		228	char* cur_dir; // [esp+120h] [ebp-104h]
		229	char dir_name[256]; // [esp+124h] [ebp-100h] BYREF
		230
		231	if (gS3_enabled) {
		232	dir_name[0] = 0;
		233	soundbank_filename[0] = 0;
		234	cur_dir = S3GetCurrentDir();
		235	strcpy(dir_name, cur_dir);
		236	strcat(dir_name, gS3_directory_separator);
		237	strcat(dir_name, "DATA");
		238	strcat(dir_name, gS3_directory_separator);
		239	strcat(dir_name, gS3_directory_name);
		240	strcat(dir_name, gS3_directory_separator);
		241	strcpy(soundbank_filename, pSoundbank_filename);
		242	buffer = S3LoadSoundBankFile(soundbank_filename);
		243	if (!buffer) {
		244	return gS3_last_error;
		245	}
		246	read_ctx.data = (char*)buffer;
		247	read_ctx.data_len = gS3_soundbank_buffer_len;
		248	read_ctx.nlines = 0;
		249	S3SoundBankReaderSkipWhitespace(&read_ctx);
		250	while (S3SoundBankReadEntry(&read_ctx, dir_name, pLow_memory_mode)) {
		251	;
		252	}
		253	S3MemFree(buffer);
		254	}
		255	return 0;
		256	}
		257
		258	char* S3LoadSoundBankFile(char* pThe_path) {
		259	size_t bytes_read;
		260	// int fd; // [esp+Ch] [ebp-2Ch]
		261	char* buffer;
		262	// struct _stat stat_result;
		263
		264	FILE* fd;
		265	size_t file_size;
		266
		267	// fd = _open(pThe_path, 0x8000);
		268	fd = OS_fopen(pThe_path, "rb");
		269	if (!fd) {
		270	gS3_last_error = eS3_error_readfile;
		271	return 0;
		272	}
		273
		274	// if (_fstat(fd, &stat_result)) {
		275	// gS3_last_error = eS3_error_readfile;
		276	// return 0;
		277	// }
		278
		279	if (fseek(fd, 0, SEEK_END) != 0) {
		280	gS3_last_error = eS3_error_readfile;
		281	return 0;
		282	}
		283	file_size = ftell(fd);
		284	fseek(fd, 0, SEEK_SET);
		285
		286	buffer = S3MemAllocate(file_size + 1, kMem_S3_sample);
		287	if (buffer == NULL) {
		288	fclose(fd);
		289	gS3_last_error = eS3_error_memory;
		290	return 0;
		291	}
		292	buffer[file_size] = 0;
		293	bytes_read = fread(buffer, 1, file_size, fd);
		294	if (bytes_read == file_size) {
		295	gS3_soundbank_buffer = buffer;
		296	gS3_soundbank_buffer_len = file_size;
		297	fclose(fd);
		298	return buffer;
		299	}
		300	gS3_last_error = eS3_error_readfile;
		301	return 0;
		302	}
		303
		304	void S3SoundBankReaderNextLine(tS3_soundbank_read_ctx* ctx) {
		305	S3SoundBankReaderSkipToNewline(ctx);
		306	S3SoundBankReaderSkipWhitespace(ctx);
		307	}
		308
		309	void S3SoundBankReaderSkipWhitespace(tS3_soundbank_read_ctx* ctx) {
		310	while (ctx->data_len) {
		311	if (isalnum(ctx->data) \|\| ctx->data == '-') {
		312	break;
		313	}
		314	S3SoundBankReaderSkipToNewline(ctx);
		315	}
		316	}
		317
		318	void S3SoundBankReaderSkipToNewline(tS3_soundbank_read_ctx* ctx) {
		319	char* newline_ptr; // [esp+Ch] [ebp-4h]
		320
		321	newline_ptr = memchr(ctx->data, '\n', ctx->data_len);
		322	if (newline_ptr) {
		323	S3SoundBankReaderAdvance(ctx, newline_ptr + 1 - ctx->data);
		324	ctx->nlines++;
		325	} else {
		326	ctx->data_len = 0;
		327	}
		328	}
		329
		330	void S3SoundBankReaderAdvance(tS3_soundbank_read_ctx* buffer, int bytes_read) {
		331	buffer->data += bytes_read;
		332	buffer->data_len -= bytes_read;
		333	}
		334
		335	int S3SoundBankReadEntry(tS3_soundbank_read_ctx* ctx, char* dir_name, int low_memory_mode) {
		336	int nmemory_proxies; // [esp+Ch] [ebp-24h] BYREF
		337	int i; // [esp+10h] [ebp-20h]
		338	int proxy_id; // [esp+14h] [ebp-1Ch] BYREF
		339	tS3_descriptor* desc; // [esp+18h] [ebp-18h]
		340	double tmp1; // [esp+1Ch] [ebp-14h] BYREF
		341	double tmp2; // [esp+24h] [ebp-Ch] BYREF
		342	int char_count; // [esp+2Ch] [ebp-4h] BYREF
		343	char cda_dir_name[4];
		344
		345	desc = S3CreateDescriptor();
		346	if (!desc) {
		347	return gS3_last_error;
		348	}
		349	if (sscanf(ctx->data, "%i%n", &desc->id, &char_count) != 1) {
		350	return 0;
		351	}
		352	S3SoundBankReaderAdvance(ctx, char_count);
		353	S3SoundBankReaderNextLine(ctx);
		354	if (sscanf(ctx->data, "%i,%i%n", &desc->type, &desc->flags, &char_count) != 2) {
		355	return 0;
		356	}
		357	S3SoundBankReaderAdvance(ctx, char_count);
		358	S3SoundBankReaderNextLine(ctx);
		359	if (desc->type == eS3_ST_cda) {
		360	dir_name = cda_dir_name;
		361	cda_dir_name[0] = '\0';
		362	}
		363	if (!S3SoundBankReaderReadFilename(&desc->filename, ctx, dir_name)) {
		364	return 0;
		365	}
		366	S3SoundBankReaderNextLine(ctx);
		367	if (sscanf(ctx->data, "%i%n", (int*)&desc->priority, &char_count) != 1) {
		368	return 0;
		369	}
		370	S3SoundBankReaderAdvance(ctx, char_count);
		371	S3SoundBankReaderNextLine(ctx);
		372	if (sscanf(ctx->data, "%i%n", &desc->repeats, &char_count) != 1) {
		373	return 0;
		374	}
		375	S3SoundBankReaderAdvance(ctx, char_count);
		376	S3SoundBankReaderNextLine(ctx);
		377	if (sscanf(ctx->data, "%i,%i%n", &desc->min_volume, &desc->max_volume, &char_count) != 2) {
		378	return 0;
		379	}
		380	S3SoundBankReaderAdvance(ctx, char_count);
		381	S3SoundBankReaderNextLine(ctx);
		382	if (sscanf(ctx->data, "%lf,%lf%n", &tmp1, &tmp2, &char_count) != 2) {
		383	return 0;
		384	}
		385	S3SoundBankReaderAdvance(ctx, char_count);
		386	S3SoundBankReaderNextLine(ctx);
		387	if (tmp1 == 0.0f) {
		388	tmp1 = 1.0f;
		389	}
		390	if (tmp2 == 0.0f) {
		391	tmp2 = 1.0f;
		392	}
		393	desc->min_pitch = ldexpf(tmp1, 16);
		394	desc->max_pitch = ldexpf(tmp2, 16);
		395	if (sscanf(ctx->data, "%lf,%lf%n", &tmp1, &tmp2, &char_count) != 2) {
		396	return 0;
		397	}
		398	S3SoundBankReaderAdvance(ctx, char_count);
		399	S3SoundBankReaderNextLine(ctx);
		400	if (tmp1 == 0.0) {
		401	tmp1 = 1.0;
		402	}
		403	if (tmp2 == 0.0) {
		404	tmp2 = 1.0;
		405	}
		406	desc->min_speed = ldexpf(tmp1, 16);
		407	desc->max_speed = ldexpf(tmp2, 16);
		408	if (sscanf(ctx->data, "%i%n", &desc->special_fx, &char_count) != 1) {
		409	return 0;
		410	}
		411	S3SoundBankReaderAdvance(ctx, char_count);
		412	S3SoundBankReaderNextLine(ctx);
		413	if (sscanf(ctx->data, "%d%n", &nmemory_proxies, &char_count) != 1) {
		414	return 0;
		415	}
		416	S3SoundBankReaderAdvance(ctx, char_count);
		417	S3SoundBankReaderNextLine(ctx);
		418	desc->memory_proxy = -1;
		419	for (i = 0; i < nmemory_proxies; i++) {
		420	if (sscanf(ctx->data, "%d%n", &proxy_id, &char_count) != 1) {
		421	return 0;
		422	}
		423	if (low_memory_mode == i + 1) {
		424	desc->memory_proxy = proxy_id;
		425	}
		426	S3SoundBankReaderAdvance(ctx, char_count);
		427	S3SoundBankReaderNextLine(ctx);
		428	}
		429	if ((desc->flags & 1) != 0 && desc->memory_proxy == -1) {
		430	if (desc->type == eS3_ST_midi) {
		431	desc->sound_data = NULL;
		432	} else if (S3LoadSample(desc->id) != 0) {
		433	printf("\nSound bank file: couldn't load '%s'\n", desc->filename);
		434	ctx->data_len = 1;
		435	return 0;
		436	}
		437	}
		438	return 1;
		439	}
		440
		441	tS3_descriptor* S3CreateDescriptor(void) {
		442	tS3_descriptor* root;
		443	tS3_descriptor* d;
		444
		445	d = S3MemAllocate(sizeof(tS3_descriptor), kMem_S3_descriptor);
		446	if (!d) {
		447	gS3_last_error = eS3_error_memory;
		448	return NULL;
		449	}
		450	memset(d, 0, sizeof(tS3_descriptor));
		451	root = gS3_root_descriptor;
		452	gS3_root_descriptor->next = d;
		453	d->prev = root;
		454	gS3_root_descriptor = d;
		455	return d;
		456	}
		457
		458	int S3SoundBankReaderReadFilename(char** filename, tS3_soundbank_read_ctx* ctx, const char* dir_name) {
		459	char* data_start; // [esp+10h] [ebp-Ch]
		460	unsigned int bytes_read; // [esp+14h] [ebp-8h]
		461	unsigned int dir_name_len; // [esp+18h] [ebp-4h]
		462
		463	data_start = ctx->data;
		464	dir_name_len = strlen(dir_name);
		465	while (ctx->data_len) {
		466	if (isspace(*ctx->data)) {
		467	break;
		468	}
		469	S3SoundBankReaderAdvance(ctx, 1);
		470	}
		471	bytes_read = ctx->data - data_start;
		472	if (!bytes_read) {
		473	return 0;
		474	}
		475	*filename = S3MemAllocate(bytes_read + dir_name_len + 1, kMem_S3_scan_name);
		476	if (!*filename) {
		477	return 0;
		478	}
		479	strcpy(*filename, dir_name);
		480	memcpy(&(*filename)[dir_name_len], data_start, bytes_read);
		481	(*filename)[bytes_read + dir_name_len] = '\0';
		482	return 1;
		483	}
		484
		485	tS3_outlet* S3CreateOutlet(int unk1, int pChannel_count) {
		486	tS3_outlet* o;
		487	int nchannels;
		488	tS3_outlet* outlet;
		489	int channels_remaining;
		490
		491	// nchannels = (int)operator new(unk1, (void*)pChannel_count);
		492	nchannels = pChannel_count;
		493
		494	if (nchannels == 0) {
		495	gS3_last_error = eS3_error_channel_alloc;
		496	return NULL;
		497	}
		498	outlet = S3MemAllocate(sizeof(tS3_outlet), kMem_S3_outlet);
		499	if (outlet == NULL) {
		500	gS3_last_error = eS3_error_memory;
		501	return 0;
		502	}
		503	memset(outlet, 0, sizeof(tS3_outlet));
		504	channels_remaining = S3CreateOutletChannels(outlet, nchannels);
		505	if (channels_remaining == nchannels) {
		506	S3MemFree(outlet);
		507	return NULL;
		508	}
		509	o = gS3_outlets;
		510	if (gS3_outlets) {
		511	while (o->next) {
		512	o = o->next;
		513	}
		514	o->next = outlet;
		515	outlet->prev = o;
		516	} else {
		517	gS3_outlets = outlet;
		518	}
		519	outlet->max_channels = nchannels - channels_remaining;
		520	outlet->id = gS3_next_outlet_id;
		521	gS3_next_outlet_id++;
		522	outlet->independent_pitch = gS3_hardware_info.independent_pitch;
		523	gS3_noutlets++;
		524	return outlet;
		525	}
		526
		527	int S3CreateOutletChannels(tS3_outlet* outlet, int pChannel_count) {
		528	tS3_channel* chan; // [esp+Ch] [ebp-8h]
		529	tS3_channel* last_chan; // [esp+10h] [ebp-4h]
		530
		531	last_chan = NULL;
		532	while (pChannel_count) {
		533	chan = (tS3_channel*)S3MemAllocate(sizeof(tS3_channel), kMem_S3_channel);
		534	if (!chan) {
		535	return pChannel_count;
		536	}
		537	memset(chan, 0, sizeof(tS3_channel));
		538	chan->owner_outlet = outlet;
		539
		540	if (S3CreateTypeStructs(chan) == 0) {
		541	S3MemFree(chan);
		542	return pChannel_count;
		543	}
		544	chan->volume_multiplier = 1.0f;
		545	if (last_chan) {
		546	last_chan->next = chan;
		547	} else {
		548	outlet->channel_list = chan;
		549	}
		550	last_chan = chan;
		551	pChannel_count--;
		552	}
		553	return 0;
		554	}
		555
		556	void S3ReleaseOutlet(tS3_outlet* outlet) {
		557	tS3_outlet* next;
		558	tS3_outlet* prev;
		559
		560	if (outlet) {
		561	S3UnbindChannels(outlet);
		562	prev = outlet->prev;
		563	next = outlet->next;
		564	if (prev != NULL) {
		565	prev->next = next;
		566	} else {
		567	gS3_outlets = outlet->next;
		568	}
		569	if (next != NULL) {
		570	next->prev = prev;
		571	}
		572	if (gS3_noutlets) {
		573	gS3_noutlets--;
		574	if (gS3_noutlets == 0) {
		575	gS3_outlets = NULL;
		576	}
		577	}
		578	S3MemFree(outlet);
		579	}
		580	}
		581
		582	int S3UnbindChannels(tS3_outlet* outlet) {
		583	tS3_channel* chan;
		584	tS3_channel* next;
		585
		586	for (chan = outlet->channel_list; chan; chan = next) {
		587	next = chan->next;
		588	S3ReleaseTypeStructs(chan);
		589	if (gS3_unbound_channels) {
		590	gS3_last_unbound_channel->next = chan;
		591	} else {
		592	gS3_unbound_channels = chan;
		593	}
		594	gS3_last_unbound_channel = chan;
		595	memset(chan, 0, sizeof(tS3_channel));
		596	}
		597	outlet->channel_list = NULL;
		598	return 1;
		599	}
		600
		601	void S3ReleaseUnboundChannels(void) {
		602	tS3_channel* channel; // [esp+Ch] [ebp-8h]
		603	tS3_channel* next_channel; // [esp+10h] [ebp-4h]
		604
		605	for (channel = gS3_unbound_channels; channel != NULL; channel = next_channel) {
		606	next_channel = channel->next;
		607	S3MemFree(channel);
		608	}
		609	}
		610
		611	tS3_channel* S3AllocateChannel(tS3_outlet* outlet, int priority) {
		612	tS3_channel* c; // [esp+Ch] [ebp-10h]
		613	int lowest_priority; // [esp+10h] [ebp-Ch] MAPDST
		614	int this_priority; // [esp+14h] [ebp-8h]
		615	tS3_channel* lowest_priority_chan; // [esp+18h] [ebp-4h]
		616
		617	lowest_priority_chan = outlet->channel_list;
		618	c = outlet->channel_list;
		619	if (lowest_priority_chan == NULL) {
		620	return NULL;
		621	}
		622	while (c) {
		623	if (!c->active \|\| c->needs_service) {
		624	if (!c->needs_service) {
		625	c->active = 1;
		626	return c;
		627	}
		628	} else {
		629	if (lowest_priority_chan->descriptor) {
		630	lowest_priority = lowest_priority_chan->descriptor->priority
		631	* (lowest_priority_chan->right_volume + lowest_priority_chan->left_volume + 1);
		632	} else {
		633	lowest_priority = 0;
		634	}
		635	if (c->descriptor) {
		636	this_priority = c->descriptor->priority * (c->left_volume + c->right_volume + 1);
		637	} else {
		638	this_priority = 0;
		639	}
		640	if (this_priority <= lowest_priority) {
		641	lowest_priority_chan = c;
		642	}
		643	}
		644	c = c->next;
		645	}
		646	if (!lowest_priority_chan->descriptor \|\| lowest_priority_chan->needs_service) {
		647	lowest_priority = 0;
		648	} else {
		649	lowest_priority = lowest_priority_chan->descriptor->priority * (lowest_priority_chan->right_volume + lowest_priority_chan->left_volume + 1);
		650	}
		651	if (priority > lowest_priority && !lowest_priority_chan->needs_service) {
		652	lowest_priority_chan->termination_reason = 2;
		653	S3StopChannel(lowest_priority_chan);
		654	lowest_priority_chan->active = 1;
		655	}
		656
		657	return NULL;
		658	}
		659
		660	int S3StopChannel(tS3_channel* chan) {
		661	if (!chan->tag) {
		662	return eS3_error_bad_stag;
		663	}
		664	chan->termination_reason = eS3_tr_stopped;
		665	if (chan->active) {
		666	chan->needs_service = 1;
		667	}
		668	if (chan->type == eS3_ST_sample) {
		669	if (chan->sound_source_ptr) {
		670	chan->sound_source_ptr->tag = 0;
		671	chan->sound_source_ptr->channel = 0;
		672	chan->sound_source_ptr->volume = 0;
		673	}
		674	if (S3StopSample(chan) == 0) {
		675	return eS3_error_function_failed;
		676	}
		677	} else if (chan->type == eS3_ST_midi) {
		678	if (S3StopMIDI(chan) != 0) {
		679	return eS3_error_function_failed;
		680	}
		681	} else if (chan->type == eS3_ST_cda) {
		682	if (S3StopCDA(chan) != 0) {
		683	return eS3_error_function_failed;
		684	}
		685	}
		686
		687	if ((chan->descriptor->flags & 2) != 0) {
		688	S3ReleaseSound(chan->descriptor->id);
		689	}
		690	chan->repetitions = 1;
		691	return 0;
		692	}
		693
		694	tS3_sound_source* S3CreateSoundSourceBR(br_vector3* pPosition, br_vector3* pVelocity, tS3_outlet* pBound_outlet) {
		695	tS3_sound_source* source; // [esp+Ch] [ebp-4h]
		696
		697	if (!gS3_enabled) {
		698	return 0;
		699	}
		700	source = S3CreateSoundSource(pPosition, pVelocity, pBound_outlet);
		701	if (source != NULL) {
		702	source->brender_vector = 1;
		703	}
		704	return source;
		705	}
		706
		707	tS3_sound_source* S3CreateSoundSource(void* pPosition, void* pVelocity, tS3_outlet* pBound_outlet) {
		708	tS3_sound_source* src; // [esp+Ch] [ebp-8h]
		709	tS3_sound_source* s; // [esp+10h] [ebp-4h]
		710
		711	src = S3MemAllocate(sizeof(tS3_sound_source), kMem_S3_source);
		712	if (src == NULL) {
		713	gS3_last_error = eS3_error_memory;
		714	return 0;
		715	}
		716	memset(src, 0, sizeof(tS3_sound_source));
		717	src->bound_outlet = pBound_outlet;
		718	src->position_ptr = pPosition;
		719	src->velocity_ptr = pVelocity;
		720	s = gS3_sound_sources;
		721	if (gS3_sound_sources) {
		722	while (s->next) {
		723	s = s->next;
		724	}
		725	s->next = src;
		726	src->prev = s;
		727	} else {
		728	gS3_sound_sources = src;
		729	}
		730	gS3_nsound_sources++;
		731	return src;
		732	}
		733
		734	int S3ReleaseSoundSource(tS3_sound_source* src) {
		735	tS3_sound_source* prev; // [esp+Ch] [ebp-8h]
		736	tS3_sound_source* next; // [esp+10h] [ebp-4h]
		737
		738	if (!gS3_enabled) {
		739	return 0;
		740	}
		741
		742	if (src) {
		743	prev = src->prev;
		744	next = src->next;
		745	if (prev) {
		746	prev->next = next;
		747	} else {
		748	gS3_sound_sources = src->next;
		749	}
		750	if (next) {
		751	next->prev = prev;
		752	}
		753	if (gS3_nsound_sources) {
		754	gS3_nsound_sources--;
		755	if (gS3_nsound_sources == 0) {
		756	gS3_sound_sources = NULL;
		757	}
		758	}
		759	S3StopSoundSource(src);
		760	S3MemFree(src);
		761	}
		762	return 0;
		763	}
		764
		765	void S3Service(int inside_cockpit, int unk1) {
		766
		767	int now; // [esp+Ch] [ebp-10h]
		768	tS3_channel* c; // [esp+10h] [ebp-Ch]
		769	tS3_outlet* o; // [esp+14h] [ebp-8h]
		770	int v5; // [esp+18h] [ebp-4h]
		771
		772	v5 = 0;
		773	gS3_inside_cockpit = inside_cockpit;
		774	if (!gS3_enabled) {
		775	return;
		776	}
		777	now = PDGetTotalTime();
		778	gS3_service_time_delta = now - gS3_last_service_time;
		779	gS3_last_service_time = now;
		780	S3ServiceOutlets();
		781	if (unk1 == 1) {
		782	S3UpdateListenerVectors();
		783	S3ServiceAmbientSoundSources();
		784	}
		785	for (o = gS3_outlets; o; o = o->next) {
		786	for (c = o->channel_list; c; c = c->next) {
		787	if (c->needs_service) {
		788	c->needs_service = 0;
		789	if (c->descriptor && c->descriptor->flags == 2) {
		790	S3ReleaseSound(c->descriptor->id);
		791	}
		792	c->active = 0;
		793	if (c->type != eS3_ST_midi) {
		794	c->tag = 0;
		795	}
		796	} else if (c->spatial_sound && c->active) {
		797	if (S3UpdateSpatialSound(c)) {
		798	if (c->sound_source_ptr && c->sound_source_ptr->ambient && !S3SoundStillPlaying(c->tag)) {
		799	S3UpdateSoundSource(NULL, -1, c->sound_source_ptr, -1.0f, -1, -1, 0, -1, -1);
		800	}
		801	} else if (c->sound_source_ptr) {
		802	if (c->sound_source_ptr->ambient) {
		803	S3UpdateSoundSource(NULL, -1, c->sound_source_ptr, -1.0f, -1, -1, 0, -1, -1);
		804	}
		805	} else {
		806	S3StopChannel(c);
		807	}
		808	} else if (c->type == eS3_ST_midi && c->active) {
		809	// sub_4124BE(c);
		810	}
		811	if (unk1 < 2 && gS3_last_service_time > dword_5216C0) {
		812	v5 = 1;
		813	if (!c->active && c->spatial_sound == 2) {
		814	// null_unknown_libname_8(); /* no-op */
		815	}
		816	}
		817	}
		818	}
		819	if (v5) {
		820	dword_5216C0 = gS3_last_service_time;
		821	}
		822	}
		823
		824	void S3ServiceOutlets(void) {
		825	tS3_channel* c; // [esp+Ch] [ebp-8h]
		826	tS3_outlet* o; // [esp+10h] [ebp-4h]
		827
		828	for (o = gS3_outlets; o; o = o->next) {
		829	for (c = o->channel_list; c; c = c->next) {
		830	S3ServiceChannel(c);
		831	}
		832	}
		833	}
		834
		835	int S3ServiceChannel(tS3_channel* chan) {
		836	if (chan->type == eS3_ST_sample) {
		837	if (AudioBackend_SoundIsPlaying(chan)) {
		838	return 1;
		839	}
		840	S3StopSample(chan);
		841	return 0;
		842	} else if (chan->type == eS3_ST_midi) {
		843	return !S3IsMIDIStopped(chan);
		844	} else if (chan->type == eS3_ST_cda) {
		845	return S3IsCDAPlaying();
		846	} else {
		847	return 0;
		848	}
		849	}
		850
		851	void S3StopAllOutletSounds(void) {
		852	tS3_outlet* o; // [esp+Ch] [ebp-4h]
		853
		854	if (!gS3_enabled) {
		855	return;
		856	}
		857
		858	for (o = gS3_outlets; o; o = o->next) {
		859	S3StopOutletSound(o);
		860	}
		861	}
		862
		863	tS3_sound_tag S3StartSound(tS3_outlet* pOutlet, tS3_sound_id pSound) {
		864	int repetitions; // eax
		865	tS3_channel* chan; // [esp+14h] [ebp-Ch]
		866	tS3_descriptor* desc; // [esp+1Ch] [ebp-4h]
		867
		868	if (!gS3_enabled) {
		869	return 0;
		870	}
		871	if (!pOutlet) {
		872	gS3_last_error = eS3_error_bad_id;
		873	return 0;
		874	}
		875	desc = S3GetDescriptorByID(pSound);
		876	if (!desc) {
		877	gS3_last_error = eS3_error_bad_id;
		878	return 0;
		879	}
		880	memset(&gS3_channel_template, 0, sizeof(gS3_channel_template));
		881	S3CalculateRandomizedFields(&gS3_channel_template, desc);
		882	chan = S3AllocateChannel(pOutlet, desc->priority * (gS3_channel_template.right_volume + gS3_channel_template.left_volume + 1));
		883	if (!chan) {
		884	gS3_last_error = eS3_error_channel_alloc;
		885	return 0;
		886	}
		887	chan->left_volume = gS3_channel_template.left_volume * chan->volume_multiplier;
		888	chan->right_volume = gS3_channel_template.right_volume * chan->volume_multiplier;
		889	chan->rate = gS3_channel_template.rate;
		890	if (desc->type == eS3_ST_sample && (!desc->sound_data \|\| desc->flags == 2)) {
		891	if (!S3LoadSample(pSound)) {
		892	chan->needs_service = 1;
		893	gS3_last_error = eS3_error_load_sound;
		894	return 0;
		895	}
		896	}
		897	if (chan->descriptor && chan->descriptor->type == 1 && chan->descriptor->id != pSound) {
		898	S3ReleaseMIDI(chan->tag);
		899	}
		900	chan->spatial_sound = 0;
		901	chan->sound_source_ptr = 0;
		902	chan->descriptor = desc;
		903	chan->type = desc->type;
		904	repetitions = desc->repeats;
		905	if (repetitions <= 0) {
		906	repetitions = 0;
		907	}
		908	chan->repetitions = repetitions;
		909	chan->needs_service = 0;
		910	chan->termination_reason = eS3_tr_natural;
		911	chan->tag = S3GenerateTag(pOutlet);
		912	if (desc->type == eS3_ST_midi && !desc->sound_data) {
		913	if (S3MIDILoadSong(chan)) {
		914	chan->needs_service = 1;
		915	return 0;
		916	}
		917	}
		918	if (chan->type == eS3_ST_sample) {
		919	S3ExecuteSampleFilterFuncs(chan);
		920	if (S3PlaySample(chan) == 0) {
		921	gS3_last_error = eS3_error_start_sound;
		922	chan->needs_service = 1;
		923	return 0;
		924	}
		925	} else if (chan->type == eS3_ST_midi) {
		926	if (S3PlayMIDI(chan)) {
		927	chan->needs_service = 1;
		928	gS3_last_error = eS3_error_start_song;
		929	return 0;
		930	}
		931	S3SetMIDIVolume(chan);
		932	} else if (chan->type == eS3_ST_cda) {
		933	if (S3PlayCDA(chan)) {
		934	chan->needs_service = 1;
		935	gS3_last_error = eS3_error_start_cda;
		936	return 0;
		937	}
		938	}
		939
		940	return chan->tag;
		941	}
		942
		943	tS3_sound_tag S3StartSound2(tS3_outlet* pOutlet, tS3_sound_id pSound, tS3_repeats pRepeats, tS3_volume pLVolume, tS3_volume pRVolume, tS3_pitch pPitch, tS3_speed pSpeed) {
		944	tS3_channel* chan; // [esp+30h] [ebp-Ch]
		945	tS3_descriptor* desc; // [esp+38h] [ebp-4h]
		946
		947	if (!gS3_enabled) {
		948	return 0;
		949	}
		950	desc = S3GetDescriptorByID(pSound);
		951	if (!desc) {
		952	gS3_last_error = eS3_error_bad_id;
		953	return 0;
		954	}
		955	if (pLVolume < 0) {
		956	pLVolume = 128;
		957	}
		958	if (pRVolume < 0) {
		959	pRVolume = 128;
		960	}
		961	if (pLVolume > 255) {
		962	pLVolume = 255;
		963	}
		964	if (pRVolume > 255) {
		965	pRVolume = 255;
		966	}
		967	chan = S3AllocateChannel(pOutlet, desc->priority * (pLVolume + pRVolume + 1));
		968	if (chan == NULL) {
		969	gS3_last_error = eS3_error_channel_alloc;
		970	return 0;
		971	}
		972	if (desc->type == eS3_ST_sample) {
		973	if (desc->sound_data == NULL && (!S3LoadSample(pSound) \|\| (desc->flags & 2) != 0)) {
		974	chan->needs_service = 1;
		975	gS3_last_error = eS3_error_load_sound;
		976	return 0;
		977	}
		978	}
		979
		980	if (chan->descriptor && chan->descriptor->type == eS3_ST_midi) {
		981	if (chan->descriptor->id != pSound) {
		982	S3ReleaseMIDI(chan->tag);
		983	}
		984	}
		985	chan->spatial_sound = 0;
		986	chan->descriptor = desc;
		987	chan->needs_service = 0;
		988	chan->termination_reason = eS3_tr_natural;
		989	chan->type = desc->type;
		990	chan->sound_source_ptr = NULL;
		991	chan->repetitions = MAX(pRepeats, 0);
		992	S3CalculateRandomizedFields(chan, desc);
		993	chan->left_volume = pLVolume * chan->volume_multiplier;
		994	chan->right_volume = pRVolume * chan->volume_multiplier;
		995	chan->tag = S3GenerateTag(pOutlet);
		996	if (pPitch == -1) {
		997	pPitch = 0x10000;
		998	}
		999	if (pSpeed == -1) {
		1000	pSpeed = 0x10000;
		1001	}
		1002	chan->rate = ldexpf(pPitch, -16) * chan->rate;
		1003	if (!pOutlet->independent_pitch) {
		1004	chan->rate = ldexpf(pSpeed, -16) * chan->rate;
		1005	}
		1006	if (desc->type == eS3_ST_midi && desc->sound_data == NULL && S3MIDILoadSong(chan)) {
		1007	chan->needs_service = 1;
		1008	return 0;
		1009	}
		1010
		1011	switch (chan->type) {
		1012	case eS3_ST_sample:
		1013	S3ExecuteSampleFilterFuncs(chan);
		1014	if (!S3PlaySample(chan)) {
		1015	chan->needs_service = 1;
		1016	gS3_last_error = eS3_error_start_sound;
		1017	return 0;
		1018	}
		1019	break;
		1020
		1021	case eS3_ST_midi:
		1022	if (S3PlayMIDI(chan)) {
		1023	chan->needs_service = 1;
		1024	gS3_last_error = eS3_error_start_song;
		1025	return 0;
		1026	}
		1027	S3SetMIDIVolume(chan);
		1028	break;
		1029
		1030	case eS3_ST_cda:
		1031	if (S3PlayCDA(chan)) {
		1032	chan->needs_service = 1;
		1033	gS3_last_error = eS3_error_start_cda;
		1034	return 0;
		1035	}
		1036	break;
		1037	}
		1038
		1039	return chan->tag;
		1040	}
		1041
		1042	void S3CalculateRandomizedFields(tS3_channel* chan, tS3_descriptor* desc) {
		1043	int vol; // eax
		1044
		1045	vol = S3IRandomBetween(desc->min_volume, desc->max_volume, 128);
		1046	chan->left_volume = vol;
		1047	chan->right_volume = vol;
		1048	if (desc->type == eS3_ST_sample) {
		1049	#if defined(DETHRACE_FIX_BUGS)
		1050	/* Avoid a possible NULL pointer dereference. */
		1051	if (desc->sound_data == NULL) {
		1052	chan->rate = desc->min_pitch;
		1053	return;
		1054	}
		1055	#endif
		1056	chan->rate = S3IRandomBetweenLog(desc->min_pitch, desc->max_pitch, ((tS3_sample*)desc->sound_data)->rate);
		1057	}
		1058	}
		1059
		1060	// duplicate of S3IRandomBetween2
		1061	int S3IRandomBetween(int pMin, int pMax, int pDefault) {
		1062	if (pMin == -1) {
		1063	return pDefault;
		1064	}
		1065	if (pMax <= pMin) {
		1066	return pMin;
		1067	}
		1068	return rand() % (pMax - pMin) + pMin;
		1069	}
		1070
		1071	// duplicate of S3IRandomBetweenLog2
		1072	int S3IRandomBetweenLog(int pMin, int pMax, int pDefault) {
		1073	float v4; // st7
		1074
		1075	if (pMin == -1 \|\| pMin >= pMax) {
		1076	return pDefault;
		1077	}
		1078	v4 = S3FRandomBetween(log(pMin), log(pMax));
		1079	return ldexp(exp(v4), -16) * pDefault;
		1080	}
		1081
		1082	// duplicate of S3FRandomBetween2
		1083	double S3FRandomBetween(double pMin, double pMax) {
		1084	return (double)rand() * (pMax - pMin) / (double)RAND_MAX + pMin;
		1085	}
		1086
		1087	int S3GenerateTag(tS3_outlet* outlet) {
		1088	gS3_tag_seed += 256;
		1089	return gS3_tag_seed \| outlet->id;
		1090	}
		1091
		1092	int S3SoundStillPlaying(tS3_sound_tag pTag) {
		1093	tS3_channel* chan;
		1094
		1095	if (!gS3_enabled) {
		1096	return 0;
		1097	}
		1098	if (!pTag) {
		1099	return 0;
		1100	}
		1101	chan = S3GetChannelForTag(pTag);
		1102	if (!chan) {
		1103	return 0;
		1104	}
		1105	return S3ServiceChannel(chan) != 0;
		1106	}
		1107
		1108	int S3ChangePitchSpeed(tS3_sound_tag pTag, tS3_pitch pNew_pitch) {
		1109	tS3_channel* chan;
		1110
		1111	if (!gS3_enabled) {
		1112	return 0;
		1113	}
		1114	if (pNew_pitch == -1) {
		1115	pNew_pitch = 0x10000;
		1116	}
		1117	chan = S3GetChannelForTag(pTag);
		1118	if (chan == NULL) {
		1119	return eS3_error_bad_stag;
		1120	}
		1121	if (chan->type != eS3_ST_sample) {
		1122	return 0;
		1123	}
		1124	chan->rate = ldexp(pNew_pitch, -16) * ((tS3_sample*)chan->descriptor->sound_data)->rate;
		1125	if (S3SyncSampleRate(chan)) {
		1126	return 0;
		1127	} else {
		1128	return eS3_error_function_failed;
		1129	}
		1130	}
		1131
		1132	int S3StopSound(tS3_sound_tag pTag) {
		1133	tS3_channel* chan; // [esp+Ch] [ebp-4h]
		1134
		1135	if (!gS3_enabled) {
		1136	return 0;
		1137	}
		1138	if (!pTag) {
		1139	return eS3_error_bad_stag;
		1140	}
		1141	chan = S3GetChannelForTag(pTag);
		1142	if (!chan) {
		1143	return eS3_error_bad_stag;
		1144	}
		1145	chan->termination_reason = eS3_tr_stopped;
		1146	chan->initial_volume = 0;
		1147	if (chan->active) {
		1148	chan->needs_service = 1;
		1149	}
		1150	if (chan->type == eS3_ST_sample) {
		1151	if (chan->sound_source_ptr) {
		1152	chan->sound_source_ptr->tag = 0;
		1153	chan->sound_source_ptr->channel = NULL;
		1154	chan->sound_source_ptr->volume = 0;
		1155	}
		1156	if (!S3StopSample(chan)) {
		1157	return eS3_error_function_failed;
		1158	}
		1159	} else if (chan->type == eS3_ST_midi) {
		1160	if (S3StopMIDI(chan)) {
		1161	return eS3_error_function_failed;
		1162	}
		1163	} else if (chan->type == eS3_ST_cda) {
		1164	if (S3StopCDA(chan)) {
		1165	return eS3_error_function_failed;
		1166	}
		1167	}
		1168
		1169	if ((chan->descriptor->flags & 2) != 0) {
		1170	S3ReleaseSound(chan->descriptor->id);
		1171	}
		1172	chan->repetitions = 1;
		1173	return 0;
		1174	}
		1175
		1176	int S3StopOutletSound(tS3_outlet* pOutlet) {
		1177	tS3_channel* c; // [esp+Ch] [ebp-4h]
		1178
		1179	if (!gS3_enabled) {
		1180	return 0;
		1181	}
		1182	for (c = pOutlet->channel_list; c; c = c->next) {
		1183	// null_unknown_libname_8();
		1184	if (c->active) {
		1185	c->spatial_sound = 0;
		1186	S3StopChannel(c);
		1187	c->needs_service = 1;
		1188	}
		1189	}
		1190	return 0;
		1191	}
		1192
		1193	char* S3GetCurrentDir(void) {
		1194	if (!gS3_have_current_dir) {
		1195	if (getcwd(gS3_current_dir, 260) == NULL) {
		1196	LOG_PANIC("failed to call getcwd"); // added by dethrace
		1197	};
		1198	gS3_have_current_dir = 1;
		1199	}
		1200	return gS3_current_dir;
		1201	}
		1202
		1203	tS3_descriptor* S3GetDescriptorByID(tS3_sound_tag id) {
		1204	tS3_descriptor* d; // [esp+Ch] [ebp-4h]
		1205
		1206	for (d = gS3_descriptors;; d = d->next) {
		1207	if (!d) {
		1208	return 0;
		1209	}
		1210	if (d->id == id) {
		1211	break;
		1212	}
		1213	}
		1214	if (d->memory_proxy < 0) {
		1215	return d;
		1216	} else {
		1217	return S3GetDescriptorByID(d->memory_proxy);
		1218	}
		1219	}
		1220
		1221	int S3SetOutletVolume(tS3_outlet* pOutlet, tS3_volume pVolume) {
		1222	tS3_channel* c; // [esp+10h] [ebp-4h]
		1223
		1224	if (!gS3_enabled) {
		1225	return 0;
		1226	}
		1227	if (pVolume > 255) {
		1228	pVolume = 255;
		1229	}
		1230	if (pVolume < 10) {
		1231	pVolume = 10;
		1232	}
		1233	if (!pOutlet) {
		1234	return 0;
		1235	}
		1236	for (c = pOutlet->channel_list; c; c = c->next) {
		1237	c->volume_multiplier = pVolume / 150.0f;
		1238	if (c->active) {
		1239	S3ChangeVolume(c->tag, pVolume);
		1240	}
		1241	}
		1242	return 0;
		1243	}
		1244
		1245	tS3_channel* S3GetChannelForTag(tS3_sound_tag tag) {
		1246	tS3_channel* c; // [esp+Ch] [ebp-Ch]
		1247	tS3_outlet* o; // [esp+14h] [ebp-4h]
		1248
		1249	if (!tag) {
		1250	return 0;
		1251	}
		1252	for (o = gS3_outlets; o && o->id != (uint8_t)tag; o = o->next) {
		1253	;
		1254	}
		1255	if (!o) {
		1256	return 0;
		1257	}
		1258	for (c = o->channel_list; c; c = c->next) {
		1259	if (c->tag == tag) {
		1260	return c;
		1261	}
		1262	}
		1263	return 0;
		1264	}
		1265
		1266	int S3ChangeVolume(tS3_sound_tag pTag, tS3_volume pVolume) {
		1267	tS3_channel* chan; // [esp+14h] [ebp-4h]
		1268
		1269	if (!gS3_enabled) {
		1270	return 0;
		1271	}
		1272	chan = S3GetChannelForTag(pTag);
		1273	if (!chan) {
		1274	return eS3_error_bad_stag;
		1275	}
		1276	if (pVolume < 0) {
		1277	pVolume = 128;
		1278	}
		1279	if (pVolume > 255) {
		1280	pVolume = 255;
		1281	}
		1282	if (chan->type == eS3_ST_sample) {
		1283	chan->left_volume = pVolume * chan->volume_multiplier;
		1284	chan->right_volume = pVolume * chan->volume_multiplier;
		1285	if (!S3SyncSampleVolumeAndPan(chan)) {
		1286	return eS3_error_function_failed;
		1287	}
		1288	} else if (chan->type == eS3_ST_midi) {
		1289	S3SetMIDIVolume(chan);
		1290	} else if (chan->type == eS3_ST_cda) {
		1291	S3SetCDAVolume(chan, pVolume);
		1292	}
		1293
		1294	return 0;
		1295	}

Subversion Repositories Games.Carmageddon

Games.Carmageddon//src/S3/audio.c – Rev 20