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 <string.h>
  35
  36 /*******************
  37         Code
  38 ********************/
  39
  40 /* unsupported stub function */
  41
  42 static void * d_unsupp(char * drvname, char * filename,
  43         int freq, int n_channels, int * ssize) { return(NULL); }
  44
  45
  46 #ifdef CONFOPT_ARTS
  47
  48 /* Arts driver */
  49
  50 #include <artsc.h>
  51
  52 struct ss_outdrv_arts
  53 /* control structure */
  54 {
  55         void (*func)(void *, short int *);
  56         arts_stream_t arts;
  57         int size;
  58 };
  59
  60 static void d_arts_func(void * d, short int * frame)
  61 /* writing / close function */
  62 {
  63         struct ss_outdrv_arts * drv=d;
  64
  65         if(frame != NULL)
  66                 arts_write(drv->arts, frame, drv->size);
  67         else
  68                 arts_free();
  69 }
  70
  71 static void * d_arts(char * drvname, char * filename,
  72         int freq, int n_channels, int * ssize)
  73 /* init function */
  74 {
  75         static struct ss_outdrv_arts drv;
  76
  77         if(drvname && strcmp("arts", drvname) != 0)
  78                 return(NULL);
  79
  80         /* filename specified? get out */
  81         if(filename != NULL) return(NULL);
  82
  83         *ssize=sizeof(struct ss_outdrv_arts);
  84         drv.func=d_arts_func;
  85         drv.size=n_channels >= 2 ? 2 : 1;
  86
  87         if(arts_init() || (drv.arts=arts_play_stream(freq, 16,
  88                 drv.size, "annhell")) == NULL)
  89                 return(NULL);
  90
  91         drv.size *= sizeof(short int);
  92
  93         return(&drv);
  94 }
  95
  96
  97 #else /* CONFOPT_ARTS */
  98
  99 #define d_arts d_unsupp
 100
 101 #endif /* CONFOPT_ARTS */
 102
 103 /************************************************/
 104
 105 #ifdef CONFOPT_ESD
 106
 107 /* ESD driver */
 108
 109 #include <unistd.h>
 110 #include <esd.h>
 111
 112 struct ss_outdrv_esd
 113 /* control structure */
 114 {
 115         void (*func)(void *, short int *);
 116         int fd;
 117         int size;
 118 };
 119
 120 static void d_esd_func(void * d, short int * frame)
 121 /* write / close function */
 122 {
 123         struct ss_outdrv_esd * drv=d;
 124
 125         if(frame != NULL)
 126                 write(drv->fd, frame, drv->size);
 127         else
 128                 close(drv->fd);
 129 }
 130
 131 static void * d_esd(char * drvname, char * filename,
 132         int freq, int n_channels, int * ssize)
 133 /* init function */
 134 {
 135         static struct ss_outdrv_esd drv;
 136         esd_format_t format;
 137
 138         if(drvname && strcmp("esd", drvname) != 0)
 139                 return(NULL);
 140
 141         *ssize=sizeof(struct ss_outdrv_esd);
 142         drv.func=d_esd_func;
 143         drv.size=n_channels >= 2 ? 2 : 1;
 144
 145         format = ESD_STREAM | ESD_PLAY | ESD_BITS16;
 146         format |= drv.size == 2 ? ESD_STEREO : ESD_MONO;
 147
 148         if(esd_open_sound(filename) < 0 ||
 149                 (drv.fd=esd_play_stream_fallback(format, freq, NULL, "annhell")) < 0)
 150                 return(NULL);
 151
 152         drv.size *= sizeof(short int);
 153
 154         return(&drv);
 155 }
 156
 157
 158 #else /* CONFOPT_ESD */
 159
 160 #define d_esd d_unsupp
 161
 162 #endif /* CONFOPT_ESD */
 163
 164 /************************************************/
 165
 166 #ifdef CONFOPT_SGI
 167
 168 /* SGI Irix driver */
 169
 170 #include <dmedia/audio.h>
 171
 172 struct ss_outdrv_sgi
 173 /* control structure */
 174 {
 175         void (*func)(void *, short int *);
 176         ALconfig ac;
 177         ALport ap;
 178 };
 179
 180 static void d_sgi_func(void * d, short int * frame)
 181 /* write / close function */
 182 {
 183         struct ss_outdrv_sgi * drv=d;
 184
 185         if(frame != NULL)
 186                 alWriteFrames(drv->ap, frame, 1);
 187         else
 188         {
 189                 alClosePort(drv->ap);
 190                 alFreeConfig(drv->ac);
 191         }
 192 }
 193
 194 static void * d_sgi(char * drvname, char * filename,
 195         int freq, int n_channels, int * ssize)
 196 /* init function */
 197 {
 198         static struct ss_outdrv_sgi drv;
 199         ALpv p[2];
 200
 201         if(drvname && strcmp("sgi", drvname) != 0)
 202                 return(NULL);
 203
 204         /* filename specified? get out */
 205         if(filename != NULL) return(NULL);
 206
 207         *ssize=sizeof(struct ss_outdrv_sgi);
 208         drv.func=d_sgi_func;
 209
 210         p[0].param=AL_MASTER_CLOCK;
 211         p[0].value.i=AL_CRYSTAL_MCLK_TYPE;
 212         p[1].param=AL_RATE;
 213         p[1].value.ll=alDoubleToFixed((double) freq);
 214
 215         if(!(drv.ac=alNewConfig()))
 216                 return(NULL);
 217
 218         if(alSetChannels(drv.ac, n_channels) < 0 ||
 219                 alSetWidth(drv.ac, AL_SAMPLE_16) < 0 ||
 220                 alSetSampFmt(drv.ac, AL_SAMPFMT_TWOSCOMP) < 0 ||
 221                 alSetQueueSize(drv.ac, 2048) < 0 ||
 222                 alSetDevice(drv.ac, AL_DEFAULT_OUTPUT) < 0 ||
 223                 alSetParams(alGetDevice(drv.ac), p, 2) < 0 ||
 224                 !(drv.ap=alOpenPort("annhell", "w", drv.ac)))
 225         {
 226                 alFreeConfig(drv.ac);
 227                 return(NULL);
 228         }
 229
 230         return(&drv);
 231 }
 232
 233 #else /* CONFOPT_SGI */
 234
 235 #define d_sgi d_unsupp
 236
 237 #endif /* CONFOPT_SGI */
 238
 239 /************************************************/
 240
 241 #ifdef CONFOPT_LINUX_OSS
 242
 243 /* Linux OSS driver */
 244
 245 #include <fcntl.h>
 246 #include <sys/ioctl.h>
 247 #include <linux/soundcard.h>
 248 #include <unistd.h>
 249
 250 struct ss_outdrv_oss
 251 /* control structure */
 252 {
 253         void (*func)(void *, short int *);
 254         int fd;
 255         int size;
 256 };
 257
 258 static int is_little_endian(void)
 259 /* is this machine little endian? */
 260 {
 261         short s=1;
 262         unsigned char * c=(unsigned char *) &s;
 263
 264         return(*c == 1);
 265 }
 266
 267 static void d_oss_func(void * d, short int * frame)
 268 /* write / close function */
 269 {
 270         struct ss_outdrv_oss * drv=d;
 271
 272         if(frame != NULL)
 273                 write(drv->fd, frame, drv->size);
 274         else
 275                 close(drv->fd);
 276 }
 277
 278
 279 static void * d_oss(char * drvname, char * filename,
 280         int freq, int n_channels, int * ssize)
 281 /* init function */
 282 {
 283         static struct ss_outdrv_oss drv;
 284         int fr, st, fm;
 285
 286         if(drvname && strcmp("oss", drvname) != 0)
 287                 return(NULL);
 288
 289         if(filename == NULL) filename="/dev/dsp";
 290
 291         fr=(2 << 16)|14;
 292         st=n_channels >= 2 ? 1 : 0;
 293         fm=is_little_endian() ? AFMT_S16_LE : AFMT_S16_BE;
 294
 295         *ssize=sizeof(struct ss_outdrv_oss);
 296         drv.func=d_oss_func;
 297         drv.size=n_channels >= 2 ? 2 : 1;
 298
 299         if((drv.fd=open(filename, O_WRONLY)) < 0)
 300                 return(NULL);
 301
 302         if(ioctl(drv.fd, SNDCTL_DSP_SETFRAGMENT, &fr) < 0 ||
 303                 ioctl(drv.fd, SNDCTL_DSP_RESET, 0) < 0 ||
 304                 ioctl(drv.fd, SNDCTL_DSP_SPEED, &freq) < 0 ||
 305                 ioctl(drv.fd, SNDCTL_DSP_STEREO, &st) < 0 ||
 306                 ioctl(drv.fd, SNDCTL_DSP_SETFMT, &fm) < 0)
 307         {
 308                 close(drv.fd);
 309                 return(NULL);
 310         }
 311
 312         drv.size *= sizeof(short int);
 313
 314         return(&drv);
 315 }
 316
 317 #else /* CONFOPT_LINUX_OSS */
 318
 319 #define d_oss d_unsupp
 320
 321 #endif /* CONFOPT_LINUX_OSS */
 322
 323 /************************************************/
 324
 325 /* WAV file driver */
 326
 327 struct ss_outdrv_wav
 328 /* control structure */
 329 {
 330         void (*func)(void *, short int *);
 331         FILE * fd;
 332         int size;
 333         int n_frames;
 334 };
 335
 336 static void fput16(short int i, FILE * f)
 337 /* writes a 16 bit integer, in any machine order */
 338 {
 339         fputc(i & 0x00ff, f);
 340         fputc((i & 0xff00) >> 8, f);
 341 }
 342
 343 static void fput32(int i, FILE * f)
 344 /* writes a 32 bit integer, in any machine order */
 345 {
 346         fputc(i & 0x000000ff, f);
 347         fputc((i & 0x0000ff00) >> 8, f);
 348         fputc((i & 0x00ff0000) >> 16, f);
 349         fputc((i & 0xff000000) >> 24, f);
 350 }
 351
 352 static void d_wav_func(void * d, short int * frame)
 353 /* write / close function */
 354 {
 355         struct ss_outdrv_wav * drv=d;
 356
 357         if(frame != NULL)
 358         {
 359                 int n;
 360
 361                 for(n=0;n < drv->size;n++)
 362                         fput16(frame[n], drv->fd);
 363
 364                 drv->n_frames++;
 365         }
 366         else
 367         {
 368                 /* rewind file and write total size */
 369                 fseek(drv->fd, 4, SEEK_SET);
 370                 fput32((drv->n_frames * drv->size * 2) + 36, drv->fd);
 371
 372                 fseek(drv->fd, 40, SEEK_SET);
 373                 fput32((drv->n_frames * drv->size * 2), drv->fd);
 374
 375                 fclose(drv->fd);
 376         }
 377 }
 378
 379 static void * d_wav(char * drvname, char * filename,
 380         int freq, int n_channels, int * ssize)
 381 /* init function */
 382 {
 383         static struct ss_outdrv_wav drv;
 384
 385         if(drvname && strcmp("wav", drvname) != 0)
 386                 return(NULL);
 387
 388         if(filename == NULL) filename="output.wav";
 389
 390         *ssize=sizeof(struct ss_outdrv_wav);
 391         drv.func=d_wav_func;
 392         drv.size=n_channels;
 393         drv.n_frames=0;
 394
 395         if((drv.fd=fopen(filename, "w")) == NULL)
 396                 return(0);
 397
 398         /* write wav header */
 399
 400         fwrite("RIFF", 1, 4, drv.fd);
 401         fput32(36, drv.fd);                     /* first checkpoint (offset: 4) */
 402         fwrite("WAVE", 1, 4, drv.fd);
 403         fwrite("fmt ", 1, 4, drv.fd);
 404         fput32(16, drv.fd);                     /* chunk size */
 405         fput16(1, drv.fd);                      /* 1: uncompressed PCM */
 406         fput16(n_channels, drv.fd);             /* # of channels */
 407         fput32(freq, drv.fd);                   /* sample rate */
 408         fput32(freq * n_channels * 2, drv.fd);  /* bytes per second */
 409         fput16(n_channels * 2, drv.fd);         /* 'block align' */
 410         fput16(16, drv.fd);                     /* 16 bits per sample */
 411         fwrite("data", 1, 4, drv.fd);
 412         fput32(0, drv.fd);                      /* second checkpoint (offset: 40) */
 413
 414         return(&drv);
 415 }
 416
 417
 418 /*******************************************/
 419
 420 /* interface */
 421
 422 void * ss_outdev_open(char * drvname, char * file, int freq, int n_channels)
 423 {
 424         int size;
 425         void * drv;
 426         void * ret=NULL;
 427
 428         if((drv=d_arts(drvname, file, freq, n_channels, &size)) != NULL ||
 429            (drv=d_esd(drvname, file, freq, n_channels, &size)) != NULL ||
 430            (drv=d_sgi(drvname, file, freq, n_channels, &size)) != NULL ||
 431            (drv=d_oss(drvname, file, freq, n_channels, &size)) != NULL ||
 432            (drv=d_wav(drvname, file, freq, n_channels, &size)) != NULL)
 433         {
 434                 ret=malloc(size);
 435                 memcpy(ret, drv, size);
 436         }
 437
 438         return(ret);
 439 }
 440
 441
 442 void ss_outdev_write(void * drv, short int * frame)
 443 {
 444         void (**func)(void *, short int *)=drv;
 445
 446         (*func)(drv, frame);
 447 }
 448
 449
 450 void * ss_outdev_close(void * drv)
 451 {
 452         if(drv != NULL)
 453         {
 454                 ss_outdev_write(drv, NULL);
 455                 free(drv);
 456         }
 457
 458         return(NULL);
 459 }