snd_alsa.c

   1 /*
   2         Copyright (C) 2006  Mathieu Olivier
   3
   4         This program is free software; you can redistribute it and/or
   5         modify it under the terms of the GNU General Public License
   6         as published by the Free Software Foundation; either version 2
   7         of the License, or (at your option) any later version.
   8
   9         This program is distributed in the hope that it will be useful,
  10         but WITHOUT ANY WARRANTY; without even the implied warranty of
  11         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13         See the GNU General Public License for more details.
  14
  15         You should have received a copy of the GNU General Public License
  16         along with this program; if not, write to:
  17
  18                 Free Software Foundation, Inc.
  19                 59 Temple Place - Suite 330
  20                 Boston, MA  02111-1307, USA
  21
  22 */
  23
  24 // ALSA module, used by Linux
  25
  26 #include "quakedef.h"
  27
  28 #include <alsa/asoundlib.h>
  29
  30 #include "snd_main.h"
  31
  32
  33 #define NB_PERIODS 4
  34
  35 static snd_pcm_t* pcm_handle = NULL;
  36 static snd_pcm_sframes_t expected_delay = 0;
  37 static unsigned int alsasoundtime;
  38
  39 static snd_seq_t* seq_handle = NULL;
  40
  41 /*
  42 ====================
  43 SndSys_Init
  44
  45 Create "snd_renderbuffer" with the proper sound format if the call is successful
  46 May return a suggested format if the requested format isn't available
  47 ====================
  48 */
  49 qboolean SndSys_Init (const snd_format_t* requested, snd_format_t* suggested)
  50 {
  51         const char* pcm_name, *seq_name;
  52         int i, err, seq_client, seq_port;
  53         snd_pcm_hw_params_t* hw_params = NULL;
  54         snd_pcm_format_t snd_pcm_format;
  55         snd_pcm_uframes_t buffer_size;
  56
  57         Con_Print ("SndSys_Init: using the ALSA module\n");
  58
  59         seq_name = NULL;
  60 // COMMANDLINEOPTION: Linux ALSA Sound: -sndseqin <client>:<port> selects which sequencer port to use for input, by default no sequencer port is used (MIDI note events from that port get mapped to MIDINOTE<n> keys that can be bound)
  61         i = COM_CheckParm ("-sndseqin"); // TODO turn this into a cvar, maybe
  62         if (i != 0 && i < com_argc - 1)
  63                 seq_name = com_argv[i + 1];
  64         if(seq_name)
  65         {
  66                 seq_client = atoi(seq_name);
  67                 seq_port = 0;
  68                 if(strchr(seq_name, ':'))
  69                         seq_port = atoi(strchr(seq_name, ':') + 1);
  70                 Con_Printf ("SndSys_Init: seq input port has been set to \"%d:%d\". Enabling sequencer input...\n", seq_client, seq_port);
  71                 err = snd_seq_open (&seq_handle, "default", SND_SEQ_OPEN_INPUT, 0);
  72                 if (err < 0)
  73                 {
  74                         Con_Print ("SndSys_Init: can't open seq device\n");
  75                         goto seqdone;
  76                 }
  77                 err = snd_seq_set_client_name(seq_handle, gamename);
  78                 if (err < 0)
  79                 {
  80                         Con_Print ("SndSys_Init: can't set name of seq device\n");
  81                         goto seqerror;
  82                 }
  83                 err = snd_seq_create_simple_port(seq_handle, gamename, SND_SEQ_PORT_CAP_WRITE | SND_SEQ_PORT_CAP_SUBS_WRITE, SND_SEQ_PORT_TYPE_MIDI_GENERIC | SND_SEQ_PORT_TYPE_APPLICATION);
  84                 if(err < 0)
  85                 {
  86                         Con_Print ("SndSys_Init: can't create seq port\n");
  87                         goto seqerror;
  88                 }
  89                 err = snd_seq_connect_from(seq_handle, 0, seq_client, seq_port);
  90                 if(err < 0)
  91                 {
  92                         Con_Printf ("SndSys_Init: can't connect to seq port \"%d:%d\"\n", seq_client, seq_port);
  93                         goto seqerror;
  94                 }
  95                 err = snd_seq_nonblock(seq_handle, 1);
  96                 if(err < 0)
  97                 {
  98                         Con_Print ("SndSys_Init: can't make seq nonblocking\n");
  99                         goto seqerror;
 100                 }
 101
 102                 goto seqdone;
 103
 104 seqerror:
 105                 snd_seq_close(seq_handle);
 106                 seq_handle = NULL;
 107         }
 108
 109 seqdone:
 110         // Check the requested sound format
 111         if (requested->width < 1 || requested->width > 2)
 112         {
 113                 Con_Printf ("SndSys_Init: invalid sound width (%hu)\n",
 114                                         requested->width);
 115
 116                 if (suggested != NULL)
 117                 {
 118                         memcpy (suggested, requested, sizeof (*suggested));
 119
 120                         if (requested->width < 1)
 121                                 suggested->width = 1;
 122                         else
 123                                 suggested->width = 2;
 124
 125                         Con_Printf ("SndSys_Init: suggesting sound width = %hu\n",
 126                                                 suggested->width);
 127                 }
 128
 129                 return false;
 130     }
 131
 132         if (pcm_handle != NULL)
 133         {
 134                 Con_Print ("SndSys_Init: WARNING: Init called before Shutdown!\n");
 135                 SndSys_Shutdown ();
 136         }
 137
 138         // Determine the name of the PCM handle we'll use
 139         switch (requested->channels)
 140         {
 141                 case 4:
 142                         pcm_name = "surround40";
 143                         break;
 144                 case 6:
 145                         pcm_name = "surround51";
 146                         break;
 147                 case 8:
 148                         pcm_name = "surround71";
 149                         break;
 150                 default:
 151                         pcm_name = "default";
 152                         break;
 153         }
 154 // COMMANDLINEOPTION: Linux ALSA Sound: -sndpcm <devicename> selects which pcm device to use, default is "default"
 155         i = COM_CheckParm ("-sndpcm");
 156         if (i != 0 && i < com_argc - 1)
 157                 pcm_name = com_argv[i + 1];
 158
 159         // Open the audio device
 160         Con_Printf ("SndSys_Init: PCM device is \"%s\"\n", pcm_name);
 161         err = snd_pcm_open (&pcm_handle, pcm_name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 162         if (err < 0)
 163         {
 164                 Con_Printf ("SndSys_Init: can't open audio device \"%s\" (%s)\n",
 165                                         pcm_name, snd_strerror (err));
 166                 return false;
 167         }
 168
 169         // Allocate the hardware parameters
 170         err = snd_pcm_hw_params_malloc (&hw_params);
 171         if (err < 0)
 172         {
 173                 Con_Printf ("SndSys_Init: can't allocate hardware parameters (%s)\n",
 174                                         snd_strerror (err));
 175                 goto init_error;
 176         }
 177         err = snd_pcm_hw_params_any (pcm_handle, hw_params);
 178         if (err < 0)
 179         {
 180                 Con_Printf ("SndSys_Init: can't initialize hardware parameters (%s)\n",
 181                                         snd_strerror (err));
 182                 goto init_error;
 183         }
 184
 185         // Set the access type
 186         err = snd_pcm_hw_params_set_access (pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED);
 187         if (err < 0)
 188         {
 189                 Con_Printf ("SndSys_Init: can't set access type (%s)\n",
 190                                         snd_strerror (err));
 191                 goto init_error;
 192         }
 193
 194         // Set the sound width
 195         if (requested->width == 1)
 196                 snd_pcm_format = SND_PCM_FORMAT_U8;
 197         else
 198                 snd_pcm_format = SND_PCM_FORMAT_S16;
 199         err = snd_pcm_hw_params_set_format (pcm_handle, hw_params, snd_pcm_format);
 200         if (err < 0)
 201         {
 202                 Con_Printf ("SndSys_Init: can't set sound width to %hu (%s)\n",
 203                                         requested->width, snd_strerror (err));
 204                 goto init_error;
 205         }
 206
 207         // Set the sound channels
 208         err = snd_pcm_hw_params_set_channels (pcm_handle, hw_params, requested->channels);
 209         if (err < 0)
 210         {
 211                 Con_Printf ("SndSys_Init: can't set sound channels to %hu (%s)\n",
 212                                         requested->channels, snd_strerror (err));
 213                 goto init_error;
 214         }
 215
 216         // Set the sound speed
 217         err = snd_pcm_hw_params_set_rate (pcm_handle, hw_params, requested->speed, 0);
 218         if (err < 0)
 219         {
 220                 Con_Printf ("SndSys_Init: can't set sound speed to %u (%s)\n",
 221                                         requested->speed, snd_strerror (err));
 222                 goto init_error;
 223         }
 224
 225         // pick a buffer size that is a power of 2 (by masking off low bits)
 226         buffer_size = i = (int)(requested->speed * 0.15f);
 227         while (buffer_size & (buffer_size-1))
 228                 buffer_size &= (buffer_size-1);
 229         // then check if it is the nearest power of 2 and bump it up if not
 230         if (i - buffer_size >= buffer_size >> 1)
 231                 buffer_size *= 2;
 232
 233         err = snd_pcm_hw_params_set_buffer_size_near (pcm_handle, hw_params, &buffer_size);
 234         if (err < 0)
 235         {
 236                 Con_Printf ("SndSys_Init: can't set sound buffer size to %lu (%s)\n",
 237                                         buffer_size, snd_strerror (err));
 238                 goto init_error;
 239         }
 240
 241         // pick a period size near the buffer_size we got from ALSA
 242         snd_pcm_hw_params_get_buffer_size (hw_params, &buffer_size);
 243         buffer_size /= NB_PERIODS;
 244         err = snd_pcm_hw_params_set_period_size_near(pcm_handle, hw_params, &buffer_size, 0);
 245         if (err < 0)
 246         {
 247                 Con_Printf ("SndSys_Init: can't set sound period size to %lu (%s)\n",
 248                                         buffer_size, snd_strerror (err));
 249                 goto init_error;
 250         }
 251
 252         err = snd_pcm_hw_params (pcm_handle, hw_params);
 253         if (err < 0)
 254         {
 255                 Con_Printf ("SndSys_Init: can't set hardware parameters (%s)\n",
 256                                         snd_strerror (err));
 257                 goto init_error;
 258         }
 259
 260         snd_pcm_hw_params_free (hw_params);
 261
 262         snd_renderbuffer = Snd_CreateRingBuffer(requested, 0, NULL);
 263         expected_delay = 0;
 264         alsasoundtime = 0;
 265         if (snd_channellayout.integer == SND_CHANNELLAYOUT_AUTO)
 266                 Cvar_SetValueQuick (&snd_channellayout, SND_CHANNELLAYOUT_ALSA);
 267
 268         return true;
 269
 270
 271 // It's not very clean, but it avoids a lot of duplicated code.
 272 init_error:
 273
 274         if (hw_params != NULL)
 275                 snd_pcm_hw_params_free (hw_params);
 276
 277         snd_pcm_close(pcm_handle);
 278         pcm_handle = NULL;
 279
 280         return false;
 281 }
 282
 283
 284 /*
 285 ====================
 286 SndSys_Shutdown
 287
 288 Stop the sound card, delete "snd_renderbuffer" and free its other resources
 289 ====================
 290 */
 291 void SndSys_Shutdown (void)
 292 {
 293         if (seq_handle != NULL)
 294         {
 295                 snd_seq_close(seq_handle);
 296                 seq_handle = NULL;
 297         }
 298
 299         if (pcm_handle != NULL)
 300         {
 301                 snd_pcm_close(pcm_handle);
 302                 pcm_handle = NULL;
 303         }
 304
 305         if (snd_renderbuffer != NULL)
 306         {
 307                 Mem_Free(snd_renderbuffer->ring);
 308                 Mem_Free(snd_renderbuffer);
 309                 snd_renderbuffer = NULL;
 310         }
 311 }
 312
 313
 314 /*
 315 ====================
 316 SndSys_Recover
 317
 318 Try to recover from errors
 319 ====================
 320 */
 321 static qboolean SndSys_Recover (int err_num)
 322 {
 323         int err;
 324
 325         // We can only do something on underrun ("broken pipe") errors
 326         if (err_num != -EPIPE)
 327                 return false;
 328
 329         err = snd_pcm_prepare (pcm_handle);
 330         if (err < 0)
 331         {
 332                 Con_Printf ("SndSys_Recover: unable to recover (%s)\n",
 333                                          snd_strerror (err));
 334
 335                 // TOCHECK: should we stop the playback ?
 336
 337                 return false;
 338         }
 339
 340         return true;
 341 }
 342
 343
 344 /*
 345 ====================
 346 SndSys_Write
 347 ====================
 348 */
 349 static snd_pcm_sframes_t SndSys_Write (const unsigned char* buffer, unsigned int nbframes)
 350 {
 351         snd_pcm_sframes_t written;
 352
 353         written = snd_pcm_writei (pcm_handle, buffer, nbframes);
 354         if (written < 0)
 355         {
 356                 if (developer_insane.integer && vid_activewindow)
 357                         Con_DPrintf ("SndSys_Write: audio write returned %ld (%s)!\n",
 358                                                  written, snd_strerror (written));
 359
 360                 if (SndSys_Recover (written))
 361                 {
 362                         written = snd_pcm_writei (pcm_handle, buffer, nbframes);
 363                         if (written < 0)
 364                                 Con_DPrintf ("SndSys_Write: audio write failed again (error %ld: %s)!\n",
 365                                                          written, snd_strerror (written));
 366                 }
 367         }
 368         if (written > 0)
 369         {
 370                 snd_renderbuffer->startframe += written;
 371                 expected_delay += written;
 372         }
 373
 374         return written;
 375 }
 376
 377
 378 /*
 379 ====================
 380 SndSys_Submit
 381
 382 Submit the contents of "snd_renderbuffer" to the sound card
 383 ====================
 384 */
 385 void SndSys_Submit (void)
 386 {
 387         unsigned int startoffset, factor;
 388         snd_pcm_uframes_t limit, nbframes;
 389         snd_pcm_sframes_t written;
 390
 391         if (pcm_handle == NULL ||
 392                 snd_renderbuffer->startframe == snd_renderbuffer->endframe)
 393                 return;
 394
 395         startoffset = snd_renderbuffer->startframe % snd_renderbuffer->maxframes;
 396         factor = snd_renderbuffer->format.width * snd_renderbuffer->format.channels;
 397         limit = snd_renderbuffer->maxframes - startoffset;
 398         nbframes = snd_renderbuffer->endframe - snd_renderbuffer->startframe;
 399
 400         if (nbframes > limit)
 401         {
 402                 written = SndSys_Write (&snd_renderbuffer->ring[startoffset * factor], limit);
 403                 if (written < 0 || (snd_pcm_uframes_t)written != limit)
 404                         return;
 405
 406                 nbframes -= limit;
 407                 startoffset = 0;
 408         }
 409
 410         written = SndSys_Write (&snd_renderbuffer->ring[startoffset * factor], nbframes);
 411         if (written < 0)
 412                 return;
 413 }
 414
 415
 416 /*
 417 ====================
 418 SndSys_GetSoundTime
 419
 420 Returns the number of sample frames consumed since the sound started
 421 ====================
 422 */
 423 unsigned int SndSys_GetSoundTime (void)
 424 {
 425         snd_pcm_sframes_t delay, timediff;
 426         int err;
 427
 428         if (pcm_handle == NULL)
 429                 return 0;
 430
 431         err = snd_pcm_delay (pcm_handle, &delay);
 432         if (err < 0)
 433         {
 434                 if (developer_insane.integer && vid_activewindow)
 435                         Con_DPrintf ("SndSys_GetSoundTime: can't get playback delay (%s)\n",
 436                                                  snd_strerror (err));
 437
 438                 if (! SndSys_Recover (err))
 439                         return 0;
 440
 441                 err = snd_pcm_delay (pcm_handle, &delay);
 442                 if (err < 0)
 443                 {
 444                         Con_DPrintf ("SndSys_GetSoundTime: can't get playback delay, again (%s)\n",
 445                                                  snd_strerror (err));
 446                         return 0;
 447                 }
 448         }
 449
 450         if (expected_delay < delay)
 451         {
 452                 Con_DPrintf ("SndSys_GetSoundTime: expected_delay(%ld) < delay(%ld)\n",
 453                                          expected_delay, delay);
 454                 timediff = 0;
 455         }
 456         else
 457                 timediff = expected_delay - delay;
 458         expected_delay = delay;
 459
 460         alsasoundtime += (unsigned int)timediff;
 461
 462         return alsasoundtime;
 463 }
 464
 465
 466 /*
 467 ====================
 468 SndSys_LockRenderBuffer
 469
 470 Get the exclusive lock on "snd_renderbuffer"
 471 ====================
 472 */
 473 qboolean SndSys_LockRenderBuffer (void)
 474 {
 475         // Nothing to do
 476         return true;
 477 }
 478
 479
 480 /*
 481 ====================
 482 SndSys_UnlockRenderBuffer
 483
 484 Release the exclusive lock on "snd_renderbuffer"
 485 ====================
 486 */
 487 void SndSys_UnlockRenderBuffer (void)
 488 {
 489         // Nothing to do
 490 }
 491
 492 /*
 493 ====================
 494 SndSys_SendKeyEvents
 495
 496 Send keyboard events originating from the sound system (e.g. MIDI)
 497 ====================
 498 */
 499 void SndSys_SendKeyEvents(void)
 500 {
 501         snd_seq_event_t *event;
 502         if(!seq_handle)
 503                 return;
 504         for(;;)
 505         {
 506                 if(snd_seq_event_input(seq_handle, &event) <= 0)
 507                         break;
 508                 if(event)
 509                 {
 510                         switch(event->type)
 511                         {
 512                                 case SND_SEQ_EVENT_NOTEON:
 513                                         if(event->data.note.velocity)
 514                                         {
 515                                                 Key_Event(K_MIDINOTE0 + event->data.note.note, 0, true);
 516                                                 break;
 517                                         }
 518                                 case SND_SEQ_EVENT_NOTEOFF:
 519                                         Key_Event(K_MIDINOTE0 + event->data.note.note, 0, false);
 520                                         break;
 521                         }
 522                 }
 523         }
 524 }