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