ss_outdev.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2005/2011 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 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 static void *d_unsupp(const char *drvname, const char *filename, int freq,
  33                       int n_channels, int *ssize)
  34 /* unsupported stub function */
  35 {
  36     return NULL;
  37 }
  38
  39
  40 /** Arts driver **/
  41
  42 #ifdef CONFOPT_ARTS
  43
  44 #include <artsc.h>
  45
  46 struct ss_outdrv_arts
  47 /* control structure */
  48 {
  49     void (*func) (void *, short int *);
  50     arts_stream_t arts;
  51     int size;
  52 };
  53
  54 static void d_arts_func(void *d, short int *frame)
  55 /* writing / close function */
  56 {
  57     struct ss_outdrv_arts *drv = d;
  58
  59     if (frame != NULL)
  60         arts_write(drv->arts, frame, drv->size);
  61     else
  62         arts_free();
  63 }
  64
  65 static void *d_arts(const char *drvname, const char *filename, int freq,
  66                     int n_channels, int *ssize)
  67 /* init function */
  68 {
  69     static struct ss_outdrv_arts drv;
  70
  71     if (drvname && strcmp("arts", drvname) != 0)
  72         return NULL;
  73
  74     /* filename specified? get out */
  75     if (filename != NULL)
  76         return NULL;
  77
  78     *ssize = sizeof(struct ss_outdrv_arts);
  79     drv.func = d_arts_func;
  80     drv.size = n_channels >= 2 ? 2 : 1;
  81
  82     if (arts_init()
  83         || (drv.arts =
  84             arts_play_stream(freq, 16, drv.size, "ahxm")) == NULL)
  85         return NULL;
  86
  87     drv.size *= sizeof(short int);
  88
  89     return &drv;
  90 }
  91
  92
  93 #else                           /* CONFOPT_ARTS */
  94
  95 #define d_arts d_unsupp
  96
  97 #endif                          /* CONFOPT_ARTS */
  98
  99
 100 /** ESD driver **/
 101
 102 #ifdef CONFOPT_ESD
 103
 104 #include <unistd.h>
 105 #include <esd.h>
 106
 107 struct ss_outdrv_esd
 108 /* control structure */
 109 {
 110     void (*func) (void *, short int *);
 111     int fd;
 112     int size;
 113 };
 114
 115 static void d_esd_func(void *d, short int *frame)
 116 /* write / close function */
 117 {
 118     struct ss_outdrv_esd *drv = d;
 119
 120     if (frame != NULL)
 121         write(drv->fd, frame, drv->size);
 122     else
 123         close(drv->fd);
 124 }
 125
 126 static void *d_esd(const char *drvname, const char *filename, int freq,
 127                    int n_channels, int *ssize)
 128 /* init function */
 129 {
 130     static struct ss_outdrv_esd drv;
 131     esd_format_t format;
 132
 133     if (drvname && strcmp("esd", drvname) != 0)
 134         return NULL;
 135
 136     *ssize = sizeof(struct ss_outdrv_esd);
 137     drv.func = d_esd_func;
 138     drv.size = n_channels >= 2 ? 2 : 1;
 139
 140     format = ESD_STREAM | ESD_PLAY | ESD_BITS16;
 141     format |= drv.size == 2 ? ESD_STEREO : ESD_MONO;
 142
 143     if (esd_open_sound(filename) < 0 ||
 144         (drv.fd =
 145          esd_play_stream_fallback(format, freq, NULL, "ahxm")) < 0)
 146         return NULL;
 147
 148     drv.size *= sizeof(short int);
 149
 150     return &drv;
 151 }
 152
 153
 154 #else                           /* CONFOPT_ESD */
 155
 156 #define d_esd d_unsupp
 157
 158 #endif                          /* CONFOPT_ESD */
 159
 160
 161 /** Pulseaudio driver **/
 162
 163 #ifdef CONFOPT_PULSEAUDIO
 164
 165 #include <pulse/simple.h>
 166 #include <pulse/error.h>
 167
 168 struct ss_outdrv_pulse
 169 /* control structure */
 170 {
 171     void (*func) (void *, short int *);
 172     pa_simple *pa;
 173     int size;
 174 };
 175
 176 static void d_pulse_func(void *d, short int *frame)
 177 /* write / close function */
 178 {
 179     struct ss_outdrv_pulse *drv = d;
 180     int error;
 181
 182     if (frame != NULL)
 183         pa_simple_write(drv->pa, frame, drv->size, &error);
 184     else {
 185         pa_simple_drain(drv->pa, &error);
 186         pa_simple_free(drv->pa);
 187     }
 188 }
 189
 190 static void *d_pulse(const char *drvname, const char *filename, int freq,
 191                      int n_channels, int *ssize)
 192 /* init function */
 193 {
 194     static struct ss_outdrv_pulse drv;
 195     pa_sample_spec ss;
 196
 197     if (drvname && strcmp("pulse", drvname) != 0)
 198         return NULL;
 199
 200     ss.format = PA_SAMPLE_S16LE;
 201     ss.rate = freq;
 202     ss.channels = n_channels;
 203
 204     *ssize = sizeof(struct ss_outdrv_pulse);
 205     drv.func = d_pulse_func;
 206     drv.size = n_channels * sizeof(short int);
 207
 208     if ((drv.pa = pa_simple_new(filename, "ahxm", PA_STREAM_PLAYBACK,
 209                                 NULL, "ahxm", &ss, NULL, NULL,
 210                                 NULL)) == NULL)
 211         return NULL;
 212
 213     return &drv;
 214 }
 215
 216 #else                           /* CONFOPT_PULSEAUDIO */
 217
 218 #define d_pulse d_unsupp
 219
 220 #endif                          /* CONFOPT_PULSEAUDIO */
 221
 222
 223 /** SGI Irix driver **/
 224
 225 #ifdef CONFOPT_SGI
 226
 227 #include <dmedia/audio.h>
 228
 229 struct ss_outdrv_sgi
 230 /* control structure */
 231 {
 232     void (*func) (void *, short int *);
 233     ALconfig ac;
 234     ALport ap;
 235 };
 236
 237 static void d_sgi_func(void *d, short int *frame)
 238 /* write / close function */
 239 {
 240     struct ss_outdrv_sgi *drv = d;
 241
 242     if (frame != NULL)
 243         alWriteFrames(drv->ap, frame, 1);
 244     else {
 245         alClosePort(drv->ap);
 246         alFreeConfig(drv->ac);
 247     }
 248 }
 249
 250 static void *d_sgi(const char *drvname, const char *filename, int freq,
 251                    int n_channels, int *ssize)
 252 /* init function */
 253 {
 254     static struct ss_outdrv_sgi drv;
 255     ALpv p[2];
 256
 257     if (drvname && strcmp("sgi", drvname) != 0)
 258         return NULL;
 259
 260     /* filename specified? get out */
 261     if (filename != NULL)
 262         return NULL;
 263
 264     *ssize = sizeof(struct ss_outdrv_sgi);
 265     drv.func = d_sgi_func;
 266
 267     p[0].param = AL_MASTER_CLOCK;
 268     p[0].value.i = AL_CRYSTAL_MCLK_TYPE;
 269     p[1].param = AL_RATE;
 270     p[1].value.ll = alDoubleToFixed((double) freq);
 271
 272     if (!(drv.ac = alNewConfig()))
 273         return NULL;
 274
 275     if (alSetChannels(drv.ac, n_channels) < 0 ||
 276         alSetWidth(drv.ac, AL_SAMPLE_16) < 0 ||
 277         alSetSampFmt(drv.ac, AL_SAMPFMT_TWOSCOMP) < 0 ||
 278         alSetQueueSize(drv.ac, 2048) < 0 ||
 279         alSetDevice(drv.ac, AL_DEFAULT_OUTPUT) < 0 ||
 280         alSetParams(alGetDevice(drv.ac), p, 2) < 0 ||
 281         !(drv.ap = alOpenPort("ahxm", "w", drv.ac))) {
 282         alFreeConfig(drv.ac);
 283         return NULL;
 284     }
 285
 286     return &drv;
 287 }
 288
 289 #else                           /* CONFOPT_SGI */
 290
 291 #define d_sgi d_unsupp
 292
 293 #endif                          /* CONFOPT_SGI */
 294
 295
 296 /** Linux OSS driver **/
 297
 298 #ifdef CONFOPT_LINUX_OSS
 299
 300 #include <fcntl.h>
 301 #include <sys/ioctl.h>
 302 #include <linux/soundcard.h>
 303 #include <unistd.h>
 304
 305 struct ss_outdrv_oss
 306 /* control structure */
 307 {
 308     void (*func) (void *, short int *);
 309     int fd;
 310     int size;
 311 };
 312
 313 static int is_little_endian(void)
 314 /* is this machine little endian? */
 315 {
 316     short s = 1;
 317     unsigned char *c = (unsigned char *) &s;
 318
 319     return *c == 1;
 320 }
 321
 322 static void d_oss_func(void *d, short int *frame)
 323 /* write / close function */
 324 {
 325     struct ss_outdrv_oss *drv = d;
 326
 327     if (frame != NULL)
 328         write(drv->fd, frame, drv->size);
 329     else
 330         close(drv->fd);
 331 }
 332
 333
 334 static void *d_oss(const char *drvname, const char *filename, int freq,
 335                    int n_channels, int *ssize)
 336 /* init function */
 337 {
 338     static struct ss_outdrv_oss drv;
 339     int fr, st, fm;
 340
 341     if (drvname && strcmp("oss", drvname) != 0)
 342         return NULL;
 343
 344     if (filename == NULL)
 345         filename = "/dev/dsp";
 346
 347     fr = (2 << 16) | 12;
 348     st = n_channels >= 2 ? 1 : 0;
 349     fm = is_little_endian()? AFMT_S16_LE : AFMT_S16_BE;
 350
 351     *ssize = sizeof(struct ss_outdrv_oss);
 352     drv.func = d_oss_func;
 353     drv.size = n_channels >= 2 ? 2 : 1;
 354
 355     if ((drv.fd = open(filename, O_WRONLY)) < 0)
 356         return NULL;
 357
 358     if (ioctl(drv.fd, SNDCTL_DSP_SETFRAGMENT, &fr) < 0 ||
 359         ioctl(drv.fd, SNDCTL_DSP_RESET, 0) < 0 ||
 360         ioctl(drv.fd, SNDCTL_DSP_SPEED, &freq) < 0 ||
 361         ioctl(drv.fd, SNDCTL_DSP_STEREO, &st) < 0 ||
 362         ioctl(drv.fd, SNDCTL_DSP_SETFMT, &fm) < 0) {
 363         close(drv.fd);
 364         return NULL;
 365     }
 366
 367     drv.size *= sizeof(short int);
 368
 369     return &drv;
 370 }
 371
 372 #else                           /* CONFOPT_LINUX_OSS */
 373
 374 #define d_oss d_unsupp
 375
 376 #endif                          /* CONFOPT_LINUX_OSS */
 377
 378
 379 /** WAV file driver **/
 380
 381 struct ss_outdrv_wav
 382 /* control structure */
 383 {
 384     void (*func) (void *, short int *);
 385     FILE *fd;
 386     int size;
 387     int n_frames;
 388 };
 389
 390 static void fput16(short int i, FILE * f)
 391 /* writes a 16 bit integer, in any machine order */
 392 {
 393     fputc(i & 0x00ff, f);
 394     fputc((i & 0xff00) >> 8, f);
 395 }
 396
 397 static void fput32(int i, FILE * f)
 398 /* writes a 32 bit integer, in any machine order */
 399 {
 400     fputc(i & 0x000000ff, f);
 401     fputc((i & 0x0000ff00) >> 8, f);
 402     fputc((i & 0x00ff0000) >> 16, f);
 403     fputc((i & 0xff000000) >> 24, f);
 404 }
 405
 406 static void d_wav_func(void *d, short int *frame)
 407 /* write / close function */
 408 {
 409     struct ss_outdrv_wav *drv = d;
 410
 411     if (frame != NULL) {
 412         int n;
 413
 414         for (n = 0; n < drv->size; n++)
 415             fput16(frame[n], drv->fd);
 416
 417         drv->n_frames++;
 418     }
 419     else {
 420         /* rewind file and write total size */
 421         fseek(drv->fd, 4, SEEK_SET);
 422         fput32((drv->n_frames * drv->size * 2) + 36, drv->fd);
 423
 424         fseek(drv->fd, 40, SEEK_SET);
 425         fput32((drv->n_frames * drv->size * 2), drv->fd);
 426
 427         fclose(drv->fd);
 428     }
 429 }
 430
 431 static void *d_wav(const char *drvname, const char *filename, int freq,
 432                    int n_channels, int *ssize)
 433 /* init function */
 434 {
 435     static struct ss_outdrv_wav drv;
 436
 437     if (drvname && strcmp("wav", drvname) != 0)
 438         return NULL;
 439
 440     if (filename == NULL)
 441         filename = "output.wav";
 442
 443     *ssize = sizeof(struct ss_outdrv_wav);
 444     drv.func = d_wav_func;
 445     drv.size = n_channels;
 446     drv.n_frames = 0;
 447
 448     if ((drv.fd = fopen(filename, "wb")) == NULL)
 449         return 0;
 450
 451     /* write wav header */
 452
 453     fwrite("RIFF", 1, 4, drv.fd);
 454     fput32(36, drv.fd);         /* first checkpoint (offset: 4) */
 455     fwrite("WAVE", 1, 4, drv.fd);
 456     fwrite("fmt ", 1, 4, drv.fd);
 457     fput32(16, drv.fd);         /* chunk size */
 458     fput16(1, drv.fd);          /* 1: uncompressed PCM */
 459     fput16(n_channels, drv.fd); /* # of channels */
 460     fput32(freq, drv.fd);       /* sample rate */
 461     fput32(freq * n_channels * 2, drv.fd);      /* bytes per second */
 462     fput16(n_channels * 2, drv.fd);     /* 'block align' */
 463     fput16(16, drv.fd);         /* 16 bits per sample */
 464     fwrite("data", 1, 4, drv.fd);
 465     fput32(0, drv.fd);          /* second checkpoint (offset: 40) */
 466
 467     return &drv;
 468 }
 469
 470
 471 /** Pthread support **/
 472
 473 #ifdef CONFOPT_PTHREADS
 474
 475 #include <pthread.h>
 476
 477 static pthread_t consumer;
 478 static pthread_mutex_t mutex;
 479 static pthread_cond_t cond;
 480
 481 /* the real function inside the driver */
 482 static void (*real_drv_func) (void *, short int *) = NULL;
 483
 484 /* number of ints in frame_cpy */
 485 static int frame_cpy_n = 0;
 486
 487 /* a copy of the frame */
 488 static short int *frame_cpy = NULL;
 489
 490 static void *outdev_thread(void *driver)
 491 /* pthread 'consumer' function */
 492 {
 493     pthread_mutex_lock(&mutex);
 494
 495     for (;;) {
 496         /* wait for data available */
 497         pthread_cond_wait(&cond, &mutex);
 498
 499         /* call the real function */
 500         real_drv_func(driver, frame_cpy);
 501
 502         /* no more? */
 503         if (frame_cpy == NULL)
 504             break;
 505     }
 506
 507     pthread_mutex_unlock(&mutex);
 508     return NULL;
 509 }
 510
 511
 512 static void outdev_producer_wrapper(void *d, short int *frame)
 513 /* wrapper 'producer' function */
 514 {
 515     int n;
 516
 517     pthread_mutex_lock(&mutex);
 518
 519     if (frame == NULL) {
 520         /* close */
 521         free(frame_cpy);
 522         frame_cpy = NULL;
 523         frame_cpy_n = 0;
 524     }
 525     else {
 526         /* copy the frame */
 527         for (n = 0; n < frame_cpy_n; n++)
 528             frame_cpy[n] = frame[n];
 529     }
 530
 531     pthread_cond_signal(&cond);
 532     pthread_mutex_unlock(&mutex);
 533 }
 534
 535
 536 static void thread_setup(void *d, int n_channels)
 537 {
 538     void (**drv) (void *, short int *) = d;
 539
 540     /* create the buffer */
 541     frame_cpy_n = n_channels;
 542     frame_cpy = malloc(frame_cpy_n * sizeof(short int));
 543
 544     pthread_mutex_init(&mutex, NULL);
 545     pthread_cond_init(&cond, NULL);
 546
 547     /* 'patch' the driver */
 548     real_drv_func = *drv;
 549     *drv = outdev_producer_wrapper;
 550
 551     /* launch the thread */
 552     pthread_create(&consumer, NULL, outdev_thread, d);
 553 }
 554
 555
 556 #else                           /* CONFOPT_PTHREADS */
 557
 558 void thread_setup(void *d, int n)
 559 {
 560     /* do nothing */
 561 }
 562
 563 #endif                          /* CONFOPT_PTHREADS */
 564
 565
 566 /** win32 waveout support **/
 567
 568 #ifdef CONFOPT_WIN32
 569
 570 #include <windows.h>
 571 #include <mmsystem.h>
 572
 573 #define WAVEOUT_BUF_SIZE    4096 * 4
 574 #define WAVEOUT_N_BUFFERS   8
 575
 576 struct _wob {
 577     WAVEHDR header;
 578     unsigned char buf[WAVEOUT_BUF_SIZE];
 579     int offset;
 580 };
 581
 582 struct ss_outdrv_win32
 583 /* control structure */
 584 {
 585     void (*func) (void *, short int *);
 586     HWAVEOUT hwaveout;
 587     struct _wob wob[WAVEOUT_N_BUFFERS];
 588     int wob_i;
 589     int size;
 590 };
 591
 592 static void d_win32_func(void *d, short int *frame)
 593 {
 594     struct ss_outdrv_win32 *drv = d;
 595     struct _wob *b = &drv->wob[drv->wob_i];
 596     int w = 1;
 597
 598     if (frame != NULL) {
 599         /* fill buffer */
 600         memcpy(b->buf + b->offset, frame, drv->size);
 601         b->offset += drv->size;
 602
 603         /* still not full? do not write then */
 604         if (b->offset + drv->size < WAVEOUT_BUF_SIZE)
 605             w = 0;
 606     }
 607
 608     if (w) {
 609         /* clean previous buffer, if needed */
 610         if (b->header.lpData)
 611             waveOutUnprepareHeader(drv->hwaveout, &b->header,
 612                                    sizeof(WAVEHDR));
 613
 614         /* prepare new buffer */
 615         b->header.dwBufferLength = b->offset;
 616         b->header.lpData = (LPSTR) b->buf;
 617
 618         /* send it */
 619         waveOutPrepareHeader(drv->hwaveout, &b->header, sizeof(WAVEHDR));
 620         waveOutWrite(drv->hwaveout, &b->header, sizeof(WAVEHDR));
 621
 622         if (frame != NULL) {
 623             /* next buffer */
 624             if (++drv->wob_i == WAVEOUT_N_BUFFERS)
 625                 drv->wob_i = 0;
 626
 627             b = &drv->wob[drv->wob_i];
 628
 629             /* reset */
 630             b->offset = 0;
 631         }
 632
 633         /* wait until buffer is done */
 634         while (b->header.lpData != NULL
 635                && !(b->header.dwFlags & WHDR_DONE))
 636             Sleep(1);
 637     }
 638 }
 639
 640
 641 static void *d_win32(const char *drvname, const char *filename, int freq,
 642                      int n_channels, int *ssize)
 643 {
 644     static struct ss_outdrv_win32 drv;
 645     WAVEFORMATEX wfx;
 646
 647     if (drvname && strcmp("win32", drvname) != 0)
 648         return NULL;
 649
 650     memset(&drv, '\0', sizeof(drv));
 651
 652     wfx.nSamplesPerSec = freq;
 653     wfx.wBitsPerSample = 16;
 654     wfx.nChannels = n_channels;
 655     wfx.cbSize = 0;
 656     wfx.wFormatTag = WAVE_FORMAT_PCM;
 657     wfx.nBlockAlign = (wfx.wBitsPerSample >> 3) * wfx.nChannels;
 658     wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
 659
 660     if (waveOutOpen(&drv.hwaveout, WAVE_MAPPER,
 661                     &wfx, 0, 0, CALLBACK_NULL) != MMSYSERR_NOERROR)
 662         return NULL;
 663
 664     drv.func = d_win32_func;
 665     drv.size = n_channels * sizeof(short int);
 666     drv.wob_i = 0;
 667
 668     *ssize = sizeof(struct ss_outdrv_win32);
 669
 670     return &drv;
 671 }
 672
 673
 674 #else                           /* CONFOPT_WIN32 */
 675
 676 #define d_win32 d_unsupp
 677
 678 #endif                          /* CONFOPT_WIN32 */
 679
 680
 681 /** Interface **/
 682
 683 void *ss_outdev_open(const char *drvname, const char *file, int freq,
 684                      int n_channels)
 685 {
 686     int size;
 687     void *drv;
 688     void *ret = NULL;
 689
 690     if ((drv = d_arts(drvname, file, freq, n_channels, &size)) != NULL ||
 691         (drv = d_esd(drvname, file, freq, n_channels, &size)) != NULL ||
 692         (drv = d_pulse(drvname, file, freq, n_channels, &size)) != NULL ||
 693         (drv = d_sgi(drvname, file, freq, n_channels, &size)) != NULL ||
 694         (drv = d_oss(drvname, file, freq, n_channels, &size)) != NULL ||
 695         (drv = d_win32(drvname, file, freq, n_channels, &size)) != NULL ||
 696         (drv = d_wav(drvname, file, freq, n_channels, &size)) != NULL) {
 697         ret = malloc(size);
 698         memcpy(ret, drv, size);
 699     }
 700
 701     thread_setup(ret, n_channels);
 702
 703     return ret;
 704 }
 705
 706
 707 void ss_outdev_write(void *drv, short int *frame)
 708 {
 709     void (**func) (void *, short int *) = drv;
 710
 711     (*func) (drv, frame);
 712 }
 713
 714
 715 void *ss_outdev_close(void *drv)
 716 {
 717     if (drv != NULL) {
 718         ss_outdev_write(drv, NULL);
 719         free(drv);
 720     }
 721
 722     return NULL;
 723 }