arch/linux/alsadigi.c

   1 /*
   2  *
   3  * ALSA digital audio support
   4  *
   5  */
   6
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <alsa/asoundlib.h>
  11 #include <pthread.h>
  12
  13 #include "dxxerror.h"
  14 #include "mono.h"
  15 #include "maths.h"
  16 #include "gr.h" // needed for piggy.h
  17 #include "inferno.h"
  18
  19
  20 //edited 05/17/99 Matt Mueller - added ifndef NO_ASM
  21 //added on 980905 by adb to add inline fixmul for mixer on i386
  22 #ifndef NO_ASM
  23 #ifdef __i386__
  24 #define do_fixmul(x,y)                          \
  25 ({                                              \
  26         int _ax, _dx;                           \
  27         asm("imull %2\n\tshrdl %3,%1,%0"        \
  28             : "=a"(_ax), "=d"(_dx)              \
  29             : "rm"(y), "i"(16), "0"(x));        \
  30         _ax;                                    \
  31 })
  32 extern inline fix fixmul(fix x, fix y) { return do_fixmul(x,y); }
  33 #endif
  34 #endif
  35 //end edit by adb
  36 //end edit -MM
  37
  38 //changed on 980905 by adb to increase number of concurrent sounds
  39 #define MAX_SOUND_SLOTS 32
  40 //end changes by adb
  41 #define SOUND_BUFFER_SIZE 512
  42
  43 #define MIN_VOLUME 10
  44
  45 /* This table is used to add two sound values together and pin
  46  * the value to avoid overflow.  (used with permission from ARDI)
  47  * DPH: Taken from SDL/src/SDL_mixer.c.
  48  */
  49 static const ubyte mix8[] =
  50 {
  51   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  52   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  53   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  54   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  55   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  56   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  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, 0x01, 0x02, 0x03,
  63   0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
  64   0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
  65   0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
  66   0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
  67   0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
  68   0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
  69   0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
  70   0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
  71   0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
  72   0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
  73   0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
  74   0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
  75   0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
  76   0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
  77   0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
  78   0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
  79   0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
  80   0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
  81   0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
  82   0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
  83   0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
  84   0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
  85   0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF,
  86   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  87   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  88   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  89   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  90   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  91   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 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,
  98 };
  99
 100 //added/changed on 980905 by adb to make sfx volume work, on 990221 by adb changed F1_0 to F1_0 / 2
 101 #define SOUND_MAX_VOLUME (F1_0 / 2)
 102
 103 int digi_volume = SOUND_MAX_VOLUME;
 104 //end edit by adb
 105
 106 static int Digi_initialized = 0;
 107
 108 struct sound_slot {
 109  int soundno;
 110  int playing;   // Is there a sample playing on this channel?
 111  int looped;    // Play this sample looped?
 112  fix pan;       // 0 = far left, 1 = far right
 113  fix volume;    // 0 = nothing, 1 = fully on
 114  //changed on 980905 by adb from char * to unsigned char *
 115  unsigned char *samples;
 116  //end changes by adb
 117  unsigned int length; // Length of the sample
 118  unsigned int position; // Position we are at at the moment.
 119         int soundobj;   // Which soundobject is on this channel
 120         int persistent; // This can't be pre-empted
 121 } SoundSlots[MAX_SOUND_SLOTS];
 122
 123 static int digi_max_channels = 16;
 124
 125 static int next_channel = 0;
 126
 127 /* Threading/ALSA stuff */
 128 #define LOCK() pthread_mutex_lock(&mutex)
 129 #define UNLOCK() pthread_mutex_unlock(&mutex)
 130 snd_pcm_t *snd_devhandle;
 131 pthread_t thread_id;
 132 pthread_mutex_t mutex;
 133
 134
 135 /* Audio mixing callback */
 136 //changed on 980905 by adb to cleanup, add pan support and optimize mixer
 137 static void audio_mixcallback(void *userdata, ubyte *stream, int len)
 138 {
 139  ubyte *streamend = stream + len;
 140  struct sound_slot *sl;
 141
 142  for (sl = SoundSlots; sl < SoundSlots + MAX_SOUND_SLOTS; sl++)
 143  {
 144   if (sl->playing)
 145   {
 146    ubyte *sldata = sl->samples + sl->position, *slend = sl->samples + sl->length;
 147    ubyte *sp = stream;
 148    signed char v;
 149    fix vl, vr;
 150    int x;
 151
 152    if ((x = sl->pan) & 0x8000)
 153    {
 154     vl = 0x20000 - x * 2;
 155     vr = 0x10000;
 156    }
 157    else
 158    {
 159     vl = 0x10000;
 160     vr = x * 2;
 161    }
 162    vl = fixmul(vl, (x = sl->volume));
 163    vr = fixmul(vr, x);
 164    while (sp < streamend)
 165    {
 166     if (sldata == slend)
 167     {
 168      if (!sl->looped)
 169      {
 170       sl->playing = 0;
 171       break;
 172      }
 173      sldata = sl->samples;
 174     }
 175     v = *(sldata++) - 0x80;
 176                                 *sp = mix8[*sp + fixmul(v, vl) + 0x80];
 177                                 sp++;
 178                                 *sp = mix8[*sp + fixmul(v, vr) + 0x80];
 179                                 sp++;
 180    }
 181    sl->position = sldata - sl->samples;
 182   }
 183  }
 184 }
 185 //end changes by adb
 186
 187 void *mixer_thread(void *data)
 188 {
 189         int err;
 190         ubyte buffer[SOUND_BUFFER_SIZE];
 191
 192         /* Allow ourselves to be asynchronously cancelled */
 193         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
 194         while (1)
 195         {
 196                 memset(buffer, 0x80, SOUND_BUFFER_SIZE);
 197                 LOCK();
 198                 audio_mixcallback(NULL,buffer,512);
 199                 UNLOCK();
 200         again:
 201                 err = snd_pcm_writei(snd_devhandle, buffer, SOUND_BUFFER_SIZE / 2);
 202
 203                 if (err == -EPIPE)
 204                 {
 205                         // Sound buffer underrun
 206                         err = snd_pcm_prepare(snd_devhandle);
 207                         if (err < 0)
 208                         {
 209                                 fprintf(stderr, "Can't recover from underrun: %s\n", snd_strerror(err));
 210                         }
 211                 }
 212                 else if (err == -EAGAIN)
 213                 {
 214                         goto again;
 215                 }
 216                 else if (err != SOUND_BUFFER_SIZE / 2)
 217                 {
 218                         // Each frame has size 2 bytes - hence we expect SOUND_BUFFER_SIZE/2
 219                         // frames to be written.
 220                         fprintf(stderr, "Unknown err %d: %s\n", err, snd_strerror(err));
 221                 }
 222         }
 223         return 0;
 224 }
 225
 226
 227 /* Initialise audio devices. */
 228 int digi_init()
 229 {
 230         int err, tmp;
 231         char *device = "plughw:0,0";
 232         snd_pcm_hw_params_t *params;
 233  pthread_attr_t attr;
 234  pthread_mutexattr_t mutexattr;
 235
 236  //added on 980905 by adb to init sound kill system
 237  memset(SampleHandles, 255, sizeof(SampleHandles));
 238  //end edit by adb
 239
 240  /* Open the ALSA sound device */
 241         if ((err = snd_pcm_open(&snd_devhandle, device, SND_PCM_STREAM_PLAYBACK)) < 0)
 242         {
 243      fprintf(stderr, "open failed: %s\n", snd_strerror( err ));
 244      return -1;
 245         }
 246
 247         snd_pcm_hw_params_alloca(&params);
 248         err = snd_pcm_hw_params_any(snd_devhandle, params);
 249         if (err < 0)
 250         {
 251                 printf("ALSA: Error %s\n", snd_strerror(err));
 252                 return -1;
 253         }
 254         err = snd_pcm_hw_params_set_access(snd_devhandle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
 255         if (err < 0)
 256         {
 257                 printf("ALSA: Error %s\n", snd_strerror(err));
 258                 return -1;
 259         }
 260         err = snd_pcm_hw_params_set_format(snd_devhandle, params, SND_PCM_FORMAT_U8);
 261         if (err < 0)
 262         {
 263                 printf("ALSA: Error %s\n", snd_strerror(err));
 264                 return -1;
 265         }
 266         err = snd_pcm_hw_params_set_channels(snd_devhandle, params, 2);
 267         if (err < 0)
 268         {
 269                 printf("ALSA: Error %s\n", snd_strerror(err));
 270                 return -1;
 271         }
 272         tmp = 11025;
 273         err = snd_pcm_hw_params_set_rate_near(snd_devhandle, params, &tmp, NULL);
 274         if (err < 0)
 275         {
 276                 printf("ALSA: Error %s\n", snd_strerror(err));
 277                 return -1;
 278         }
 279         snd_pcm_hw_params_set_periods(snd_devhandle, params, 3, 0);
 280         snd_pcm_hw_params_set_buffer_size(snd_devhandle,params, (SOUND_BUFFER_SIZE*3)/2);
 281
 282         err = snd_pcm_hw_params(snd_devhandle, params);
 283         if (err < 0)
 284         {
 285                 printf("ALSA: Error %s\n", snd_strerror(err));
 286                 return -1;
 287         }
 288
 289  /* Start the mixer thread */
 290
 291  /* We really should check the results of these */
 292  pthread_mutexattr_init(&mutexattr);
 293  pthread_mutex_init(&mutex,&mutexattr);
 294  pthread_mutexattr_destroy(&mutexattr);
 295
 296  if (pthread_attr_init(&attr) != 0) {
 297   fprintf(stderr, "failed to init attr\n");
 298   snd_pcm_close( snd_devhandle );
 299   return -1;
 300  }
 301
 302  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 303
 304  pthread_create(&thread_id,&attr,mixer_thread,NULL);
 305  pthread_attr_destroy(&attr);
 306
 307  atexit(digi_close);
 308  Digi_initialized = 1;
 309  return 0;
 310 }
 311
 312 /* Toggle audio */
 313 void digi_reset() { }
 314
 315 /* Shut down audio */
 316 void digi_close()
 317 {
 318  if (!Digi_initialized) return;
 319  pthread_cancel(thread_id);
 320  Digi_initialized = 0;
 321  pthread_mutex_destroy(&mutex);
 322  snd_pcm_close(snd_devhandle);
 323 }
 324
 325 void digi_stop_all_channels()
 326 {
 327         int i;
 328
 329         for (i = 0; i < MAX_SOUND_SLOTS; i++)
 330                 digi_stop_sound(i);
 331 }
 332
 333
 334 extern void digi_end_soundobj(int channel);
 335 extern int SoundQ_channel;
 336 extern void SoundQ_end();
 337 int verify_sound_channel_free(int channel);
 338
 339 // Volume 0-F1_0
 340 int digi_start_sound(short soundnum, fix volume, int pan, int looping, int loop_start, int loop_end, int soundobj)
 341 {
 342         int i, starting_channel;
 343
 344         if (!Digi_initialized) return -1;
 345
 346         if (soundnum < 0) return -1;
 347
 348         LOCK();
 349         Assert(GameSounds[soundnum].data != (void *)-1);
 350
 351         starting_channel = next_channel;
 352
 353         while(1)
 354         {
 355                 if (!SoundSlots[next_channel].playing)
 356                         break;
 357
 358                 if (!SoundSlots[next_channel].persistent)
 359                         break;  // use this channel!
 360
 361                 next_channel++;
 362                 if (next_channel >= digi_max_channels)
 363                         next_channel = 0;
 364                 if (next_channel == starting_channel)
 365                 {
 366                         mprintf((1, "OUT OF SOUND CHANNELS!!!\n"));
 367                         UNLOCK();
 368                         return -1;
 369                 }
 370         }
 371         if (SoundSlots[next_channel].playing)
 372         {
 373                 SoundSlots[next_channel].playing = 0;
 374                 if (SoundSlots[next_channel].soundobj > -1)
 375                 {
 376                         digi_end_soundobj(SoundSlots[next_channel].soundobj);
 377                 }
 378                 if (SoundQ_channel == next_channel)
 379                         SoundQ_end();
 380         }
 381
 382 #ifndef NDEBUG
 383         verify_sound_channel_free(next_channel);
 384 #endif
 385
 386         SoundSlots[next_channel].soundno = soundnum;
 387         SoundSlots[next_channel].samples = GameSounds[soundnum].data;
 388         SoundSlots[next_channel].length = GameSounds[soundnum].length;
 389         SoundSlots[next_channel].volume = fixmul(digi_volume, volume);
 390         SoundSlots[next_channel].pan = pan;
 391         SoundSlots[next_channel].position = 0;
 392         SoundSlots[next_channel].looped = looping;
 393         SoundSlots[next_channel].playing = 1;
 394         SoundSlots[next_channel].soundobj = soundobj;
 395         SoundSlots[next_channel].persistent = 0;
 396         if ((soundobj > -1) || (looping) || (volume > F1_0))
 397                 SoundSlots[next_channel].persistent = 1;
 398
 399         i = next_channel;
 400         next_channel++;
 401         if (next_channel >= digi_max_channels)
 402                 next_channel = 0;
 403         UNLOCK();
 404
 405         return i;
 406 }
 407
 408 // Returns the channel a sound number is playing on, or
 409 // -1 if none.
 410 int digi_find_channel(int soundno)
 411 {
 412         if (!Digi_initialized)
 413                 return -1;
 414
 415         if (soundno < 0 )
 416                 return -1;
 417
 418         if (GameSounds[soundno].data == NULL)
 419         {
 420                 Int3();
 421                 return -1;
 422         }
 423
 424         //FIXME: not implemented
 425         return -1;
 426 }
 427
 428
 429 //added on 980905 by adb from original source to make sfx volume work
 430 void digi_set_digi_volume( int dvolume )
 431 {
 432         dvolume = fixmuldiv( dvolume, SOUND_MAX_VOLUME, 0x7fff);
 433         if ( dvolume > SOUND_MAX_VOLUME )
 434                 digi_volume = SOUND_MAX_VOLUME;
 435         else if ( dvolume < 0 )
 436                 digi_volume = 0;
 437         else
 438                 digi_volume = dvolume;
 439
 440         if ( !Digi_initialized ) return;
 441
 442         digi_sync_sounds();
 443 }
 444 //end edit by adb
 445
 446 void digi_set_volume(int dvolume, int mvolume)
 447 {
 448         digi_set_digi_volume(dvolume);
 449         digi_set_midi_volume(mvolume);
 450 //      mprintf(( 1, "Volume: 0x%x and 0x%x\n", digi_volume, midi_volume ));
 451 }
 452
 453 int digi_is_sound_playing(int soundno)
 454 {
 455         int i;
 456
 457         soundno = digi_xlat_sound(soundno);
 458
 459         LOCK();
 460         for (i = 0; i < MAX_SOUND_SLOTS; i++)
 461                   //changed on 980905 by adb: added SoundSlots[i].playing &&
 462                   if (SoundSlots[i].playing && SoundSlots[i].soundno == soundno)
 463                   //end changes by adb
 464                   { UNLOCK();   return 1; }
 465         UNLOCK();
 466         return 0;
 467 }
 468
 469
 470  //added on 980905 by adb to make sound channel setting work
 471 void digi_set_max_channels(int n) {
 472         digi_max_channels       = n;
 473
 474         if ( digi_max_channels < 1 )
 475                 digi_max_channels = 1;
 476         if (digi_max_channels > MAX_SOUND_SLOTS)
 477                 digi_max_channels = MAX_SOUND_SLOTS;
 478
 479         if ( !Digi_initialized ) return;
 480
 481         digi_stop_all_channels();
 482 }
 483
 484 int digi_get_max_channels() {
 485         return digi_max_channels;
 486 }
 487 // end edit by adb
 488
 489 int digi_is_channel_playing(int channel)
 490 {
 491         if (!Digi_initialized)
 492                 return 0;
 493
 494         LOCK();
 495         if (SoundSlots[channel].playing)
 496         {
 497                 UNLOCK();
 498                 return 1;
 499         }
 500         UNLOCK();
 501         return 0;
 502 }
 503
 504 void digi_set_channel_volume(int channel, int volume)
 505 {
 506         if (!Digi_initialized)
 507                 return;
 508
 509         LOCK();
 510         if (SoundSlots[channel].playing)
 511                 SoundSlots[channel].volume = fixmuldiv(volume, digi_volume, F1_0);
 512         UNLOCK();
 513 }
 514
 515 void digi_set_channel_pan(int channel, int pan)
 516 {
 517         if (!Digi_initialized)
 518                 return;
 519
 520         LOCK();
 521         if (SoundSlots[channel].playing)
 522                 SoundSlots[channel].pan = pan;
 523         UNLOCK();
 524 }
 525
 526 void digi_stop_sound(int channel)
 527 {
 528         LOCK();
 529         SoundSlots[channel].playing = 0;
 530         SoundSlots[channel].soundobj = -1;
 531         SoundSlots[channel].persistent = 0;
 532         UNLOCK();
 533 }
 534
 535 void digi_end_sound(int channel)
 536 {
 537         if (!Digi_initialized)
 538                 return;
 539
 540         LOCK();
 541         if (SoundSlots[channel].playing)
 542         {
 543                 SoundSlots[channel].soundobj = -1;
 544                 SoundSlots[channel].persistent = 0;
 545         }
 546         UNLOCK();
 547 }
 548
 549
 550 // MIDI stuff follows.
 551 //added/killed on 11/25/98 by Matthew Mueller
 552 //void digi_set_midi_volume( int mvolume ) { }
 553 //void digi_play_midi_song( char * filename, char * melodic_bank, char * drum_bank, int loop ) {}
 554 //void digi_stop_current_song()
 555 //{
 556 //#ifdef HMIPLAY
 557 //        char buf[10];
 558 //
 559 //        sprintf(buf,"s");
 560 //        send_ipc(buf);
 561 //#endif
 562 //}
 563 //end this section kill - MM