datalore/CnC_Red_Alert
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
0dc09bb1d6
CnC_Red_Alert/WWFLAT32/AUDIO/SOUNDIO.CPP

1468 lines
57 KiB
C++
Raw Normal View History

Initial commit of Command & Conquer Red Alert source code.
2025-02-27 17:15:05 +01:00
/*
** Command & Conquer Red Alert(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* $Id: soundio.cpp 1.41 1994/06/20 15:01:39 joe_bostic Exp $ */
/***********************************************************************************************
** C O N F I D E N T I A L --- W E S T W O O D A S S O C I A T E S **
***********************************************************************************************
* *
* Project Name : Sound Library *
* *
* File Name : SOUND.CPP *
* *
* Programmer : Joe L. Bostic *
* *
* Start Date : July 22, 1991 *
* *
*---------------------------------------------------------------------------------------------*
* Functions: *
* File_Callback -- called to fill queue buffer for streaming sample *
* Stream_Sample_Volume -- generic streaming sample playback init *
* Stream_Sample -- generic streaming sample playback init *
* File_Stream_Sample -- Streams a sample directly from a file. *
* File_Stream_Preload -- Handles initial proload of a streaming samples *
* File_Stream_Sample_Volume -- Streams a sample directly from a file w/volume. *
* Sound_Callback -- Audio driver callback function. *
* Load_Sample -- Loads a digitized sample into RAM. *
* Load_Sample_Into_Buffer -- Loads a digitized sample into a buffer. *
* Free_Sample -- Frees a previously loaded digitized sample. *
* Sound_End -- Uninitializes the sound driver. *
* Stop_Sample -- Stops any currently playing sampled sound. *
* Sample_Status -- Queries the current playing sample status (if any). *
* Sample_Length -- returns length of a sample in ticks *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
#pragma pack(4)
#include "soundint.h"
#include <dos.h>
#include <mem.h>
#include <stdio.h>
#include <string.h>
#include <direct.h>
#include <stdlib.h>
#include <wwmem.h>
#include <keyboard.h>
#include <file.h>
#include <i86.h>
#include <timer.h>
#pragma pack(1)
#include "audio.h"
#pragma pack(4)
//int Mono_Printf(char const *string, ...);
#include <mono.h>
/*
** If this is defined, then the streaming audio buffer will be filled
** to maximum whenever filling is to occur. If undefined, it will fill
** the streaming buffer in smaller chunks.
*/
#define SIMPLE_FILLING
/*
** This define (if present) enables the simple HMI hardware initialization process.
** The process does not do auto detection, but rather takes the value directly from
** the setup program and uses that as the sound card number. The only "detection" it
** does is to recognized the presence of the card and fetch its settings.
*/
#define SIMPLE_HMI_INIT
/*
** This is the rate that the maintenance callback gets called.
*/
#define MAINTENANCE_RATE 60
/*
** Size of the temporary buffer in XMS/EMS that direct file
** streaming of sounds will allocate.
*/
#define STREAM_BUFFER_SIZE (128L*1024L)
/*
** Define the number of "StreamBufferSize" blocks that are read in
** at a minimum when the streaming sample load callback routine
** is called. We will IGNORE loads that are less that this in order
** to avoid constant seeking on the CD.
*/
#define STREAM_CUSHION_BLOCKS 4
/*
** This is the maximum size that a sonarc block can be. All sonarc blocks
** must be either a multiple of this value or a binary root of this value.
*/
#define LARGEST_SONARC_BLOCK 2048
//////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////// structs ///////////////////////////////////////
static _SOS_CAPABILITIES DigiCaps;
static _SOS_HARDWARE DigiHardware;
static WORD MidiHandle = -1;
static unsigned int far DigiTimer = 0;
static unsigned int far MaintainTimer = 0;
static unsigned int far SystemTimer = 0;
static int Bits_Per_Sample;
VOID *DigiBuffer = NULL;
static BOOL StartingFileStream = FALSE;
short StreamLowImpact = FALSE;
MemoryFlagType StreamBufferFlag = MEM_NORMAL;
int Misc;
SFX_Type SoundType;
Sample_Type SampleType;
int ReverseChannels = FALSE;
/*=========================================================================*/
/* The following PRIVATE functions are in this file: */
/*=========================================================================*/
static BOOL File_Callback(WORD id, WORD *odd, VOID **buffer, LONG *size);
static int cdecl Stream_Sample_Vol(void *buffer, long size, BOOL (*callback)(WORD id, WORD *odd, VOID **buffer, LONG *size), int volume, int handle);
static int cdecl Stream_Sample(void *buffer, long size, BOOL (*callback)(WORD id, WORD *odd, VOID **buffer, LONG *size));
/*= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =*/
/***************************************************************************
* FILE_CALLBACK -- called to fill queue buffer for streaming sample *
* *
* This callback is called whenever the queue buffer playback has begun *
* and another buffer is needed for queuing up. Returns TRUE if there *
* is more data to read from the file. *
* *
* INPUT: WORD id - the sample id number *
* WORD *odd - which sample buffer to put info in *
* VOID **buffer - the buffer pointer to load data into *
* LONG *size - the amount to load *
* *
* OUTPUT: BOOL true if more data to load, FALSE if done loading *
* *
* HISTORY: *
* 07/17/1995 PWG : Created. *
*=========================================================================*/
static BOOL File_Callback(WORD id, WORD *odd, VOID **buffer, LONG *size)
{
SampleTrackerType *st; // Pointer to sample playback control struct.
VOID *ptr; // Pointer to working portion of file buffer.
if (id != -1) {
st = &LockedData.SampleTracker[id];
ptr = st->FileBuffer;
if (ptr) {
/*
** Move the next pending block into the primary
** position. Do this only if the queue pointer is
** null.
*/
st->DontTouch = TRUE;
if (!*buffer && st->FilePending) {
*buffer = Add_Long_To_Pointer(ptr, (long)(*odd % LockedData.StreamBufferCount)*(long)LockedData.StreamBufferSize);
st->FilePending--;
*odd = *odd + 1;
if (!st->FilePending) {
*size = st->FilePendingSize;
} else {
*size = LockedData.StreamBufferSize;
}
}
st->DontTouch = FALSE;
maintenance_callback();
/*
** If the file handle is still valid, then read in the next
** block and add it to the next pending slot available.
*/
if (st->FilePending <
(StreamLowImpact ? (LockedData.StreamBufferCount>>1) : ((LockedData.StreamBufferCount-3))) && st->FileHandle != ERROR) {
int num_empty_buffers;
#ifdef SIMPLE_FILLING
num_empty_buffers = (LockedData.StreamBufferCount-2) - st->FilePending;
#else
//
// num_empty_buffers will be from 1 to StreamBufferCount
//
if (StreamLowImpact) {
num_empty_buffers = MIN((LockedData.StreamBufferCount >> 1)+STREAM_CUSHION_BLOCKS, (LockedData.StreamBufferCount - 2) - st->FilePending);
}
else {
num_empty_buffers = (LockedData.StreamBufferCount - 2) - st->FilePending;
}
#endif
while (num_empty_buffers && st->FileHandle != ERROR) {
int tofill;
long psize;
tofill = (*odd + st->FilePending) % LockedData.StreamBufferCount;
ptr = Add_Long_To_Pointer(st->FileBuffer, (long)tofill * (long)LockedData.StreamBufferSize);
psize = Read_File(st->FileHandle, ptr, LockedData.StreamBufferSize);
/*
** If less than the requested amount of data was read, this
** indicates that the source file is exhausted. Flag the source
** file as closed so that no further reading is attempted.
*/
if (psize != LockedData.StreamBufferSize) {
Close_File(st->FileHandle);
st->FileHandle = ERROR;
}
/*
** If any real data went into the pending buffer, then flag
** that this buffer is valid.
*/
if (psize) {
st->DontTouch = TRUE;
st->FilePendingSize = psize;
st->FilePending++;
st->DontTouch = FALSE;
maintenance_callback();
}
num_empty_buffers--;
}
/*
** After filling all pending buffers, check to see if the queue buffer
** is empty. If so, then assign the first available pending buffer to the
** queue.
*/
st->DontTouch = TRUE;
if (!st->QueueBuffer && st->FilePending) {
st->QueueBuffer = Add_Long_To_Pointer(st->FileBuffer, (long)(st->Odd%LockedData.StreamBufferCount)*(long)LockedData.StreamBufferSize);
st->FilePending--;
st->Odd++;
if (!st->FilePending) {
st->QueueSize = st->FilePendingSize;
} else {
st->QueueSize = LockedData.StreamBufferSize;
}
}
st->DontTouch = FALSE;
maintenance_callback();
}
/*
** If there are no more buffers that the callback routine
** can slot into the primary position, then signal that
** no furthur callbacks are needed.
*/
if (st->FilePending) {
return(TRUE);
}
}
}
return(FALSE);
}
/***************************************************************************
* STREAM_SAMPLE_VOLUME -- generic streaming sample playback init *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 07/17/1995 PWG : Created. *
*=========================================================================*/
static int cdecl Stream_Sample_Vol(void *buffer, long size, BOOL (*callback)(WORD id, WORD *odd, VOID **buffer, LONG *size), int volume, int handle)
{
int playid=-1; // Sample play ID.
SampleTrackerType *st; // Working pointer to sample control structure.
long oldsize; // Copy of original sound size.
AUDHeaderType header;
if (buffer && size && LockedData.DigiHandle != -1) {
/*
** Start the first section of the sound playing.
*/
Mem_Copy(buffer, &header, sizeof(header));
oldsize = header.Size;
header.Size = size-sizeof(header);
Mem_Copy(&header, buffer, sizeof(header));
playid = Play_Sample_Handle(buffer, 0xFF, volume, 0x0, handle);
header.Size = oldsize;
Mem_Copy(&header, buffer, sizeof(header));
/*
** If the sample actually started playing, then flag this
** sample as a streaming type and signal for a callback
** to occur.
*/
if (playid != -1) {
st = &LockedData.SampleTracker[playid];
st->Callback = callback;
st->Odd = 0;
}
}
return (playid);
}
/***************************************************************************
* STREAM_SAMPLE -- generic streaming sample playback init *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 07/17/1995 PWG : Created. *
*=========================================================================*/
static int cdecl Stream_Sample(void *buffer, long size, BOOL (*callback)(WORD id, WORD *odd, VOID **buffer, LONG *size), int handle)
{
return Stream_Sample_Vol(buffer, size, callback, 0xFF, handle);
}
/***********************************************************************************************
* File_Stream_Sample -- Streams a sample directly from a file. *
* *
* This will take the file specified and play it directly from disk. *
* It performs this by allocating a temporary buffer in XMS/EMS and *
* then keeping this buffer filled by the Sound_Callback() routine. *
* *
* INPUT: filename -- The name of the file to play. *
* *
* OUTPUT: Returns the handle to the sound -- just like Play_Sample(). *
* *
* WARNINGS: The temporary buffer is allocated when this routine is *
* called and then freed when the sound is finished. Keep *
* this in mind. *
* *
* HISTORY: *
* 01/06/1994 JLB : Created. *
*=============================================================================================*/
int File_Stream_Sample(char const *filename, BOOL real_time_start)
{
return File_Stream_Sample_Vol(filename, 0xFF, real_time_start);
}
/***************************************************************************
* FILE_STREAM_PRELOAD -- Handles initial proload of streaming samples *
* *
* This function is called before a sample which streams from disk is *
* started. It can be called to either fill the buffer in small chunks *
* from the call back routine or to fill the entire buffer at once. This *
* is wholely dependant on whether the Loading bit is set within the *
* sample tracker. *
* *
* INPUT: LockedData.SampleTracker * to the header which tracks this samples *
* processing. *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 06/05/1995 PWG : Created. *
*=========================================================================*/
void File_Stream_Preload(int handle)
{
SampleTrackerType *st = &LockedData.SampleTracker[handle];
int fh = st->FileHandle;
int maxnum = (LockedData.StreamBufferCount >> 1) + STREAM_CUSHION_BLOCKS;
void *buffer = st->FileBuffer;
int num;
/*
** Figure just how much we need to load. If we are doing the load in progress
** then we will only load two blocks.
*/
if (st->Loading) {
num = st->FilePending + 2;
num = MIN(num, maxnum);
} else {
num = maxnum;
}
//printf("Before buffer load!\n");
/*
** Loop through the blocks and load up the number we need.
*/
for (int index = st->FilePending; index < num; index++) {
long s = Read_File(fh, Add_Long_To_Pointer(buffer, (long)index * (long)LockedData.StreamBufferSize), LockedData.StreamBufferSize);
//printf("Reading block of size %d Stream Buffer = %d\n");
if (s) {
st->FilePendingSize = s;
st->FilePending++;
}
if (s < LockedData.StreamBufferSize) break;
}
/*
** If the last block was incomplete (ie. it didn't completely fill the buffer) or
** we have now filled up as much of the Streaming Buffer as we need to, then now is
** the time to kick off the sample.
*/
if (st->FilePendingSize < LockedData.StreamBufferSize || index == maxnum) {
//printf("Before Stream Sample Volume!\n");
/*
** Actually start the sample playing, and don't worry about the file callback
** it won't be called for a while.
*/
{
int old = LockedData.SoundVolume;
int size = (st->FilePending == 1) ? st->FilePendingSize : LockedData.StreamBufferSize;
LockedData.SoundVolume = LockedData.ScoreVolume;
StartingFileStream = TRUE;
Stream_Sample_Vol(buffer, size, File_Callback, st->Volume, handle);
StartingFileStream = FALSE;
LockedData.SoundVolume = old;
}
//printf("After Stream Sample Volume!\n");
/*
** The Sample is finished loading (if it was loading in small pieces) so record that
** so that it will now use the active logic in the file call back.
*/
st->Loading = FALSE;
/*
** Decrement the file pending because the first block is already playing thanks
** to the play sample call above.
*/
st->FilePending--;
/*
** If File pending is now a zero, then we only preloaded one block and there
** is nothing more to play. So clear the sample tracing structure of the
** information it no longer needs.
*/
if (!st->FilePending) {
st->Odd = 0;
st->QueueBuffer = 0;
st->QueueSize = 0;
st->FilePendingSize = 0;
st->Callback = NULL;
Close_File(fh);
} else {
/*
** The QueueBuffer counts as an already played block so remove it from the total.
** Note: We didn't remove it before because there might not have been one.
*/
st->FilePending--;
/*
** When we start loading we need to start past the first two blocks. Why this
** is called Odd, I haven't got the slightest.
*/
st->Odd = 2;
/*
** If the file pending size is less than the stream buffer, then the last block
** we loaded was the last block period. So close the file and reset the handle.
*/
if (st->FilePendingSize != LockedData.StreamBufferSize) {
Close_File(fh);
st->FileHandle = ERROR;
}
/*
** The Queue buffer needs to point at the next block to be processed. The size
** of the queue is dependant on how many more blocks there are.
*/
st->QueueBuffer = Add_Long_To_Pointer(buffer, LockedData.StreamBufferSize);
if (!st->FilePending) {
st->QueueSize = st->FilePendingSize;
} else {
st->QueueSize = LockedData.StreamBufferSize;
}
}
}
}
/***********************************************************************************************
* File_Stream_Sample_Vol -- Streams a sample directly from a file. *
* *
* This will take the file specified and play it directly from disk. *
* It performs this by allocating a temporary buffer in XMS/EMS and *
* then keeping this buffer filled by the Sound_Callback() routine. *
* *
* INPUT: filename -- The name of the file to play. *
* *
* OUTPUT: Returns the handle to the sound -- just like Play_Sample(). *
* *
* WARNINGS: The temporary buffer is allocated when this routine is *
* called and then freed when the sound is finished. Keep *
* this in mind. *
* *
* HISTORY: *
* 01/06/1994 JLB : Created. *
*=============================================================================================*/
int File_Stream_Sample_Vol(char const *filename, int volume, BOOL real_time_start)
{
static VOID *buffer = NULL;
SampleTrackerType *st;
int fh;
int handle = -1;
long size;
int index;
if (LockedData.DigiHandle != -1 && filename && Find_File(filename)) {
//printf("Before initialize memory!\n");
/*
** Make sure all sample tracker structures point to the same
** upper memory buffer. This allocation only occurs if at
** least one sample gets "streamed".
*/
if (!buffer) {
buffer = Alloc(LockedData.StreamBufferSize * LockedData.StreamBufferCount, (MemoryFlagType)(StreamBufferFlag | MEM_TEMP | MEM_LOCK));
for (index = 0; index < LockedData.MaxSamples; index++) {
LockedData.SampleTracker[index].FileBuffer = buffer;
}
}
/*
** If after trying to allocate the buffer we still fail then
** we can stream this sample.
*/
if (!buffer) return(-1);
//printf("Before Open File!\n");
/*
** Lets see if we can sucessfully open up the file. If we can't,
** then there is no point in going any farther.
*/
if ((fh = Open_File(filename, READ)) == -1) {
return (-1);
}
//printf("Before Get Free Handle!\n");
/*
** Reserve a handle so that we can fill in the sample tracker
** with the needed information. If we dont get valid handle then
** we might as well give up.
*/
if ((unsigned)(handle = Get_Free_Sample_Handle(0xFF)) >= LockedData.MaxSamples) {
return(-1);
}
/*
** Now lets get a pointer to the proper sample handler and start
** our manipulations.
*/
st = &LockedData.SampleTracker[handle];
st->IsScore = TRUE;
st->FilePending = 0;
st->FilePendingSize = 0;
st->Loading = real_time_start;
st->Volume = volume;
st->FileHandle = fh;
/*
** Now that we have setup our initial data properly, let load up
** the beginning of the sample we intend to stream.
*/
//printf("Before Preload!\n");
File_Stream_Preload(handle);
}
return (handle);
}
/***********************************************************************************************
* Sound_Callback -- Audio driver callback function. *
* *
* Maintains the audio buffers. This routine must be called at least *
* 11 times per second or else audio glitches will occur. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: If this routine is not called often enough then audio *
* glitches will occur. *
* *
* HISTORY: *
* 01/06/1994 JLB : Created. *
*=============================================================================================*/
VOID cdecl __saveregs __loadds Sound_Callback(VOID)
{
int index;
SampleTrackerType *st;
if (LockedData.DigiHandle != -1) {
st = &LockedData.SampleTracker[0];
for (index = 0; index < LockedData.MaxSamples; index++) {
if (st->Loading) {
File_Stream_Preload(index);
} else {
/*
** General service routine to handle moving small blocks from the
** source into the low RAM staging buffers.
*/
if (st->Active) {
/*
** Special check to see if the sample is a fading one AND
** it has faded to silence, then stop it here.
*/
if (st->Reducer && !st->Volume) {
Stop_Sample(index);
} else {
/*
** Fill the queuebuffer if it is currently empty
** and there is a callback function defined to fill it.
**
** PWG/CDY & CO: We should be down by at least two blocks
** before we bother with this
*/
if ((!st->QueueBuffer ||
(st->FileHandle != ERROR && st->FilePending < LockedData.StreamBufferCount-3)) &&
st->Callback) {
if (!st->Callback(index, &st->Odd, &st->QueueBuffer, &st->QueueSize)) {
st->Callback = NULL;
}
}
}
} else {
/*
** This catches the case where a streaming sample gets
** aborted prematurely because of failure to call the
** callback function frequently enough. In this case, the
** sample will be flagged as inactive, but the file handle
** will not have been closed.
*/
if (st->FileHandle != ERROR) {
Close_File(st->FileHandle);
st->FileHandle = ERROR;
}
}
}
/*
** Advance to the next sample control structure.
*/
st++;
}
}
}
/***********************************************************************************************
* Load_Sample -- Loads a digitized sample into RAM. *
* *
* This routine loads a digitized sample into RAM. *
* *
* INPUT: filename -- Name of the sound file to load. *
* *
* OUTPUT: Returns with a pointer to the loaded sound file. This pointer *
* is passed to Play_Sample when playback is desired. *
* *
* WARNINGS: If there is insufficient memory to load the sample, then *
* NULL will be returned. *
* *
* HISTORY: *
* 04/17/1992 JLB : Created. *
* 01/06/1994 JLB : HMI version. *
*=============================================================================================*/
VOID *Load_Sample(char const *filename)
{
void *buffer = NULL;
long size;
int fh;
if (LockedData.DigiHandle == -1 || !filename || !Find_File(filename)) {
return (NULL);
}
fh = Open_File(filename, READ);
if (fh != ERROR) {
size = File_Size(fh)+sizeof(AUDHeaderType);
buffer = Alloc(size, MEM_NORMAL);
if (buffer) {
Sample_Read(fh, buffer, size);
}
Close_File(fh);
Misc = size;
}
return(buffer);
}
/***********************************************************************************************
* Load_Sample_Into_Buffer -- Loads a digitized sample into a buffer. *
* *
* This routine is used to load a digitized sample into a buffer *
* provided by the programmer. This buffer can be in XMS or EMS. *
* *
* INPUT: filename -- The filename to load. *
* *
* buffer -- Pointer to the buffer to load into. *
* *
* size -- The size of the buffer to load into. *
* *
* OUTPUT: Returns the number of bytes actually used in the buffer. *
* *
* WARNINGS: This routine will not overflow the buffer provided. This *
* means that the buffer must be big enough to hold the data *
* or else the sound will be cut short. *
* *
* HISTORY: *
* 01/06/1994 JLB : Created. *
*=============================================================================================*/
long Load_Sample_Into_Buffer(char const *filename, void *buffer, long size)
{
int fh;
/*
** Verify legality of parameters.
*/
if (!buffer || !size || LockedData.DigiHandle == -1 || !filename || !Find_File(filename)) {
return (NULL);
}
fh = Open_File(filename, READ);
if (fh != ERROR) {
size = Sample_Read(fh, buffer, size);
Close_File(fh);
} else {
return(0);
}
return(size);
}
/***********************************************************************************************
* Sample_Read -- Reads sample data from an openned file. *
* *
* This routine reads a sample file. It is presumed that the file is *
* already positioned at the start of the sample. From this, it can *
* determine if it is a VOC or raw data and proceed accordingly. *
* *
* INPUT: fh -- File handle of already openned sample file. *
* *
* buffer -- Pointer to the buffer to load data into. *
* *
* size -- The size of the buffer. *
* *
* OUTPUT: Returns the number of bytes actually used in the buffer. *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 01/06/1994 JLB : Created. *
*=============================================================================================*/
long Sample_Read(int fh, void *buffer, long size)
{
AUDHeaderType RawHeader;
VOID *outbuffer; // Pointer to start of raw data.
long actual_bytes_read; // Actual bytes read in, including header
/*
Conversion formula for TCrate and Hz rate.
TC = 256 - 1m/rate
rate = 1m / (256-TC)
*/
if (!buffer || fh == ERROR || size <= sizeof(RawHeader)) return(NULL);
size -= sizeof(RawHeader);
outbuffer = Add_Long_To_Pointer(buffer, sizeof(RawHeader));
actual_bytes_read =
Read_File(fh, &RawHeader, sizeof(RawHeader));
actual_bytes_read +=
Read_File(fh, outbuffer, MIN(size, RawHeader.Size));
Mem_Copy(&RawHeader, buffer, sizeof(RawHeader));
return(actual_bytes_read);
}
/***********************************************************************************************
* Free_Sample -- Frees a previously loaded digitized sample. *
* *
* Use this routine to free the memory allocated by a previous call to *
* Load_Sample. *
* *
* INPUT: sample -- Pointer to the sample to be freed. *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/17/1992 JLB : Created. *
*=============================================================================================*/
VOID Free_Sample(VOID const *sample)
{
if (sample) Free((void *)sample);
}
BOOL Sound_Init(int sfx, int score, int sample, RateType rate, int bits_per_sample, int max_samples, int reverse_channels)
{
return Audio_Init(sample, -1, -1, -1, rate, bits_per_sample, max_samples, reverse_channels);
}
BOOL Audio_Init(int sample, int address, int inter, int dma, RateType rate, int bits_per_sample, int max_samples, int reverse_channels)
{
int error; // Function error return code.
unsigned int port;
int index;
_SOS_INIT_DRIVER init; // Driver init structure.
Init_Locked_Data();
memset(&LockedData.SampleTracker[0], 0, sizeof(LockedData.SampleTracker));
LockedData.Rate = rate;
Bits_Per_Sample = bits_per_sample;
sosTIMERInitSystem(_TIMER_DOS_RATE, _SOS_DEBUG_NORMAL);
if (TimerSystemOn) {
sosTIMERRegisterEvent(60, &Timer_Interrupt_Func, &SystemTimer);
// TickCount.Start();
} else
sosTIMERRegisterEvent(60, &HMI_TimerCallback, &SystemTimer);
/*
** Special code to handle the HMI problem with running under Windows.
*/
if (/*Operating_System() != OS_DOS ||*/ sample == SAMPLE_NONE) {
return(FALSE);
}
while (sample) {
#ifdef SIMPLE_HMI_INIT
if (address == -1 || inter == -1 || dma == -1) {
error = sosDIGIDetectInit((LPSTR)NULL);
if (error) {
printf("Cannot initialize detection system (%d).\n", error);
Get_Key();
break;
}
error = sosDIGIDetectFindHardware(sample, &DigiCaps, &port);
if (error) {
printf("Cannot find sound card specified.\n");
Get_Key();
break;
}
/*
** Handle the override for Address, Interrupt, and DMA settings.
*/
error = sosDIGIDetectGetSettings(&DigiHardware);
sosDIGIDetectUnInit();
if (error) {
printf("Cannot get sound card settings.\n");
Get_Key();
break;
}
} else {
DigiHardware.wPort = address;
DigiHardware.wIRQ = inter;
DigiHardware.wDMA = dma;
}
#endif
/*
** Initialize the digi-system and driver.
*/
sosDIGIInitSystem((LPSTR)NULL, _SOS_DEBUG_NORMAL);
init.wBufferSize = 1024*8; // Specify the DMA buf size
init.lpBuffer = (LPSTR)NULL;
init.wAllocateBuffer = TRUE;
init.wSampleRate = rate; // Sample playback rate.
init.wParam = 19;
init.dwParam = 0;
init.lpFillHandler = NULL;
init.lpDriverMemory = (LPSTR)NULL;
init.lpTimerMemory = (LPSTR)NULL;
init.wTimerID = _SOS_NORMAL_TIMER;
error = 0;
error = sosDIGIInitDriver( (int)sample, &DigiHardware, &init, &LockedData.DigiHandle);
if (error) {
printf("Unable to initialize the sound driver.\n");
Get_Key();
break;
}
error = 0;
if (sample >= _GUS_8_MONO && sample <= _GUS_16_ST) {
error = sosTIMERRegisterEvent(120, init.lpFillHandler, &DigiTimer);
} else {
error = sosTIMERRegisterEvent(60, init.lpFillHandler, &DigiTimer);
}
if (error) {
printf("Unable to regiser the fill handler.\n");
Get_Key();
sosDIGIUnInitDriver(LockedData.DigiHandle, TRUE, TRUE);
LockedData.DigiHandle = -1;
break;
}
/*
** Allocate a decompression buffer equal to the size of a SONARC frame
** block.
*/
LockedData.UncompBuffer = Alloc(LARGEST_SONARC_BLOCK + 50, (MemoryFlagType)(MEM_NORMAL|MEM_CLEAR|MEM_LOCK));
LockedData.MaxSamples = max_samples;
/*
** Allocate private staging buffers for double buffering sound into HMI
** driver.
*/
DigiBuffer = Alloc(2048+(((LONG)LockedData.MaxSamples*2) * (LONG)(SFX_MINI_STAGE_BUFFER_SIZE+SONARC_MARGIN)), (MemoryFlagType)(MEM_NORMAL|MEM_CLEAR|MEM_LOCK));
for (index = 0; index < LockedData.MaxSamples; index++) {
LockedData.SampleTracker[index].Buffer[0] = Add_Long_To_Pointer(DigiBuffer, ((LONG)index*2) * (LONG)(SFX_MINI_STAGE_BUFFER_SIZE+SONARC_MARGIN));
LockedData.SampleTracker[index].Buffer[1] = Add_Long_To_Pointer(DigiBuffer, ((LONG)index*2+1) * (LONG)(SFX_MINI_STAGE_BUFFER_SIZE+SONARC_MARGIN));
LockedData.SampleTracker[index].FileHandle = ERROR;
LockedData.SampleTracker[index].QueueBuffer = NULL;
}
error = sosTIMERRegisterEvent(MAINTENANCE_RATE, (void (__far *)(void))maintenance_callback, &MaintainTimer);
if (error) {
printf("Unable to initialize the maintenance callback.\n");
Get_Key();
sosTIMERRemoveEvent(DigiTimer);
sosDIGIUnInitDriver(LockedData.DigiHandle, TRUE, TRUE);
LockedData.DigiHandle = -1;
break;
}
SoundType = (SFX_Type)sample;
SampleType = (Sample_Type)sample;
ReverseChannels = reverse_channels;
break;
}
return(TRUE);
}
/***********************************************************************************************
* Sound_End -- Uninitializes the sound driver. *
* *
* This routine will uninitialize the sound driver (if any was *
* installed). This routine must be called at program termination *
* time. *
* *
* INPUT: none *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 07/23/1991 JLB : Created. *
*=============================================================================================*/
VOID Sound_End(VOID)
{
if (LockedData.DigiHandle != -1) {
sosTIMERRemoveEvent(DigiTimer);
sosTIMERRemoveEvent(MaintainTimer);
sosDIGIUnInitDriver(LockedData.DigiHandle, TRUE, TRUE);
sosDIGIUnInitSystem();
LockedData.DigiHandle = -1;
}
if (DigiBuffer) {
Free(DigiBuffer);
DigiBuffer = 0;
}
if (LockedData.UncompBuffer) {
Free(LockedData.UncompBuffer);
LockedData.UncompBuffer = 0;
}
sosTIMERRemoveEvent(SystemTimer);
sosTIMERUnInitSystem(0);
Unlock_Locked_Data();
}
/***********************************************************************************************
* Stop_Sample -- Stops any currently playing sampled sound. *
* *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 06/02/1992 JLB : Created. *
*=============================================================================================*/
VOID Stop_Sample(int handle)
{
if (LockedData.DigiHandle != -1 && (unsigned)handle < LockedData.MaxSamples) {
if (LockedData.SampleTracker[handle].Active || LockedData.SampleTracker[handle].Loading) {
LockedData.SampleTracker[handle].Active = FALSE;
if (!LockedData.SampleTracker[handle].IsScore) {
DPMI_Unlock(LockedData.SampleTracker[handle].Original, LockedData.SampleTracker[handle].OriginalSize);
LockedData.SampleTracker[handle].Original = NULL;
}
LockedData.SampleTracker[handle].Priority = 0;
/*
** Stop the sample if it is playing.
*/
if (!LockedData.SampleTracker[handle].Loading) {
sosDIGIStopSample(LockedData.DigiHandle, LockedData.SampleTracker[handle].Handle);
}
LockedData.SampleTracker[handle].Loading = FALSE;
/*
** If this is a streaming sample, then close the source file.
*/
if (LockedData.SampleTracker[handle].FileHandle != ERROR) {
Close_File(LockedData.SampleTracker[handle].FileHandle);
LockedData.SampleTracker[handle].FileHandle = ERROR;
}
LockedData.SampleTracker[handle].QueueBuffer = NULL;
}
}
}
/***********************************************************************************************
* Sample_Status -- Queries the current playing sample status (if any). *
* *
* *
* *
* INPUT: *
* *
* OUTPUT: *
* *
* WARNINGS: *
* *
* HISTORY: *
* 06/02/1992 JLB : Created. *
*=============================================================================================*/
BOOL Sample_Status(int handle)
{
/*
** If its an invalid handle or we do not have a sound driver then
** the sample in question is not playing.
*/
if (LockedData.DigiHandle == -1 || (unsigned)handle >= LockedData.MaxSamples) return(FALSE);
/*
** If the sample is loading, then for all intents and purposes the
** sample is playing.
*/
if (LockedData.SampleTracker[handle].Loading) return(TRUE);
/*
** If the sample is not active, then it is not playing
*/
if (!LockedData.SampleTracker[handle].Active) return(FALSE);
/*
** If we made it this far, then the Sample is still playing if sos says
** that it is.
*/
return (!sosDIGISampleDone(LockedData.DigiHandle, LockedData.SampleTracker[handle].Handle));
}
BOOL Is_Sample_Playing(void const * sample)
{
int index;
if (!sample) return FALSE;
for (index = 0; index < LockedData.MaxSamples; index++) {
if (LockedData.SampleTracker[index].Original == sample && Sample_Status(index)) {
return (TRUE);
}
}
return (FALSE);
}
VOID Stop_Sample_Playing(void const * sample)
{
int index;
if (sample) {
for (index = 0; index < LockedData.MaxSamples; index++) {
if (LockedData.SampleTracker[index].Original == sample) {
Stop_Sample(index);
break;
}
}
}
}
int Get_Free_Sample_Handle(int priority)
{
int id;
/*
** Find a free SFX holding buffer slot.
*/
for (id = LockedData.MaxSamples - 1; id >= 0; id--) {
if (!LockedData.SampleTracker[id].Active && !LockedData.SampleTracker[id].Loading) {
if (!StartingFileStream && LockedData.SampleTracker[id].IsScore) {
StartingFileStream = TRUE; // Ensures only one channel is kept free for scores.
continue;
}
break;
}
}
if (id < 0) {
for (id = 0; id < LockedData.MaxSamples; id++) {
if (LockedData.SampleTracker[id].Priority <= priority) break;
}
if (id == LockedData.MaxSamples) {
return(-1); // Cannot play!
}
Stop_Sample(id); // This sample gets clobbered.
}
if (id == -1) {
return -1;
}
if (LockedData.SampleTracker[id].FileHandle != ERROR) {
Close_File(LockedData.SampleTracker[id].FileHandle);
LockedData.SampleTracker[id].FileHandle = ERROR;
}
if (LockedData.SampleTracker[id].Original && !LockedData.SampleTracker[id].IsScore) {
DPMI_Unlock(LockedData.SampleTracker[id].Original, LockedData.SampleTracker[id].OriginalSize);
LockedData.SampleTracker[id].Original = NULL;
}
LockedData.SampleTracker[id].IsScore = FALSE;
return(id);
}
int Play_Sample(void const *sample, int priority, int volume, signed short panloc)
{
return(Play_Sample_Handle(sample, priority, volume, panloc, Get_Free_Sample_Handle(priority)));
}
/***********************************************************************************************
* Play_Sample_Vol -- Plays a digitized sample. *
* *
* Use this routine to play a previously loaded digitized sample. *
* *
* INPUT: sample -- Sample pointer as returned from Load_Sample. *
* *
* volume -- The volume to play (0..255 with 255=loudest). *
* *
* OUTPUT: none *
* *
* WARNINGS: none *
* *
* HISTORY: *
* 04/17/1992 JLB : Created. *
* 05/24/1992 JLB : Volume support -- Soundblaster Pro *
* 04/22/1994 JLB : Multiple sample playback rates. *
*=============================================================================================*/
int Play_Sample_Handle(void const *sample, int priority, int volume, signed short panloc, int id)
{
AUDHeaderType RawHeader;
_SOS_START_SAMPLE start;
SampleTrackerType *st=NULL; // Working pointer to sample tracker structure.
if (!sample || LockedData.DigiHandle == -1) {
return(-1);
}
if (id == -1) {
return -1;
}
/*
** Fetch the control bytes from the start of the sample data.
*/
Mem_Copy((void *)sample, (void *)&RawHeader, sizeof(RawHeader));
/*
** Prepare the sample tracker structure for processing of this
** sample. Fill the structure with data that can be determined
** before the sample is started.
*/
st = &LockedData.SampleTracker[id];
st->Compression = (SCompressType) ((unsigned char)RawHeader.Compression);
st->Original = sample;
st->OriginalSize = RawHeader.Size + sizeof(RawHeader);
if (!st->IsScore) {
DPMI_Lock(st->Original, st->OriginalSize);
}
st->Priority = priority;
st->DontTouch = FALSE;
st->Odd = 0;
st->Reducer = 0;
st->Restart = FALSE;
st->QueueBuffer = NULL;
st->QueueSize = NULL;
st->TrailerLen = 0;
st->Remainder = RawHeader.Size;
st->Source = Add_Long_To_Pointer((void *)sample, sizeof(RawHeader));
st->Service = FALSE;
/*
** If the code in question using HMI based compression then we need
** to set up for uncompressing it.
*/
if (st->Compression == SCOMP_SOS) {
st->sosinfo.wChannels = (RawHeader.Flags & AUD_FLAG_STEREO) ? 2 : 1;
st->sosinfo.wBitSize = (RawHeader.Flags & AUD_FLAG_16BIT) ? 16 : 8;
st->sosinfo.dwCompSize = RawHeader.Size;
st->sosinfo.dwUnCompSize = RawHeader.Size * ( st->sosinfo.wBitSize / 4 );
sosCODECInitStream(&st->sosinfo);
}
/*
** Fill in one or both staging buffers if possible.
*/
_disable();
// Disable_Timer_Interrupt();
if (SFX_MINI_STAGE_BUFFER_SIZE ==
Sample_Copy(st,
&st->Source,
&st->Remainder,
&st->QueueBuffer,
&st->QueueSize,
st->Buffer[0],
SFX_MINI_STAGE_BUFFER_SIZE,
st->Compression,
&st->Trailer[0],
&st->TrailerLen)) {
st->DataLength = Sample_Copy(st,
&st->Source,
&st->Remainder,
&st->QueueBuffer,
&st->QueueSize,
st->Buffer[1],
SFX_MINI_STAGE_BUFFER_SIZE,
st->Compression,
&st->Trailer[0],
&st->TrailerLen);
st->Index = 1;
} else {
st->Index = 0;
st->DataLength = 0;
}
_enable();
// Enable_Timer_Interrupt();
/*
** Fill in the HMI start sample structure.
*/
memset(&start, 0, sizeof(start));
start.lpSamplePtr = (LPSTR)st->Buffer[0];
if (st->Index == 1) {
start.dwSampleSize = SFX_MINI_STAGE_BUFFER_SIZE-1;
} else {
start.dwSampleSize = st->DataLength-1;
}
start.lpCallback = (void cdecl (far *)(unsigned int, unsigned int, unsigned int))&DigiCallback;
start.wLoopCount = 0;
start.wSampleID = id;
/*
** Adjust pitch shifting as necessary so that lower playback
** samples can be supported.
*/
if (RawHeader.Rate != LockedData.Rate) {
ldiv_t result;
result = ldiv((long)RawHeader.Rate, LockedData.Rate);
start.dwSamplePitchAdd = (long)MAKE_LONG((short)result.quot, (short)(((long)result.rem * 0x10000L) / LockedData.Rate));
start.wSampleFlags |= _PITCH_SHIFT;
}
/*
** Sample translation flag.
*/
if (RawHeader.Flags & AUD_FLAG_16BIT) {
if (Bits_Per_Sample == 8) {
start.wSampleFlags |= _TRANSLATE16TO8;
}
} else {
if (Bits_Per_Sample == 16) {
start.wSampleFlags |= _TRANSLATE8TO16;
}
}
/*
** Sample stereo flag.
*/
if (RawHeader.Flags & AUD_FLAG_STEREO) {
start.wChannel = _INTERLEAVED;
start.wSampleFlags |= _STEREOTOMONO;
} else {
start.wChannel = _CENTER_CHANNEL;
}
/*
** Sample volume control flags. Always give it volume control because
** if not, then future volume control is either ignored or stops the
** sample.
*/
st->Volume = volume << 7;
start.wVolume = (st->Volume >> 8) * LockedData.SoundVolume;
start.wSampleFlags |= _VOLUME;
/*
** If we have defined a panning location for the sound driver than
** take care of it here. Panning will only work with a stereo driver
** and only if the sample is played _CENTER_CHANNEL.
*/
if ((panloc != 0x0) && (!(RawHeader.Flags & AUD_FLAG_STEREO))) {
start.wChannel = _CENTER_CHANNEL;
panloc = ((ReverseChannels) ? ((-panloc) + 0x8000) : ((panloc) + 0x8000));
start.wSampleFlags |= _PANNING;
start.wSamplePanLocation= panloc;
}
st->Stereo = start.wChannel;
st->Pitch = start.dwSamplePitchAdd;
st->Flags = start.wSampleFlags;
/*
** Start the sample playing now.
*/
_disable(); // NEW
// Disable_Timer_Interrupt();
st->Handle = sosDIGIStartSample(LockedData.DigiHandle, &start);
if (st->Handle == -1) {
id = -1;
} else {
/*
** Fill in the sample tracker structure with those values that are
** determined AFTER the sample starts.
*/
st->Active = TRUE;
}
_enable(); // NEW
// Enable_Timer_Interrupt();
return(id);
}
int Set_Sound_Vol(int volume)
{
int old;
old = LockedData.SoundVolume;
LockedData.SoundVolume = volume & 0xFF;
return(old);
}
int Set_Score_Vol(int volume)
{
int old;
old = LockedData.ScoreVolume;
LockedData.ScoreVolume = volume & 0xFF;
return(old);
}
VOID Fade_Sample(int handle, int ticks)
{
if (Sample_Status(handle)) {
if (!ticks || LockedData.SampleTracker[handle].Loading) {
Stop_Sample(handle);
} else {
SampleTrackerType * st;
st = &LockedData.SampleTracker[handle];
st->Reducer = (st->Volume / ticks)+1;
}
}
}
int Get_Digi_Handle(void)
{
return(LockedData.DigiHandle);
}
/***************************************************************************
* SAMPLE_LENGTH -- returns length of a sample in ticks *
* *
* INPUT: void const *sample - pointer to the sample to get length *
* of. *
* *
* OUTPUT: long - length of the sample in ticks (60/sec) *
* *
* HISTORY: *
* 07/05/1995 PWG : Created. *
*=========================================================================*/
long Sample_Length(void const *sample)
{
AUDHeaderType RawHeader;
if (!sample) return(0);
Mem_Copy((void *)sample, (void *)&RawHeader, sizeof(RawHeader));
long time = RawHeader.UncompSize;
/*
** If the sample is a 16 bit sample, then it will take only half
** as long to play.
*/
if (RawHeader.Flags & AUD_FLAG_16BIT) {
time >>= 1;
}
/*
** If the sample is a stereo sample, then it will take only half
** as long to play.
*/
if (RawHeader.Flags & AUD_FLAG_STEREO) {
time >>= 1;
}
if (RawHeader.Rate/60) {
time /= (RawHeader.Rate/60);
}
return(time);
}
Reference in New Issue Copy Permalink