mirror of
https://github.com/KolibriOS/kolibrios.git
synced 2024-12-04 22:32:05 +03:00
986 lines
23 KiB
C
986 lines
23 KiB
C
// Emacs style mode select -*- C++ -*-
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Id:$
|
|
//
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
//
|
|
// This source is available for distribution and/or modification
|
|
// only under the terms of the DOOM Source Code License as
|
|
// published by id Software. All rights reserved.
|
|
//
|
|
// The source is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
|
// for more details.
|
|
//
|
|
// $Log:$
|
|
//
|
|
// DESCRIPTION: none
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
static const char
|
|
rcsid[] = "$Id: s_sound.c,v 1.6 1997/02/03 22:45:12 b1 Exp $";
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "i_system.h"
|
|
#include "i_sound.h"
|
|
#include "sounds.h"
|
|
#include "s_sound.h"
|
|
|
|
#include "z_zone.h"
|
|
#include "m_random.h"
|
|
#include "w_wad.h"
|
|
|
|
#include "doomdef.h"
|
|
#include "p_local.h"
|
|
//#include "m_music.h"
|
|
|
|
#include "doomstat.h"
|
|
|
|
//#include "qmus2mid.h"
|
|
|
|
|
|
#include "kolibri.h"
|
|
#include "sound.h"
|
|
|
|
void WriteDebug(char *);
|
|
|
|
// Purpose?
|
|
const char snd_prefixen[]
|
|
= { 'P', 'P', 'A', 'S', 'S', 'S', 'M', 'M', 'M', 'S', 'S', 'S' };
|
|
|
|
#define S_MAX_VOLUME 127
|
|
|
|
// when to clip out sounds
|
|
// Does not fit the large outdoor areas.
|
|
#define S_CLIPPING_DIST (1200*0x10000)
|
|
|
|
// Distance tp origin when sounds should be maxed out.
|
|
// This should relate to movement clipping resolution
|
|
// (see BLOCKMAP handling).
|
|
// Originally: (200*0x10000).
|
|
#define S_CLOSE_DIST (160*0x10000)
|
|
|
|
|
|
#define S_ATTENUATOR ((S_CLIPPING_DIST-S_CLOSE_DIST)>>FRACBITS)
|
|
|
|
// Adjustable by menu.
|
|
#define NORM_VOLUME snd_MaxVolume
|
|
|
|
#define NORM_PITCH 128
|
|
#define NORM_PRIORITY 64
|
|
#define NORM_SEP 128
|
|
|
|
#define S_PITCH_PERTURB 1
|
|
#define S_STEREO_SWING (96*0x10000)
|
|
|
|
// percent attenuation from front to back
|
|
#define S_IFRACVOL 30
|
|
|
|
#define NA 0
|
|
//#define S_NUMCHANNELS 2
|
|
#define NUM_CHANNELS 16
|
|
|
|
// Current music/sfx card - index useless
|
|
// w/o a reference LUT in a sound module.
|
|
extern int snd_MusicDevice;
|
|
extern int snd_SfxDevice;
|
|
// Config file? Same disclaimer as above.
|
|
extern int snd_DesiredMusicDevice;
|
|
extern int snd_DesiredSfxDevice;
|
|
|
|
|
|
typedef struct
|
|
{
|
|
// sound information (if null, channel avail.)
|
|
sfxinfo_t* sfxinfo;
|
|
|
|
// origin of sound
|
|
void* origin;
|
|
|
|
// handle of the sound being played
|
|
int handle;
|
|
|
|
} channel_t;
|
|
|
|
|
|
// the set of channels available
|
|
static channel_t* channels;
|
|
|
|
// These are not used, but should be (menu).
|
|
// Maximum volume of a sound effect.
|
|
// Internal default is max out of 0-15.
|
|
int snd_SfxVolume = 15;
|
|
|
|
// Maximum volume of music. Useless so far.
|
|
int snd_MusicVolume = 15;
|
|
|
|
|
|
|
|
// whether songs are mus_paused
|
|
static boolean mus_paused;
|
|
|
|
// music currently being played
|
|
static musicinfo_t* mus_playing=0;
|
|
|
|
// following is set
|
|
// by the defaults code in M_misc:
|
|
// number of channels available
|
|
int numChannels;
|
|
|
|
static int nextcleanup;
|
|
|
|
|
|
|
|
//
|
|
// Internals.
|
|
//
|
|
int
|
|
S_getChannel
|
|
( void* origin,
|
|
sfxinfo_t* sfxinfo,
|
|
int sfxid );
|
|
|
|
|
|
int
|
|
S_AdjustSoundParams
|
|
( mobj_t* listener,
|
|
mobj_t* source,
|
|
int* vol,
|
|
int* sep,
|
|
int* pitch );
|
|
|
|
void S_StopChannel(int cnum);
|
|
|
|
|
|
|
|
//
|
|
// Initializes sound stuff, including volume
|
|
// Sets channels, SFX and music volume,
|
|
// allocates channel buffer, sets S_sfx lookup.
|
|
//
|
|
|
|
|
|
SNDBUF hMixBuff;
|
|
volatile int sound_state;
|
|
void sound_proc(void);
|
|
void I_UpdateSound( void );
|
|
|
|
void S_Init
|
|
( int sfxVolume,
|
|
int musicVolume )
|
|
{
|
|
int i;
|
|
char *thread_stack;
|
|
|
|
numChannels = NUM_CHANNELS;
|
|
|
|
// Whatever these did with DMX, these are rather dummies now.
|
|
I_SetChannels();
|
|
|
|
S_SetSfxVolume(sfxVolume);
|
|
// No music with Linux - another dummy.
|
|
S_SetMusicVolume(musicVolume);
|
|
|
|
// Allocating the internal channels for mixing
|
|
// (the maximum numer of sounds rendered
|
|
// simultaneously) within zone memory.
|
|
channels =
|
|
(channel_t *) Z_Malloc(numChannels*sizeof(channel_t), PU_STATIC, 0);
|
|
|
|
// Free all channels for use
|
|
for (i=0 ; i<numChannels ; i++)
|
|
channels[i].sfxinfo = 0;
|
|
|
|
// no sounds are playing, and they are not mus_paused
|
|
mus_paused = 0;
|
|
|
|
// Note that sounds have not been cached (yet).
|
|
for (i=1 ; i<NUMSFX ; i++)
|
|
S_sfx[i].lumpnum = S_sfx[i].usefulness = -1;
|
|
|
|
|
|
/********
|
|
if((ver = InitSound())< SOUND_VERSION )
|
|
{
|
|
printf("Sound service version mismatch\n\r");
|
|
printf("Installed version: %d, required version %d\n\r",
|
|
ver, SOUND_VERSION);
|
|
};
|
|
|
|
hMixBuff = CreateBuffer(PCM_2_16_11,0);
|
|
|
|
*********/
|
|
|
|
thread_stack = UserAlloc(4096);
|
|
thread_stack+=4092;
|
|
|
|
sound_state=1;
|
|
CreateThread(sound_proc, thread_stack);
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
unsigned int code;
|
|
unsigned int sender;
|
|
unsigned int stream;
|
|
unsigned int offset;
|
|
unsigned int size;
|
|
unsigned int unused;
|
|
}SND_EVENT;
|
|
|
|
unsigned int mix_offset;
|
|
int mix_size;
|
|
extern signed short *mixbuffer;
|
|
|
|
void sound_proc(void)
|
|
{
|
|
int ver;
|
|
int err;
|
|
SND_EVENT evnt;
|
|
int i;
|
|
|
|
if(err = InitSound(&ver))
|
|
{
|
|
printf("Error %x Sound service not installed\n\r", err);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
}
|
|
|
|
|
|
if( SOUND_VERSION>(ver&0xFFFF))
|
|
{
|
|
printf("Sound version mismatch\n\r");
|
|
printf("Current version: %d, required version %d\n\r",
|
|
ver&0xFFFF, SOUND_VERSION);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
};
|
|
|
|
if(SOUND_VERSION<(ver >> 16))
|
|
{
|
|
printf("Sound version obsolete\n\r");
|
|
printf("Compatible version: %d, required version %d\n\r",
|
|
ver, SOUND_VERSION);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
};
|
|
|
|
if (err = CreateBuffer(PCM_2_16_11|PCM_RING,0, &hMixBuff))
|
|
{
|
|
printf("Error %x sound not available\n\r", err);
|
|
printf("handle = %x\n\r", hMixBuff);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
}
|
|
|
|
if(err = GetBufferSize(hMixBuff, &mix_size))
|
|
{
|
|
printf("Error %x get buffer size\n\r", err);
|
|
printf("size = %x\n\r", mix_size);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
};
|
|
mix_size= mix_size/2;
|
|
|
|
printf("mixer size %d\n\r", mix_size);
|
|
|
|
if(err=PlayBuffer(hMixBuff, 0))
|
|
{
|
|
printf("Error %x play buffer\n\r", err);
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
}
|
|
|
|
mixbuffer = malloc(mix_size);
|
|
|
|
while(sound_state)
|
|
{
|
|
GetNotify(&evnt);
|
|
|
|
if(evnt.code != 0xFF000001)
|
|
{
|
|
printf("invalid code %d\n\r", evnt.code);
|
|
continue;
|
|
}
|
|
|
|
if(evnt.stream != hMixBuff)
|
|
{
|
|
printf("invalid stream %d hMixBuff= %d\n\r", evnt.stream, hMixBuff);
|
|
continue;
|
|
};
|
|
mix_offset= evnt.offset;
|
|
I_UpdateSound();
|
|
};
|
|
|
|
//flush sound buffers
|
|
|
|
for(i=0; i<32; i++)
|
|
{
|
|
GetNotify(&evnt);
|
|
|
|
if(evnt.code != 0xFF000001)
|
|
{
|
|
printf("invalid code %d\n\r", evnt.code);
|
|
continue;
|
|
}
|
|
|
|
if(evnt.stream != hMixBuff)
|
|
{
|
|
printf("invalid stream %d hMixBuff= %d\n\r", evnt.stream, hMixBuff);
|
|
continue;
|
|
};
|
|
mix_offset= evnt.offset;
|
|
I_UpdateSound();
|
|
};
|
|
|
|
_asm
|
|
{
|
|
mov eax, -1
|
|
int 0x40
|
|
};
|
|
|
|
};
|
|
|
|
//
|
|
// Per level startup code.
|
|
// Kills playing sounds at start of level,
|
|
// determines music if any, changes music.
|
|
//
|
|
void S_Start(void)
|
|
{
|
|
int cnum;
|
|
int mnum;
|
|
|
|
// kill all playing sounds at start of level
|
|
// (trust me - a good idea)
|
|
for (cnum=0 ; cnum<numChannels ; cnum++)
|
|
if (channels[cnum].sfxinfo)
|
|
S_StopChannel(cnum);
|
|
|
|
// start new music for the level
|
|
mus_paused = 0;
|
|
|
|
if (gamemode == commercial)
|
|
mnum = mus_runnin + gamemap - 1;
|
|
else
|
|
{
|
|
int spmus[]=
|
|
{
|
|
// Song - Who? - Where?
|
|
mus_e3m4, // American e4m1
|
|
mus_e3m2, // Romero e4m2
|
|
mus_e3m3, // Shawn e4m3
|
|
mus_e1m5, // American e4m4
|
|
mus_e2m7, // Tim e4m5
|
|
mus_e2m4, // Romero e4m6
|
|
mus_e2m6, // J.Anderson e4m7 CHIRON.WAD
|
|
mus_e2m5, // Shawn e4m8
|
|
mus_e1m9 // Tim e4m9
|
|
};
|
|
|
|
if (gameepisode < 4)
|
|
mnum = mus_e1m1 + (gameepisode-1)*9 + gamemap-1;
|
|
else
|
|
mnum = spmus[gamemap-1];
|
|
}
|
|
|
|
// HACK FOR COMMERCIAL
|
|
// if (commercial && mnum > mus_e3m9)
|
|
// mnum -= mus_e3m9;
|
|
|
|
S_ChangeMusic(mnum, true);
|
|
|
|
nextcleanup = 15;
|
|
}
|
|
|
|
void S_StartSoundAtVolume( void *origin_p, int sfx_id, int volume )
|
|
{
|
|
int rc;
|
|
int sep;
|
|
int pitch;
|
|
int priority;
|
|
sfxinfo_t *sfx;
|
|
int cnum;
|
|
// int chnum; <-- 10.9.98 compiler warning
|
|
|
|
mobj_t* origin = (mobj_t *)origin_p;
|
|
|
|
//WriteDebug("S_StartSoundAtVolume...\n");
|
|
|
|
// Debug.
|
|
/*fprintf( stderr,"S_StartSoundAtVolume: playing sound %d (%s)\n",sfx_id, S_sfx[sfx_id].name );*/
|
|
|
|
// check for bogus sound #
|
|
if (sfx_id < 1 || sfx_id > NUMSFX)
|
|
I_Error("Bad sfx #: %d", sfx_id);
|
|
|
|
sfx = &S_sfx[sfx_id];
|
|
|
|
// Initialize sound parameters
|
|
if (sfx->link)
|
|
{
|
|
pitch = sfx->pitch;
|
|
priority = sfx->priority;
|
|
volume += sfx->volume;
|
|
|
|
if (volume < 1)
|
|
{
|
|
//WriteDebug("Volume off...\n");
|
|
return;
|
|
}
|
|
|
|
if (volume > snd_SfxVolume)
|
|
volume = snd_SfxVolume;
|
|
}
|
|
else
|
|
{
|
|
pitch = NORM_PITCH;
|
|
priority = NORM_PRIORITY;
|
|
}
|
|
|
|
|
|
// Check to see if it is audible,
|
|
// and if not, modify the params
|
|
if (origin && origin != players[consoleplayer].mo)
|
|
{
|
|
rc = S_AdjustSoundParams(players[consoleplayer].mo, origin, &volume, &sep, &pitch);
|
|
if ( origin->x == players[consoleplayer].mo->x && origin->y == players[consoleplayer].mo->y)
|
|
{
|
|
sep = NORM_SEP;
|
|
}
|
|
if (!rc)
|
|
{
|
|
//WriteDebug("No rc from S_AdjustSoundParams...\n");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sep = NORM_SEP;
|
|
}
|
|
|
|
// hacks to vary the sfx pitches
|
|
if (sfx_id >= sfx_sawup && sfx_id <= sfx_sawhit)
|
|
{
|
|
pitch += 8 - (M_Random()&15);
|
|
if (pitch < 0)
|
|
pitch = 0;
|
|
else
|
|
if (pitch>255)
|
|
pitch = 255;
|
|
}
|
|
else
|
|
if (sfx_id != sfx_itemup && sfx_id != sfx_tink)
|
|
{
|
|
pitch += 16 - (M_Random()&31);
|
|
if (pitch<0)
|
|
pitch = 0;
|
|
else
|
|
if (pitch > 255)
|
|
pitch = 255;
|
|
}
|
|
|
|
// kill old sound
|
|
S_StopSound(origin);
|
|
|
|
// try to find a channel
|
|
cnum = S_getChannel(origin, sfx, sfx_id);
|
|
|
|
if (cnum<0)
|
|
{
|
|
//WriteDebug("cnum < 0 -- no channel...\n");
|
|
return;
|
|
}
|
|
|
|
//
|
|
// This is supposed to handle the loading/caching.
|
|
// For some odd reason, the caching is done nearly
|
|
// each time the sound is needed?
|
|
//
|
|
|
|
// get lumpnum if necessary
|
|
if (sfx->lumpnum < 0)
|
|
sfx->lumpnum = I_GetSfxLumpNum(sfx);
|
|
|
|
// cache data if necessary
|
|
if (!sfx->data)
|
|
{
|
|
sfx->data = (void *) W_CacheLumpNum(sfx->lumpnum, PU_MUSIC);
|
|
|
|
}
|
|
|
|
// increase the usefulness
|
|
if (sfx->usefulness++ < 0)
|
|
sfx->usefulness = 1;
|
|
|
|
// Assigns the handle to one of the channels in the
|
|
// mix/output buffer.
|
|
//WriteDebug("I_StartSound...\n");
|
|
channels[cnum].handle = I_StartSound(sfx_id,volume,sep,pitch,priority);
|
|
channels[cnum].handle = cnum;
|
|
channels[cnum].sfxinfo = sfx;
|
|
channels[cnum].origin = origin;
|
|
}
|
|
|
|
void S_StartSound( void *origin, int sfx_id )
|
|
{
|
|
#ifdef SAWDEBUG
|
|
// if (sfx_id == sfx_sawful)
|
|
// sfx_id = sfx_itemup;
|
|
#endif
|
|
|
|
S_StartSoundAtVolume(origin, sfx_id, snd_SfxVolume);
|
|
|
|
|
|
// UNUSED. We had problems, had we not?
|
|
#ifdef SAWDEBUG
|
|
{
|
|
int i;
|
|
int n;
|
|
|
|
static mobj_t* last_saw_origins[10] = {1,1,1,1,1,1,1,1,1,1};
|
|
static int first_saw=0;
|
|
static int next_saw=0;
|
|
|
|
if (sfx_id == sfx_sawidl
|
|
|| sfx_id == sfx_sawful
|
|
|| sfx_id == sfx_sawhit)
|
|
{
|
|
for (i=first_saw;i!=next_saw;i=(i+1)%10)
|
|
if (last_saw_origins[i] != origin)
|
|
fprintf(stderr, "old origin 0x%lx != "
|
|
"origin 0x%lx for sfx %d\n",
|
|
last_saw_origins[i],
|
|
origin,
|
|
sfx_id);
|
|
|
|
last_saw_origins[next_saw] = origin;
|
|
next_saw = (next_saw + 1) % 10;
|
|
if (next_saw == first_saw)
|
|
first_saw = (first_saw + 1) % 10;
|
|
|
|
for (n=i=0; i<numChannels ; i++)
|
|
{
|
|
if (channels[i].sfxinfo == &S_sfx[sfx_sawidl]
|
|
|| channels[i].sfxinfo == &S_sfx[sfx_sawful]
|
|
|| channels[i].sfxinfo == &S_sfx[sfx_sawhit]) n++;
|
|
}
|
|
|
|
if (n>1)
|
|
{
|
|
for (i=0; i<numChannels ; i++)
|
|
{
|
|
if (channels[i].sfxinfo == &S_sfx[sfx_sawidl]
|
|
|| channels[i].sfxinfo == &S_sfx[sfx_sawful]
|
|
|| channels[i].sfxinfo == &S_sfx[sfx_sawhit])
|
|
{
|
|
fprintf(stderr,
|
|
"chn: sfxinfo=0x%lx, origin=0x%lx, "
|
|
"handle=%d\n",
|
|
channels[i].sfxinfo,
|
|
channels[i].origin,
|
|
channels[i].handle);
|
|
}
|
|
}
|
|
fprintf(stderr, "\n");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void S_StopSound(void *origin)
|
|
{
|
|
|
|
int cnum;
|
|
|
|
for (cnum=0 ; cnum<numChannels ; cnum++)
|
|
{
|
|
if (channels[cnum].sfxinfo && channels[cnum].origin == origin)
|
|
{
|
|
S_StopChannel(cnum);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Stop and resume music, during game PAUSE.
|
|
//
|
|
void S_PauseSound(void)
|
|
{
|
|
if (mus_playing && !mus_paused)
|
|
{
|
|
I_PauseSong(mus_playing->handle);
|
|
mus_paused = true;
|
|
}
|
|
}
|
|
|
|
void S_ResumeSound(void)
|
|
{
|
|
if (mus_playing && mus_paused)
|
|
{
|
|
I_ResumeSong(mus_playing->handle);
|
|
mus_paused = false;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Updates music & sounds
|
|
//
|
|
void S_UpdateSounds(void* listener_p)
|
|
{
|
|
int audible;
|
|
int cnum;
|
|
int volume;
|
|
int sep;
|
|
int pitch;
|
|
sfxinfo_t* sfx;
|
|
channel_t* c;
|
|
|
|
mobj_t* listener = (mobj_t*)listener_p;
|
|
|
|
|
|
|
|
// Clean up unused data.
|
|
// This is currently not done for 16bit (sounds cached static).
|
|
// DOS 8bit remains.
|
|
/*if (gametic > nextcleanup)
|
|
{
|
|
for (i=1 ; i<NUMSFX ; i++)
|
|
{
|
|
if (S_sfx[i].usefulness < 1
|
|
&& S_sfx[i].usefulness > -1)
|
|
{
|
|
if (--S_sfx[i].usefulness == -1)
|
|
{
|
|
Z_ChangeTag(S_sfx[i].data, PU_CACHE);
|
|
S_sfx[i].data = 0;
|
|
}
|
|
}
|
|
}
|
|
nextcleanup = gametic + 15;
|
|
}*/
|
|
|
|
for (cnum=0 ; cnum<numChannels ; cnum++)
|
|
{
|
|
c = &channels[cnum];
|
|
sfx = c->sfxinfo;
|
|
|
|
if (c->sfxinfo)
|
|
{
|
|
if (I_SoundIsPlaying(c->handle))
|
|
{
|
|
// initialize parameters
|
|
volume = snd_SfxVolume;
|
|
pitch = NORM_PITCH;
|
|
sep = NORM_SEP;
|
|
|
|
if (sfx->link)
|
|
{
|
|
pitch = sfx->pitch;
|
|
volume += sfx->volume;
|
|
if (volume < 1)
|
|
{
|
|
S_StopChannel(cnum);
|
|
continue;
|
|
}
|
|
else if (volume > snd_SfxVolume)
|
|
{
|
|
volume = snd_SfxVolume;
|
|
}
|
|
}
|
|
|
|
// check non-local sounds for distance clipping
|
|
// or modify their params
|
|
if (c->origin && listener_p != c->origin)
|
|
{
|
|
audible = S_AdjustSoundParams(listener,
|
|
c->origin,
|
|
&volume,
|
|
&sep,
|
|
&pitch);
|
|
|
|
if (!audible)
|
|
{
|
|
S_StopChannel(cnum);
|
|
}
|
|
else
|
|
I_UpdateSoundParams(c->handle, volume, sep, pitch);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if channel is allocated but sound has stopped,
|
|
// free it
|
|
S_StopChannel(cnum);
|
|
}
|
|
}
|
|
}
|
|
// kill music if it is a single-play && finished
|
|
// if ( mus_playing
|
|
// && !I_QrySongPlaying(mus_playing->handle)
|
|
// && !mus_paused )
|
|
// S_StopMusic();
|
|
}
|
|
|
|
|
|
void S_SetMusicVolume(int volume)
|
|
{
|
|
if (volume < 0 || volume > 127)
|
|
{
|
|
I_Error("Attempt to set music volume at %d",
|
|
volume);
|
|
}
|
|
|
|
I_SetMusicVolume(127);
|
|
I_SetMusicVolume(volume);
|
|
snd_MusicVolume = volume;
|
|
}
|
|
|
|
|
|
|
|
void S_SetSfxVolume(int volume)
|
|
{
|
|
|
|
if (volume < 0 || volume > 127)
|
|
I_Error("Attempt to set sfx volume at %d", volume);
|
|
|
|
snd_SfxVolume = volume;
|
|
|
|
}
|
|
|
|
//
|
|
// Starts some music with the music id found in sounds.h.
|
|
//
|
|
void S_StartMusic(int m_id)
|
|
{
|
|
// S_ChangeMusic(m_id, false);
|
|
}
|
|
|
|
|
|
// clean-up&code for orig midi 10.9.98-dlw
|
|
void S_ChangeMusic(int musicnum, int looping)
|
|
{
|
|
|
|
// I_PlaySong(music->handle, looping);
|
|
// mus_playing = music;
|
|
}
|
|
|
|
|
|
void S_StopMusic(void)
|
|
{
|
|
if (mus_playing)
|
|
{
|
|
if (mus_paused) I_ResumeSong(mus_playing->handle);
|
|
I_StopSong(mus_playing->handle);
|
|
I_UnRegisterSong(mus_playing->handle);
|
|
Z_ChangeTag(mus_playing->data, PU_CACHE);
|
|
mus_playing->data = 0;
|
|
mus_playing = 0;
|
|
}
|
|
}
|
|
|
|
void S_StopChannel(int cnum)
|
|
{
|
|
|
|
int i;
|
|
channel_t* c = &channels[cnum];
|
|
|
|
if (c->sfxinfo)
|
|
{
|
|
// stop the sound playing
|
|
if (I_SoundIsPlaying(c->handle))
|
|
{
|
|
#ifdef SAWDEBUG
|
|
if (c->sfxinfo == &S_sfx[sfx_sawful])
|
|
fprintf(stderr, "stopped\n");
|
|
#endif
|
|
I_StopSound(c->handle);
|
|
}
|
|
|
|
// check to see
|
|
// if other channels are playing the sound
|
|
for (i=0 ; i<numChannels ; i++)
|
|
{
|
|
if (cnum != i
|
|
&& c->sfxinfo == channels[i].sfxinfo)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
// degrade usefulness of sound data
|
|
c->sfxinfo->usefulness--;
|
|
|
|
c->sfxinfo = 0;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Changes volume, stereo-separation, and pitch variables
|
|
// from the norm of a sound effect to be played.
|
|
// If the sound is not audible, returns a 0.
|
|
// Otherwise, modifies parameters and returns 1.
|
|
//
|
|
int
|
|
S_AdjustSoundParams (mobj_t* listener, mobj_t* source,
|
|
int* vol, int* sep, int* pitch)
|
|
{
|
|
fixed_t approx_dist;
|
|
fixed_t adx;
|
|
fixed_t ady;
|
|
angle_t angle;
|
|
|
|
// calculate the distance to sound origin
|
|
// and clip it if necessary
|
|
adx = abs(listener->x - source->x);
|
|
ady = abs(listener->y - source->y);
|
|
|
|
// From _GG1_ p.428. Appox. eucledian distance fast.
|
|
approx_dist = adx + ady - ((adx < ady ? adx : ady)>>1);
|
|
|
|
if (gamemap != 8
|
|
&& approx_dist > S_CLIPPING_DIST)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
// angle of source to listener
|
|
angle = R_PointToAngle2(listener->x,
|
|
listener->y,
|
|
source->x,
|
|
source->y);
|
|
|
|
if (angle > listener->angle)
|
|
angle = angle - listener->angle;
|
|
else
|
|
angle = angle + (0xffffffff - listener->angle);
|
|
|
|
angle >>= ANGLETOFINESHIFT;
|
|
|
|
// stereo separation
|
|
*sep = 128 - (FixedMul(S_STEREO_SWING,finesine[angle])>>FRACBITS);
|
|
|
|
// volume calculation
|
|
if (approx_dist < S_CLOSE_DIST)
|
|
{
|
|
*vol = snd_SfxVolume;
|
|
}
|
|
else if (gamemap == 8)
|
|
{
|
|
if (approx_dist > S_CLIPPING_DIST)
|
|
approx_dist = S_CLIPPING_DIST;
|
|
|
|
*vol = 15+ ((snd_SfxVolume-15)
|
|
*((S_CLIPPING_DIST - approx_dist)>>FRACBITS))
|
|
/ S_ATTENUATOR;
|
|
}
|
|
else
|
|
{
|
|
// distance effect
|
|
*vol = (snd_SfxVolume
|
|
* ((S_CLIPPING_DIST - approx_dist)>>FRACBITS))
|
|
/ S_ATTENUATOR;
|
|
}
|
|
|
|
return (*vol > 0);
|
|
}
|
|
|
|
//
|
|
// S_getChannel :
|
|
// If none available, return -1. Otherwise channel #.
|
|
//
|
|
int S_getChannel( void *origin, sfxinfo_t *sfxinfo, int sfxid )
|
|
{
|
|
// channel number to use
|
|
int cnum;
|
|
|
|
channel_t* c;
|
|
|
|
// Find an open channel
|
|
//for (cnum = 0; cnum < numChannels; cnum++)
|
|
for (cnum = 0; cnum < NUM_CHANNELS; cnum++)
|
|
{
|
|
if (!channels[cnum].sfxinfo)
|
|
break;
|
|
else
|
|
if (origin && channels[cnum].origin == origin)
|
|
{
|
|
S_StopChannel(cnum);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// None available
|
|
if (cnum == NUM_CHANNELS)
|
|
{
|
|
// Look for lower priority
|
|
for (cnum = NUMSFX; cnum < NUM_CHANNELS; cnum++)
|
|
if (channels[cnum].sfxinfo->priority >= sfxinfo->priority)
|
|
break;
|
|
|
|
if (cnum == numChannels)
|
|
{
|
|
// FUCK! No lower priority. Sorry, Charlie.
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
// Otherwise, kick out lower priority.
|
|
S_StopChannel(cnum);
|
|
}
|
|
}
|
|
|
|
c = &channels[cnum];
|
|
|
|
// channel is decided to be cnum.
|
|
c->sfxinfo = sfxinfo;
|
|
c->origin = origin;
|
|
|
|
return cnum;
|
|
}
|
|
|
|
|
|
|
|
|