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