ss_outdev.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2005 Angel Ortega <angel@triptico.com>
   5
   6     ss_outdev.c - Softsynth output devices
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 /*******************
  27         Data
  28 ********************/
  29
  30 #include "config.h"
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <unistd.h>
  35 #include <string.h>
  36
  37 struct ss_outdrv
  38 {
  39         char * drvname;                 /* driver name */
  40         int (*open)(char *, int, int);  /* open function */
  41         void (*write)(int *, int);      /* write frame function */
  42         void (*close)(void);            /* close function */
  43         char * deffile;                 /* default file or device */
  44         int max_channels;               /* maximum channels (0, unlimited) */
  45 };
  46
  47 struct ss_outdrv * drv=NULL;
  48
  49 /*******************
  50         Code
  51 ********************/
  52
  53 #ifdef CONFOPT_ARTS
  54
  55 #include <artsc.h>
  56
  57 static arts_stream_t arts;
  58
  59 static int d_arts_open(char * file, int freq, int n_channels)
  60 {
  61         int ret=0;
  62
  63         if(!arts_init() &&
  64                 (arts=arts_play_stream(freq, 16, n_channels, "annhell")))
  65                 ret=1;
  66
  67         return(ret);
  68 }
  69
  70
  71 static void d_arts_write(int frame[], int size)
  72 {
  73         arts_write(arts, frame, size);
  74 }
  75
  76
  77 static void d_arts_close(void)
  78 {
  79         arts_free();
  80 }
  81
  82 struct ss_outdrv outdrv_arts=
  83 { "arts", d_arts_open, d_arts_write, d_arts_close, NULL, 2 };
  84
  85 #else /* CONFOPT_ARTS */
  86
  87 struct ss_outdrv outdrv_arts=
  88 { "arts", NULL, NULL, NULL, NULL, 2 };
  89
  90 #endif /* CONFOPT_ARTS */
  91
  92 /************************************************/
  93
  94 #ifdef CONFOPT_ESD
  95
  96 #include <unistd.h>
  97 #include <esd.h>
  98
  99 static int esd_fd;
 100
 101 static int d_esd_open(char * file, int freq, int n_channels)
 102 {
 103         int ret=0;
 104         esd_format_t format;
 105
 106         format = ESD_STREAM | ESD_PLAY | ESD_BITS16;
 107         format |= n_channels == 2 ? ESD_STEREO : ESD_MONO;
 108
 109         if(esd_open_sound(file) >= 0 &&
 110                 (esd_fd=esd_play_stream_fallback(format, freq, NULL, "annhell")) >= 0)
 111                 ret=1;
 112
 113         return(ret);
 114 }
 115
 116 static void d_esd_write(int frame[], int size)
 117 {
 118         write(esd_fd, frame, size);
 119 }
 120
 121
 122 static void d_esd_close(void)
 123 {
 124         close(esd_fd);
 125 }
 126
 127 struct ss_outdrv outdrv_esd=
 128 { "esd", d_esd_open, d_esd_write, d_esd_close, NULL, 2 };
 129
 130 #else /* CONFOPT_ESD */
 131
 132 struct ss_outdrv outdrv_esd=
 133 { "esd", NULL, NULL, NULL, NULL, 2 };
 134
 135 #endif /* CONFOPT_ESD */
 136
 137 /************************************************/
 138
 139 #ifdef CONFOPT_SGI
 140
 141 #include <dmedia/audio.h>
 142
 143 static ALconfig ac;
 144 static ALport ap;
 145
 146 static int d_sgi_open(char * file, int freq, int n_channels)
 147 {
 148         int ret=0;
 149         ALpv p[2];
 150
 151         p[0].param=AL_MASTER_CLOCK;
 152         p[0].value.i=AL_CRYSTAL_MCLK_TYPE;
 153         p[1].param=AL_RATE;
 154         p[1].value.ll=alDoubleToFixed((double) freq);
 155
 156         if((ac=alNewConfig()))
 157         {
 158                 if(alSetChannels(ac, n_channels) >= 0 &&
 159                         alSetWidth(ac, AL_SAMPLE_16) >= 0 &&
 160                         alSetSampFmt(ac, AL_SAMPFMT_TWOSCOMP) >= 0 &&
 161                         alSetQueueSize(ac, 2048) >=0 &&
 162                         alSetDevice(ac, AL_DEFAULT_OUTPUT) >= 0 &&
 163                         alSetParams(alGetDevice(ac), p, 2) >= 0 &&
 164                         (ap=alOpenPort("annhell", "w", ac)))
 165                         ret=1;
 166         }
 167
 168         return(ret);
 169 }
 170
 171
 172 static int d_sgi_write(int frame[], int size)
 173 {
 174         alWriteFrames(ap, frame, 1);
 175 }
 176
 177
 178 static int d_sgi_close(void)
 179 {
 180         alClosePort(ap);
 181         alFreeConfig(ac);
 182 }
 183
 184 struct ss_outdrv outdrv_sgi=
 185 { "sgi", d_sgi_open, d_sgi_write, d_sgi_close, NULL, 0 };
 186
 187 #else /* CONFOPT_SGI */
 188
 189 struct ss_outdrv outdrv_sgi=
 190 { "sgi", NULL, NULL, NULL, NULL, 0 };
 191
 192
 193 #endif /* CONFOPT_SGI */
 194
 195 /************************************************/
 196
 197 #ifdef CONFOPT_LINUX_OSS
 198
 199 #include <fcntl.h>
 200 #include <sys/ioctl.h>
 201 #include <linux/soundcard.h>
 202
 203 static int is_little_endian(void)
 204 {
 205         short s=1;
 206         unsigned char * c=(unsigned char *) &s;
 207
 208         return(*c == 1);
 209 }
 210
 211 static int oss_fd;
 212
 213 static int d_oss_open(char * file, int freq, int n_channels)
 214 {
 215         int ret=0;
 216         int fr, st, fm;
 217
 218         fr=(2 << 16)|(1 << 10);
 219         st=n_channels == 2 ? 1 : 0;
 220         fm=is_little_endian() ? AFMT_S16_LE : AFMT_S16_BE;
 221
 222         if((oss_fd=open(file, O_WRONLY)) >= 0)
 223         {
 224                 if(ioctl(oss_fd, SNDCTL_DSP_SETFRAGMENT, &fr) >= 0 &&
 225                 ioctl(oss_fd, SNDCTL_DSP_RESET, 0) >= 0 &&
 226                 ioctl(oss_fd, SNDCTL_DSP_SPEED, &freq) >= 0 &&
 227                 ioctl(oss_fd, SNDCTL_DSP_STEREO, &st) >= 0 &&
 228                 ioctl(oss_fd, SNDCTL_DSP_SETFMT, &fm) >= 0)
 229                         ret=1;
 230         }
 231
 232         return(ret);
 233 }
 234
 235
 236 static void d_oss_write(int frame[], int size)
 237 {
 238         write(oss_fd, frame, size);
 239 }
 240
 241
 242 static void d_oss_close(void)
 243 {
 244         close(oss_fd);
 245 }
 246
 247 struct ss_outdrv outdrv_oss=
 248 { "oss", d_oss_open, d_oss_write, d_oss_close, "/dev/dsp", 2 };
 249
 250 #else /* CONFOPT_LINUX_OSS */
 251
 252 struct ss_outdrv outdrv_oss=
 253 { "oss", NULL, NULL, NULL, NULL, 2 };
 254
 255 #endif /* CONFOPT_LINUX_OSS */
 256
 257 /************************************************/
 258
 259 static void fput16(short int i, FILE * f)
 260 {
 261         fputc(i & 0x00ff, f);
 262         fputc((i & 0xff00) >> 8, f);
 263 }
 264
 265
 266 static void fput32(int i, FILE * f)
 267 {
 268         fputc(i & 0x000000ff, f);
 269         fputc((i & 0x0000ff00) >> 8, f);
 270         fputc((i & 0x00ff0000) >> 16, f);
 271         fputc((i & 0xff000000) >> 24, f);
 272 }
 273
 274 static FILE * wav_fd;
 275 static int wav_frames;
 276
 277 static int d_wav_open(char * file, int freq, int n_channels)
 278 {
 279         if((wav_fd=fopen(file, "w")) == NULL) return(0);
 280
 281         /* write wav header */
 282
 283         fwrite("RIFF", 1, 4, wav_fd);
 284         fput32(36, wav_fd);                     /* first checkpoint (offset: 4) */
 285         fwrite("WAVE", 1, 4, wav_fd);
 286         fwrite("fmt ", 1, 4, wav_fd);
 287         fput32(16, wav_fd);                     /* chunk size */
 288         fput16(1, wav_fd);                      /* 1: uncompressed PCM */
 289         fput16(n_channels, wav_fd);             /* # of channels */
 290         fput32(freq, wav_fd);                   /* sample rate */
 291         fput32(freq * n_channels * 2, wav_fd);  /* bytes per second */
 292         fput16(n_channels * 2, wav_fd);         /* 'block align' */
 293         fput16(16, wav_fd);                     /* 16 bits per sample */
 294         fwrite("data", 1, 4, wav_fd);
 295         fput32(0, wav_fd);                      /* second checkpoint (offset: 40) */
 296
 297         wav_frames=0;
 298
 299         return(1);
 300 }
 301
 302
 303 static void d_wav_write(int frame[], int size)
 304 {
 305         int n;
 306
 307         size /= sizeof(short int);
 308
 309         for(n=0;n < size;n++)
 310                 fput16(frame[n], wav_fd);
 311
 312         wav_frames++;
 313 }
 314
 315
 316 static void d_wav_close(void)
 317 {
 318         /* rewind file and write total size */
 319         fseek(wav_fd, 4, SEEK_SET);
 320         fput32((wav_frames * n_channels) + 36, wav_fd);
 321
 322         fseek(wav_fd, 40, SEEK_SET);
 323         fput32(wav_frames * n_channels, wav_fd);
 324
 325         fclose(wav_fd);
 326 }
 327
 328 struct ss_outdrv outdrv_wav=
 329 { "wav", d_wav_open, d_wav_write, d_wav_close, "output.wav", 0 };
 330
 331 static struct ss_outdrvs[] = {
 332         &outdrv_arts,
 333         &outdrv_esd,
 334         &outdrv_sgi,
 335         &outdrv_oss,
 336         &outdrv_wav,
 337         NULL
 338 };
 339
 340 int ss_outdev(char * drv, char * file, int freq, int n_channels)
 341 {
 342         int p[2], n;
 343
 344         pipe(p);
 345
 346         if(fork() != 0)
 347         {
 348                 /* parent; return immediately */
 349                 close(p[0]);
 350                 return(p[1]);
 351         }
 352
 353         /* forked child */
 354
 355         /* closes the writing part of the pipe */
 356         close(p[1]);
 357
 358         /* detaches from group */
 359         setpgid(0, 0);
 360
 361         /* find the appropriate driver */
 362         for(n=0;drivers[n].drvname != NULL;n++)
 363         {
 364                 if(drv == NULL || strcmp(drv, drivers[n].drvname) == 0)
 365                 {
 366                         if(drivers[n].func(p[0],
 367                                 file ? file : drivers[n].deffile,
 368                                 freq, n_channels))
 369                                 break;
 370                 }
 371         }
 372
 373         close(p[0]);
 374         exit(0);
 375
 376         return(0);
 377 }