doom

i_sound.c (11575B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 
 #include <math.h>
 #include <errno.h>
 
 #include <sys/time.h>
 #include <sys/types.h>
 
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 
 
 #include <linux/soundcard.h>
 
 
 #include <time.h>
 #include <signal.h>
 
 #include "z_zone.h"
 
 #include "i_system.h"
 #include "i_sound.h"
 #include "m_argv.h"
 #include "m_misc.h"
 #include "w_wad.h"
 
 #include "doomdef.h"
 
 
 #ifdef SNDSERV
 
 FILE*	sndserver=0;
 char*	sndserver_filename = "./sndserver ";
 #elif SNDINTR
 
 
 
 
 #define SOUND_INTERVAL     500
 
 
 int I_SoundSetTimer( int duration_of_tick );
 void I_SoundDelTimer( void );
 #else
 
 #endif
 
 
 
 
 
 static int flag = 0;
 
 
 
 
 
 
 
 
 #define SAMPLECOUNT		512
 #define NUM_CHANNELS		8
 
 #define BUFMUL                  4
 #define MIXBUFFERSIZE		(SAMPLECOUNT*BUFMUL)
 
 #define SAMPLERATE		11025	
 #define SAMPLESIZE		2   	
 
 
 int 		lengths[NUMSFX];
 
 
 int	audio_fd;
 
 
 
 
 
 signed short	mixbuffer[MIXBUFFERSIZE];
 
 
 
 unsigned int	channelstep[NUM_CHANNELS];
 
 unsigned int	channelstepremainder[NUM_CHANNELS];
 
 
 
 unsigned char*	channels[NUM_CHANNELS];
 unsigned char*	channelsend[NUM_CHANNELS];
 
 
 
 
 
 
 
 int		channelstart[NUM_CHANNELS];
 
 
 
 
 
 int 		channelhandles[NUM_CHANNELS];
 
 
 
 int		channelids[NUM_CHANNELS];			
 
 
 int		steptable[256];
 
 
 int		vol_lookup[128*256];
 
 
 int*		channelleftvol_lookup[NUM_CHANNELS];
 int*		channelrightvol_lookup[NUM_CHANNELS];
 
 
 
 
 
 
 
 void
 myioctl
 ( int	fd,
   int	command,
   int*	arg )
 {   
     int		rc;
     
     rc = ioctl(fd, command, arg);  
     if (rc < 0)
     {
 	fprintf(stderr, "ioctl(dsp,%d,arg) failed\n", command);
 	fprintf(stderr, "errno=%d\n", errno);
 	exit(-1);
     }
 }
 
 
 
 
 
 
 
 
 
 void*
 getsfx
 ( char*         sfxname,
   int*          len )
 {
     unsigned char*      sfx;
     unsigned char*      paddedsfx;
     int                 i;
     int                 size;
     int                 paddedsize;
     char                name[20];
     int                 sfxlump;
 
     
     
     
     sprintf(name, "DS%s", sfxname);
 
     
     
     
     
     
     
     
     
     
     
     if ( W_CheckNumForName(name) == -1 )
       sfxlump = W_GetNumForName("DSPISTOL");
     else
       sfxlump = W_GetNumForName(name);
     
     size = W_LumpLength( sfxlump );
 
     
     
     
     
     
     
     sfx = (unsigned char*)W_CacheLumpNum( sfxlump, PU_STATIC );
 
     
     
     paddedsize = ((size-8 + (SAMPLECOUNT-1)) / SAMPLECOUNT) * SAMPLECOUNT;
 
     
     paddedsfx = (unsigned char*)Z_Malloc( paddedsize+8, PU_STATIC, 0 );
     
     
     
 
     
     memcpy(  paddedsfx, sfx, size );
     for (i=size ; i<paddedsize+8 ; i++)
         paddedsfx[i] = 128;
 
     
     Z_Free( sfx );
     
     
     *len = paddedsize;
 
     
     return (void *) (paddedsfx + 8);
 }
 
 
 
 
 
 
 
 
 
 
 
 
 int
 addsfx
 ( int		sfxid,
   int		volume,
   int		step,
   int		seperation )
 {
     static unsigned short	handlenums = 0;
  
     int		i;
     int		rc = -1;
     
     int		oldest = gametic;
     int		oldestnum = 0;
     int		slot;
 
     int		rightvol;
     int		leftvol;
 
     
     
     if ( sfxid == sfx_sawup
 	 || sfxid == sfx_sawidl
 	 || sfxid == sfx_sawful
 	 || sfxid == sfx_sawhit
 	 || sfxid == sfx_stnmov
 	 || sfxid == sfx_pistol	 )
     {
 	
 	for (i=0 ; i<NUM_CHANNELS ; i++)
 	{
 	    
 	    if ( (channels[i])
 		 && (channelids[i] == sfxid) )
 	    {
 		
 		channels[i] = 0;
 		
 		
 		break;
 	    }
 	}
     }
 
     
     for (i=0; (i<NUM_CHANNELS) && (channels[i]); i++)
     {
 	if (channelstart[i] < oldest)
 	{
 	    oldestnum = i;
 	    oldest = channelstart[i];
 	}
     }
 
     
     
     
     
     if (i == NUM_CHANNELS)
 	slot = oldestnum;
     else
 	slot = i;
 
     
     
     
     channels[slot] = (unsigned char *) S_sfx[sfxid].data;
     
     channelsend[slot] = channels[slot] + lengths[sfxid];
 
     
     if (!handlenums)
 	handlenums = 100;
 
     
     
     channelhandles[slot] = rc = handlenums++;
 
     
     
     channelstep[slot] = step;
     
     channelstepremainder[slot] = 0;
     
     channelstart[slot] = gametic;
 
     
     
     seperation += 1;
 
     
     
     
     leftvol =
 	volume - ((volume*seperation*seperation) >> 16); 
     seperation = seperation - 257;
     rightvol =
 	volume - ((volume*seperation*seperation) >> 16);	
 
     
     if (rightvol < 0 || rightvol > 127)
 	I_Error("rightvol out of bounds");
     
     if (leftvol < 0 || leftvol > 127)
 	I_Error("leftvol out of bounds");
     
     
     
     channelleftvol_lookup[slot] = &vol_lookup[leftvol*256];
     channelrightvol_lookup[slot] = &vol_lookup[rightvol*256];
 
     
     
     channelids[slot] = sfxid;
 
     
     return rc;
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 void I_SetChannels()
 {
   
   
   
   int		i;
   int		j;
     
   int*	steptablemid = steptable + 128;
   
   
   /*for (i=0; i<NUM_CHANNELS; i++)
   {
     channels[i] = 0;
   }*/
 
   
   
   for (i=-128 ; i<128 ; i++)
     steptablemid[i] = (int)(pow(2.0, (i/64.0))*65536.0);
   
   
   
   
   
   for (i=0 ; i<128 ; i++)
     for (j=0 ; j<256 ; j++)
       vol_lookup[i*256+j] = (i*(j-128)*256)/127;
 }	
 
  
 void I_SetSfxVolume(int volume)
 {
   
   
   
   
   
   snd_SfxVolume = volume;
 }
 
 
 void I_SetMusicVolume(int volume)
 {
   
   snd_MusicVolume = volume;
   
   
 }
 
 
 
 
 
 
 int I_GetSfxLumpNum(sfxinfo_t* sfx)
 {
     char namebuf[9];
     sprintf(namebuf, "DS%s", sfx->name);
     return W_GetNumForName(namebuf);
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 int
 I_StartSound
 ( int		id,
   int		vol,
   int		sep,
   int		pitch,
   int		priority )
 {
 
   
   priority = 0;
   
 #ifdef SNDSERV 
     if (sndserver)
     {
 	fprintf(sndserver, "p%2.2x%2.2x%2.2x%2.2x\n", id, pitch, vol, sep);
 	fflush(sndserver);
     }
     
     return id;
 #else
     
     
     
     
     id = addsfx( id, vol, steptable[pitch], sep );
 
     
     
     return id;
 #endif
 }
 
 
 
 void I_StopSound (int handle)
 {
   
   
   
   
   
   
   handle = 0;
 }
 
 
 int I_SoundIsPlaying(int handle)
 {
     
     return gametic < handle;
 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 void I_UpdateSound( void )
 {
 #ifdef SNDINTR
   static int misses = 0;
 #endif
 
   
   
   
   register unsigned int	sample;
   register int		dl;
   register int		dr;
   
   
   signed short*		leftout;
   signed short*		rightout;
   signed short*		leftend;
   
   int				step;
 
   
   int				chan;
     
     
     
     leftout = mixbuffer;
     rightout = mixbuffer+1;
     step = 2;
 
     
     
     leftend = mixbuffer + SAMPLECOUNT*step;
 
     
     
     
     while (leftout != leftend)
     {
 	
 	dl = 0;
 	dr = 0;
 
 	
 	
 	
 	for ( chan = 0; chan < NUM_CHANNELS; chan++ )
 	{
 	    
 	    if (channels[ chan ])
 	    {
 		
 		sample = *channels[ chan ];
 		
 		
 		
 		
 		dl += channelleftvol_lookup[ chan ][sample];
 		dr += channelrightvol_lookup[ chan ][sample];
 		
 		channelstepremainder[ chan ] += channelstep[ chan ];
 		
 		channels[ chan ] += channelstepremainder[ chan ] >> 16;
 		
 		channelstepremainder[ chan ] &= 65536-1;
 
 		
 		if (channels[ chan ] >= channelsend[ chan ])
 		    channels[ chan ] = 0;
 	    }
 	}
 	
 	
 	
 	
 	
 	
 
 	if (dl > 0x7fff)
 	    *leftout = 0x7fff;
 	else if (dl < -0x8000)
 	    *leftout = -0x8000;
 	else
 	    *leftout = dl;
 
 	
 	if (dr > 0x7fff)
 	    *rightout = 0x7fff;
 	else if (dr < -0x8000)
 	    *rightout = -0x8000;
 	else
 	    *rightout = dr;
 
 	
 	leftout += step;
 	rightout += step;
     }
 
 #ifdef SNDINTR
     
     if ( flag )
     {
       misses += flag;
       flag = 0;
     }
     
     if ( misses > 10 )
     {
       fprintf( stderr, "I_SoundUpdate: missed 10 buffer writes\n");
       misses = 0;
     }
     
     
     flag++;
 #endif
 }
 
 
 
 
 
 
 
 
 
 
 void
 I_SubmitSound(void)
 {
   
   write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL);
 }
 
 
 
 void
 I_UpdateSoundParams
 ( int	handle,
   int	vol,
   int	sep,
   int	pitch)
 {
   
   
   
   
 
   
   handle = vol = sep = pitch = 0;
 }
 
 
 
 
 void I_ShutdownSound(void)
 {    
 #ifdef SNDSERV
   if (sndserver)
   {
     
     fprintf(sndserver, "q\n");
     fflush(sndserver);
   }
 #else
   
   int done = 0;
   int i;
   
 
   
   fprintf( stderr, "I_ShutdownSound: NOT finishing pending sounds\n");
   fflush( stderr );
   
   while ( !done )
   {
     for( i=0 ; i<8 && !channels[i] ; i++);
     
     
     
     done=1;
   }
 #ifdef SNDINTR
   I_SoundDelTimer();
 #endif
   
   
   close ( audio_fd );
 #endif
 
   
   return;
 }
 
 
 
 
 
 
 void
 I_InitSound()
 { 
 #ifdef SNDSERV
   char buffer[256];
   
   if (getenv("DOOMWADDIR"))
     sprintf(buffer, "%s/%s",
 	    getenv("DOOMWADDIR"),
 	    sndserver_filename);
   else
     sprintf(buffer, "%s", sndserver_filename);
   
   
   if ( !access(buffer, X_OK) )
   {
     strcat(buffer, " -quiet");
     sndserver = popen(buffer, "w");
   }
   else
     fprintf(stderr, "Could not start sound server [%s]\n", buffer);
 #else
     
   int i;
   
 #ifdef SNDINTR
   fprintf( stderr, "I_SoundSetTimer: %d microsecs\n", SOUND_INTERVAL );
   I_SoundSetTimer( SOUND_INTERVAL );
 #endif
     
   
   fprintf( stderr, "I_InitSound: ");
   
   audio_fd = open("/dev/dsp", O_WRONLY);
   if (audio_fd<0)
     fprintf(stderr, "Could not open /dev/dsp\n");
   
                      
   i = 11 | (2<<16);                                           
   myioctl(audio_fd, SNDCTL_DSP_SETFRAGMENT, &i);
   myioctl(audio_fd, SNDCTL_DSP_RESET, 0);
   
   i=SAMPLERATE;
   
   myioctl(audio_fd, SNDCTL_DSP_SPEED, &i);
   
   i=1;
   myioctl(audio_fd, SNDCTL_DSP_STEREO, &i);
   
   myioctl(audio_fd, SNDCTL_DSP_GETFMTS, &i);
   
   if (i&=AFMT_S16_LE)    
     myioctl(audio_fd, SNDCTL_DSP_SETFMT, &i);
   else
     fprintf(stderr, "Could not play signed 16 data\n");
 
   fprintf(stderr, " configured audio device\n" );
 
     
   
   fprintf( stderr, "I_InitSound: ");
   
   for (i=1 ; i<NUMSFX ; i++)
   { 
     
     if (!S_sfx[i].link)
     {
       
       S_sfx[i].data = getsfx( S_sfx[i].name, &lengths[i] );
     }	
     else
     {
       
       S_sfx[i].data = S_sfx[i].link->data;
       lengths[i] = lengths[(S_sfx[i].link - S_sfx)/sizeof(sfxinfo_t)];
     }
   }
 
   fprintf( stderr, " pre-cached all sound data\n");
   
   
   for ( i = 0; i< MIXBUFFERSIZE; i++ )
     mixbuffer[i] = 0;
   
   
   fprintf(stderr, "I_InitSound: sound module ready\n");
     
 #endif
 }
 
 
 
 
 
 
 
 
 
 void I_InitMusic(void)		{ }
 void I_ShutdownMusic(void)	{ }
 
 static int	looping=0;
 static int	musicdies=-1;
 
 void I_PlaySong(int handle, int looping)
 {
   
   handle = looping = 0;
   musicdies = gametic + TICRATE*30;
 }
 
 void I_PauseSong (int handle)
 {
   
   handle = 0;
 }
 
 void I_ResumeSong (int handle)
 {
   
   handle = 0;
 }
 
 void I_StopSong(int handle)
 {
   
   handle = 0;
   
   looping = 0;
   musicdies = 0;
 }
 
 void I_UnRegisterSong(int handle)
 {
   
   handle = 0;
 }
 
 int I_RegisterSong(void* data)
 {
   
   data = NULL;
   
   return 1;
 }
 
 
 int I_QrySongPlaying(int handle)
 {
   
   handle = 0;
   return looping || musicdies > gametic;
 }
 
 
 
 
 
 
 
 
 
 
 
 #ifdef sun
     typedef     sigset_t        tSigSet;
 #else    
     typedef     int             tSigSet;
 #endif
 
 
 
 
 
 
 static int /*__itimer_which*/  itimer = ITIMER_REAL;
 
 static int sig = SIGALRM;
 
 
 void I_HandleSoundTimer( int ignore )
 {
   
   
   
   
   if ( flag )
   {
     
     
     write(audio_fd, mixbuffer, SAMPLECOUNT*BUFMUL);
 
     
     flag = 0;
   }
   else
     return;
   
   
   ignore = 0;
   return;
 }
 
 
 int I_SoundSetTimer( int duration_of_tick )
 {
   
   struct itimerval    value;
   struct itimerval    ovalue;
   struct sigaction    act;
   struct sigaction    oact;
 
   int res;
   
   
   
   
   
   act.sa_handler = I_HandleSoundTimer;
 #ifndef sun    
   
 #endif
   act.sa_flags = SA_RESTART;
   
   sigaction( sig, &act, &oact );
 
   value.it_interval.tv_sec    = 0;
   value.it_interval.tv_usec   = duration_of_tick;
   value.it_value.tv_sec       = 0;
   value.it_value.tv_usec      = duration_of_tick;
 
   
   res = setitimer( itimer, &value, &ovalue );
 
   
   if ( res == -1 )
     fprintf( stderr, "I_SoundSetTimer: interrupt n.a.\n");
   
   return res;
 }
 
 
 
 void I_SoundDelTimer()
 {
   
   if ( I_SoundSetTimer( 0 ) == -1)
     fprintf( stderr, "I_SoundDelTimer: failed to remove interrupt. Doh!\n");
 }