ss_outdev.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2005/2006 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, "ahxm")) == 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, "ahxm")) < 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("ahxm", "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)|12;
 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 #ifdef CONFOPT_PTHREADS
 421
 422 /* pthread support */
 423
 424 #include <pthread.h>
 425
 426 static pthread_t consumer;
 427 static pthread_mutex_t mutex;
 428 static pthread_cond_t cond;
 429
 430 /* the real function inside the driver */
 431 static void (* real_drv_func)(void *, short int *) = NULL;
 432
 433 /* number of ints in frame_cpy */
 434 static int frame_cpy_n = 0;
 435
 436 /* a copy of the frame */
 437 static short int * frame_cpy = NULL;
 438
 439 static void * outdev_thread(void * driver)
 440 /* pthread 'consumer' function */
 441 {
 442         pthread_mutex_lock(&mutex);
 443
 444         for(;;)
 445         {
 446                 /* wait for data available */
 447                 pthread_cond_wait(&cond, &mutex);
 448
 449                 /* call the real function */
 450                 real_drv_func(driver, frame_cpy);
 451
 452                 /* no more? */
 453                 if(frame_cpy == NULL)
 454                         break;
 455         }
 456
 457         pthread_mutex_unlock(&mutex);
 458         return(NULL);
 459 }
 460
 461
 462 static void outdev_producer_wrapper(void * d, short int * frame)
 463 /* wrapper 'producer' function */
 464 {
 465         int n;
 466
 467         pthread_mutex_lock(&mutex);
 468
 469         if(frame == NULL)
 470         {
 471                 /* close */
 472                 free(frame_cpy);
 473                 frame_cpy = NULL;
 474                 frame_cpy_n = 0;
 475         }
 476         else
 477         {
 478                 /* copy the frame */
 479                 for(n = 0;n < frame_cpy_n;n++)
 480                         frame_cpy[n] = frame[n];
 481         }
 482
 483         pthread_cond_signal(&cond);
 484         pthread_mutex_unlock(&mutex);
 485 }
 486
 487
 488 static void thread_setup(void * d, int n_channels)
 489 {
 490         void (**drv)(void *, short int *) = d;
 491
 492         /* create the buffer */
 493         frame_cpy_n = n_channels;
 494         frame_cpy = malloc(frame_cpy_n * sizeof(short int));
 495
 496         pthread_mutex_init(&mutex, NULL);
 497         pthread_cond_init(&cond, NULL);
 498
 499         /* 'patch' the driver */
 500         real_drv_func = *drv;
 501         *drv = outdev_producer_wrapper;
 502
 503         /* launch the thread */
 504         pthread_create(&consumer, NULL, outdev_thread, d);
 505 }
 506
 507
 508 #else /* CONFOPT_PTHREADS */
 509
 510 void thread_setup(void * d, int n)
 511 {
 512         /* do nothing */
 513 }
 514
 515 #endif /* CONFOPT_PTHREADS */
 516
 517 /*******************************************/
 518
 519 /* interface */
 520
 521 void * ss_outdev_open(char * drvname, char * file, int freq, int n_channels)
 522 {
 523         int size;
 524         void * drv;
 525         void * ret = NULL;
 526
 527         if((drv = d_arts(drvname, file, freq, n_channels, &size)) != NULL ||
 528            (drv = d_esd(drvname, file, freq, n_channels, &size)) != NULL ||
 529            (drv = d_sgi(drvname, file, freq, n_channels, &size)) != NULL ||
 530            (drv = d_oss(drvname, file, freq, n_channels, &size)) != NULL ||
 531            (drv = d_wav(drvname, file, freq, n_channels, &size)) != NULL)
 532         {
 533                 ret = malloc(size);
 534                 memcpy(ret, drv, size);
 535         }
 536
 537         thread_setup(ret, n_channels);
 538
 539         return(ret);
 540 }
 541
 542
 543 void ss_outdev_write(void * drv, short int * frame)
 544 {
 545         void (**func)(void *, short int *) = drv;
 546
 547         (*func)(drv, frame);
 548 }
 549
 550
 551 void * ss_outdev_close(void * drv)
 552 {
 553         if(drv != NULL)
 554         {
 555                 ss_outdev_write(drv, NULL);
 556                 free(drv);
 557         }
 558
 559         return(NULL);
 560 }