snd_alsa.c

   1 /*
   2         snd_alsa.c
   3
   4         Support for the ALSA 1.0.1 sound driver
   5
   6         Copyright (C) 1999,2000  contributors of the QuakeForge project
   7         Please see the file "AUTHORS" for a list of contributors
   8
   9         This program is free software; you can redistribute it and/or
  10         modify it under the terms of the GNU General Public License
  11         as published by the Free Software Foundation; either version 2
  12         of the License, or (at your option) any later version.
  13
  14         This program is distributed in the hope that it will be useful,
  15         but WITHOUT ANY WARRANTY; without even the implied warranty of
  16         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18         See the GNU General Public License for more details.
  19
  20         You should have received a copy of the GNU General Public License
  21         along with this program; if not, write to:
  22
  23                 Free Software Foundation, Inc.
  24                 59 Temple Place - Suite 330
  25                 Boston, MA  02111-1307, USA
  26
  27 */
  28
  29 #include <alsa/asoundlib.h>
  30
  31 #include "quakedef.h"
  32 #include "snd_main.h"
  33
  34 static snd_pcm_uframes_t buffer_size;
  35
  36 static const char  *pcmname = NULL;
  37 static snd_pcm_t   *pcm;
  38
  39 qboolean SNDDMA_Init (void)
  40 {
  41         int                                     err, i, j;
  42         int                                     width;
  43         int                                     channels;
  44         unsigned int            rate;
  45         snd_pcm_hw_params_t     *hw;
  46         snd_pcm_sw_params_t     *sw;
  47         snd_pcm_uframes_t       frag_size;
  48
  49         snd_pcm_hw_params_alloca (&hw);
  50         snd_pcm_sw_params_alloca (&sw);
  51
  52 // COMMANDLINEOPTION: Linux ALSA Sound: -sndbits <number> sets sound precision to 8 or 16 bit (email me if you want others added)
  53         width = 2;
  54         if ((i=COM_CheckParm("-sndbits")) != 0)
  55         {
  56                 j = atoi(com_argv[i+1]);
  57                 if (j == 16 || j == 8)
  58                         width = j / 8;
  59                 else
  60                         Con_Printf("Error: invalid sample bits: %d\n", j);
  61         }
  62
  63 // COMMANDLINEOPTION: Linux ALSA Sound: -sndspeed <hz> chooses 44100 hz, 22100 hz, or 11025 hz sound output rate
  64         rate = 44100;
  65         if ((i=COM_CheckParm("-sndspeed")) != 0)
  66         {
  67                 j = atoi(com_argv[i+1]);
  68                 if (j >= 1)
  69                         rate = j;
  70                 else
  71                         Con_Printf("Error: invalid sample rate: %d\n", rate);
  72         }
  73
  74         for (channels = 8;channels >= 1;channels--)
  75         {
  76                 if ((channels & 1) && channels != 1)
  77                         continue;
  78 // COMMANDLINEOPTION: Linux ALSA Sound: -sndmono sets sound output to mono
  79                 if ((i=COM_CheckParm("-sndmono")) != 0)
  80                         if (channels != 1)
  81                                 continue;
  82 // COMMANDLINEOPTION: Linux ALSA Sound: -sndstereo sets sound output to stereo
  83                 if ((i=COM_CheckParm("-sndstereo")) != 0)
  84                         if (channels != 2)
  85                                 continue;
  86 // COMMANDLINEOPTION: Linux ALSA Sound: -sndquad sets sound output to 4 channel surround
  87                 if ((i=COM_CheckParm("-sndquad")) != 0)
  88                         if (channels != 4)
  89                                 continue;
  90
  91 // COMMANDLINEOPTION: Linux ALSA Sound: -sndpcm <devicename> selects which pcm device to us, default is "default"
  92                 if (channels == 8)
  93                         pcmname = "surround71";
  94                 else if (channels == 6)
  95                         pcmname = "surround51";
  96                 else if (channels == 4)
  97                         pcmname = "surround40";
  98                 else
  99                         pcmname = "default";
 100                 if ((i=COM_CheckParm("-sndpcm"))!=0)
 101                         pcmname = com_argv[i+1];
 102
 103                 Con_Printf ("ALSA: Trying PCM %s.\n", pcmname);
 104
 105                 err = snd_pcm_open (&pcm, pcmname, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK);
 106                 if (0 > err)
 107                 {
 108                         Con_Printf ("Error: audio open error: %s\n", snd_strerror (err));
 109                         continue;
 110                 }
 111
 112                 err = snd_pcm_hw_params_any (pcm, hw);
 113                 if (0 > err)
 114                 {
 115                         Con_Printf ("ALSA: error setting hw_params_any. %s\n", snd_strerror (err));
 116                         snd_pcm_close (pcm);
 117                         continue;
 118                 }
 119
 120                 err = snd_pcm_hw_params_set_access (pcm, hw, SND_PCM_ACCESS_MMAP_INTERLEAVED);
 121                 if (0 > err)
 122                 {
 123                         Con_Printf ("ALSA: Failure to set interleaved mmap PCM access. %s\n", snd_strerror (err));
 124                         snd_pcm_close (pcm);
 125                         continue;
 126                 }
 127
 128                 err = snd_pcm_hw_params_set_format (pcm, hw, width == 1 ? SND_PCM_FORMAT_U8 : SND_PCM_FORMAT_S16);
 129                 if (0 > err)
 130                 {
 131                         Con_Printf ("ALSA: desired bits %i not supported by driver.  %s\n", width * 8, snd_strerror (err));
 132                         snd_pcm_close (pcm);
 133                         continue;
 134                 }
 135
 136                 err = snd_pcm_hw_params_set_channels (pcm, hw, channels);
 137                 if (0 > err)
 138                 {
 139                         Con_Printf ("ALSA: no usable channels. %s\n", snd_strerror (err));
 140                         snd_pcm_close (pcm);
 141                         continue;
 142                 }
 143
 144                 err = snd_pcm_hw_params_set_rate_near (pcm, hw, &rate, 0);
 145                 if (0 > err)
 146                 {
 147                         Con_Printf ("ALSA: desired rate %i not supported by driver. %s\n", rate, snd_strerror (err));
 148                         snd_pcm_close (pcm);
 149                         continue;
 150                 }
 151
 152                 frag_size = 64 * width * rate / 11025;
 153                 err = snd_pcm_hw_params_set_period_size_near (pcm, hw, &frag_size, 0);
 154                 if (0 > err)
 155                 {
 156                         Con_Printf ("ALSA: unable to set period size near %i. %s\n", (int) frag_size, snd_strerror (err));
 157                         snd_pcm_close (pcm);
 158                         continue;
 159                 }
 160                 err = snd_pcm_hw_params (pcm, hw);
 161                 if (0 > err)
 162                 {
 163                         Con_Printf ("ALSA: unable to install hw params: %s\n", snd_strerror (err));
 164                         snd_pcm_close (pcm);
 165                         continue;
 166                 }
 167                 err = snd_pcm_sw_params_current (pcm, sw);
 168                 if (0 > err)
 169                 {
 170                         Con_Printf ("ALSA: unable to determine current sw params. %s\n", snd_strerror (err));
 171                         snd_pcm_close (pcm);
 172                         continue;
 173                 }
 174                 err = snd_pcm_sw_params_set_start_threshold (pcm, sw, ~0U);
 175                 if (0 > err)
 176                 {
 177                         Con_Printf ("ALSA: unable to set playback threshold. %s\n", snd_strerror (err));
 178                         snd_pcm_close (pcm);
 179                         continue;
 180                 }
 181                 err = snd_pcm_sw_params_set_stop_threshold (pcm, sw, ~0U);
 182                 if (0 > err)
 183                 {
 184                         Con_Printf ("ALSA: unable to set playback stop threshold. %s\n", snd_strerror (err));
 185                         snd_pcm_close (pcm);
 186                         continue;
 187                 }
 188                 err = snd_pcm_sw_params (pcm, sw);
 189                 if (0 > err)
 190                 {
 191                         Con_Printf ("ALSA: unable to install sw params. %s\n", snd_strerror (err));
 192                         snd_pcm_close (pcm);
 193                         continue;
 194                 }
 195
 196                 err = snd_pcm_hw_params_get_buffer_size (hw, &buffer_size);
 197                 if (0 > err)
 198                 {
 199                         Con_Printf ("ALSA: unable to get buffer size. %s\n", snd_strerror (err));
 200                         snd_pcm_close (pcm);
 201                         continue;
 202                 }
 203
 204                 memset( (void*) shm, 0, sizeof(*shm) );
 205                 shm->format.channels = channels;
 206                 shm->format.width = width;
 207                 shm->format.speed = rate;
 208                 shm->samplepos = 0;
 209                 shm->sampleframes = buffer_size;
 210                 shm->samples = shm->sampleframes * shm->format.channels;
 211                 SNDDMA_GetDMAPos ();            // sets shm->buffer
 212
 213                 return true;
 214         }
 215         return false;
 216 }
 217
 218 int SNDDMA_GetDMAPos (void)
 219 {
 220         const snd_pcm_channel_area_t *areas;
 221         snd_pcm_uframes_t offset;
 222         snd_pcm_uframes_t nframes = shm->sampleframes;
 223
 224         if (!shm)
 225                 return 0;
 226
 227         snd_pcm_avail_update (pcm);
 228         snd_pcm_mmap_begin (pcm, &areas, &offset, &nframes);
 229         offset *= shm->format.channels;
 230         nframes *= shm->format.channels;
 231         shm->samplepos = offset;
 232         shm->buffer = (unsigned char *)areas->addr;
 233         return shm->samplepos;
 234 }
 235
 236 void SNDDMA_Shutdown (void)
 237 {
 238         snd_pcm_close (pcm);
 239 }
 240
 241 /*
 242         SNDDMA_Submit
 243
 244         Send sound to device if buffer isn't really the dma buffer
 245 */
 246 void SNDDMA_Submit (void)
 247 {
 248         int                     state;
 249         int                     count = paintedtime - soundtime;
 250         const snd_pcm_channel_area_t *areas;
 251         snd_pcm_uframes_t nframes;
 252         snd_pcm_uframes_t offset;
 253
 254         nframes = count / shm->format.channels;
 255
 256         snd_pcm_avail_update (pcm);
 257         snd_pcm_mmap_begin (pcm, &areas, &offset, &nframes);
 258
 259         state = snd_pcm_state (pcm);
 260
 261         switch (state) {
 262                 case SND_PCM_STATE_PREPARED:
 263                         snd_pcm_mmap_commit (pcm, offset, nframes);
 264                         snd_pcm_start (pcm);
 265                         break;
 266                 case SND_PCM_STATE_RUNNING:
 267                         snd_pcm_mmap_commit (pcm, offset, nframes);
 268                         break;
 269                 default:
 270                         break;
 271         }
 272 }
 273
 274 void *S_LockBuffer(void)
 275 {
 276         return shm->buffer;
 277 }
 278
 279 void S_UnlockBuffer(void)
 280 {
 281 }