waveout.c

   1 /*
   2  * Copyright 2007 dnk <dnk@bjum.net>
   3  * Based on oss.c
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18  * 02111-1307, USA.
  19  */
  20
  21 #include "op.h"
  22 #include "sf.h"
  23 #include "utils.h"
  24 #include "xmalloc.h"
  25 #include "debug.h"
  26
  27 #define WIN32_LEAN_AND_MEAN
  28 #include <windows.h>
  29 #include <mmsystem.h>
  30
  31 static HWAVEOUT wave_out;
  32 static sample_format_t waveout_sf;
  33 static int buffer_size = 4096;
  34 static int buffer_count = 12;
  35 static WAVEHDR *buffers;
  36 static int buffer_idx;
  37 static int buffers_free;
  38
  39 #define FRAME_SIZE_ALIGN(x) \
  40         (((x) / sf_get_frame_size(waveout_sf)) * sf_get_frame_size(waveout_sf))
  41
  42 static void waveout_error(const char *name, int rc)
  43 {
  44         const char *errstr = "UNKNOWN";
  45
  46         switch (rc) {
  47         case MMSYSERR_ALLOCATED:        errstr = "MMSYSERR_ALLOCATED"; break;
  48         case MMSYSERR_INVALHANDLE:      errstr = "MMSYSERR_INVALHANDLE"; break;
  49         case MMSYSERR_NODRIVER:         errstr = "MMSYSERR_NODRIVER"; break;
  50         case MMSYSERR_BADDEVICEID:      errstr = "MMSYSERR_BADDEVICEID"; break;
  51         case MMSYSERR_NOMEM:            errstr = "MMSYSERR_NOMEM"; break;
  52         case MMSYSERR_NOTSUPPORTED:     errstr = "MMSYSERR_NOTSUPPORTED"; break;
  53         case WAVERR_STILLPLAYING:       errstr = "WAVERR_STILLPLAYING"; break;
  54         case WAVERR_UNPREPARED:         errstr = "WAVERR_UNPREPARED"; break;
  55         case WAVERR_BADFORMAT:          errstr = "WAVERR_BADFORMAT"; break;
  56         case WAVERR_SYNC:               errstr = "WAVERR_SYNC"; break;
  57         }
  58
  59         d_print("%s returned error %s (%d)\n", name, errstr, rc);
  60 }
  61
  62 static void clean_buffers(void)
  63 {
  64         int i;
  65
  66         /* mark used buffers clean */
  67         for (i = 0; i < buffer_count; i++) {
  68                 WAVEHDR *hdr = &buffers[(buffer_idx + i) % buffer_count];
  69
  70                 if (!(hdr->dwFlags & WHDR_DONE))
  71                         break;
  72                 buffers_free++;
  73                 waveOutUnprepareHeader(wave_out, hdr, sizeof(WAVEHDR));
  74                 hdr->dwFlags = 0;
  75         }
  76 }
  77
  78 static int waveout_open(sample_format_t sf)
  79 {
  80         WAVEFORMATEX  format;
  81         int rc, i;
  82
  83         /* WAVEFORMATEX does not support channels > 2, waveOutWrite() wants little endian signed PCM */
  84         if (sf_get_bigendian(sf) || !sf_get_signed(sf) || sf_get_channels(sf) > 2) {
  85                 return -OP_ERROR_SAMPLE_FORMAT;
  86         }
  87
  88         memset(&format, 0, sizeof(format));
  89         format.cbSize = sizeof(format);
  90         format.wFormatTag = WAVE_FORMAT_PCM;
  91         format.nChannels = sf_get_channels(sf);
  92         format.nSamplesPerSec = sf_get_rate(sf);
  93         format.wBitsPerSample = sf_get_bits(sf);
  94         format.nAvgBytesPerSec = sf_get_second_size(sf);
  95         format.nBlockAlign = sf_get_frame_size(sf);
  96
  97         rc = waveOutOpen(&wave_out, WAVE_MAPPER, &format, 0, 0, CALLBACK_NULL);
  98         if (rc != MMSYSERR_NOERROR) {
  99                 switch (rc) {
 100                 case MMSYSERR_ALLOCATED:
 101                         errno = EBUSY;
 102                         return -OP_ERROR_ERRNO;
 103                 case MMSYSERR_BADDEVICEID:
 104                 case MMSYSERR_NODRIVER:
 105                         errno = ENODEV;
 106                         return -OP_ERROR_ERRNO;
 107                 case MMSYSERR_NOMEM:
 108                         errno = ENOMEM;
 109                         return -OP_ERROR_ERRNO;
 110                 case WAVERR_BADFORMAT:
 111                         return -OP_ERROR_SAMPLE_FORMAT;
 112                 }
 113                 return -OP_ERROR_INTERNAL;
 114         }
 115
 116         /* reset buffers */
 117         for (i = 0; i < buffer_count; i++) {
 118                 buffers[i].dwFlags = 0;
 119         }
 120         buffer_idx = 0;
 121         buffers_free = buffer_count;
 122
 123         waveout_sf = sf;
 124
 125         return 0;
 126 }
 127
 128 static int waveout_close(void)
 129 {
 130         int rc;
 131
 132         waveOutReset(wave_out);
 133
 134         clean_buffers();
 135
 136         rc = waveOutClose(wave_out);
 137         if (rc != MMSYSERR_NOERROR) {
 138                 waveout_error("waveOutClose", rc);
 139                 return -1;
 140         }
 141         wave_out = NULL;
 142
 143         return 0;
 144 }
 145
 146 static int waveout_init(void)
 147 {
 148         WAVEHDR *hdr;
 149         int i;
 150
 151         /* create buffers */
 152         buffers = xnew(WAVEHDR, buffer_count);
 153         for (i = 0; i < buffer_count; i++) {
 154                 hdr = &buffers[i];
 155
 156                 memset(hdr, 0, sizeof(WAVEHDR));
 157                 hdr->lpData = xmalloc(buffer_size);
 158         }
 159         return 0;
 160 }
 161
 162 static int waveout_exit(void)
 163 {
 164         int i;
 165
 166         for (i = 0; i < buffer_count; i++) {
 167                 free(buffers[i].lpData);
 168         }
 169         free(buffers);
 170         buffers = NULL;
 171
 172         return 0;
 173 }
 174
 175 static int waveout_write(const char *buffer, int count)
 176 {
 177         int written = 0;
 178         int len, rc;
 179
 180         count = FRAME_SIZE_ALIGN(count);
 181
 182         clean_buffers();
 183
 184         while (count > 0) {
 185                 WAVEHDR *hdr = &buffers[buffer_idx];
 186
 187                 if (hdr->dwFlags != 0) {
 188                         /* no free buffers */
 189                         break;
 190                 }
 191
 192                 len = FRAME_SIZE_ALIGN(min(count, buffer_size));
 193                 hdr->dwBufferLength = len;
 194                 memcpy(hdr->lpData, buffer + written, len);
 195
 196                 rc = waveOutPrepareHeader(wave_out, hdr, sizeof(WAVEHDR));
 197                 if (rc != MMSYSERR_NOERROR) {
 198                         waveout_error("waveOutPrepareHeader", rc);
 199                         break;
 200                 }
 201
 202                 rc = waveOutWrite(wave_out, hdr, sizeof(WAVEHDR));
 203                 if (rc != MMSYSERR_NOERROR) {
 204                         waveOutUnprepareHeader(wave_out, hdr, sizeof(WAVEHDR));
 205                         hdr->dwFlags = 0;
 206                         waveout_error("waveOutWrite", rc);
 207                         break;
 208                 }
 209
 210                 written += len;
 211                 count -= len;
 212                 buffer_idx = (buffer_idx + 1) % buffer_count;
 213                 buffers_free--;
 214         }
 215
 216         return written;
 217 }
 218
 219 static int waveout_pause(void)
 220 {
 221         if (waveOutPause(wave_out) != MMSYSERR_NOERROR)
 222                 return -1;
 223         return 0;
 224 }
 225
 226 static int waveout_unpause(void)
 227 {
 228         if (waveOutRestart(wave_out) != MMSYSERR_NOERROR)
 229                 return -1;
 230         return 0;
 231 }
 232
 233 static int waveout_buffer_space(void)
 234 {
 235         clean_buffers();
 236         if (buffers_free == 0)
 237                 return -1;
 238         return buffers_free * FRAME_SIZE_ALIGN(buffer_size);
 239 }
 240
 241 static int waveout_set_option(int key, const char *val)
 242 {
 243         long int ival;
 244         int reinit = 0;
 245
 246         switch (key) {
 247         case 0:
 248                 if (str_to_int(val, &ival) || ival < 4096 || ival > 65536) {
 249                         errno = EINVAL;
 250                         return -OP_ERROR_ERRNO;
 251                 }
 252                 if (buffers) {
 253                         waveout_exit();
 254                         reinit = 1;
 255                 }
 256                 buffer_size = ival;
 257                 break;
 258         case 1:
 259                 if (str_to_int(val, &ival) || ival < 2 || ival > 64) {
 260                         errno = EINVAL;
 261                         return -OP_ERROR_ERRNO;
 262                 }
 263                 if (buffers) {
 264                         waveout_exit();
 265                         reinit = 1;
 266                 }
 267                 buffer_count = ival;
 268                 break;
 269         default:
 270                 return -OP_ERROR_NOT_OPTION;
 271         }
 272
 273         if (reinit) {
 274                 waveout_init();
 275         }
 276
 277         return 0;
 278 }
 279
 280 static int waveout_get_option(int key, char **val)
 281 {
 282         switch (key) {
 283         case 0:
 284                 *val = xnew(char, 22);
 285                 snprintf(*val, 22, "%d", buffer_size);
 286                 break;
 287         case 1:
 288                 *val = xnew(char, 22);
 289                 snprintf(*val, 22, "%d", buffer_count);
 290                 break;
 291         default:
 292                 return -OP_ERROR_NOT_OPTION;
 293         }
 294         return 0;
 295 }
 296
 297 const struct output_plugin_ops op_pcm_ops = {
 298         .init = waveout_init,
 299         .exit = waveout_exit,
 300         .open = waveout_open,
 301         .close = waveout_close,
 302         .write = waveout_write,
 303         .pause = waveout_pause,
 304         .unpause = waveout_unpause,
 305         .buffer_space = waveout_buffer_space,
 306         .set_option = waveout_set_option,
 307         .get_option = waveout_get_option
 308 };
 309
 310 const char * const op_pcm_options[] = {
 311         "buffer_size",
 312         "buffer_count",
 313         NULL
 314 };
 315
 316 const int op_priority = 0;