arch/linux/alsadigi.c

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