sound/dos_digi.c

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