ss_outdev.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2005/2007 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, int freq, int n_channels, int *ssize)
  43 {
  44         return NULL;
  45 }
  46
  47
  48 #ifdef CONFOPT_ARTS
  49
  50 /* Arts driver */
  51
  52 #include <artsc.h>
  53
  54 struct ss_outdrv_arts
  55 /* control structure */
  56 {
  57         void (*func) (void *, short int *);
  58         arts_stream_t arts;
  59         int size;
  60 };
  61
  62 static void d_arts_func(void *d, short int *frame)
  63 /* writing / close function */
  64 {
  65         struct ss_outdrv_arts *drv = d;
  66
  67         if (frame != NULL)
  68                 arts_write(drv->arts, frame, drv->size);
  69         else
  70                 arts_free();
  71 }
  72
  73 static void *d_arts(char *drvname, char *filename, int freq, int n_channels, int *ssize)
  74 /* init function */
  75 {
  76         static struct ss_outdrv_arts drv;
  77
  78         if (drvname && strcmp("arts", drvname) != 0)
  79                 return NULL;
  80
  81         /* filename specified? get out */
  82         if (filename != NULL)
  83                 return NULL;
  84
  85         *ssize = sizeof(struct ss_outdrv_arts);
  86         drv.func = d_arts_func;
  87         drv.size = n_channels >= 2 ? 2 : 1;
  88
  89         if (arts_init() || (drv.arts = arts_play_stream(freq, 16, drv.size, "ahxm")) == NULL)
  90                 return NULL;
  91
  92         drv.size *= sizeof(short int);
  93
  94         return &drv;
  95 }
  96
  97
  98 #else                           /* CONFOPT_ARTS */
  99
 100 #define d_arts d_unsupp
 101
 102 #endif                          /* CONFOPT_ARTS */
 103
 104 /************************************************/
 105
 106 #ifdef CONFOPT_ESD
 107
 108 /* ESD driver */
 109
 110 #include <unistd.h>
 111 #include <esd.h>
 112
 113 struct ss_outdrv_esd
 114 /* control structure */
 115 {
 116         void (*func) (void *, short int *);
 117         int fd;
 118         int size;
 119 };
 120
 121 static void d_esd_func(void *d, short int *frame)
 122 /* write / close function */
 123 {
 124         struct ss_outdrv_esd *drv = d;
 125
 126         if (frame != NULL)
 127                 write(drv->fd, frame, drv->size);
 128         else
 129                 close(drv->fd);
 130 }
 131
 132 static void *d_esd(char *drvname, char *filename, 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_PULSEAUDIO
 167
 168 /* Pulseaudio driver */
 169
 170 #include <pulse/simple.h>
 171 #include <pulse/error.h>
 172
 173 struct ss_outdrv_pulse
 174 /* control structure */
 175 {
 176         void (*func) (void *, short int *);
 177         pa_simple * pa;
 178         int size;
 179 };
 180
 181 static void d_pulse_func(void *d, short int *frame)
 182 /* write / close function */
 183 {
 184         struct ss_outdrv_pulse *drv = d;
 185         int error;
 186
 187         if (frame != NULL)
 188                 pa_simple_write(drv->pa, frame, drv->size, &error);
 189         else {
 190                 pa_simple_drain(drv->pa, &error);
 191                 pa_simple_free(drv->pa);
 192         }
 193 }
 194
 195 static void *d_pulse(char *drvname, char *filename, int freq, int n_channels, int *ssize)
 196 /* init function */
 197 {
 198         static struct ss_outdrv_pulse drv;
 199         pa_sample_spec ss;
 200
 201         if (drvname && strcmp("pulse", drvname) != 0)
 202                 return NULL;
 203
 204         ss.format = PA_SAMPLE_S16LE;
 205         ss.rate = freq;
 206         ss.channels = n_channels;
 207
 208         *ssize = sizeof(struct ss_outdrv_pulse);
 209         drv.func = d_pulse_func;
 210         drv.size = n_channels * sizeof(short int);
 211
 212         if ((drv.pa = pa_simple_new(filename, "ahxm", PA_STREAM_PLAYBACK,
 213                                 NULL, "ahxm", &ss, NULL, NULL, NULL)) == NULL)
 214                 return NULL;
 215
 216         return &drv;
 217 }
 218
 219 #else                           /* CONFOPT_PULSEAUDIO */
 220
 221 #define d_pulse d_unsupp
 222
 223 #endif                          /* CONFOPT_PULSEAUDIO */
 224
 225 /************************************************/
 226
 227 #ifdef CONFOPT_SGI
 228
 229 /* SGI Irix driver */
 230
 231 #include <dmedia/audio.h>
 232
 233 struct ss_outdrv_sgi
 234 /* control structure */
 235 {
 236         void (*func) (void *, short int *);
 237         ALconfig ac;
 238         ALport ap;
 239 };
 240
 241 static void d_sgi_func(void *d, short int *frame)
 242 /* write / close function */
 243 {
 244         struct ss_outdrv_sgi *drv = d;
 245
 246         if (frame != NULL)
 247                 alWriteFrames(drv->ap, frame, 1);
 248         else {
 249                 alClosePort(drv->ap);
 250                 alFreeConfig(drv->ac);
 251         }
 252 }
 253
 254 static void *d_sgi(char *drvname, char *filename, int freq, int n_channels, int *ssize)
 255 /* init function */
 256 {
 257         static struct ss_outdrv_sgi drv;
 258         ALpv p[2];
 259
 260         if (drvname && strcmp("sgi", drvname) != 0)
 261                 return NULL;
 262
 263         /* filename specified? get out */
 264         if (filename != NULL)
 265                 return NULL;
 266
 267         *ssize = sizeof(struct ss_outdrv_sgi);
 268         drv.func = d_sgi_func;
 269
 270         p[0].param = AL_MASTER_CLOCK;
 271         p[0].value.i = AL_CRYSTAL_MCLK_TYPE;
 272         p[1].param = AL_RATE;
 273         p[1].value.ll = alDoubleToFixed((double) freq);
 274
 275         if (!(drv.ac = alNewConfig()))
 276                 return NULL;
 277
 278         if (alSetChannels(drv.ac, n_channels) < 0 ||
 279             alSetWidth(drv.ac, AL_SAMPLE_16) < 0 ||
 280             alSetSampFmt(drv.ac, AL_SAMPFMT_TWOSCOMP) < 0 ||
 281             alSetQueueSize(drv.ac, 2048) < 0 ||
 282             alSetDevice(drv.ac, AL_DEFAULT_OUTPUT) < 0 ||
 283             alSetParams(alGetDevice(drv.ac), p, 2) < 0 ||
 284             !(drv.ap = alOpenPort("ahxm", "w", drv.ac))) {
 285                 alFreeConfig(drv.ac);
 286                 return NULL;
 287         }
 288
 289         return &drv;
 290 }
 291
 292 #else                           /* CONFOPT_SGI */
 293
 294 #define d_sgi d_unsupp
 295
 296 #endif                          /* CONFOPT_SGI */
 297
 298 /************************************************/
 299
 300 #ifdef CONFOPT_LINUX_OSS
 301
 302 /* Linux OSS driver */
 303
 304 #include <fcntl.h>
 305 #include <sys/ioctl.h>
 306 #include <linux/soundcard.h>
 307 #include <unistd.h>
 308
 309 struct ss_outdrv_oss
 310 /* control structure */
 311 {
 312         void (*func) (void *, short int *);
 313         int fd;
 314         int size;
 315 };
 316
 317 static int is_little_endian(void)
 318 /* is this machine little endian? */
 319 {
 320         short s = 1;
 321         unsigned char *c = (unsigned char *) &s;
 322
 323         return *c == 1;
 324 }
 325
 326 static void d_oss_func(void *d, short int *frame)
 327 /* write / close function */
 328 {
 329         struct ss_outdrv_oss *drv = d;
 330
 331         if (frame != NULL)
 332                 write(drv->fd, frame, drv->size);
 333         else
 334                 close(drv->fd);
 335 }
 336
 337
 338 static void *d_oss(char *drvname, char *filename, int freq, int n_channels, int *ssize)
 339 /* init function */
 340 {
 341         static struct ss_outdrv_oss drv;
 342         int fr, st, fm;
 343
 344         if (drvname && strcmp("oss", drvname) != 0)
 345                 return NULL;
 346
 347         if (filename == NULL)
 348                 filename = "/dev/dsp";
 349
 350         fr = (2 << 16) | 12;
 351         st = n_channels >= 2 ? 1 : 0;
 352         fm = is_little_endian()? AFMT_S16_LE : AFMT_S16_BE;
 353
 354         *ssize = sizeof(struct ss_outdrv_oss);
 355         drv.func = d_oss_func;
 356         drv.size = n_channels >= 2 ? 2 : 1;
 357
 358         if ((drv.fd = open(filename, O_WRONLY)) < 0)
 359                 return NULL;
 360
 361         if (ioctl(drv.fd, SNDCTL_DSP_SETFRAGMENT, &fr) < 0 ||
 362             ioctl(drv.fd, SNDCTL_DSP_RESET, 0) < 0 ||
 363             ioctl(drv.fd, SNDCTL_DSP_SPEED, &freq) < 0 ||
 364             ioctl(drv.fd, SNDCTL_DSP_STEREO, &st) < 0 ||
 365             ioctl(drv.fd, SNDCTL_DSP_SETFMT, &fm) < 0) {
 366                 close(drv.fd);
 367                 return NULL;
 368         }
 369
 370         drv.size *= sizeof(short int);
 371
 372         return &drv;
 373 }
 374
 375 #else                           /* CONFOPT_LINUX_OSS */
 376
 377 #define d_oss d_unsupp
 378
 379 #endif                          /* CONFOPT_LINUX_OSS */
 380
 381 /************************************************/
 382
 383 /* WAV file driver */
 384
 385 struct ss_outdrv_wav
 386 /* control structure */
 387 {
 388         void (*func) (void *, short int *);
 389         FILE *fd;
 390         int size;
 391         int n_frames;
 392 };
 393
 394 static void fput16(short int i, FILE * f)
 395 /* writes a 16 bit integer, in any machine order */
 396 {
 397         fputc(i & 0x00ff, f);
 398         fputc((i & 0xff00) >> 8, f);
 399 }
 400
 401 static void fput32(int i, FILE * f)
 402 /* writes a 32 bit integer, in any machine order */
 403 {
 404         fputc(i & 0x000000ff, f);
 405         fputc((i & 0x0000ff00) >> 8, f);
 406         fputc((i & 0x00ff0000) >> 16, f);
 407         fputc((i & 0xff000000) >> 24, f);
 408 }
 409
 410 static void d_wav_func(void *d, short int *frame)
 411 /* write / close function */
 412 {
 413         struct ss_outdrv_wav *drv = d;
 414
 415         if (frame != NULL) {
 416                 int n;
 417
 418                 for (n = 0; n < drv->size; n++)
 419                         fput16(frame[n], drv->fd);
 420
 421                 drv->n_frames++;
 422         }
 423         else {
 424                 /* rewind file and write total size */
 425                 fseek(drv->fd, 4, SEEK_SET);
 426                 fput32((drv->n_frames * drv->size * 2) + 36, drv->fd);
 427
 428                 fseek(drv->fd, 40, SEEK_SET);
 429                 fput32((drv->n_frames * drv->size * 2), drv->fd);
 430
 431                 fclose(drv->fd);
 432         }
 433 }
 434
 435 static void *d_wav(char *drvname, char *filename, int freq, int n_channels, int *ssize)
 436 /* init function */
 437 {
 438         static struct ss_outdrv_wav drv;
 439
 440         if (drvname && strcmp("wav", drvname) != 0)
 441                 return NULL;
 442
 443         if (filename == NULL)
 444                 filename = "output.wav";
 445
 446         *ssize = sizeof(struct ss_outdrv_wav);
 447         drv.func = d_wav_func;
 448         drv.size = n_channels;
 449         drv.n_frames = 0;
 450
 451         if ((drv.fd = fopen(filename, "w")) == NULL)
 452                 return 0;
 453
 454         /* write wav header */
 455
 456         fwrite("RIFF", 1, 4, drv.fd);
 457         fput32(36, drv.fd);     /* first checkpoint (offset: 4) */
 458         fwrite("WAVE", 1, 4, drv.fd);
 459         fwrite("fmt ", 1, 4, drv.fd);
 460         fput32(16, drv.fd);     /* chunk size */
 461         fput16(1, drv.fd);      /* 1: uncompressed PCM */
 462         fput16(n_channels, drv.fd);     /* # of channels */
 463         fput32(freq, drv.fd);   /* sample rate */
 464         fput32(freq * n_channels * 2, drv.fd);  /* bytes per second */
 465         fput16(n_channels * 2, drv.fd); /* 'block align' */
 466         fput16(16, drv.fd);     /* 16 bits per sample */
 467         fwrite("data", 1, 4, drv.fd);
 468         fput32(0, drv.fd);      /* second checkpoint (offset: 40) */
 469
 470         return &drv;
 471 }
 472
 473
 474 /*******************************************/
 475
 476 #ifdef CONFOPT_PTHREADS
 477
 478 /* pthread support */
 479
 480 #include <pthread.h>
 481
 482 static pthread_t consumer;
 483 static pthread_mutex_t mutex;
 484 static pthread_cond_t cond;
 485
 486 /* the real function inside the driver */
 487 static void (*real_drv_func) (void *, short int *) = NULL;
 488
 489 /* number of ints in frame_cpy */
 490 static int frame_cpy_n = 0;
 491
 492 /* a copy of the frame */
 493 static short int *frame_cpy = NULL;
 494
 495 static void *outdev_thread(void *driver)
 496 /* pthread 'consumer' function */
 497 {
 498         pthread_mutex_lock(&mutex);
 499
 500         for (;;) {
 501                 /* wait for data available */
 502                 pthread_cond_wait(&cond, &mutex);
 503
 504                 /* call the real function */
 505                 real_drv_func(driver, frame_cpy);
 506
 507                 /* no more? */
 508                 if (frame_cpy == NULL)
 509                         break;
 510         }
 511
 512         pthread_mutex_unlock(&mutex);
 513         return NULL;
 514 }
 515
 516
 517 static void outdev_producer_wrapper(void *d, short int *frame)
 518 /* wrapper 'producer' function */
 519 {
 520         int n;
 521
 522         pthread_mutex_lock(&mutex);
 523
 524         if (frame == NULL) {
 525                 /* close */
 526                 free(frame_cpy);
 527                 frame_cpy = NULL;
 528                 frame_cpy_n = 0;
 529         }
 530         else {
 531                 /* copy the frame */
 532                 for (n = 0; n < frame_cpy_n; n++)
 533                         frame_cpy[n] = frame[n];
 534         }
 535
 536         pthread_cond_signal(&cond);
 537         pthread_mutex_unlock(&mutex);
 538 }
 539
 540
 541 static void thread_setup(void *d, int n_channels)
 542 {
 543         void (**drv) (void *, short int *) = d;
 544
 545         /* create the buffer */
 546         frame_cpy_n = n_channels;
 547         frame_cpy = malloc(frame_cpy_n * sizeof(short int));
 548
 549         pthread_mutex_init(&mutex, NULL);
 550         pthread_cond_init(&cond, NULL);
 551
 552         /* 'patch' the driver */
 553         real_drv_func = *drv;
 554         *drv = outdev_producer_wrapper;
 555
 556         /* launch the thread */
 557         pthread_create(&consumer, NULL, outdev_thread, d);
 558 }
 559
 560
 561 #else                           /* CONFOPT_PTHREADS */
 562
 563 void thread_setup(void *d, int n)
 564 {
 565         /* do nothing */
 566 }
 567
 568 #endif                          /* CONFOPT_PTHREADS */
 569
 570 /*******************************************/
 571
 572 /* interface */
 573
 574 void *ss_outdev_open(char *drvname, char *file, int freq, int n_channels)
 575 {
 576         int size;
 577         void *drv;
 578         void *ret = NULL;
 579
 580         if ((drv = d_arts(drvname, file, freq, n_channels, &size)) != NULL ||
 581             (drv = d_esd(drvname, file, freq, n_channels, &size)) != NULL ||
 582             (drv = d_pulse(drvname, file, freq, n_channels, &size)) != NULL ||
 583             (drv = d_sgi(drvname, file, freq, n_channels, &size)) != NULL ||
 584             (drv = d_oss(drvname, file, freq, n_channels, &size)) != NULL ||
 585             (drv = d_wav(drvname, file, freq, n_channels, &size)) != NULL) {
 586                 ret = malloc(size);
 587                 memcpy(ret, drv, size);
 588         }
 589
 590         thread_setup(ret, n_channels);
 591
 592         return ret;
 593 }
 594
 595
 596 void ss_outdev_write(void *drv, short int *frame)
 597 {
 598         void (**func) (void *, short int *) = drv;
 599
 600         (*func) (drv, frame);
 601 }
 602
 603
 604 void *ss_outdev_close(void *drv)
 605 {
 606         if (drv != NULL) {
 607                 ss_outdev_write(drv, NULL);
 608                 free(drv);
 609         }
 610
 611         return NULL;
 612 }