added timer_delay, faster timer_get_fixed_seconds
[btb/d2x.git] / arch / sdl / digi.c
1 /* $Id: digi.c,v 1.4 2002-08-02 11:05:25 btb Exp $ */
2 /*
3  *
4  * SDL digital audio support
5  *
6  *
7  */
8
9 #ifdef HAVE_CONFIG_H
10 #include <conf.h>
11 #endif
12
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <string.h>
16
17 #include <SDL/SDL.h>
18 #include <SDL/SDL_audio.h>
19
20 #include "pstypes.h"
21 #include "error.h"
22 #include "mono.h"
23 #include "fix.h"
24 #include "vecmat.h"
25 #include "gr.h" // needed for piggy.h
26 #include "piggy.h"
27 #include "digi.h"
28 #include "sounds.h"
29 #include "wall.h"
30 #include "newdemo.h"
31 #include "kconfig.h"
32
33 int digi_sample_rate=11025;
34
35 //edited 05/17/99 Matt Mueller - added ifndef NO_ASM
36 //added on 980905 by adb to add inline fixmul for mixer on i386
37 #ifndef NO_ASM
38 #ifdef __i386__
39 #define do_fixmul(x,y)                          \
40 ({                                              \
41         int _ax, _dx;                           \
42         asm("imull %2\n\tshrdl %3,%1,%0"        \
43             : "=a"(_ax), "=d"(_dx)              \
44             : "rm"(y), "i"(16), "0"(x));        \
45         _ax;                                    \
46 })
47 extern inline fix fixmul(fix x, fix y) { return do_fixmul(x,y); }
48 #endif
49 #endif
50 //end edit by adb
51 //end edit -MM
52
53 //changed on 980905 by adb to increase number of concurrent sounds
54 #define MAX_SOUND_SLOTS 32
55 //end changes by adb
56 #define SOUND_BUFFER_SIZE 512
57
58 #define MIN_VOLUME 10
59
60 /* This table is used to add two sound values together and pin
61  * the value to avoid overflow.  (used with permission from ARDI)
62  * DPH: Taken from SDL/src/SDL_mixer.c.
63  */
64 static const Uint8 mix8[] =
65 {
66   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
67   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
68   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
69   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
70   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
71   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
72   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
73   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
74   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
75   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
76   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
77   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
78   0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
79   0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
80   0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
81   0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
82   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
83   0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
84   0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
85   0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
86   0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
87   0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
88   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
89   0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
90   0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
91   0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
92   0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
93   0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
94   0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
95   0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
96   0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
97   0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
98   0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
99   0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
100   0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF,
101   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
102   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
103   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
104   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
105   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
106   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
107   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
108   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
109   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
110   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
111   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
112   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
113 };
114
115 #define SOF_USED                        1               // Set if this sample is used
116 #define SOF_PLAYING                     2               // Set if this sample is playing on a channel
117 #define SOF_LINK_TO_OBJ         4               // Sound is linked to a moving object. If object dies, then finishes play and quits.
118 #define SOF_LINK_TO_POS         8               // Sound is linked to segment, pos
119 #define SOF_PLAY_FOREVER        16              // Play forever (or until level is stopped), otherwise plays once
120
121 typedef struct sound_object {
122         short           signature;              // A unique signature to this sound
123         ubyte           flags;                  // Used to tell if this slot is used and/or currently playing, and how long.
124         fix             max_volume;             // Max volume that this sound is playing at
125         fix             max_distance;           // The max distance that this sound can be heard at...
126         int             volume;                 // Volume that this sound is playing at
127         int             pan;                    // Pan value that this sound is playing at
128         int             handle;                 // What handle this sound is playing on.  Valid only if SOF_PLAYING is set.
129         short           soundnum;               // The sound number that is playing
130         union { 
131                 struct {
132                         short           segnum;                         // Used if SOF_LINK_TO_POS field is used
133                         short           sidenum;
134                         vms_vector      position;
135                 }pos;
136                 struct {
137                         short            objnum;                         // Used if SOF_LINK_TO_OBJ field is used
138                         short            objsignature;
139                 }obj;
140         }link;
141 } sound_object;
142 #define lp_segnum link.pos.segnum
143 #define lp_sidenum link.pos.sidenum
144 #define lp_position link.pos.position
145
146 #define lo_objnum link.obj.objnum
147 #define lo_objsignature link.obj.objsignature
148
149 #define MAX_SOUND_OBJECTS 16
150 sound_object SoundObjects[MAX_SOUND_OBJECTS];
151 short next_signature=0;
152
153 //added/changed on 980905 by adb to make sfx volume work, on 990221 by adb changed F1_0 to F1_0 / 2
154 #define SOUND_MAX_VOLUME (F1_0 / 2)
155
156 int digi_volume = SOUND_MAX_VOLUME;
157 //end edit by adb
158
159 int digi_lomem = 0;
160
161 static int digi_initialised = 0;
162
163 struct sound_slot {
164  int soundno;
165  int playing;   // Is there a sample playing on this channel?
166  int looped;    // Play this sample looped?
167  fix pan;       // 0 = far left, 1 = far right
168  fix volume;    // 0 = nothing, 1 = fully on
169  //changed on 980905 by adb from char * to unsigned char * 
170  unsigned char *samples;
171  //end changes by adb
172  unsigned int length; // Length of the sample
173  unsigned int position; // Position we are at at the moment.
174 } SoundSlots[MAX_SOUND_SLOTS];
175
176 static SDL_AudioSpec WaveSpec;
177 static int digi_sounds_initialized = 0;
178
179 //added on 980905 by adb to add rotating/volume based sound kill system
180 static int digi_max_channels = 16;
181 static int next_handle = 0;
182 int SampleHandles[32];
183 void reset_sounds_on_channel(int channel);
184 //end edit by adb
185
186 void digi_reset_digi_sounds(void);
187
188 /* Audio mixing callback */
189 //changed on 980905 by adb to cleanup, add pan support and optimize mixer
190 static void audio_mixcallback(void *userdata, Uint8 *stream, int len)
191 {
192  Uint8 *streamend = stream + len;
193  struct sound_slot *sl;
194   
195  for (sl = SoundSlots; sl < SoundSlots + MAX_SOUND_SLOTS; sl++)
196  {
197   if (sl->playing)
198   {
199    Uint8 *sldata = sl->samples + sl->position, *slend = sl->samples + sl->length;
200    Uint8 *sp = stream, s;
201    signed char v;
202    fix vl, vr;
203    int x;
204
205    if ((x = sl->pan) & 0x8000)
206    {
207     vl = 0x20000 - x * 2;
208     vr = 0x10000;
209    }
210    else
211    {
212     vl = 0x10000;
213     vr = x * 2;
214    }
215    vl = fixmul(vl, (x = sl->volume));
216    vr = fixmul(vr, x);
217    while (sp < streamend) 
218    {
219     if (sldata == slend)
220     {
221      if (!sl->looped)
222      {
223       sl->playing = 0;
224       break;
225      }
226      sldata = sl->samples;
227     }
228     v = *(sldata++) - 0x80;
229     s = *sp;
230     *(sp++) = mix8[ s + fixmul(v, vl) + 0x80 ];
231     s = *sp;
232     *(sp++) = mix8[ s + fixmul(v, vr) + 0x80 ];
233    }
234    sl->position = sldata - sl->samples;
235   }
236  }
237 }
238 //end changes by adb
239
240 /* Initialise audio devices. */
241 int digi_init()
242 {
243  if (SDL_InitSubSystem(SDL_INIT_AUDIO)<0){
244     Error("SDL audio initialisation failed: %s.",SDL_GetError());
245  }
246  //added on 980905 by adb to init sound kill system
247  memset(SampleHandles, 255, sizeof(SampleHandles));
248  //end edit by adb
249
250  WaveSpec.freq = 11025;
251 //added/changed by Sam Lantinga on 12/01/98 for new SDL version
252  WaveSpec.format = AUDIO_U8;
253  WaveSpec.channels = 2;
254 //end this section addition/change - SL
255  WaveSpec.samples = SOUND_BUFFER_SIZE;
256  WaveSpec.callback = audio_mixcallback;
257
258  if ( SDL_OpenAudio(&WaveSpec, NULL) < 0 ) {
259 //edited on 10/05/98 by Matt Mueller - should keep running, just with no sound.
260          Warning("\nError: Couldn't open audio: %s\n", SDL_GetError());
261 //killed  exit(2);
262          return 1;
263 //end edit -MM
264  }
265  SDL_PauseAudio(0);
266
267  atexit(digi_close);
268  digi_initialised = 1;
269  return 0;
270 }
271
272 /* Toggle audio */
273 void digi_reset() { }
274
275 /* Shut down audio */
276 void digi_close()
277 {
278  if (!digi_initialised) return;
279  digi_initialised = 0;
280  SDL_CloseAudio();
281 }
282
283 /* Find the sound which actually equates to a sound number */
284 int digi_xlat_sound(int soundno)
285 {
286         if ( soundno < 0 ) return -1;
287
288         if ( digi_lomem )       {
289                 soundno = AltSounds[soundno];
290                 if ( soundno == 255 ) return -1;
291         }
292         return Sounds[soundno];
293 }
294
295 static int get_free_slot()
296 {
297  int i;
298  for (i=0; i<MAX_SOUND_SLOTS; i++)
299  {
300   if (!SoundSlots[i].playing) return i;
301  }
302  return -1;
303 }
304
305 int digi_start_sound(int soundnum, fix volume, fix pan, int unknown1, int unknown2, int unknown3, int unknown4)
306 {
307  int ntries;
308  int slot;
309
310  if (!digi_initialised) return -1;
311
312  //added on 980905 by adb from original source to add sound kill system
313  // play at most digi_max_channel samples, if possible kill sample with low volume
314  ntries = 0;
315
316 TryNextChannel:
317  if ( (SampleHandles[next_handle] >= 0) && (SoundSlots[SampleHandles[next_handle]].playing)  )
318  {
319   if ( (SoundSlots[SampleHandles[next_handle]].volume > digi_volume) && (ntries<digi_max_channels) )
320   {
321    //mprintf(( 0, "Not stopping loud sound %d.\n", next_handle ));
322    next_handle++;
323    if ( next_handle >= digi_max_channels )
324     next_handle = 0;
325    ntries++;
326    goto TryNextChannel;
327   }
328   //mprintf(( 0, "[SS:%d]", next_handle ));
329   SoundSlots[SampleHandles[next_handle]].playing = 0;
330   SampleHandles[next_handle] = -1;
331  }
332  //end edit by adb
333
334  slot = get_free_slot();
335  if (slot<0) return -1;
336
337  SoundSlots[slot].soundno = soundnum;
338  SoundSlots[slot].samples = GameSounds[soundnum].data;
339  SoundSlots[slot].length = GameSounds[soundnum].length;
340  SoundSlots[slot].volume = fixmul(digi_volume, volume);
341  SoundSlots[slot].pan = pan;
342  SoundSlots[slot].position = 0;
343  SoundSlots[slot].looped = 0;
344  SoundSlots[slot].playing = 1;
345
346  //added on 980905 by adb to add sound kill system from original sos digi.c
347  reset_sounds_on_channel(slot);
348  SampleHandles[next_handle] = slot;
349  next_handle++;
350  if ( next_handle >= digi_max_channels )
351   next_handle = 0;
352  //end edit by adb
353
354  return slot;
355 }
356
357  //added on 980905 by adb to add sound kill system from original sos digi.c
358 void reset_sounds_on_channel( int channel )
359 {
360  int i;
361
362  for (i=0; i<digi_max_channels; i++)
363   if (SampleHandles[i] == channel)
364    SampleHandles[i] = -1;
365 }
366 //end edit by adb
367
368 int digi_start_sound_object(int obj)
369 {
370  int slot;
371
372  if (!digi_initialised) return -1;
373  slot = get_free_slot();
374
375  if (slot<0) return -1;
376
377
378  SoundSlots[slot].soundno = SoundObjects[obj].soundnum;
379  SoundSlots[slot].samples = GameSounds[SoundObjects[obj].soundnum].data;
380  SoundSlots[slot].length = GameSounds[SoundObjects[obj].soundnum].length;
381  SoundSlots[slot].volume = fixmul(digi_volume, SoundObjects[obj].volume);
382  SoundSlots[slot].pan = SoundObjects[obj].pan;
383  SoundSlots[slot].position = 0;
384  SoundSlots[slot].looped = (SoundObjects[obj].flags & SOF_PLAY_FOREVER);
385  SoundSlots[slot].playing = 1;
386
387  SoundObjects[obj].signature = next_signature++;
388  SoundObjects[obj].handle = slot;
389
390  SoundObjects[obj].flags |= SOF_PLAYING;
391  //added on 980905 by adb to add sound kill system from original sos digi.c
392  reset_sounds_on_channel(slot);
393  //end edit by adb
394  
395  return 0;
396 }
397
398
399 // Play the given sound number.
400 // Volume is max at F1_0.
401 void digi_play_sample( int soundno, fix max_volume )
402 {
403 #ifdef NEWDEMO
404         if ( Newdemo_state == ND_STATE_RECORDING )
405                 newdemo_record_sound( soundno );
406 #endif
407         soundno = digi_xlat_sound(soundno);
408
409         if (!digi_initialised) return;
410
411         if (soundno < 0 ) return;
412
413         digi_start_sound(soundno, max_volume, F0_5, 0, 0, 0, 0);
414 }
415
416 // Play the given sound number. If the sound is already playing,
417 // restart it.
418 void digi_play_sample_once( int soundno, fix max_volume )
419 {
420         int i;
421
422 #ifdef NEWDEMO
423         if ( Newdemo_state == ND_STATE_RECORDING )
424                 newdemo_record_sound( soundno );
425 #endif
426         soundno = digi_xlat_sound(soundno);
427
428         if (!digi_initialised) return;
429
430         if (soundno < 0 ) return;
431
432         for (i=0; i < MAX_SOUND_SLOTS; i++)
433           if (SoundSlots[i].soundno == soundno)
434             SoundSlots[i].playing = 0;
435         digi_start_sound(soundno, max_volume, F0_5, 0, 0, 0, 0);
436
437 }
438
439 void digi_play_sample_3d( int soundno, int angle, int volume, int no_dups ) // Volume from 0-0x7fff
440 {
441         no_dups = 1;
442
443 #ifdef NEWDEMO
444         if ( Newdemo_state == ND_STATE_RECORDING )              {
445                 if ( no_dups )
446                         newdemo_record_sound_3d_once( soundno, angle, volume );
447                 else
448                         newdemo_record_sound_3d( soundno, angle, volume );
449         }
450 #endif
451         soundno = digi_xlat_sound(soundno);
452
453         if (!digi_initialised) return;
454         if (soundno < 0 ) return;
455
456         if (volume < MIN_VOLUME ) return;
457         digi_start_sound(soundno, volume, angle, 0, 0, 0, 0);
458 }
459
460 void digi_get_sound_loc( vms_matrix * listener, vms_vector * listener_pos, int listener_seg, vms_vector * sound_pos, int sound_seg, fix max_volume, int *volume, int *pan, fix max_distance )
461 {         
462         vms_vector      vector_to_sound;
463         fix angle_from_ear, cosang,sinang;
464         fix distance;
465         fix path_distance;
466
467         *volume = 0;
468         *pan = 0;
469
470         max_distance = (max_distance*5)/4;              // Make all sounds travel 1.25 times as far.
471
472         //      Warning: Made the vm_vec_normalized_dir be vm_vec_normalized_dir_quick and got illegal values to acos in the fang computation.
473         distance = vm_vec_normalized_dir_quick( &vector_to_sound, sound_pos, listener_pos );
474                 
475         if (distance < max_distance )   {
476                 int num_search_segs = f2i(max_distance/20);
477                 if ( num_search_segs < 1 ) num_search_segs = 1;
478
479                 path_distance = find_connected_distance(listener_pos, listener_seg, sound_pos, sound_seg, num_search_segs, WID_RENDPAST_FLAG );
480                 if ( path_distance > -1 )       {
481                         *volume = max_volume - fixdiv(path_distance,max_distance);
482                         //mprintf( (0, "Sound path distance %.2f, volume is %d / %d\n", f2fl(distance), *volume, max_volume ));
483                         if (*volume > 0 )       {
484                                 angle_from_ear = vm_vec_delta_ang_norm(&listener->rvec,&vector_to_sound,&listener->uvec);
485                                 fix_sincos(angle_from_ear,&sinang,&cosang);
486                                 //mprintf( (0, "volume is %.2f\n", f2fl(*volume) ));
487                                 if (Config_channels_reversed) cosang *= -1;
488                                 *pan = (cosang + F1_0)/2;
489                         } else {
490                                 *volume = 0;
491                         }
492                 }
493         }                                                                                                                                                                         
494 }
495
496 int digi_link_sound_to_object2( int org_soundnum, short objnum, int forever, fix max_volume, fix  max_distance )
497 {
498         int i,volume,pan;
499         object * objp;
500         int soundnum;
501
502         soundnum = digi_xlat_sound(org_soundnum);
503
504         if ( max_volume < 0 ) return -1;
505 //      if ( max_volume > F1_0 ) max_volume = F1_0;
506
507         if (!digi_initialised) return -1;
508         if (soundnum < 0 ) return -1;
509         if (GameSounds[soundnum].data==NULL) {
510                 Int3();
511                 return -1;
512         }
513         if ((objnum<0)||(objnum>Highest_object_index))
514                 return -1;
515
516         if ( !forever ) {
517                 // Hack to keep sounds from building up...
518                 digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, &Objects[objnum].pos, Objects[objnum].segnum, max_volume,&volume, &pan, max_distance );
519                 digi_play_sample_3d( org_soundnum, pan, volume, 0 );
520                 return -1;
521         }
522
523         for (i=0; i<MAX_SOUND_OBJECTS; i++ )
524                 if (SoundObjects[i].flags==0)
525                    break;
526
527         if (i==MAX_SOUND_OBJECTS) {
528                 mprintf((1, "Too many sound objects!\n" ));
529                 return -1;
530         }
531
532         SoundObjects[i].signature=next_signature++;
533         SoundObjects[i].flags = SOF_USED | SOF_LINK_TO_OBJ;
534         if ( forever )
535                 SoundObjects[i].flags |= SOF_PLAY_FOREVER;
536         SoundObjects[i].lo_objnum = objnum;
537         SoundObjects[i].lo_objsignature = Objects[objnum].signature;
538         SoundObjects[i].max_volume = max_volume;
539         SoundObjects[i].max_distance = max_distance;
540         SoundObjects[i].volume = 0;
541         SoundObjects[i].pan = 0;
542         SoundObjects[i].soundnum = soundnum;
543
544         objp = &Objects[SoundObjects[i].lo_objnum];
545         digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
546                        &objp->pos, objp->segnum, SoundObjects[i].max_volume,
547                        &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
548
549         if (!forever || SoundObjects[i].volume >= MIN_VOLUME)
550                digi_start_sound_object(i);
551
552         return SoundObjects[i].signature;
553 }
554
555 int digi_link_sound_to_object( int soundnum, short objnum, int forever, fix max_volume )
556 { return digi_link_sound_to_object2( soundnum, objnum, forever, max_volume, 256*F1_0); }
557
558 int digi_link_sound_to_pos2( int org_soundnum, short segnum, short sidenum, vms_vector * pos, int forever, fix max_volume, fix max_distance )
559 {
560         int i, volume, pan;
561         int soundnum;
562
563         soundnum = digi_xlat_sound(org_soundnum);
564
565         if ( max_volume < 0 ) return -1;
566 //      if ( max_volume > F1_0 ) max_volume = F1_0;
567
568         if (!digi_initialised) return -1;
569         if (soundnum < 0 ) return -1;
570         if (GameSounds[soundnum].data==NULL) {
571                 Int3();
572                 return -1;
573         }
574
575         if ((segnum<0)||(segnum>Highest_segment_index))
576                 return -1;
577
578         if ( !forever ) {
579                 // Hack to keep sounds from building up...
580                 digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, pos, segnum, max_volume, &volume, &pan, max_distance );
581                 digi_play_sample_3d( org_soundnum, pan, volume, 0 );
582                 return -1;
583         }
584
585         for (i=0; i<MAX_SOUND_OBJECTS; i++ )
586                 if (SoundObjects[i].flags==0)
587                         break;
588         
589         if (i==MAX_SOUND_OBJECTS) {
590                 mprintf((1, "Too many sound objects!\n" ));
591                 return -1;
592         }
593
594
595         SoundObjects[i].signature=next_signature++;
596         SoundObjects[i].flags = SOF_USED | SOF_LINK_TO_POS;
597         if ( forever )
598                 SoundObjects[i].flags |= SOF_PLAY_FOREVER;
599         SoundObjects[i].lp_segnum = segnum;
600         SoundObjects[i].lp_sidenum = sidenum;
601         SoundObjects[i].lp_position = *pos;
602         SoundObjects[i].soundnum = soundnum;
603         SoundObjects[i].max_volume = max_volume;
604         SoundObjects[i].max_distance = max_distance;
605         SoundObjects[i].volume = 0;
606         SoundObjects[i].pan = 0;
607         digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
608                                            &SoundObjects[i].lp_position, SoundObjects[i].lp_segnum,
609                                            SoundObjects[i].max_volume,
610                        &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
611         
612         if (!forever || SoundObjects[i].volume >= MIN_VOLUME)
613                 digi_start_sound_object(i);
614
615         return SoundObjects[i].signature;
616 }
617
618 int digi_link_sound_to_pos( int soundnum, short segnum, short sidenum, vms_vector * pos, int forever, fix max_volume )
619 {
620         return digi_link_sound_to_pos2( soundnum, segnum, sidenum, pos, forever, max_volume, F1_0 * 256 );
621 }
622
623 void digi_kill_sound_linked_to_segment( int segnum, int sidenum, int soundnum )
624 {
625         int i,killed;
626
627         soundnum = digi_xlat_sound(soundnum);
628
629         if (!digi_initialised) return;
630
631         killed = 0;
632
633         for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
634                 if ( (SoundObjects[i].flags & SOF_USED) && (SoundObjects[i].flags & SOF_LINK_TO_POS) )  {
635                         if ((SoundObjects[i].lp_segnum == segnum) && (SoundObjects[i].soundnum==soundnum ) && (SoundObjects[i].lp_sidenum==sidenum) ) {
636                                 if ( SoundObjects[i].flags & SOF_PLAYING )      {
637                                         SoundSlots[SoundObjects[i].handle].playing = 0;
638                                 }
639                                 SoundObjects[i].flags = 0;      // Mark as dead, so some other sound can use this sound
640                                 killed++;
641                         }
642                 }
643         }
644         // If this assert happens, it means that there were 2 sounds
645         // that got deleted. Weird, get John.
646         if ( killed > 1 )       {
647                 mprintf( (1, "ERROR: More than 1 sounds were deleted from seg %d\n", segnum ));
648         }
649 }
650
651 void digi_kill_sound_linked_to_object( int objnum )
652 {
653         int i,killed;
654
655         if (!digi_initialised) return;
656
657         killed = 0;
658
659         for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
660                 if ( (SoundObjects[i].flags & SOF_USED) && (SoundObjects[i].flags & SOF_LINK_TO_OBJ ) ) {
661                         if (SoundObjects[i].lo_objnum == objnum)   {
662                                 if ( SoundObjects[i].flags & SOF_PLAYING )      {
663                                      SoundSlots[SoundObjects[i].handle].playing = 0;
664                                 }
665                                 SoundObjects[i].flags = 0;      // Mark as dead, so some other sound can use this sound
666                                 killed++;
667                         }
668                 }
669         }
670         // If this assert happens, it means that there were 2 sounds
671         // that got deleted. Weird, get John.
672         if ( killed > 1 )       {
673                 mprintf( (1, "ERROR: More than 1 sounds were deleted from object %d\n", objnum ));
674         }
675 }
676
677 void digi_sync_sounds()
678 {
679         int i;
680         int oldvolume, oldpan;
681
682         if (!digi_initialised) return;
683
684         for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
685                 if ( SoundObjects[i].flags & SOF_USED ) {
686                         oldvolume = SoundObjects[i].volume;
687                         oldpan = SoundObjects[i].pan;
688
689                         if ( !(SoundObjects[i].flags & SOF_PLAY_FOREVER) )      {
690                                 // Check if its done.
691                                 if (SoundObjects[i].flags & SOF_PLAYING) {
692                                         if (!SoundSlots[SoundObjects[i].handle].playing) {
693                                                 SoundObjects[i].flags = 0;      // Mark as dead, so some other sound can use this sound
694                                                 continue;               // Go on to next sound...
695                                         }
696                                 }
697                         }                       
698                 
699                         if ( SoundObjects[i].flags & SOF_LINK_TO_POS )  {
700                                 digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
701                                                                 &SoundObjects[i].lp_position, SoundObjects[i].lp_segnum,
702                                                                 SoundObjects[i].max_volume,
703                                 &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
704
705                         } else if ( SoundObjects[i].flags & SOF_LINK_TO_OBJ )   {
706                                 object * objp;
707         
708                                 objp = &Objects[SoundObjects[i].lo_objnum];
709                 
710                                 if ((objp->type==OBJ_NONE) || (objp->signature!=SoundObjects[i].lo_objsignature))  {
711                                         // The object that this is linked to is dead, so just end this sound if it is looping.
712                                         if ( (SoundObjects[i].flags & SOF_PLAYING)  && (SoundObjects[i].flags & SOF_PLAY_FOREVER))      {
713                                              SoundSlots[SoundObjects[i].handle].playing = 0;
714                                         }
715                                         SoundObjects[i].flags = 0;      // Mark as dead, so some other sound can use this sound
716                                         continue;               // Go on to next sound...
717                                 } else {
718                                         digi_get_sound_loc( &Viewer->orient, &Viewer->pos, Viewer->segnum, 
719                                         &objp->pos, objp->segnum, SoundObjects[i].max_volume,
720                                    &SoundObjects[i].volume, &SoundObjects[i].pan, SoundObjects[i].max_distance );
721                                 }
722                         }
723                          
724                         if (oldvolume != SoundObjects[i].volume)        {
725                                 if ( SoundObjects[i].volume < MIN_VOLUME )       {
726                                         // Sound is too far away, so stop it from playing.
727                                         if ((SoundObjects[i].flags & SOF_PLAYING)&&(SoundObjects[i].flags & SOF_PLAY_FOREVER))  {
728                                                 SoundSlots[SoundObjects[i].handle].playing = 0;
729                                                 SoundObjects[i].flags &= ~SOF_PLAYING;          // Mark sound as not playing
730                                         }
731                                 } else {
732                                         if (!(SoundObjects[i].flags & SOF_PLAYING))     {
733                                                 digi_start_sound_object(i);
734                                         } else {
735                                                 SoundSlots[SoundObjects[i].handle].volume = fixmuldiv(SoundObjects[i].volume,digi_volume,F1_0);
736                                         }
737                                 }
738                         }
739                                 
740                         if (oldpan != SoundObjects[i].pan)      {
741                                 if (SoundObjects[i].flags & SOF_PLAYING)
742                                         SoundSlots[SoundObjects[i].handle].pan = SoundObjects[i].pan;
743                         }
744                 }
745         }
746 }
747
748 void digi_init_sounds()
749 {
750         int i;
751
752         if (!digi_initialised) return;
753
754         digi_reset_digi_sounds();
755
756         for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
757                 if (digi_sounds_initialized) {
758                         if ( SoundObjects[i].flags & SOF_PLAYING )      {
759                                 SoundSlots[SoundObjects[i].handle].playing=0;
760                         }
761                 }
762                 SoundObjects[i].flags = 0;      // Mark as dead, so some other sound can use this sound
763         }
764         digi_sounds_initialized = 1;
765 }
766
767 //added on 980905 by adb from original source to make sfx volume work
768 void digi_set_digi_volume( int dvolume )
769 {
770         dvolume = fixmuldiv( dvolume, SOUND_MAX_VOLUME, 0x7fff);
771         if ( dvolume > SOUND_MAX_VOLUME )
772                 digi_volume = SOUND_MAX_VOLUME;
773         else if ( dvolume < 0 )
774                 digi_volume = 0;
775         else
776                 digi_volume = dvolume;
777
778         if ( !digi_initialised ) return;
779
780         digi_sync_sounds();
781 }
782 //end edit by adb
783
784 void digi_set_volume( int dvolume, int mvolume )
785 {
786         digi_set_digi_volume(dvolume);
787         digi_set_midi_volume(mvolume);
788 //      mprintf(( 1, "Volume: 0x%x and 0x%x\n", digi_volume, midi_volume ));
789 }
790
791 int digi_is_sound_playing(int soundno)
792 {
793         int i;
794
795         soundno = digi_xlat_sound(soundno);
796
797         for (i = 0; i < MAX_SOUND_SLOTS; i++)
798                   //changed on 980905 by adb: added SoundSlots[i].playing &&
799                   if (SoundSlots[i].playing && SoundSlots[i].soundno == soundno)
800                   //end changes by adb
801                         return 1;
802         return 0;
803 }
804
805
806 void digi_pause_all() { }
807 void digi_resume_all() { }
808 void digi_stop_all() {
809        int i;
810        // ... Ano. The lack of this was causing ambient sounds to crash.
811        // fixed, added digi_stop_all 07/19/01 - bluecow
812        
813        for (i=0; i<MAX_SOUND_OBJECTS; i++ )    {
814                if ( SoundObjects[i].flags & SOF_USED ) {
815                        SoundSlots[SoundObjects[i].handle].playing = 0;
816                        SoundObjects[i].flags = 0;
817                }
818        }
819 }
820
821  //added on 980905 by adb to make sound channel setting work
822 void digi_set_max_channels(int n) { 
823         digi_max_channels       = n;
824
825         if ( digi_max_channels < 1 ) 
826                 digi_max_channels = 1;
827         if ( digi_max_channels > (MAX_SOUND_SLOTS-MAX_SOUND_OBJECTS) ) 
828                 digi_max_channels = (MAX_SOUND_SLOTS-MAX_SOUND_OBJECTS);
829
830         if ( !digi_initialised ) return;
831
832         digi_reset_digi_sounds();
833 }
834
835 int digi_get_max_channels() { 
836         return digi_max_channels; 
837 }
838 // end edit by adb
839
840 void digi_reset_digi_sounds() {
841  int i;
842
843  for (i=0; i< MAX_SOUND_SLOTS; i++)
844   SoundSlots[i].playing=0;
845  
846  //added on 980905 by adb to reset sound kill system
847  memset(SampleHandles, 255, sizeof(SampleHandles));
848  next_handle = 0;
849  //end edit by adb
850 }
851
852
853 // MIDI stuff follows.
854 //added/killed on 11/25/98 by Matthew Mueller
855 //void digi_set_midi_volume( int mvolume ) { }
856 //void digi_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop ) {}
857 //void digi_stop_current_song()
858 //{
859 //#ifdef HMIPLAY
860 //        char buf[10];
861 //    
862 //        sprintf(buf,"s");
863 //        send_ipc(buf);
864 //#endif
865 //}
866 //end this section kill - MM