Alc/wave.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26 #include "alMain.h"
  27 #include "AL/al.h"
  28 #include "AL/alc.h"
  29
  30
  31 typedef struct {
  32     FILE *f;
  33     long DataStart;
  34
  35     ALvoid *buffer;
  36     ALuint size;
  37
  38     volatile int killNow;
  39     ALvoid *thread;
  40 } wave_data;
  41
  42
  43 static ALCchar *waveDevice;
  44
  45
  46 static ALuint WaveProc(ALvoid *ptr)
  47 {
  48     ALCdevice *pDevice = (ALCdevice*)ptr;
  49     wave_data *data = (wave_data*)pDevice->ExtraData;
  50     ALuint frameSize;
  51     ALuint now, last;
  52     size_t WriteCnt;
  53     size_t fs;
  54     ALuint avail;
  55     union {
  56         short s;
  57         char b[sizeof(short)];
  58     } uSB;
  59
  60     uSB.s = 1;
  61     frameSize = aluBytesFromFormat(pDevice->Format) *
  62                 aluChannelsFromFormat(pDevice->Format);
  63
  64     last = timeGetTime();
  65     while(!data->killNow)
  66     {
  67         now = timeGetTime();
  68
  69         avail = (now-last) * pDevice->Frequency / 1000;
  70         if(avail < pDevice->UpdateSize)
  71         {
  72             Sleep(1);
  73             continue;
  74         }
  75
  76         while(avail > 0)
  77         {
  78             SuspendContext(NULL);
  79             WriteCnt = min(data->size, avail);
  80             aluMixData(pDevice->Context, data->buffer, WriteCnt * frameSize,
  81                        pDevice->Format);
  82             ProcessContext(NULL);
  83
  84             if(uSB.b[0] != 1 && aluBytesFromFormat(pDevice->Format) > 1)
  85             {
  86                 ALubyte *bytes = data->buffer;
  87                 ALuint i;
  88
  89                 for(i = 0;i < WriteCnt*frameSize;i++)
  90                     fputc(bytes[i^1], data->f);
  91             }
  92             else
  93                 fs = fwrite(data->buffer, frameSize, WriteCnt, data->f);
  94             if(ferror(data->f))
  95             {
  96                 AL_PRINT("Error writing to file\n");
  97                 data->killNow = 1;
  98                 break;
  99             }
 100
 101             avail -= WriteCnt;
 102         }
 103         last = now;
 104     }
 105
 106     return 0;
 107 }
 108
 109 static ALCboolean wave_open_playback(ALCdevice *device, const ALCchar *deviceName)
 110 {
 111     wave_data *data;
 112     const char *fname;
 113
 114     fname = GetConfigValue("wave", "file", "");
 115     if(!fname[0])
 116         return ALC_FALSE;
 117
 118     if(deviceName)
 119     {
 120         if(strcmp(deviceName, waveDevice) != 0)
 121             return ALC_FALSE;
 122         device->szDeviceName = waveDevice;
 123     }
 124     else
 125         device->szDeviceName = waveDevice;
 126
 127     data = (wave_data*)calloc(1, sizeof(wave_data));
 128
 129     data->f = fopen(fname, "wb");
 130     if(!data->f)
 131     {
 132         free(data);
 133         AL_PRINT("Could not open file '%s': %s\n", fname, strerror(errno));
 134         return ALC_FALSE;
 135     }
 136
 137     device->ExtraData = data;
 138     return ALC_TRUE;
 139 }
 140
 141 static void wave_close_playback(ALCdevice *device)
 142 {
 143     wave_data *data = (wave_data*)device->ExtraData;
 144     ALuint dataLen;
 145     long size;
 146
 147     data->killNow = 1;
 148     StopThread(data->thread);
 149
 150     size = ftell(data->f);
 151     if(size > 0)
 152     {
 153         dataLen = size - data->DataStart;
 154         if(fseek(data->f, data->DataStart-4, SEEK_SET) == 0)
 155         {
 156             fputc(dataLen&0xff, data->f); // 'data' header len
 157             fputc((dataLen>>8)&0xff, data->f);
 158             fputc((dataLen>>16)&0xff, data->f);
 159             fputc((dataLen>>24)&0xff, data->f);
 160         }
 161         if(fseek(data->f, 4, SEEK_SET) == 0)
 162         {
 163             size -= 8;
 164             fputc(size&0xff, data->f); // 'WAVE' header len
 165             fputc((size>>8)&0xff, data->f);
 166             fputc((size>>16)&0xff, data->f);
 167             fputc((size>>24)&0xff, data->f);
 168         }
 169     }
 170
 171     fclose(data->f);
 172     free(data);
 173     device->ExtraData = NULL;
 174 }
 175
 176 static ALCboolean wave_start_context(ALCdevice *device, ALCcontext *Context)
 177 {
 178     wave_data *data = (wave_data*)device->ExtraData;
 179     ALuint channels, bits, i;
 180     (void)Context;
 181
 182     fseek(data->f, 0, SEEK_SET);
 183     clearerr(data->f);
 184
 185     bits = aluBytesFromFormat(device->Format) * 8;
 186     channels = aluChannelsFromFormat(device->Format);
 187     switch(bits)
 188     {
 189         case 8:
 190         case 16:
 191         case 32:
 192             if(channels == 0)
 193             {
 194                 AL_PRINT("Unknown format?! %x\n", device->Format);
 195                 return ALC_FALSE;
 196             }
 197             break;
 198
 199         default:
 200             AL_PRINT("Unknown format?! %x\n", device->Format);
 201             return ALC_FALSE;
 202     }
 203
 204     fprintf(data->f, "RIFF");
 205     fputc(0, data->f); // 'RIFF' header len; filled in at close
 206     fputc(0, data->f);
 207     fputc(0, data->f);
 208     fputc(0, data->f);
 209
 210     fprintf(data->f, "WAVE");
 211
 212     fprintf(data->f, "fmt ");
 213     fputc(16, data->f); // 'fmt ' header len; 16 bytes for PCM
 214     fputc(0, data->f);
 215     fputc(0, data->f);
 216     fputc(0, data->f);
 217     // 16-bit val, format type id (PCM: 1)
 218     fputc(1, data->f);
 219     fputc(0, data->f);
 220     // 16-bit val, channel count
 221     fputc(channels&0xff, data->f);
 222     fputc((channels>>8)&0xff, data->f);
 223     // 32-bit val, frequency
 224     fputc(device->Frequency&0xff, data->f);
 225     fputc((device->Frequency>>8)&0xff, data->f);
 226     fputc((device->Frequency>>16)&0xff, data->f);
 227     fputc((device->Frequency>>24)&0xff, data->f);
 228     // 32-bit val, bytes per second
 229     i = device->Frequency * channels * bits / 8;
 230     fputc(i&0xff, data->f);
 231     fputc((i>>8)&0xff, data->f);
 232     fputc((i>>16)&0xff, data->f);
 233     fputc((i>>24)&0xff, data->f);
 234     // 16-bit val, frame size
 235     i = channels * bits / 8;
 236     fputc(i&0xff, data->f);
 237     fputc((i>>8)&0xff, data->f);
 238     // 16-bit val, bits per sample
 239     fputc(bits&0xff, data->f);
 240     fputc((bits>>8)&0xff, data->f);
 241
 242     fprintf(data->f, "data");
 243     fputc(0, data->f); // 'data' header len; filled in at close
 244     fputc(0, data->f);
 245     fputc(0, data->f);
 246     fputc(0, data->f);
 247
 248     if(ferror(data->f))
 249     {
 250         AL_PRINT("Error writing header: %s\n", strerror(errno));
 251         return ALC_FALSE;
 252     }
 253
 254     data->DataStart = ftell(data->f);
 255
 256     device->UpdateSize = device->BufferSize / 4;
 257
 258     data->size = device->UpdateSize;
 259     data->buffer = malloc(data->size * channels * bits / 8);
 260     if(!data->buffer)
 261     {
 262         AL_PRINT("buffer malloc failed\n");
 263         return ALC_FALSE;
 264     }
 265
 266     data->thread = StartThread(WaveProc, device);
 267     if(data->thread == NULL)
 268     {
 269         free(data->buffer);
 270         data->buffer = NULL;
 271         return ALC_FALSE;
 272     }
 273
 274     return ALC_TRUE;
 275 }
 276
 277 static void wave_stop_context(ALCdevice *device, ALCcontext *Context)
 278 {
 279     wave_data *data = (wave_data*)device->ExtraData;
 280     ALuint dataLen;
 281     long size;
 282     (void)Context;
 283
 284     if(!data->thread)
 285         return;
 286
 287     data->killNow = 1;
 288     StopThread(data->thread);
 289     data->thread = NULL;
 290
 291     free(data->buffer);
 292     data->buffer = NULL;
 293
 294     size = ftell(data->f);
 295     if(size > 0)
 296     {
 297         dataLen = size - data->DataStart;
 298         if(fseek(data->f, data->DataStart-4, SEEK_SET) == 0)
 299         {
 300             fputc(dataLen&0xff, data->f); // 'data' header len
 301             fputc((dataLen>>8)&0xff, data->f);
 302             fputc((dataLen>>16)&0xff, data->f);
 303             fputc((dataLen>>24)&0xff, data->f);
 304         }
 305         if(fseek(data->f, 4, SEEK_SET) == 0)
 306         {
 307             size -= 8;
 308             fputc(size&0xff, data->f); // 'WAVE' header len
 309             fputc((size>>8)&0xff, data->f);
 310             fputc((size>>16)&0xff, data->f);
 311             fputc((size>>24)&0xff, data->f);
 312         }
 313     }
 314 }
 315
 316
 317 static ALCboolean wave_open_capture(ALCdevice *pDevice, const ALCchar *deviceName)
 318 {
 319     (void)pDevice;
 320     (void)deviceName;
 321     return ALC_FALSE;
 322 }
 323
 324 static void wave_close_capture(ALCdevice *pDevice)
 325 {
 326     (void)pDevice;
 327 }
 328
 329 static void wave_start_capture(ALCdevice *pDevice)
 330 {
 331     (void)pDevice;
 332 }
 333
 334 static void wave_stop_capture(ALCdevice *pDevice)
 335 {
 336     (void)pDevice;
 337 }
 338
 339 static void wave_capture_samples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 340 {
 341     (void)pDevice;
 342     (void)pBuffer;
 343     (void)lSamples;
 344 }
 345
 346 static ALCuint wave_available_samples(ALCdevice *pDevice)
 347 {
 348     (void)pDevice;
 349     return 0;
 350 }
 351
 352
 353 BackendFuncs wave_funcs = {
 354     wave_open_playback,
 355     wave_close_playback,
 356     wave_start_context,
 357     wave_stop_context,
 358     wave_open_capture,
 359     wave_close_capture,
 360     wave_start_capture,
 361     wave_stop_capture,
 362     wave_capture_samples,
 363     wave_available_samples
 364 };
 365
 366 void alc_wave_init(BackendFuncs *func_list)
 367 {
 368     *func_list = wave_funcs;
 369
 370     waveDevice = AppendDeviceList("Wave File Writer");
 371     AppendAllDeviceList(waveDevice);
 372 }