src/tX_audiodevice.cc

   1 /*
   2     terminatorX - realtime audio scratching software
   3     Copyright (C) 1999-2003  Alexander König
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     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 the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19     File: tX_aduiodevice.cc
  20
  21     Description: Implements Audiodevice handling...
  22 */
  23
  24 #define ALSA_PCM_NEW_HW_PARAMS_API
  25
  26 #include "tX_audiodevice.h"
  27 #include "tX_vtt.h"
  28
  29 #include <sys/types.h>
  30 #include <sys/stat.h>
  31 #include <sys/ioctl.h>
  32 #include <fcntl.h>
  33 #include <sys/soundcard.h>
  34 #include <config.h>
  35
  36 #include "tX_endian.h"
  37
  38 #ifndef __USE_XOPEN
  39 #       define __USE_XOPEN // we need this for swab()
  40 #       include <unistd.h>
  41 #       undef __USE_XOPEN
  42 #else
  43 #       include <unistd.h>
  44 #endif
  45
  46 #include <string.h>
  47 #include <errno.h>
  48 #include <stdlib.h>
  49 #include "tX_engine.h"
  50
  51 tX_audiodevice :: tX_audiodevice() : samples_per_buffer(0),
  52 current_buffer(0), buffer_pos(0)
  53 {
  54         sample_buffer[0]=NULL;
  55         sample_buffer[1]=NULL;
  56         engine=tX_engine::get_instance();
  57 }
  58
  59 void tX_audiodevice :: start() {
  60         sample_buffer[0]=new int16_t[samples_per_buffer*2];
  61         sample_buffer[1]=new int16_t[samples_per_buffer*2];
  62         int current=0;
  63         vtt_buffer_size=vtt_class::get_mix_buffer_size()<<1;
  64
  65         buffer_pos=0;
  66
  67         while (!engine->is_stopped()) {
  68                 current=current ? 0 : 1;
  69
  70                 int16_t *current_buffer=sample_buffer[current];
  71                 int16_t *next_buffer=sample_buffer[current ? 0 : 1];
  72
  73                 fill_buffer(current_buffer, next_buffer);
  74                 play(current_buffer);
  75         }
  76
  77         delete [] sample_buffer[0];
  78         delete [] sample_buffer[1];
  79 }
  80
  81 void tX_audiodevice :: fill_buffer(int16_t *target_buffer, int16_t *next_target_buffer) {
  82         int prefill=0;
  83
  84         while (buffer_pos <= samples_per_buffer) {
  85                 int16_t *data=engine->render_cycle();
  86
  87                 int rest=(buffer_pos+vtt_buffer_size)-samples_per_buffer;
  88
  89                 if (rest<=0) {
  90                         memcpy(&target_buffer[buffer_pos], data, vtt_buffer_size << 1);
  91                 } else {
  92                         memcpy(&target_buffer[buffer_pos], data, (vtt_buffer_size-rest) << 1);
  93                         memcpy(next_target_buffer, &data[vtt_buffer_size-rest], rest << 1);
  94                         prefill=rest;
  95                 }
  96
  97                 buffer_pos+=vtt_buffer_size;
  98         }
  99
 100         buffer_pos=prefill;
 101 }
 102
 103 /* Driver Specific Code follows.. */
 104
 105 #ifdef USE_OSS
 106
 107 int tX_audiodevice_oss :: open()
 108 {
 109         int i=0;
 110         int p;
 111         int buff_cfg;
 112
 113         if (fd) return (1);
 114         fd=::open(globals.oss_device, O_WRONLY, 0);
 115
 116         /* setting buffer size */
 117         buff_cfg=(globals.oss_buff_no<<16) | globals.oss_buff_size;
 118         p=buff_cfg;
 119
 120         tX_debug("tX_adudiodevice_oss::open() - buff_no: %i, buff_size: %i, buff_cfg: %08x", globals.oss_buff_no, globals.oss_buff_size, buff_cfg);
 121
 122         i = ioctl(fd, SNDCTL_DSP_SETFRAGMENT, &p);
 123         ioctl(fd, SNDCTL_DSP_RESET, 0);
 124
 125         /* 16 Bits */
 126
 127         p =  16;
 128         i +=  ioctl(fd, SOUND_PCM_WRITE_BITS, &p);
 129
 130         /* STEREO :) */
 131
 132         p =  2;
 133         i += ioctl(fd, SOUND_PCM_WRITE_CHANNELS, &p);
 134
 135         /* 44.1 khz */
 136
 137         p =  globals.oss_samplerate;
 138         i += ioctl(fd, SOUND_PCM_WRITE_RATE, &p);
 139
 140         sample_rate=globals.oss_samplerate;
 141
 142         /* Figure actual blocksize.. */
 143
 144         i += ioctl(fd, SNDCTL_DSP_GETBLKSIZE, &blocksize);
 145
 146         samples_per_buffer=blocksize/sizeof(int16_t);
 147
 148         tX_debug("tX_adudiodevice_oss::open() - blocksize: %i, samples_per_buffer: %i", blocksize, samples_per_buffer);
 149
 150         ioctl(fd, SNDCTL_DSP_SYNC, 0);
 151
 152         return i;
 153 }
 154
 155 int tX_audiodevice_oss :: close()
 156 {
 157         if (!fd)
 158         {
 159                 return(1);
 160         }
 161         ::close(fd);
 162         fd=0;
 163         blocksize=0;
 164
 165         return 0;
 166 }
 167
 168 tX_audiodevice_oss :: tX_audiodevice_oss() : tX_audiodevice(),
 169 fd(0), blocksize(0) {}
 170
 171 double tX_audiodevice_oss :: get_latency()
 172 {
 173         return 0;
 174 }
 175
 176 void tX_audiodevice_oss :: play(int16_t *buffer)
 177 {
 178 #ifdef BIG_ENDIAN_MACHINE
 179         swapbuffer (buffer, samples_per_buffer);
 180 #endif
 181         int res=write(fd, buffer, blocksize);
 182         if (res==-1) {
 183                 tX_error("failed to write to audiodevice: %s", strerror(errno));
 184                 exit(-1);
 185         }
 186 }
 187
 188 #endif //USE_OSS
 189
 190 #ifdef USE_ALSA
 191
 192 int tX_audiodevice_alsa :: open()
 193 {
 194         snd_pcm_stream_t stream = SND_PCM_STREAM_PLAYBACK;
 195         snd_pcm_hw_params_t *hw_params;
 196         char pcm_name[64];
 197         char foo[PATH_MAX];
 198
 199
 200         int card;
 201         int device;
 202
 203         sscanf(globals.alsa_device, "%i-%i: %s", &card, &device, foo);
 204         sprintf(pcm_name, "hw:%i,%i", card, device);
 205
 206         if (snd_pcm_open(&pcm_handle, pcm_name, stream, SND_PCM_NONBLOCK) < 0) {
 207                 tX_error("ALSA: Failed to access PCM device \"%s\"", pcm_name);
 208                 return -1;
 209         }
 210
 211         snd_pcm_hw_params_alloca(&hw_params);
 212
 213         if (snd_pcm_hw_params_any(pcm_handle, hw_params) < 0) {
 214                 tX_error("ALSA: Failed to configure PCM device \"%s\"", pcm_name);
 215                 snd_pcm_hw_params_free (hw_params);
 216                 return -1;
 217         }
 218
 219         /* Setting INTERLEAVED stereo... */
 220 #ifdef USE_ALSA_MEMCPY
 221         if (snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED) < 0) {
 222 #else
 223         if (snd_pcm_hw_params_set_access(pcm_handle, hw_params, SND_PCM_ACCESS_MMAP_INTERLEAVED) < 0) {
 224 #endif
 225                 tX_error("ALSA: Failed to set interleaved access for PCM device \"%s\"", pcm_name);
 226                 snd_pcm_hw_params_free (hw_params);
 227                 return -1;
 228         }
 229
 230         /* Make it 16 Bit LE - we handle converting from BE anyway... */
 231         if (snd_pcm_hw_params_set_format(pcm_handle, hw_params, SND_PCM_FORMAT_S16_LE) < 0) {
 232                 tX_error("ALSA: Error setting 16 Bit sample width for PCM device \"%s\"", pcm_name);
 233                 snd_pcm_hw_params_free (hw_params);
 234                 return -1;
 235         }
 236
 237         /* Setting sampling rate */
 238         unsigned int hw_rate=(unsigned int)globals.alsa_samplerate;
 239         int dir;
 240
 241         int res = snd_pcm_hw_params_set_rate_near(pcm_handle, hw_params, &hw_rate, &dir);
 242
 243         if (dir != 0) {
 244                 tX_warning("ALSA: The PCM device \"%s\" doesnt support 44100 Hz playback - using %i instead", pcm_name, hw_rate);
 245         }
 246
 247         sample_rate=hw_rate;
 248
 249         /* Using stereo output */
 250         if (snd_pcm_hw_params_set_channels(pcm_handle, hw_params, 2) < 0) {
 251                 tX_error("ALSA: PCM device \"%s\" does not support stereo operation", pcm_name);
 252                 snd_pcm_hw_params_free (hw_params);
 253                 return -1;
 254         }
 255
 256         unsigned int buffer_time=globals.alsa_buffer_time;
 257         unsigned int period_time=globals.alsa_period_time;
 258
 259         if (snd_pcm_hw_params_set_buffer_time_near(pcm_handle, hw_params, &buffer_time, &dir) < 0) {
 260                 tX_error("ALSA: failed to set the buffer time opf %lu usecs", globals.alsa_buffer_time);
 261                 return -1;
 262         }
 263
 264         long unsigned int buffer_size;
 265
 266         if (snd_pcm_hw_params_get_buffer_size(hw_params, &buffer_size) < 0) {
 267                 tX_error("ALSA: failed to retreive buffer size");
 268                 return -1;
 269         }
 270
 271         tX_debug("ALSA: buffer size is %i", buffer_size);
 272
 273         if (snd_pcm_hw_params_set_period_time_near(pcm_handle, hw_params, &period_time, &dir) < 0) {
 274                 tX_error("ALSA: failed to set period time %i", globals.alsa_period_time);
 275                 return -1;
 276         }
 277
 278         if (snd_pcm_hw_params_get_period_size(hw_params, &period_size, &dir)<0) {
 279                 tX_error("ALSA: failed to retreive period size");
 280                 return -1;
 281         }
 282
 283         samples_per_buffer=period_size;
 284
 285         /* Apply all that setup work.. */
 286         if (snd_pcm_hw_params(pcm_handle, hw_params) < 0) {
 287                 tX_error("ALSA: Failed to apply settings to PCM device \"%s\"", pcm_name);
 288                 snd_pcm_hw_params_free (hw_params);
 289                 return -1;
 290         }
 291
 292         snd_pcm_hw_params_free (hw_params);
 293         return snd_pcm_prepare(pcm_handle);
 294 }
 295
 296 int tX_audiodevice_alsa :: close()
 297 {
 298         snd_pcm_close(pcm_handle);
 299
 300         return 0;
 301 }
 302
 303 double tX_audiodevice_alsa :: get_latency()
 304 {
 305         return 0;
 306 }
 307
 308
 309 tX_audiodevice_alsa :: tX_audiodevice_alsa() : tX_audiodevice(),
 310 pcm_handle(NULL) {}
 311
 312 void tX_audiodevice_alsa :: play(int16_t *buffer)
 313 {
 314         snd_pcm_sframes_t pcmreturn;
 315 #ifdef BIG_ENDIAN_MACHINE
 316         swapbuffer (buffer, samples_per_buffer);
 317 #endif
 318
 319 #ifdef USE_ALSA_MEMCPY
 320         pcmreturn = snd_pcm_writei(pcm_handle, buffer, samples_per_buffer >> 1);
 321 #else
 322         pcmreturn = snd_pcm_mmap_writei(pcm_handle, buffer, samples_per_buffer >> 1);
 323 #endif
 324
 325         while (pcmreturn==-EPIPE) {
 326                 snd_pcm_prepare(pcm_handle);
 327
 328 #ifdef USE_ALSA_MEMCPY
 329                 pcmreturn = snd_pcm_writei(pcm_handle, buffer, samples_per_buffer >> 1);
 330 #else
 331                 pcmreturn = snd_pcm_mmap_writei(pcm_handle, buffer, samples_per_buffer >> 1);
 332 #endif
 333                 //tX_warning("ALSA: ** buffer underrun **");
 334         }
 335
 336         if (pcmreturn<0) {
 337                 printf("snd_pcm_writei says: %s.\n", strerror(-1*pcmreturn));
 338         }
 339 }
 340
 341 #endif //USE_ALSA