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