Classes
struct	portable_samplepair_t

struct	sfxcache_t

struct	sfx_s

struct	playsound_s

struct	dma_t

struct	channel_t

struct	wavinfo_t

Macros
#define	MAX_CHANNELS 32

#define	MAX_RAW_SAMPLES 8192

Typedefs
typedef struct sfx_s	sfx_t

typedef struct playsound_s	playsound_t

Functions
int	SNDDMA_Init (void)

int	SNDDMA_GetDMAPos (void)

void	SNDDMA_Shutdown (void)

void	SNDDMA_BeginPainting (void)

void	SNDDMA_Submit (void)

wavinfo_t	GetWavinfo (char name, byte wav, int wavlength)

void	S_InitScaletable (void)

sfxcache_t *	S_LoadSound (sfx_t *s)

void	S_IssuePlaysound (playsound_t *ps)

void	S_PaintChannels (int endtime)

channel_t *	S_PickChannel (int entnum, int entchannel)

void	S_Spatialize (channel_t *ch)

Variables
channel_t	channels [MAX_CHANNELS]

int	paintedtime

int	s_rawend

vec3_t	listener_origin

vec3_t	listener_forward

vec3_t	listener_right

vec3_t	listener_up

dma_t	dma

playsound_t	s_pendingplays

portable_samplepair_t	s_rawsamples [MAX_RAW_SAMPLES]

cvar_t *	s_volume

cvar_t *	s_nosound

cvar_t *	s_loadas8bit

cvar_t *	s_khz

cvar_t *	s_show

cvar_t *	s_mixahead

cvar_t *	s_testsound

cvar_t *	s_primary

Macro Definition Documentation

◆ MAX_CHANNELS

#define MAX_CHANNELS 32

Definition at line 126 of file snd_loc.h.

◆ MAX_RAW_SAMPLES

#define MAX_RAW_SAMPLES 8192

Definition at line 138 of file snd_loc.h.

Typedef Documentation

◆ playsound_t

typedef struct playsound_s playsound_t

◆ sfx_t

typedef struct sfx_s sfx_t

Function Documentation

◆ GetWavinfo()

wavinfo_t GetWavinfo	(	char *	name,
		byte *	wav,
		int	wavlength
	)

Definition at line 267 of file snd_mem.c.

 {
     wavinfo_t   info;
     int     i;
     int     format;
     int     samples;
  
     memset (&info, 0, sizeof(info));
  
     if (!wav)
         return info;
         
     iff_data = wav;
     iff_end = wav + wavlength;
  
 // find "RIFF" chunk
     FindChunk("RIFF");
     if (!(data_p && !strncmp(data_p+8, "WAVE", 4)))
     {
         Com_Printf("Missing RIFF/WAVE chunks\n");
         return info;
     }
  
 // get "fmt " chunk
     iff_data = data_p + 12;
 // DumpChunks ();
  
     FindChunk("fmt ");
     if (!data_p)
     {
         Com_Printf("Missing fmt chunk\n");
         return info;
     }
     data_p += 8;
     format = GetLittleShort();
     if (format != 1)
     {
         Com_Printf("Microsoft PCM format only\n");
         return info;
     }
  
     info.channels = GetLittleShort();
     info.rate = GetLittleLong();
     data_p += 4+2;
     info.width = GetLittleShort() / 8;
  
 // get cue chunk
     FindChunk("cue ");
     if (data_p)
     {
         data_p += 32;
         info.loopstart = GetLittleLong();
 //      Com_Printf("loopstart=%d\n", sfx->loopstart);
  
     // if the next chunk is a LIST chunk, look for a cue length marker
         FindNextChunk ("LIST");
         if (data_p)
         {
             if (!strncmp (data_p + 28, "mark", 4))
             {   // this is not a proper parse, but it works with cooledit...
                 data_p += 24;
                 i = GetLittleLong ();   // samples in loop
                 info.samples = info.loopstart + i;
 //              Com_Printf("looped length: %i\n", i);
             }
         }
     }
     else
         info.loopstart = -1;
  
 // find data chunk
     FindChunk("data");
     if (!data_p)
     {
         Com_Printf("Missing data chunk\n");
         return info;
     }
  
     data_p += 4;
     samples = GetLittleLong () / info.width;
  
     if (info.samples)
     {
         if (samples < info.samples)
             Com_Error (ERR_DROP, "Sound %s has a bad loop length", name);
     }
     else
         info.samples = samples;
  
     info.dataofs = data_p - wav;
     
     return info;
 }

Referenced by S_LoadSound().

◆ S_InitScaletable()

void S_InitScaletable ( void )

Definition at line 350 of file snd_mix.c.

 {
     int     i, j;
     int     scale;
  
     s_volume->modified = false;
     for (i=0 ; i<32 ; i++)
     {
         scale = i * 8 * 256 * s_volume->value;
         for (j=0 ; j<256 ; j++)
             snd_scaletable[i][j] = ((signed char)j) * scale;
     }
 }

Referenced by S_Init(), and S_Update().

◆ S_IssuePlaysound()

void S_IssuePlaysound ( playsound_t * ps )

Definition at line 550 of file snd_dma.c.

 {
     channel_t   *ch;
     sfxcache_t  *sc;
  
     if (s_show->value)
         Com_Printf ("Issue %i\n", ps->begin);
     // pick a channel to play on
     ch = S_PickChannel(ps->entnum, ps->entchannel);
     if (!ch)
     {
         S_FreePlaysound (ps);
         return;
     }
  
     // spatialize
     if (ps->attenuation == ATTN_STATIC)
         ch->dist_mult = ps->attenuation * 0.001;
     else
         ch->dist_mult = ps->attenuation * 0.0005;
     ch->master_vol = ps->volume;
     ch->entnum = ps->entnum;
     ch->entchannel = ps->entchannel;
     ch->sfx = ps->sfx;
     VectorCopy (ps->origin, ch->origin);
     ch->fixed_origin = ps->fixed_origin;
  
     S_Spatialize(ch);
  
     ch->pos = 0;
     sc = S_LoadSound (ch->sfx);
     ch->end = paintedtime + sc->length;
  
     // free the playsound
     S_FreePlaysound (ps);
 }

Referenced by S_PaintChannels().

◆ S_LoadSound()

sfxcache_t* S_LoadSound ( sfx_t * s )

Definition at line 99 of file snd_mem.c.

 {
     char    namebuffer[MAX_QPATH];
     byte    *data;
     wavinfo_t   info;
     int     len;
     float   stepscale;
     sfxcache_t  *sc;
     int     size;
     char    *name;
  
     if (s->name[0] == '*')
         return NULL;
  
 // see if still in memory
     sc = s->cache;
     if (sc)
         return sc;
  
 //Com_Printf ("S_LoadSound: %x\n", (int)stackbuf);
 // load it in
     if (s->truename)
         name = s->truename;
     else
         name = s->name;
  
     if (name[0] == '#')
         strcpy(namebuffer, &name[1]);
     else
         Com_sprintf (namebuffer, sizeof(namebuffer), "sound/%s", name);
  
 //  Com_Printf ("loading %s\n",namebuffer);
  
     size = FS_LoadFile (namebuffer, (void **)&data);
  
     if (!data)
     {
         Com_DPrintf ("Couldn't load %s\n", namebuffer);
         return NULL;
     }
  
     info = GetWavinfo (s->name, data, size);
     if (info.channels != 1)
     {
         Com_Printf ("%s is a stereo sample\n",s->name);
         FS_FreeFile (data);
         return NULL;
     }
  
     stepscale = (float)info.rate / dma.speed;   
     len = info.samples / stepscale;
  
     len = len * info.width * info.channels;
  
     sc = s->cache = Z_Malloc (len + sizeof(sfxcache_t));
     if (!sc)
     {
         FS_FreeFile (data);
         return NULL;
     }
     
     sc->length = info.samples;
     sc->loopstart = info.loopstart;
     sc->speed = info.rate;
     sc->width = info.width;
     sc->stereo = info.channels;
  
     ResampleSfx (s, sc->speed, sc->width, data + info.dataofs);
  
     FS_FreeFile (data);
  
     return sc;
 }

Referenced by S_EndRegistration(), S_IssuePlaysound(), S_PaintChannels(), S_RegisterSound(), and S_StartSound().

◆ S_PaintChannels()

void S_PaintChannels ( int endtime )

Definition at line 224 of file snd_mix.c.

 {
     int     i;
     int     end;
     channel_t *ch;
     sfxcache_t  *sc;
     int     ltime, count;
     playsound_t *ps;
  
     snd_vol = s_volume->value*256;
  
 //Com_Printf ("%i to %i\n", paintedtime, endtime);
     while (paintedtime < endtime)
     {
     // if paintbuffer is smaller than DMA buffer
         end = endtime;
         if (endtime - paintedtime > PAINTBUFFER_SIZE)
             end = paintedtime + PAINTBUFFER_SIZE;
  
         // start any playsounds
         while (1)
         {
             ps = s_pendingplays.next;
             if (ps == &s_pendingplays)
                 break;  // no more pending sounds
             if (ps->begin <= paintedtime)
             {
                 S_IssuePlaysound (ps);
                 continue;
             }
  
             if (ps->begin < end)
                 end = ps->begin;        // stop here
             break;
         }
  
     // clear the paint buffer
         if (s_rawend < paintedtime)
         {
 //          Com_Printf ("clear\n");
             memset(paintbuffer, 0, (end - paintedtime) * sizeof(portable_samplepair_t));
         }
         else
         {   // copy from the streaming sound source
             int     s;
             int     stop;
  
             stop = (end < s_rawend) ? end : s_rawend;
  
             for (i=paintedtime ; i<stop ; i++)
             {
                 s = i&(MAX_RAW_SAMPLES-1);
                 paintbuffer[i-paintedtime] = s_rawsamples[s];
             }
 //      if (i != end)
 //          Com_Printf ("partial stream\n");
 //      else
 //          Com_Printf ("full stream\n");
             for ( ; i<end ; i++)
             {
                 paintbuffer[i-paintedtime].left =
                 paintbuffer[i-paintedtime].right = 0;
             }
         }
  
  
     // paint in the channels.
         ch = channels;
         for (i=0; i<MAX_CHANNELS ; i++, ch++)
         {
             ltime = paintedtime;
         
             while (ltime < end)
             {
                 if (!ch->sfx || (!ch->leftvol && !ch->rightvol) )
                     break;
  
                 // max painting is to the end of the buffer
                 count = end - ltime;
  
                 // might be stopped by running out of data
                 if (ch->end - ltime < count)
                     count = ch->end - ltime;
         
                 sc = S_LoadSound (ch->sfx);
                 if (!sc)
                     break;
  
                 if (count > 0 && ch->sfx)
                 {   
                     if (sc->width == 1)// FIXME; 8 bit asm is wrong now
                         S_PaintChannelFrom8(ch, sc, count,  ltime - paintedtime);
                     else
                         S_PaintChannelFrom16(ch, sc, count, ltime - paintedtime);
     
                     ltime += count;
                 }
  
             // if at end of loop, restart
                 if (ltime >= ch->end)
                 {
                     if (ch->autosound)
                     {   // autolooping sounds always go back to start
                         ch->pos = 0;
                         ch->end = ltime + sc->length;
                     }
                     else if (sc->loopstart >= 0)
                     {
                         ch->pos = sc->loopstart;
                         ch->end = ltime + sc->length - ch->pos;
                     }
                     else                
                     {   // channel just stopped
                         ch->sfx = NULL;
                     }
                 }
             }
                                                               
         }
  
     // transfer out according to DMA format
         S_TransferPaintBuffer(end);
         paintedtime = end;
     }
 }

Referenced by S_Update_().

◆ S_PickChannel()

channel_t* S_PickChannel	(	int	entnum,
		int	entchannel
	)

Definition at line 375 of file snd_dma.c.

 {
     int         ch_idx;
     int         first_to_die;
     int         life_left;
     channel_t   *ch;
  
     if (entchannel<0)
         Com_Error (ERR_DROP, "S_PickChannel: entchannel<0");
  
 // Check for replacement sound, or find the best one to replace
     first_to_die = -1;
     life_left = 0x7fffffff;
     for (ch_idx=0 ; ch_idx < MAX_CHANNELS ; ch_idx++)
     {
         if (entchannel != 0     // channel 0 never overrides
         && channels[ch_idx].entnum == entnum
         && channels[ch_idx].entchannel == entchannel)
         {   // always override sound from same entity
             first_to_die = ch_idx;
             break;
         }
  
         // don't let monster sounds override player sounds
         if (channels[ch_idx].entnum == cl.playernum+1 && entnum != cl.playernum+1 && channels[ch_idx].sfx)
             continue;
  
         if (channels[ch_idx].end - paintedtime < life_left)
         {
             life_left = channels[ch_idx].end - paintedtime;
             first_to_die = ch_idx;
         }
    }
  
     if (first_to_die == -1)
         return NULL;
  
     ch = &channels[first_to_die];
     memset (ch, 0, sizeof(*ch));
  
     return ch;
 }       

Referenced by S_AddLoopSounds(), and S_IssuePlaysound().

◆ S_Spatialize()

void S_Spatialize ( channel_t * ch )

Definition at line 477 of file snd_dma.c.

 {
     vec3_t      origin;
  
     // anything coming from the view entity will always be full volume
     if (ch->entnum == cl.playernum+1)
     {
         ch->leftvol = ch->master_vol;
         ch->rightvol = ch->master_vol;
         return;
     }
  
     if (ch->fixed_origin)
     {
         VectorCopy (ch->origin, origin);
     }
     else
         CL_GetEntitySoundOrigin (ch->entnum, origin);
  
     S_SpatializeOrigin (origin, ch->master_vol, ch->dist_mult, &ch->leftvol, &ch->rightvol);
 }           

Referenced by S_IssuePlaysound(), and S_Update().

◆ SNDDMA_BeginPainting()

void SNDDMA_BeginPainting ( void )

Definition at line 707 of file snd_win.c.

 {
     int     reps;
     DWORD   dwSize2;
     DWORD   *pbuf, *pbuf2;
     HRESULT hresult;
     DWORD   dwStatus;
  
     if (!pDSBuf)
         return;
  
     // if the buffer was lost or stopped, restore it and/or restart it
     if (pDSBuf->lpVtbl->GetStatus (pDSBuf, &dwStatus) != DS_OK)
         Com_Printf ("Couldn't get sound buffer status\n");
     
     if (dwStatus & DSBSTATUS_BUFFERLOST)
         pDSBuf->lpVtbl->Restore (pDSBuf);
     
     if (!(dwStatus & DSBSTATUS_PLAYING))
         pDSBuf->lpVtbl->Play(pDSBuf, 0, 0, DSBPLAY_LOOPING);
  
     // lock the dsound buffer
  
     reps = 0;
     dma.buffer = NULL;
  
     while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, &pbuf, &locksize, 
                                    &pbuf2, &dwSize2, 0)) != DS_OK)
     {
         if (hresult != DSERR_BUFFERLOST)
         {
             Com_Printf( "S_TransferStereo16: Lock failed with error '%s'\n", DSoundError( hresult ) );
             S_Shutdown ();
             return;
         }
         else
         {
             pDSBuf->lpVtbl->Restore( pDSBuf );
         }
  
         if (++reps > 2)
             return;
     }
     dma.buffer = (unsigned char *)pbuf;
 }

Referenced by S_ClearBuffer(), and S_Update_().

◆ SNDDMA_GetDMAPos()

int SNDDMA_GetDMAPos ( void )

Definition at line 674 of file snd_win.c.

 {
     MMTIME  mmtime;
     int     s;
     DWORD   dwWrite;
  
     if (dsound_init) 
     {
         mmtime.wType = TIME_SAMPLES;
         pDSBuf->lpVtbl->GetCurrentPosition(pDSBuf, &mmtime.u.sample, &dwWrite);
         s = mmtime.u.sample - mmstarttime.u.sample;
     }
     else if (wav_init)
     {
         s = snd_sent * WAV_BUFFER_SIZE;
     }
  
  
     s >>= sample16;
  
     s &= (dma.samples-1);
  
     return s;
 }

Referenced by GetSoundtime().

◆ SNDDMA_Init()

int SNDDMA_Init ( void )

Definition at line 593 of file snd_win.c.

 {
     sndinitstat stat;
  
     memset ((void *)&dma, 0, sizeof (dma));
  
     s_wavonly = Cvar_Get ("s_wavonly", "0", 0);
  
     dsound_init = wav_init = 0;
  
     stat = SIS_FAILURE; // assume DirectSound won't initialize
  
     /* Init DirectSound */
     if (!s_wavonly->value)
     {
         if (snd_firsttime || snd_isdirect)
         {
             stat = SNDDMA_InitDirect ();
  
             if (stat == SIS_SUCCESS)
             {
                 snd_isdirect = true;
  
                 if (snd_firsttime)
                     Com_Printf ("dsound init succeeded\n" );
             }
             else
             {
                 snd_isdirect = false;
                 Com_Printf ("*** dsound init failed ***\n");
             }
         }
     }
  
 // if DirectSound didn't succeed in initializing, try to initialize
 // waveOut sound, unless DirectSound failed because the hardware is
 // already allocated (in which case the user has already chosen not
 // to have sound)
     if (!dsound_init && (stat != SIS_NOTAVAIL))
     {
         if (snd_firsttime || snd_iswave)
         {
  
             snd_iswave = SNDDMA_InitWav ();
  
             if (snd_iswave)
             {
                 if (snd_firsttime)
                     Com_Printf ("Wave sound init succeeded\n");
             }
             else
             {
                 Com_Printf ("Wave sound init failed\n");
             }
         }
     }
  
     snd_firsttime = false;
  
     snd_buffer_count = 1;
  
     if (!dsound_init && !wav_init)
     {
         if (snd_firsttime)
             Com_Printf ("*** No sound device initialized ***\n");
  
         return 0;
     }
  
     return 1;
 }

Referenced by S_Init().

◆ SNDDMA_Shutdown()

void SNDDMA_Shutdown ( void )

Definition at line 829 of file snd_win.c.

 {
     FreeSound ();
 }

Referenced by S_Shutdown().

◆ SNDDMA_Submit()

void SNDDMA_Submit ( void )

Definition at line 761 of file snd_win.c.

 {
     LPWAVEHDR   h;
     int         wResult;
  
     if (!dma.buffer)
         return;
  
     // unlock the dsound buffer
     if (pDSBuf)
         pDSBuf->lpVtbl->Unlock(pDSBuf, dma.buffer, locksize, NULL, 0);
  
     if (!wav_init)
         return;
  
     //
     // find which sound blocks have completed
     //
     while (1)
     {
         if ( snd_completed == snd_sent )
         {
             Com_DPrintf ("Sound overrun\n");
             break;
         }
  
         if ( ! (lpWaveHdr[ snd_completed & WAV_MASK].dwFlags & WHDR_DONE) )
         {
             break;
         }
  
         snd_completed++;    // this buffer has been played
     }
  
 //Com_Printf ("completed %i\n", snd_completed);
     //
     // submit a few new sound blocks
     //
     while (((snd_sent - snd_completed) >> sample16) < 8)
     {
         h = lpWaveHdr + ( snd_sent&WAV_MASK );
     if (paintedtime/256 <= snd_sent)
         break;  //  Com_Printf ("submit overrun\n");
 //Com_Printf ("send %i\n", snd_sent);
         snd_sent++;
         /* 
          * Now the data block can be sent to the output device. The 
          * waveOutWrite function returns immediately and waveform 
          * data is sent to the output device in the background. 
          */ 
         wResult = waveOutWrite(hWaveOut, h, sizeof(WAVEHDR)); 
  
         if (wResult != MMSYSERR_NOERROR)
         { 
             Com_Printf ("Failed to write block to device\n");
             FreeSound ();
             return; 
         } 
     }
 }