datalore/CnC_Red_Alert
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
CnC_Red_Alert/VQ/VQA32/AUDIO.BAK2

1247 lines
31 KiB
Plaintext
Raw Permalink Blame History

/*
** 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/>.
*/
/****************************************************************************
*
* C O N F I D E N T I A L -- W E S T W O O D S T U D I O S
*
*----------------------------------------------------------------------------
*
* PROJECT
* VQA player library. (32-Bit protected mode)
*
* FILE
* audio.c
*
* DESCRIPTION
* Audio playback and timing.
*
* PROGRAMMER
* Bill Randolph
* Denzil E. Long, Jr.
*
* DATE
* June 22, 1995
*
*----------------------------------------------------------------------------
*
* PUBLIC
* VQA_StartTimerInt - Initialize system timer interrupt.
* VQA_StopTimerInt - Remove system timer interrupt.
* VQA_SetTimer - Resets current time to given tick value.
* VQA_GetTime - Return current time.
* VQA_TimerMethod - Get timer method being used.
* VQA_OpenAudio - Open sound system.
* VQA_CloseAudio - Close sound system
* VQA_StartAudio - Starts audio playback
* VQA_StopAudio - Stop audio playback.
* CopyAudio - Copy data from Audio Temp buf into Audio play buf.
*
* PRIVATE
* TimerCallback - Timer callback routine; called by HMI
* AutoDetect - Auto detect the sound card.
* AudioCallback - Sound system callback.
*
****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <mem.h>
#include <sys\timeb.h>
#include "vqaplayp.h"
#include <vqm32\all.h>
#ifdef __WATCOMC__
#pragma pack(4);
#endif
#if(VQAAUDIO_ON)
#include "sos.h"
#endif
/*---------------------------------------------------------------------------
* AUDIO DEFINITIONS
*-------------------------------------------------------------------------*/
#define HMI_SAMPLE 0x1000
#define HMI_DEFAULT_RATE 22050
#define HMI_UNINIT 0 /* Unitialize state. */
#define HMI_VQAINIT 1 /* VQA initialized */
#define HMI_APPINIT 2 /* Application initialized */
#if(VQAAUDIO_ON)
/*---------------------------------------------------------------------------
* PROTOTYPES
*-------------------------------------------------------------------------*/
long AutoDetect(long bitsize, long channels);
void far TimerCallback(void);
void far cdecl AudioCallback(WORD wDriverHandle, WORD wAction,
WORD wSampleID);
/*---------------------------------------------------------------------------
* GLOBAL DATA
*-------------------------------------------------------------------------*/
/* HMI Start Sample structure:
*
* lpSamplePtr - Pointer to audio buffer.
* dwSampleSize - Size of buffer.
* wLoopCount - Number of time to loop (-1 = infinate)
* wChannel - Channel to play sample on.
* wVolume - Volume level to play at.
* wSampleID - ID for sample
* lpCallback - Callback function pointer.
* wSamplePort - Port to use for non-DMA
* wSampleFlags - Flags
* dwSampleByteLength - Total length including loops
* dwSampleLoopPoint -
* dwSampleLoopLength -
* dwSamplePitchAdd - Pitch shifting component.
* wSamplePitchFraction - Pitch shifting component.
* wSamplePanLocation - For panning
* wSamplePanSpeed - For panning
* wSamplePanDirection - For panning
* wSamplePanStart - For panning.
* wSamplePanEnd - For panning.
* wSampleDelayBytes - Delay part.
* wSampleDelayRepeat - Delay part.
* dwSampleADPCMPredicted - For compression
* wSampleADPCMIndex - For compression
* wSampleRootNoteMIDI - Root note for pitch shift
* dwFiller[3] - Filler for future upgrades.
*/
_SOS_START_SAMPLE sSOSSampleData = {
_NULL,
0L,
0,
_CENTER_CHANNEL,
0x7FFF,
HMI_SAMPLE,
AudioCallback,
0,
0,
0L,
0L,0L,
0L,0,
0,0,0,0,0,
0,0,
0L,0,
0,
0L,0L,0L
};
/* HMI Driver structure: Driver initialization structure.
*
* wBufferSize - Size of play buffer.
* lpBuffer - Pointer to buffer.
* wAllocateBuffer - Allocate buffer flag.
* wSampleRate - Playback rate.
* wParam -
* dwParam -
* lpFillHandler -
* lpDriverMemory -
* lpTimerMemory -
* wTimerID -
*/
_SOS_INIT_DRIVER sSOSInitDriver = {
0,
_NULL,
_TRUE,
HMI_DEFAULT_RATE,
19,
0L,
_NULL,
_NULL,
_NULL,
_SOS_NORMAL_TIMER
};
static _SOS_CAPABILITIES DigiCaps;
static _SOS_HARDWARE DigiHardware;
static WORD DigiHandle = -1;
static WORD DigiTimer = 0;
static WORD SampleHandle;
static long DigiInitFlag = HMI_UNINIT;
static long PlayingFlag = 0;
static VQAHandleP *VQAP;
static unsigned long CurBlock = 0;
static unsigned long NextBlock;
static WORD VQATimer = 0;
static long TimerMethod;
static long TimerInitFlag = HMI_UNINIT;
static long HMITimerFlag = HMI_UNINIT;
static long VQATickCount = 0;
#endif /* VQAAUDIO_ON */
static long TickOffset = 0;
char *HMIDevName = "<none>";
#if(VQAAUDIO_ON)
/****************************************************************************
*
* NAME
* VQA_StartTimerInt - Initialize system timer interrupt.
*
* SYNOPSIS
* Error = VQA_StartTimerInt(Init)
*
* long VQA_StartTimerInt(long);
*
* FUNCTION
* Initialize the HMI timer system if it hasn't been already then add
* our own timer event.
*
* INPUTS
* Init - Initialize HMI timer system flag. (TRUE = Initialize)
*
* RESULT
* Error - 0 if successful, -1 if error.
*
****************************************************************************/
long VQA_StartTimerInt(long init)
{
/* Does the caller want me to initialize the timer system? */
if (init == 0) {
/* If the timer system is uninitialized then it is the players
* responsibility to do it.
*/
if (TimerInitFlag == HMI_UNINIT) {
sosTIMERInitSystem(_TIMER_DOS_RATE, _SOS_DEBUG_NORMAL);
TimerInitFlag = HMI_VQAINIT;
}
} else {
TimerInitFlag = HMI_APPINIT;
}
/* Register the VQA_TickCount timer event. */
if (HMITimerFlag == HMI_UNINIT) {
if (sosTIMERRegisterEvent(VQA_TIMETICKS,TimerCallback,&VQATimer) == 0) {
HMITimerFlag = HMI_VQAINIT;
} else {
return (-1);
}
}
return (0);
}
/****************************************************************************
*
* NAME
* VQA_StopTimerInt - Remove system timer interrupt.
*
* SYNOPSIS
* VQA_StopTimerInt()
*
* void VQA_StopTimerInt(void);
*
* FUNCTION
* Remove our timer event from the HMI timer system. Uninitialize the
* HMI timer system if we initialized it.
*
* INPUTS
* NONE
*
* RESULT
* NONE
*
****************************************************************************/
void VQA_StopTimerInt(void)
{
/* Remove the timer event */
if (HMITimerFlag == HMI_VQAINIT) {
sosTIMERRemoveEvent(VQATimer);
}
HMITimerFlag = HMI_UNINIT;
if (TimerInitFlag == HMI_VQAINIT) {
sosTIMERUnInitSystem(0);
}
TimerInitFlag = HMI_UNINIT;
}
/****************************************************************************
*
* NAME
* TimerCallback - VQA timer event. (Called by HMI)
*
* SYNOPSIS
* TimerCallback()
*
* void TimerCallback(void);
*
* FUNCTION
* Our custom timer event. This is the timer event that we register with
* HMI for system timing.
*
* INPUTS
* NONE
*
* RESULT
* NONE
*
****************************************************************************/
void far TimerCallback(void)
{
VQATickCount++;
}
#endif /* VQAAUDIO_ON */
/****************************************************************************
*
* NAME
* VQA_SetTimer - Resets current time to given tick value.
*
* SYNOPSIS
* VQA_SetTimer(Time, Method)
*
* void VQA_SetTimer(long, long);
*
* FUNCTION
* Sets 'TickOffset' to a value that will make the current time look like
* the time passed in. This function allows the player to be "paused",
* by recording the time of the pause, and then setting the timer to
* that time. The timer method used by the player is also set. The method
* selected is not neccesarily the method that will be used because some
* timer methods work with only certain playback conditions. (EX: The
* audio DMA timer method cannot be used if there is not any audio
* playing.)
*
* INPUTS
* Time - Value to set current time to.
* Method - Timer method to use.
*
* RESULT
* NONE
*
****************************************************************************/
void VQA_SetTimer(long time, long method)
{
unsigned long curtime;
#if(VQAAUDIO_ON)
/* If the client does not have a preferencee then pick a method
* based on the state of the player.
*/
if (method == VQA_TMETHOD_DEFAULT) {
/* If we are playing audio, use the audio DMA position. */
if (PlayingFlag) {
method = VQA_TMETHOD_AUDIO;
}
/* Otherwise use the HMI timer if it is initialized. */
else if (HMITimerFlag) {
method = VQA_TMETHOD_INT;
}
/* If all else fails resort the the "jerky" DOS time. */
else {
method = VQA_TMETHOD_DOS;
}
} else {
/* We cannot use the DMA position if there isn't any audio playing. */
if (!PlayingFlag && (method == VQA_TMETHOD_AUDIO)) {
method = VQA_TMETHOD_INT;
}
/* We cannot use the timer if it has not been initialized. */
if (!HMITimerFlag && (method == VQA_TMETHOD_INT)) {
method = VQA_TMETHOD_DOS;
}
}
TimerMethod = method;
#endif
TickOffset = 0L;
curtime = VQA_GetTime();
TickOffset = (time - curtime);
}
/****************************************************************************
*
* NAME
* VQA_GetTime - Return current time.
*
* SYNOPSIS
* Time = VQA_GetTime()
*
* unsigned long VQA_GetTime(void);
*
* FUNCTION
* This routine returns timer ticks computed one of 3 ways:
*
* 1) If audio is playing, the timer is based on the DMA buffer position:
* Compute the number of audio samples that have actually been played.
* The following internal HMI variables are used:
*
* _lpSOSDMAFillCount[drv_handle]: current DMA buffer position
* _lpSOSSampleList[drv_handle][samp_handle]:
* sampleTotalBytes: total bytes sent by HMI to the DMA buffer
* sampleLastFill: HMI's last fill position in DMA buffer
*
* So, the number of samples actually played is:
*
* sampleTotalBytes - <DMA_diff>
* where <DMA_diff> is how far ahead sampleLastFill is in front of
* _lpSOSDMAFillCount: (sampleLastFill - _lpSOSDMAFillCount)
*
* These values are indices into a circular DMA buffer, so:
*
* if (sampleLastFill >= _lpSOSDMAFillCount)
* <DMA_diff> = sampleLastFill - _lpSOSDMAFillCount
* else
* <DMA_diff> = (DMA_BUF_SIZE - lpSOSDMAFillCount) + sampleLastFill
*
* Note that, if using the stereo driver with mono data, you must
* divide LastFill & FillCount by 2, but not TotalBytes. If using the
* stereo driver with stereo data, you must divide all 3 variables
* by 2.
*
* 2) If no audio is playing, but the timer interrupt is running,
* VQATickCount is used as the timer
*
* 3) If no audio is playing & no timer interrupt is going, the DOS 18.2
* system timer is used.
*
* Regardless of the method, TickOffset is used as an offset from the
* computed time.
*
* INPUTS
* NONE
*
* RESULT
* Time - Time in VQA_TIMETICKS
*
****************************************************************************/
unsigned long VQA_GetTime(void)
{
#if(VQAAUDIO_ON)
VQAAudio *audio;
unsigned long bytesleft;
unsigned long samples;
#endif
long ticks;
#if(VQAAUDIO_ON)
switch (TimerMethod) {
/* If Audio is playing then timing is based on the audio DMA buffer
* position.
*/
case VQA_TMETHOD_AUDIO:
/* Dereference commonly used data members for quicker access. */
audio = &VQAP->VQABuf->Audio;
/* Compute our current position in the audio track by getting the
* bytes processed by HMI. Then adjust the bytes processed by the
* position of the DMA fill handler, this should tell us exactly
* where we are in the audio track.
*/
samples = _lpSOSSampleList[DigiHandle][SampleHandle]->sampleTotalBytes;
bytesleft = _lpSOSSampleList[DigiHandle][SampleHandle]->sampleBytesLeft;
/* Adjust the bytes processed from the bytes left to DMA in the
* buffer.
*/
if (samples >= bytesleft) {
samples -= bytesleft;
}
/* Calculate the number of samples by taking the total number of
* bytes processed and divide it by the number of channels and
* bits per sample.
*/
samples -= (audio->NumSkipped * VQAP->Config.HMIBufSize);
samples /= (audio->Channels * (audio->BitsPerSample >> 3));
/* The elapsed ticks is calculated by the number of samples
* processed times the tick resolution per second divided by the
* sample rate.
*/
ticks = (long)((samples * VQA_TIMETICKS) / audio->SampleRate);
ticks += TickOffset;
break;
/* No audio playing, but timer interrupt is going; use VQATickCount */
case VQA_TMETHOD_INT:
ticks = (VQATickCount + TickOffset);
break;
/* No interrupts are going at all; use DOS's time */
default:
case VQA_TMETHOD_DOS:
{
struct timeb mytime;
ftime(&mytime);
ticks = (unsigned long)mytime.time*1000L+(unsigned long)mytime.millitm;
ticks = ((ticks * VQA_TIMETICKS) / 1000L);
ticks += TickOffset;
}
break;
}
#else
{
struct timeb mytime;
ftime(&mytime);
ticks = (unsigned long)mytime.time*1000L+(unsigned long)mytime.millitm;
ticks = ((ticks * VQA_TIMETICKS) / 1000L);
ticks += TickOffset;
}
#endif
return (ticks);
}
/****************************************************************************
*
* NAME
* VQA_TimerMethod - Get timer method being used.
*
* SYNOPSIS
* Method = VQA_TimerMethod()
*
* long VQA_TimerMethod(void);
*
* FUNCTION
* Returns the ID of the current timer method being used.
*
* INPUTS
* NONE
*
* RESULT
* Method - Method used for the timer.
*
****************************************************************************/
long VQA_TimerMethod(void)
{
#if(VQAAUDIO_ON)
return (TimerMethod);
#else
return (VQA_TMETHOD_DOS);
#endif
}
#if(VQAAUDIO_ON)
/****************************************************************************
*
* NAME
* VQA_OpenAudio - Open sound system.
*
* SYNOPSIS
* Error = VQA_OpenAudio(VQAHandleP)
*
* long VQA_OpenAudio(VQAHandleP *);
*
* FUNCTION
* Initialize the sound system by setting the DigiHandle to and HMI
* driver handle. The timer must first be initialized before calling
* this function.
*
* INPUTS
* VQAHandleP - Pointer to private VQAHandle.
*
* RESULT
* Error - 0 if successful, -1 if error.
*
****************************************************************************/
long VQA_OpenAudio(VQAHandleP *vqap)
{
VQAData *vqabuf;
VQAAudio *audio;
VQAConfig *config;
VQAHeader *header;
unsigned char *driver_path;
WORD port;
long rc;
/* Return if already initialized */
if (DigiInitFlag != HMI_UNINIT) {
return (0);
}
/* Dereference data memebers for quicker access. */
config = &vqap->Config;
header = &vqap->Header;
vqabuf = vqap->VQABuf;
audio = &vqabuf->Audio;
/* Fail if no audio buffer or DigiCard is 0 (no sound) */
if ((audio->Buffer == NULL) || (config->DigiCard == 0)) {
return (-1);
}
/* Reset the buffer position to the beginning. */
CurBlock = 0;
/*-------------------------------------------------------------------------
* Compute the playback rate:
*
* - If Config->AudioRate is -1, use HMI_DATA_RATE scaled to the specified
* frame rate (so the audio plays faster if we're playing faster)
* - otherwise, use the specified rate
*-----------------------------------------------------------------------*/
if (config->AudioRate != -1) {
sSOSInitDriver.wSampleRate = config->AudioRate;
}
else if (config->FrameRate != header->FPS) {
sSOSInitDriver.wSampleRate = ((audio->SampleRate * config->FrameRate)
/ (unsigned long)header->FPS);
config->AudioRate = sSOSInitDriver.wSampleRate;
} else {
sSOSInitDriver.wSampleRate = audio->SampleRate;
config->AudioRate = audio->SampleRate;
}
/* If the application has already initialized HMI then set the
* necessary variables. Otherwise we must setup HMI ourself.
*/
if (config->OptionFlags & VQAOPTF_HMIINIT) {
/* The application MUST provide the card type! */
if (config->DigiCard == -1) {
return (-1);
}
/* Init the detection system */
driver_path = (unsigned char *)".\\";
if ((rc = sosDIGIDetectInit(driver_path)) != 0) {
return (rc);
}
/* Get the capabilities of the card being used. */
rc = sosDIGIDetectGetCaps(config->DigiCard, &DigiCaps);
sosDIGIDetectUnInit();
if (rc != 0) {
return (rc);
}
DigiHandle = config->DigiHandle;
HMIDevName = "App-Specific";
TimerInitFlag = HMI_APPINIT;
DigiInitFlag = HMI_APPINIT;
} else {
/* Init the detection system */
driver_path = (unsigned char *)".\\";
if ((rc = sosDIGIDetectInit(driver_path)) != 0) {
return (rc);
}
/*-----------------------------------------------------------------------
* Initialize DigiHardware with port, IRQ, and DMA, and make sure
* Config.DigiCard contains the HMI ID we want to use:
*
* - If Config.DigiCard is -1, auto-detect the hardware; then, do a
* FindHardware so the GetSettings will work
* - If Config.DigiCard is filled in, but port, IRQ or DMA is -1, use
* FindHardware & GetSettings to get the settings
* - If all are filled in, just use them as they are
*---------------------------------------------------------------------*/
/* Auto-Detect */
if (config->DigiCard == -1) {
/* Version 1 VQA's have only 8 bit mono audio streams. */
if (header->Version == VQAHD_VER1) {
config->DigiCard = AutoDetect(8, 1);
} else {
config->DigiCard = AutoDetect(audio->BitsPerSample, audio->Channels);
/* Resort to 8bit mono */
if (config->DigiCard == -1) {
config->DigiCard = AutoDetect(8, 1);
}
}
if (config->DigiCard == -1) {
sosDIGIDetectUnInit();
return (-1);
}
}
/* Do a FindHardware & GetSettings */
if (config->DigiPort == -1) {
if (sosDIGIDetectFindHardware(config->DigiCard, &DigiCaps, &port)) {
sosDIGIDetectUnInit();
return (-1);
}
if (sosDIGIDetectGetSettings(&DigiHardware)) {
sosDIGIDetectUnInit();
return (-1);
}
config->DigiPort = DigiHardware.wPort;
config->DigiIRQ = DigiHardware.wIRQ;
config->DigiDMA = DigiHardware.wDMA;
HMIDevName = (char *)DigiCaps.szDeviceName;
} else {
DigiHardware.wPort = config->DigiPort;
DigiHardware.wIRQ = config->DigiIRQ;
DigiHardware.wDMA = config->DigiDMA;
HMIDevName = "App-Specific";
}
sosDIGIDetectUnInit();
/* Initialize the DIGI system & driver */
sosDIGIInitSystem(driver_path, _SOS_DEBUG_NORMAL);
sSOSInitDriver.wBufferSize = config->HMIBufSize;
sSOSInitDriver.lpBuffer = NULL;
sSOSInitDriver.lpFillHandler = NULL;
sSOSInitDriver.lpDriverMemory = NULL;
sSOSInitDriver.lpTimerMemory = NULL;
DigiHandle = -1;
if ((rc = sosDIGIInitDriver(config->DigiCard, &DigiHardware,
&sSOSInitDriver, &DigiHandle)) != 0) {
return (rc);
}
/*-----------------------------------------------------------------------
* Register the timer event
*---------------------------------------------------------------------*/
/* If the timer hasn't been init'd, do it now */
if (TimerInitFlag == HMI_UNINIT) {
sosTIMERInitSystem(_TIMER_DOS_RATE ,_SOS_DEBUG_NORMAL);
TimerInitFlag = HMI_VQAINIT;
}
/* Register the event */
rc = sosTIMERRegisterEvent(VQA_TIMETICKS, sSOSInitDriver.lpFillHandler,
&DigiTimer);
if (rc) {
sosDIGIUnInitDriver(DigiHandle, _TRUE, _TRUE);
sosDIGIUnInitSystem();
return (rc);
}
config->DigiHandle = DigiHandle;
DigiInitFlag = HMI_VQAINIT;
}
return (0);
}
/****************************************************************************
*
* NAME
* AutoDetect - Auto detect the sound card.
*
* SYNOPSIS
* CardID = AutoDetect(BitSize, Channels)
*
* long AutoDetect(long, long);
*
* FUNCTION
* Autodetects the type of sound card present in the system.
*
* INPUTS
* BitSize - Bits per sample size.
* Channels - Number of desired channels.
*
* RESULT
* CardID - HMI ID of the sound card found, -1 if none.
*
****************************************************************************/
long AutoDetect(long bitsize, long channels)
{
long device_id = -1;
WORD port;
long i;
long rc;
/* Search for an 8-bit mono device */
if (sosDIGIDetectFindFirst(&DigiCaps, &port)) {
return (-1);
}
channels--;
i = 0;
while (i < 6) {
i++;
if ((DigiCaps.wBitsPerSample == bitsize)
&& (DigiCaps.wChannels == channels)) {
break;
}
if (sosDIGIDetectFindNext(&DigiCaps, &port)) {
return (-1);
}
}
/* Exit if failed to find the required device */
if ((DigiCaps.wBitsPerSample != bitsize)
|| (DigiCaps.wChannels != channels)) {
return (-1);
}
/* Stash the ID */
device_id = DigiCaps.wDeviceID;
/* Now that we have handled the initial pass, verify that if we found an
* _ADLIB_GOLD_8_MONO that it is not a Logitech Sound Wave man in disguise.
*/
if ((WORD)DigiCaps.wDeviceID == _ADLIB_GOLD_8_MONO) {
rc = sosDIGIDetectFindNext(&DigiCaps, &port);
while ((i < 6) && (rc == 0)) {
i++;
if ((DigiCaps.wBitsPerSample == 8) && (DigiCaps.wChannels == 0)) {
break;
}
if ((rc = sosDIGIDetectFindNext(&DigiCaps, &port)) != 0) {
break;
}
}
/* If we don't have an error use the secondary device ID, after all,
* anything's better than an Adlib Gold. If we do have an error or there
* is nothing we can use then the device ID is already set to the adlib
* gold so just let it rip.
*/
if ((rc == 0) && ((WORD)DigiCaps.wDeviceID == _SBPRO_8_MONO)) {
return (DigiCaps.wDeviceID);
}
}
return (device_id);
}
/****************************************************************************
*
* NAME
* VQA_CloseAudio - Close sound system
*
* SYNOPSIS
* VQA_CloseAudio()
*
* void VQA_CloseAudio(void);
*
* FUNCTION
* Removes VQA's involvement in the audio system.
*
* INPUTS
* NONE
*
* RESULT
* NONE
*
****************************************************************************/
void VQA_CloseAudio(void)
{
/* Remove the Digi event */
if (DigiInitFlag == HMI_VQAINIT) {
sosTIMERRemoveEvent(DigiTimer);
}
/* Un-init timer if necessary */
if (TimerInitFlag == HMI_VQAINIT) {
sosTIMERUnInitSystem(0);
}
TimerInitFlag = HMI_UNINIT;
/* Remove the driver */
if (DigiInitFlag == HMI_VQAINIT) {
sosDIGIUnInitDriver(DigiHandle, _TRUE, _TRUE);
sosDIGIUnInitSystem();
}
DigiInitFlag = HMI_UNINIT;
if (PlayingFlag) {
PlayingFlag = 0;
}
}
/****************************************************************************
*
* NAME
* VQA_StartAudio - Starts audio playback
*
* SYNOPSIS
* Error = VQA_StartAudio(VQA)
*
* long VQA_StartAudio(VQAHandleP *);
*
* FUNCTION
* Start the audio playback for the movie.
*
* INPUTS
* VQA - Pointer to private VQA handle.
*
* RESULT
* Error - 0 if successful, or -1 error code.
*
****************************************************************************/
long VQA_StartAudio(VQAHandleP *vqap)
{
VQAConfig *config;
VQAAudio *audio;
/* Save buffers for the callback routine */
VQAP = vqap;
/* Dereference commonly used data members for quicker access. */
config = &vqap->Config;
audio = &vqap->VQABuf->Audio;
/* Return if already playing */
if (audio->Flags & VQAAUDF_ISPLAYING) {
return (-1);
}
/* Set my driver handle */
if (config->DigiHandle != -1) {
DigiHandle = config->DigiHandle;
}
if (DigiHandle == (WORD)-1) {
return (-1);
}
/*-------------------------------------------------------------------------
* Initialize the sample structure.
*-----------------------------------------------------------------------*/
memset(&sSOSSampleData, 0, sizeof(_SOS_START_SAMPLE));
sSOSSampleData.lpSamplePtr = (unsigned char *)vqap->VQABuf->Audio.Buffer;
sSOSSampleData.dwSampleSize = config->HMIBufSize;
sSOSSampleData.wVolume = (config->Volume << 7);
sSOSSampleData.wSampleID = HMI_SAMPLE;
sSOSSampleData.lpCallback = AudioCallback;
/* Set the channel flags for the type of data we have. */
if (audio->Channels == 2) {
sSOSSampleData.wChannel = _INTERLEAVED;
} else {
sSOSSampleData.wChannel = _CENTER_CHANNEL;
}
/* If the card is unable to handle stereo data the we must notify the
* sound system to convert the stereo data to mono data during playback.
*/
if ((audio->Channels - 1) > DigiCaps.wChannels) {
sSOSSampleData.wSampleFlags |= _STEREOTOMONO;
}
/* If the card is unable to handle the sample size of the audio data
* then we must notify the sound system to convert the audio data to
* the proper format.
*/
if (audio->BitsPerSample != DigiCaps.wBitsPerSample) {
if (audio->BitsPerSample > DigiCaps.wBitsPerSample) {
sSOSSampleData.wSampleFlags |= _TRANSLATE16TO8;
} else {
sSOSSampleData.wSampleFlags |= _TRANSLATE8TO16;
}
}
/* Start playback */
SampleHandle = sosDIGIStartSample(DigiHandle, &sSOSSampleData);
audio->Flags |= VQAAUDF_ISPLAYING;
PlayingFlag = 1;
return (0);
}
/****************************************************************************
*
* NAME
* VQA_StopAudio - Stop audio playback.
*
* SYNOPSIS
* VQA_StopAudio(VQA)
*
* void VQA_StopAudio(VQAHandleP *);
*
* FUNCTION
* Halts the currently playing audio stream.
*
* INPUTS
* VQA - Pointer to private VQAHandle.
*
* RESULT
* NONE
*
****************************************************************************/
void VQA_StopAudio(VQAHandleP *vqap)
{
/* Just return if not playing */
if (vqap->VQABuf->Audio.Flags & VQAAUDF_ISPLAYING) {
vqap->VQABuf->Audio.Flags &= ~VQAAUDF_ISPLAYING;
sosDIGIStopSample(DigiHandle, SampleHandle);
}
}
/****************************************************************************
*
* NAME
* AudioCallback - Sound system callback.
*
* SYNOPSIS
* AudioCallback(DriverHandle, Action, SampleID)
*
* void AudioCallback(WORD, WORD, WORD);
*
* FUNCTION
* Our custom audio callback routine that services HMI.
*
* INPUTS
* DriverHandle - HMI driver handle.
* Action - Action taken.
* SampleID - ID of sample.
*
* RESULT
* NONE
*
****************************************************************************/
void far cdecl AudioCallback(WORD wDriverHandle,WORD wAction,WORD wSampleID)
{
VQAAudio *audio;
VQAConfig *config;
/* Dereference commonly used data members for quicker access. */
audio = &VQAP->VQABuf->Audio;
config = &VQAP->Config;
/* Suppress compiler warnings */
wDriverHandle = wDriverHandle;
wSampleID = wSampleID;
/* See if we're called because the buffer is empty */
if (wAction == _SAMPLE_PROCESSED) {
/* Compute the 'NextBlock' index */
NextBlock = CurBlock + 1;
if (NextBlock >= audio->NumAudBlocks) {
NextBlock = 0;
}
/* See if the next block has data in it; if so, update the audio
* buffer play position & the 'CurBlock' value.
* If not, don't change anything and replay this block.
*/
if (audio->IsLoaded[NextBlock] == 1) {
/* Update this block's status to loadable (0) */
audio->IsLoaded[CurBlock] = 0;
/* Update position within audio buffer */
audio->PlayPosition += config->HMIBufSize;
CurBlock++;
if (audio->PlayPosition >= config->AudioBufSize) {
audio->PlayPosition = 0;
CurBlock = 0;
}
} else {
audio->NumSkipped++;
}
/* Start the new buffer playing */
sSOSSampleData.lpSamplePtr = (unsigned char *)(audio->Buffer)
+ audio->PlayPosition;
sosDIGIContinueSample(DigiHandle, SampleHandle, &sSOSSampleData);
audio->SamplesPlayed += config->HMIBufSize;
}
}
/****************************************************************************
*
* NAME
* CopyAudio - Copy data from Audio Temp buffer into Audio play buffer.
*
* SYNOPSIS
* Error = CopyAudio(VQA)
*
* long CopyAudio(VQAHandleP *);
*
* FUNCTION
* This routine just copies the data in the TempBuf into the correct
* spots in the audio play buffer. If there is no room available in the
* audio play buffer, the routine returns VQAERR_SLEEPING, which will put
* the whole Loader to "sleep" while it waits for a free buffer.
*
* If there's no data in the TempBuf to copy, the routine just returns 0.
*
* INPUTS
* VQA - Pointer to private VQAHandle structure.
*
* RESULT
* Error - 0 if successful or VQAERR_??? error code.
*
****************************************************************************/
long CopyAudio(VQAHandleP *vqap)
{
VQAAudio *audio;
VQAConfig *config;
long startblock;
long endblock;
long len1,len2;
long i;
/* Dereference commonly used data members for quicker access. */
audio = &vqap->VQABuf->Audio;
config = &vqap->Config;
/* If audio is disabled, or if we're playing from a VOC file, or if
* there's no Audio Buffer, or if there's no data to copy, just return 0
*/
#if(VQAVOC_ON && VQAAUDIO_ON)
if (((config->OptionFlags & VQAOPTF_AUDIO) == 0) || (vqap->vocfh != -1)
|| (audio->Buffer == NULL) || (audio->TempBufLen == 0)) {
#else /* VQAVOC_ON */
if (((config->OptionFlags & VQAOPTF_AUDIO) == 0) || (audio->Buffer == NULL)
|| (audio->TempBufLen == 0)) {
#endif /* VQAVOC_ON */
return (0);
}
/* Compute start & end blocks to copy into */
startblock = (audio->AudBufPos / config->HMIBufSize);
endblock = (audio->AudBufPos + audio->TempBufLen) / config->HMIBufSize;
if (endblock >= audio->NumAudBlocks) {
endblock -= audio->NumAudBlocks;
}
/* If 'endblock' hasn't played yet, return VQAERR_SLEEPING */
if (audio->IsLoaded[endblock] == 1) {
return (VQAERR_SLEEPING);
}
/* Copy the data:
*
* - If 'startblock' < 'endblock', copy the entire buffer
* - Otherwise, fill to the end of the buffer with part of the data, then
* copy the rest to the beginning of the buffer
*/
if (startblock <= endblock) {
/* Copy data */
memcpy((audio->Buffer + audio->AudBufPos), audio->TempBuf,
audio->TempBufLen);
/* Adjust current load position */
audio->AudBufPos += audio->TempBufLen;
/* Mark buffer as empty */
audio->TempBufLen = 0;
/* Set all blocks to loaded */
for (i = startblock; i < endblock; i++) {
audio->IsLoaded[i] = 1;
}
return (0);
} else {
/* Compute length of each piece */
len1 = config->AudioBufSize - audio->AudBufPos;
len2 = audio->TempBufLen - len1;
/* Copy 1st piece into end of Audio Buffer */
memcpy((audio->Buffer + audio->AudBufPos), audio->TempBuf, len1);
/* Copy 2nd piece into start of Audio Buffer */
memcpy(audio->Buffer, audio->TempBuf + len1, len2);
/* Adjust load position */
audio->AudBufPos = len2;
/* Mark buffer as empty */
audio->TempBufLen = 0;
/* Set blocks to loaded */
for (i = startblock; i < audio->NumAudBlocks; i++) {
audio->IsLoaded[i] = 1;
}
for (i = 0; i < endblock; i++) {
audio->IsLoaded[i] = 1;
}
return (0);
}
}
#ifdef __WATCOMC__
#pragma pack(1);
#endif
#endif /* VQAAUDIO_ON */
Reference in New Issue View Git Blame Copy Permalink