?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix int-to-double conversion
[openal-soft.git] / OpenAL32 / alBuffer.c
blobf34225a28d66d0541bffc84704ae4ff861061d38
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 <assert.h>
26 #include <limits.h>
27
28 #include "alMain.h"
29 #include "AL/al.h"
30 #include "AL/alc.h"
31 #include "alError.h"
32 #include "alBuffer.h"
33 #include "alDatabuffer.h"
34 #include "alThunk.h"
35
36
37 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei size, enum SrcFmtChannels chans, enum SrcFmtType type, const ALvoid *data);
38 static void ConvertData(ALvoid *dst, enum FmtType dstType, const ALvoid *src, enum SrcFmtType srcType, ALsizei len);
39 static void ConvertDataIMA4(ALvoid *dst, enum FmtType dstType, const ALvoid *src, ALint chans, ALsizei len);
40
41 #define LookupBuffer(m, k) ((ALbuffer*)LookupUIntMapKey(&(m), (k)))
42
43
44 /*
45 * Global Variables
46 */
47
48 static const long g_IMAStep_size[89]={ // IMA ADPCM Stepsize table
49 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
50 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143,
51 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658,
52 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
53 3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,11487,12635,13899,
54 15289,16818,18500,20350,22358,24633,27086,29794,32767
55 };
56
57 static const long g_IMACodeword_4[16]={ // IMA4 ADPCM Codeword decode table
58 1, 3, 5, 7, 9, 11, 13, 15,
59 -1,-3,-5,-7,-9,-11,-13,-15,
60 };
61
62 static const long g_IMAIndex_adjust_4[16]={ // IMA4 ADPCM Step index adjust decode table
63 -1,-1,-1,-1, 2, 4, 6, 8,
64 -1,-1,-1,-1, 2, 4, 6, 8
65 };
66
67 static const ALshort muLawDecompressionTable[256] = {
68 -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
69 -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
70 -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
71 -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
72 -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
73 -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
74 -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
75 -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
76 -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
77 -1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
78 -876, -844, -812, -780, -748, -716, -684, -652,
79 -620, -588, -556, -524, -492, -460, -428, -396,
80 -372, -356, -340, -324, -308, -292, -276, -260,
81 -244, -228, -212, -196, -180, -164, -148, -132,
82 -120, -112, -104, -96, -88, -80, -72, -64,
83 -56, -48, -40, -32, -24, -16, -8, 0,
84 32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
85 23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
86 15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
87 11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
88 7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
89 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
90 3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
91 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
92 1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
93 1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
94 876, 844, 812, 780, 748, 716, 684, 652,
95 620, 588, 556, 524, 492, 460, 428, 396,
96 372, 356, 340, 324, 308, 292, 276, 260,
97 244, 228, 212, 196, 180, 164, 148, 132,
98 120, 112, 104, 96, 88, 80, 72, 64,
99 56, 48, 40, 32, 24, 16, 8, 0
100 };
101
102 static const int muLawBias = 0x84;
103 static const int muLawClip = 32635;
104
105 static const char muLawCompressTable[256] =
106 {
107 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
108 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
109 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
110 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
111 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
112 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
113 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
114 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
115 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
116 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
117 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
118 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
119 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
120 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
121 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
122 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
123 };
124
125 /*
126 * alGenBuffers(ALsizei n, ALuint *buffers)
127 *
128 * Generates n AL Buffers, and stores the Buffers Names in the array pointed to by buffers
129 */
130 AL_API ALvoid AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
131 {
132 ALCcontext *Context;
133 ALsizei i=0;
134
135 Context = GetContextSuspended();
136 if(!Context) return;
137
138 // Check that we are actually generating some Buffers
139 if(n < 0 || IsBadWritePtr((void*)buffers, n * sizeof(ALuint)))
140 alSetError(Context, AL_INVALID_VALUE);
141 else
142 {
143 ALCdevice *device = Context->Device;
144 ALenum err;
145
146 // Create all the new Buffers
147 while(i < n)
148 {
149 ALbuffer *buffer = calloc(1, sizeof(ALbuffer));
150 if(!buffer)
151 {
152 alSetError(Context, AL_OUT_OF_MEMORY);
153 alDeleteBuffers(i, buffers);
154 break;
155 }
156
157 buffer->buffer = (ALuint)ALTHUNK_ADDENTRY(buffer);
158 err = InsertUIntMapEntry(&device->BufferMap, buffer->buffer, buffer);
159 if(err != AL_NO_ERROR)
160 {
161 ALTHUNK_REMOVEENTRY(buffer->buffer);
162 memset(buffer, 0, sizeof(ALbuffer));
163 free(buffer);
164
165 alSetError(Context, err);
166 alDeleteBuffers(i, buffers);
167 break;
168 }
169 buffers[i++] = buffer->buffer;
170 }
171 }
172
173 ProcessContext(Context);
174 }
175
176 /*
177 * alDeleteBuffers(ALsizei n, ALuint *buffers)
178 *
179 * Deletes the n AL Buffers pointed to by buffers
180 */
181 AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
182 {
183 ALCcontext *Context;
184 ALCdevice *device;
185 ALboolean Failed;
186 ALbuffer *ALBuf;
187 ALsizei i;
188
189 Context = GetContextSuspended();
190 if(!Context) return;
191
192 Failed = AL_TRUE;
193 device = Context->Device;
194 /* Check we are actually Deleting some Buffers */
195 if(n < 0)
196 alSetError(Context, AL_INVALID_VALUE);
197 else
198 {
199 Failed = AL_FALSE;
200
201 /* Check that all the buffers are valid and can actually be deleted */
202 for(i = 0;i < n;i++)
203 {
204 if(!buffers[i])
205 continue;
206
207 /* Check for valid Buffer ID */
208 if((ALBuf=LookupBuffer(device->BufferMap, buffers[i])) == NULL)
209 {
210 alSetError(Context, AL_INVALID_NAME);
211 Failed = AL_TRUE;
212 break;
213 }
214 else if(ALBuf->refcount != 0)
215 {
216 /* Buffer still in use, cannot be deleted */
217 alSetError(Context, AL_INVALID_OPERATION);
218 Failed = AL_TRUE;
219 break;
220 }
221 }
222 }
223
224 /* If all the Buffers were valid (and have Reference Counts of 0), then we can delete them */
225 if(!Failed)
226 {
227 for(i = 0;i < n;i++)
228 {
229 if((ALBuf=LookupBuffer(device->BufferMap, buffers[i])) == NULL)
230 continue;
231
232 /* Release the memory used to store audio data */
233 free(ALBuf->data);
234
235 /* Release buffer structure */
236 RemoveUIntMapKey(&device->BufferMap, ALBuf->buffer);
237 ALTHUNK_REMOVEENTRY(ALBuf->buffer);
238
239 memset(ALBuf, 0, sizeof(ALbuffer));
240 free(ALBuf);
241 }
242 }
243
244 ProcessContext(Context);
245 }
246
247 /*
248 * alIsBuffer(ALuint buffer)
249 *
250 * Checks if buffer is a valid Buffer Name
251 */
252 AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer)
253 {
254 ALCcontext *Context;
255 ALboolean result;
256
257 Context = GetContextSuspended();
258 if(!Context) return AL_FALSE;
259
260 result = ((!buffer || LookupBuffer(Context->Device->BufferMap, buffer)) ?
261 AL_TRUE : AL_FALSE);
262
263 ProcessContext(Context);
264
265 return result;
266 }
267
268 /*
269 * alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
270 *
271 * Fill buffer with audio data
272 */
273 AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
274 {
275 enum SrcFmtChannels SrcChannels;
276 enum SrcFmtType SrcType;
277 ALCcontext *Context;
278 ALCdevice *device;
279 ALbuffer *ALBuf;
280 ALenum err;
281
282 Context = GetContextSuspended();
283 if(!Context) return;
284
285 if(Context->SampleSource)
286 {
287 ALintptrEXT offset;
288
289 if(Context->SampleSource->state == MAPPED)
290 {
291 alSetError(Context, AL_INVALID_OPERATION);
292 ProcessContext(Context);
293 return;
294 }
295
296 offset = (const ALubyte*)data - (ALubyte*)NULL;
297 data = Context->SampleSource->data + offset;
298 }
299
300 device = Context->Device;
301 if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
302 alSetError(Context, AL_INVALID_NAME);
303 else if(ALBuf->refcount != 0)
304 alSetError(Context, AL_INVALID_VALUE);
305 else if(size < 0 || freq < 0)
306 alSetError(Context, AL_INVALID_VALUE);
307 else if(DecomposeInputFormat(format, &SrcChannels, &SrcType) == AL_FALSE)
308 alSetError(Context, AL_INVALID_ENUM);
309 else switch(SrcType)
310 {
311 case SrcFmtByte:
312 case SrcFmtUByte:
313 case SrcFmtShort:
314 case SrcFmtUShort:
315 case SrcFmtInt:
316 case SrcFmtUInt:
317 case SrcFmtFloat:
318 err = LoadData(ALBuf, freq, format, size, SrcChannels, SrcType, data);
319 if(err != AL_NO_ERROR)
320 alSetError(Context, err);
321 break;
322
323 case SrcFmtDouble: {
324 ALenum NewFormat = AL_FORMAT_MONO_FLOAT32;
325 switch(SrcChannels)
326 {
327 case SrcFmtMono: NewFormat = AL_FORMAT_MONO_FLOAT32; break;
328 case SrcFmtStereo: NewFormat = AL_FORMAT_STEREO_FLOAT32; break;
329 case SrcFmtRear: NewFormat = AL_FORMAT_REAR32; break;
330 case SrcFmtQuad: NewFormat = AL_FORMAT_QUAD32; break;
331 case SrcFmtX51: NewFormat = AL_FORMAT_51CHN32; break;
332 case SrcFmtX61: NewFormat = AL_FORMAT_61CHN32; break;
333 case SrcFmtX71: NewFormat = AL_FORMAT_71CHN32; break;
334 }
335 err = LoadData(ALBuf, freq, NewFormat, size, SrcChannels, SrcType, data);
336 if(err != AL_NO_ERROR)
337 alSetError(Context, err);
338 } break;
339
340 case SrcFmtMulaw:
341 case SrcFmtIMA4: {
342 ALenum NewFormat = AL_FORMAT_MONO16;
343 switch(SrcChannels)
344 {
345 case SrcFmtMono: NewFormat = AL_FORMAT_MONO16; break;
346 case SrcFmtStereo: NewFormat = AL_FORMAT_STEREO16; break;
347 case SrcFmtRear: NewFormat = AL_FORMAT_REAR16; break;
348 case SrcFmtQuad: NewFormat = AL_FORMAT_QUAD16; break;
349 case SrcFmtX51: NewFormat = AL_FORMAT_51CHN16; break;
350 case SrcFmtX61: NewFormat = AL_FORMAT_61CHN16; break;
351 case SrcFmtX71: NewFormat = AL_FORMAT_71CHN16; break;
352 }
353 err = LoadData(ALBuf, freq, NewFormat, size, SrcChannels, SrcType, data);
354 if(err != AL_NO_ERROR)
355 alSetError(Context, err);
356 } break;
357 }
358
359 ProcessContext(Context);
360 }
361
362 /*
363 * alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
364 *
365 * Update buffer's audio data
366 */
367 AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
368 {
369 enum SrcFmtChannels SrcChannels;
370 enum SrcFmtType SrcType;
371 ALCcontext *Context;
372 ALCdevice *device;
373 ALbuffer *ALBuf;
374
375 Context = GetContextSuspended();
376 if(!Context) return;
377
378 if(Context->SampleSource)
379 {
380 ALintptrEXT offset;
381
382 if(Context->SampleSource->state == MAPPED)
383 {
384 alSetError(Context, AL_INVALID_OPERATION);
385 ProcessContext(Context);
386 return;
387 }
388
389 offset = (const ALubyte*)data - (ALubyte*)NULL;
390 data = Context->SampleSource->data + offset;
391 }
392
393 device = Context->Device;
394 if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
395 alSetError(Context, AL_INVALID_NAME);
396 else if(length < 0 || offset < 0 || (length > 0 && data == NULL))
397 alSetError(Context, AL_INVALID_VALUE);
398 else if(DecomposeInputFormat(format, &SrcChannels, &SrcType) == AL_FALSE ||
399 SrcChannels != ALBuf->OriginalChannels ||
400 SrcType != ALBuf->OriginalType)
401 alSetError(Context, AL_INVALID_ENUM);
402 else if(offset > ALBuf->OriginalSize ||
403 length > ALBuf->OriginalSize-offset ||
404 (offset%ALBuf->OriginalAlign) != 0 ||
405 (length%ALBuf->OriginalAlign) != 0)
406 alSetError(Context, AL_INVALID_VALUE);
407 else
408 {
409 if(SrcType == SrcFmtIMA4)
410 {
411 ALuint Channels = ChannelsFromFmt(ALBuf->FmtChannels);
412 ALuint Bytes = BytesFromFmt(ALBuf->FmtType);
413
414 /* offset -> byte offset, length -> block count */
415 offset /= 36;
416 offset *= 65;
417 offset *= Bytes;
418 length /= ALBuf->OriginalAlign;
419
420 ConvertDataIMA4(&((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
421 data, Channels, length);
422 }
423 else
424 {
425 ALuint OldBytes = BytesFromFmt(SrcType);
426 ALuint Bytes = BytesFromFmt(ALBuf->FmtType);
427
428 offset /= OldBytes;
429 offset *= Bytes;
430 length /= OldBytes;
431
432 ConvertData(&((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
433 data, SrcType, length);
434 }
435 }
436
437 ProcessContext(Context);
438 }
439
440 AL_API ALvoid AL_APIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
441 {
442 alBufferSubDataSOFT(buffer, format, data, offset, length);
443 }
444
445
446 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
447 {
448 ALCcontext *pContext;
449 ALCdevice *device;
450
451 (void)flValue;
452
453 pContext = GetContextSuspended();
454 if(!pContext) return;
455
456 device = pContext->Device;
457 if(LookupBuffer(device->BufferMap, buffer) == NULL)
458 alSetError(pContext, AL_INVALID_NAME);
459 else
460 {
461 switch(eParam)
462 {
463 default:
464 alSetError(pContext, AL_INVALID_ENUM);
465 break;
466 }
467 }
468
469 ProcessContext(pContext);
470 }
471
472
473 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
474 {
475 ALCcontext *pContext;
476 ALCdevice *device;
477
478 (void)flValue1;
479 (void)flValue2;
480 (void)flValue3;
481
482 pContext = GetContextSuspended();
483 if(!pContext) return;
484
485 device = pContext->Device;
486 if(LookupBuffer(device->BufferMap, buffer) == NULL)
487 alSetError(pContext, AL_INVALID_NAME);
488 else
489 {
490 switch(eParam)
491 {
492 default:
493 alSetError(pContext, AL_INVALID_ENUM);
494 break;
495 }
496 }
497
498 ProcessContext(pContext);
499 }
500
501
502 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
503 {
504 ALCcontext *pContext;
505 ALCdevice *device;
506
507 pContext = GetContextSuspended();
508 if(!pContext) return;
509
510 device = pContext->Device;
511 if(!flValues)
512 alSetError(pContext, AL_INVALID_VALUE);
513 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
514 alSetError(pContext, AL_INVALID_NAME);
515 else
516 {
517 switch(eParam)
518 {
519 default:
520 alSetError(pContext, AL_INVALID_ENUM);
521 break;
522 }
523 }
524
525 ProcessContext(pContext);
526 }
527
528
529 AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
530 {
531 ALCcontext *pContext;
532 ALCdevice *device;
533
534 (void)lValue;
535
536 pContext = GetContextSuspended();
537 if(!pContext) return;
538
539 device = pContext->Device;
540 if(LookupBuffer(device->BufferMap, buffer) == NULL)
541 alSetError(pContext, AL_INVALID_NAME);
542 else
543 {
544 switch(eParam)
545 {
546 default:
547 alSetError(pContext, AL_INVALID_ENUM);
548 break;
549 }
550 }
551
552 ProcessContext(pContext);
553 }
554
555
556 AL_API void AL_APIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
557 {
558 ALCcontext *pContext;
559 ALCdevice *device;
560
561 (void)lValue1;
562 (void)lValue2;
563 (void)lValue3;
564
565 pContext = GetContextSuspended();
566 if(!pContext) return;
567
568 device = pContext->Device;
569 if(LookupBuffer(device->BufferMap, buffer) == NULL)
570 alSetError(pContext, AL_INVALID_NAME);
571 else
572 {
573 switch(eParam)
574 {
575 default:
576 alSetError(pContext, AL_INVALID_ENUM);
577 break;
578 }
579 }
580
581 ProcessContext(pContext);
582 }
583
584
585 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
586 {
587 ALCcontext *pContext;
588 ALCdevice *device;
589 ALbuffer *ALBuf;
590
591 pContext = GetContextSuspended();
592 if(!pContext) return;
593
594 device = pContext->Device;
595 if(!plValues)
596 alSetError(pContext, AL_INVALID_VALUE);
597 else if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
598 alSetError(pContext, AL_INVALID_NAME);
599 else
600 {
601 switch(eParam)
602 {
603 case AL_LOOP_POINTS:
604 if(ALBuf->refcount > 0)
605 alSetError(pContext, AL_INVALID_OPERATION);
606 else if(plValues[0] < 0 || plValues[1] < 0 ||
607 plValues[0] >= plValues[1] || ALBuf->size == 0)
608 alSetError(pContext, AL_INVALID_VALUE);
609 else
610 {
611 ALint maxlen = ALBuf->size /
612 FrameSizeFromFmt(ALBuf->FmtChannels, ALBuf->FmtType);
613 if(plValues[0] > maxlen || plValues[1] > maxlen)
614 alSetError(pContext, AL_INVALID_VALUE);
615 else
616 {
617 ALBuf->LoopStart = plValues[0];
618 ALBuf->LoopEnd = plValues[1];
619 }
620 }
621 break;
622
623 default:
624 alSetError(pContext, AL_INVALID_ENUM);
625 break;
626 }
627 }
628
629 ProcessContext(pContext);
630 }
631
632
633 AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
634 {
635 ALCcontext *pContext;
636 ALCdevice *device;
637
638 pContext = GetContextSuspended();
639 if(!pContext) return;
640
641 device = pContext->Device;
642 if(!pflValue)
643 alSetError(pContext, AL_INVALID_VALUE);
644 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
645 alSetError(pContext, AL_INVALID_NAME);
646 else
647 {
648 switch(eParam)
649 {
650 default:
651 alSetError(pContext, AL_INVALID_ENUM);
652 break;
653 }
654 }
655
656 ProcessContext(pContext);
657 }
658
659
660 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
661 {
662 ALCcontext *pContext;
663 ALCdevice *device;
664
665 pContext = GetContextSuspended();
666 if(!pContext) return;
667
668 device = pContext->Device;
669 if(!pflValue1 || !pflValue2 || !pflValue3)
670 alSetError(pContext, AL_INVALID_VALUE);
671 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
672 alSetError(pContext, AL_INVALID_NAME);
673 else
674 {
675 switch(eParam)
676 {
677 default:
678 alSetError(pContext, AL_INVALID_ENUM);
679 break;
680 }
681 }
682
683 ProcessContext(pContext);
684 }
685
686
687 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
688 {
689 ALCcontext *pContext;
690 ALCdevice *device;
691
692 pContext = GetContextSuspended();
693 if(!pContext) return;
694
695 device = pContext->Device;
696 if(!pflValues)
697 alSetError(pContext, AL_INVALID_VALUE);
698 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
699 alSetError(pContext, AL_INVALID_NAME);
700 else
701 {
702 switch(eParam)
703 {
704 default:
705 alSetError(pContext, AL_INVALID_ENUM);
706 break;
707 }
708 }
709
710 ProcessContext(pContext);
711 }
712
713
714 AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
715 {
716 ALCcontext *pContext;
717 ALbuffer *pBuffer;
718 ALCdevice *device;
719
720 pContext = GetContextSuspended();
721 if(!pContext) return;
722
723 device = pContext->Device;
724 if(!plValue)
725 alSetError(pContext, AL_INVALID_VALUE);
726 else if((pBuffer=LookupBuffer(device->BufferMap, buffer)) == NULL)
727 alSetError(pContext, AL_INVALID_NAME);
728 else
729 {
730 switch(eParam)
731 {
732 case AL_FREQUENCY:
733 *plValue = pBuffer->Frequency;
734 break;
735
736 case AL_BITS:
737 *plValue = BytesFromFmt(pBuffer->FmtType) * 8;
738 break;
739
740 case AL_CHANNELS:
741 *plValue = ChannelsFromFmt(pBuffer->FmtChannels);
742 break;
743
744 case AL_SIZE:
745 *plValue = pBuffer->size;
746 break;
747
748 default:
749 alSetError(pContext, AL_INVALID_ENUM);
750 break;
751 }
752 }
753
754 ProcessContext(pContext);
755 }
756
757
758 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
759 {
760 ALCcontext *pContext;
761 ALCdevice *device;
762
763 pContext = GetContextSuspended();
764 if(!pContext) return;
765
766 device = pContext->Device;
767 if(!plValue1 || !plValue2 || !plValue3)
768 alSetError(pContext, AL_INVALID_VALUE);
769 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
770 alSetError(pContext, AL_INVALID_NAME);
771 else
772 {
773 switch(eParam)
774 {
775 default:
776 alSetError(pContext, AL_INVALID_ENUM);
777 break;
778 }
779 }
780
781 ProcessContext(pContext);
782 }
783
784
785 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
786 {
787 ALCcontext *pContext;
788 ALCdevice *device;
789 ALbuffer *ALBuf;
790
791 pContext = GetContextSuspended();
792 if(!pContext) return;
793
794 device = pContext->Device;
795 if(!plValues)
796 alSetError(pContext, AL_INVALID_VALUE);
797 else if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
798 alSetError(pContext, AL_INVALID_NAME);
799 else
800 {
801 switch(eParam)
802 {
803 case AL_FREQUENCY:
804 case AL_BITS:
805 case AL_CHANNELS:
806 case AL_SIZE:
807 alGetBufferi(buffer, eParam, plValues);
808 break;
809
810 case AL_LOOP_POINTS:
811 plValues[0] = ALBuf->LoopStart;
812 plValues[1] = ALBuf->LoopEnd;
813 break;
814
815 default:
816 alSetError(pContext, AL_INVALID_ENUM);
817 break;
818 }
819 }
820
821 ProcessContext(pContext);
822 }
823
824
825 typedef ALubyte ALmulaw;
826
827 static __inline ALshort DecodeMuLaw(ALmulaw val)
828 { return muLawDecompressionTable[val]; }
829
830 static ALmulaw EncodeMuLaw(ALshort val)
831 {
832 ALint mant, exp, sign;
833
834 sign = (val>>8) & 0x80;
835 if(sign) val = (ALshort)-val;
836
837 val = min(val, muLawClip);
838 val += muLawBias;
839
840 exp = muLawCompressTable[(val>>7) & 0xff];
841 mant = (val >> (exp+3)) & 0x0f;
842
843 return ~(sign | (exp<<4) | mant);
844 }
845
846 static void DecodeIMA4Block(ALshort *dst, const ALubyte *IMAData, ALint numchans)
847 {
848 ALint Sample[2],Index[2];
849 ALuint IMACode[2];
850 ALsizei j,k,c;
851
852 for(c = 0;c < numchans;c++)
853 {
854 Sample[c] = *(IMAData++);
855 Sample[c] |= *(IMAData++) << 8;
856 Sample[c] = (Sample[c]^0x8000) - 32768;
857 Index[c] = *(IMAData++);
858 Index[c] |= *(IMAData++) << 8;
859 Index[c] = (Index[c]^0x8000) - 32768;
860
861 Index[c] = ((Index[c]<0) ? 0 : Index[c]);
862 Index[c] = ((Index[c]>88) ? 88 : Index[c]);
863
864 dst[c] = Sample[c];
865 }
866
867 j = 1;
868 while(j < 65)
869 {
870 for(c = 0;c < numchans;c++)
871 {
872 IMACode[c] = *(IMAData++);
873 IMACode[c] |= *(IMAData++) << 8;
874 IMACode[c] |= *(IMAData++) << 16;
875 IMACode[c] |= *(IMAData++) << 24;
876 }
877
878 for(k = 0;k < 8;k++,j++)
879 {
880 for(c = 0;c < numchans;c++)
881 {
882 Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
883 Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
884
885 if(Sample[c] < -32768) Sample[c] = -32768;
886 else if(Sample[c] > 32767) Sample[c] = 32767;
887
888 if(Index[c]<0) Index[c] = 0;
889 else if(Index[c]>88) Index[c] = 88;
890
891 dst[(j+k)*numchans + c] = Sample[c];
892 IMACode[c] >>= 4;
893 }
894 }
895 }
896 }
897
898
899 static __inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
900 { return val; }
901 static __inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
902 { return val^0x80; }
903 static __inline ALbyte Conv_ALbyte_ALshort(ALshort val)
904 { return val>>8; }
905 static __inline ALbyte Conv_ALbyte_ALushort(ALushort val)
906 { return (val>>8)-128; }
907 static __inline ALbyte Conv_ALbyte_ALint(ALint val)
908 { return val>>24; }
909 static __inline ALbyte Conv_ALbyte_ALuint(ALuint val)
910 { return (val>>24)-128; }
911 static __inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
912 {
913 if(val >= 1.0f) return 127;
914 if(val <= -1.0f) return -128;
915 return (ALint)(val * 127.0f);
916 }
917 static __inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
918 {
919 if(val >= 1.0) return 127;
920 if(val <= -1.0) return -128;
921 return (ALint)(val * 127.0);
922 }
923 static __inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
924 { return Conv_ALbyte_ALshort(DecodeMuLaw(val)); }
925
926 static __inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
927 { return val^0x80; }
928 static __inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
929 { return val; }
930 static __inline ALubyte Conv_ALubyte_ALshort(ALshort val)
931 { return (val>>8)+128; }
932 static __inline ALubyte Conv_ALubyte_ALushort(ALushort val)
933 { return val>>8; }
934 static __inline ALubyte Conv_ALubyte_ALint(ALint val)
935 { return (val>>24)+128; }
936 static __inline ALubyte Conv_ALubyte_ALuint(ALuint val)
937 { return val>>24; }
938 static __inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
939 {
940 if(val >= 1.0f) return 255;
941 if(val <= -1.0f) return 0;
942 return (ALint)(val * 127.0f) + 128;
943 }
944 static __inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
945 {
946 if(val >= 1.0) return 255;
947 if(val <= -1.0) return 0;
948 return (ALint)(val * 127.0) + 128;
949 }
950 static __inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
951 { return Conv_ALubyte_ALshort(DecodeMuLaw(val)); }
952
953 static __inline ALshort Conv_ALshort_ALbyte(ALbyte val)
954 { return val<<8; }
955 static __inline ALshort Conv_ALshort_ALubyte(ALubyte val)
956 { return (val-128)<<8; }
957 static __inline ALshort Conv_ALshort_ALshort(ALshort val)
958 { return val; }
959 static __inline ALshort Conv_ALshort_ALushort(ALushort val)
960 { return val^0x8000; }
961 static __inline ALshort Conv_ALshort_ALint(ALint val)
962 { return val>>16; }
963 static __inline ALshort Conv_ALshort_ALuint(ALuint val)
964 { return (val>>16)-32768; }
965 static __inline ALshort Conv_ALshort_ALfloat(ALfloat val)
966 {
967 if(val >= 1.0f) return 32767;
968 if(val <= -1.0f) return -32768;
969 return (ALint)(val * 32767.0f);
970 }
971 static __inline ALshort Conv_ALshort_ALdouble(ALdouble val)
972 {
973 if(val >= 1.0) return 32767;
974 if(val <= -1.0) return -32768;
975 return (ALint)(val * 32767.0);
976 }
977 static __inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
978 { return Conv_ALshort_ALshort(DecodeMuLaw(val)); }
979
980 static __inline ALushort Conv_ALushort_ALbyte(ALbyte val)
981 { return (val+128)<<8; }
982 static __inline ALushort Conv_ALushort_ALubyte(ALubyte val)
983 { return val<<8; }
984 static __inline ALushort Conv_ALushort_ALshort(ALshort val)
985 { return val^0x8000; }
986 static __inline ALushort Conv_ALushort_ALushort(ALushort val)
987 { return val; }
988 static __inline ALushort Conv_ALushort_ALint(ALint val)
989 { return (val>>16)+32768; }
990 static __inline ALushort Conv_ALushort_ALuint(ALuint val)
991 { return val>>16; }
992 static __inline ALushort Conv_ALushort_ALfloat(ALfloat val)
993 {
994 if(val >= 1.0f) return 65535;
995 if(val <= -1.0f) return 0;
996 return (ALint)(val * 32767.0f) + 32768;
997 }
998 static __inline ALushort Conv_ALushort_ALdouble(ALdouble val)
999 {
1000 if(val >= 1.0) return 65535;
1001 if(val <= -1.0) return 0;
1002 return (ALint)(val * 32767.0) + 32768;
1003 }
1004 static __inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
1005 { return Conv_ALushort_ALshort(DecodeMuLaw(val)); }
1006
1007 static __inline ALint Conv_ALint_ALbyte(ALbyte val)
1008 { return val<<24; }
1009 static __inline ALint Conv_ALint_ALubyte(ALubyte val)
1010 { return (val-128)<<24; }
1011 static __inline ALint Conv_ALint_ALshort(ALshort val)
1012 { return val<<16; }
1013 static __inline ALint Conv_ALint_ALushort(ALushort val)
1014 { return (val-32768)<<16; }
1015 static __inline ALint Conv_ALint_ALint(ALint val)
1016 { return val; }
1017 static __inline ALint Conv_ALint_ALuint(ALuint val)
1018 { return val-2147483648u; }
1019 static __inline ALint Conv_ALint_ALfloat(ALfloat val)
1020 {
1021 if(val >= 1.0f) return 2147483647;
1022 if(val <= -1.0f) return -2147483648u;
1023 return (ALint)(val * 2147483647.0);
1024 }
1025 static __inline ALint Conv_ALint_ALdouble(ALdouble val)
1026 {
1027 if(val >= 1.0) return 2147483647;
1028 if(val <= -1.0) return -2147483648u;
1029 return (ALint)(val * 2147483647.0);
1030 }
1031 static __inline ALint Conv_ALint_ALmulaw(ALmulaw val)
1032 { return Conv_ALint_ALshort(DecodeMuLaw(val)); }
1033
1034 static __inline ALuint Conv_ALuint_ALbyte(ALbyte val)
1035 { return (val+128)<<24; }
1036 static __inline ALuint Conv_ALuint_ALubyte(ALubyte val)
1037 { return val<<24; }
1038 static __inline ALuint Conv_ALuint_ALshort(ALshort val)
1039 { return (val+32768)<<16; }
1040 static __inline ALuint Conv_ALuint_ALushort(ALushort val)
1041 { return val<<16; }
1042 static __inline ALuint Conv_ALuint_ALint(ALint val)
1043 { return val+2147483648u; }
1044 static __inline ALuint Conv_ALuint_ALuint(ALuint val)
1045 { return val; }
1046 static __inline ALuint Conv_ALuint_ALfloat(ALfloat val)
1047 {
1048 if(val >= 1.0f) return 4294967295u;
1049 if(val <= -1.0f) return 0;
1050 return (ALint)(val * 2147483647.0) + 2147483648u;
1051 }
1052 static __inline ALuint Conv_ALuint_ALdouble(ALdouble val)
1053 {
1054 if(val >= 1.0) return 4294967295u;
1055 if(val <= -1.0) return 0;
1056 return (ALint)(val * 2147483647.0) + 2147483648u;
1057 }
1058 static __inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
1059 { return Conv_ALuint_ALshort(DecodeMuLaw(val)); }
1060
1061 static __inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
1062 { return val * (1.0f/127.0f); }
1063 static __inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
1064 { return (val-128) * (1.0f/127.0f); }
1065 static __inline ALfloat Conv_ALfloat_ALshort(ALshort val)
1066 { return val * (1.0f/32767.0f); }
1067 static __inline ALfloat Conv_ALfloat_ALushort(ALushort val)
1068 { return (val-32768) * (1.0f/32767.0f); }
1069 static __inline ALfloat Conv_ALfloat_ALint(ALint val)
1070 { return val * (1.0/2147483647.0); }
1071 static __inline ALfloat Conv_ALfloat_ALuint(ALuint val)
1072 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1073 static __inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
1074 { return val; }
1075 static __inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
1076 { return val; }
1077 static __inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
1078 { return Conv_ALfloat_ALshort(DecodeMuLaw(val)); }
1079
1080 static __inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
1081 { return val * (1.0/127.0); }
1082 static __inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
1083 { return (val-128) * (1.0/127.0); }
1084 static __inline ALdouble Conv_ALdouble_ALshort(ALshort val)
1085 { return val * (1.0/32767.0); }
1086 static __inline ALdouble Conv_ALdouble_ALushort(ALushort val)
1087 { return (val-32768) * (1.0/32767.0); }
1088 static __inline ALdouble Conv_ALdouble_ALint(ALint val)
1089 { return val * (1.0/2147483647.0); }
1090 static __inline ALdouble Conv_ALdouble_ALuint(ALuint val)
1091 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1092 static __inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
1093 { return val; }
1094 static __inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
1095 { return val; }
1096 static __inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
1097 { return Conv_ALdouble_ALshort(DecodeMuLaw(val)); }
1098
1099 #define DECL_TEMPLATE(T) \
1100 static ALmulaw Conv_ALmulaw_##T(T val) \
1101 { return EncodeMuLaw(Conv_ALshort_##T(val)); }
1102
1103 DECL_TEMPLATE(ALbyte)
1104 DECL_TEMPLATE(ALubyte)
1105 DECL_TEMPLATE(ALshort)
1106 DECL_TEMPLATE(ALushort)
1107 DECL_TEMPLATE(ALint)
1108 DECL_TEMPLATE(ALuint)
1109 DECL_TEMPLATE(ALfloat)
1110 DECL_TEMPLATE(ALdouble)
1111 DECL_TEMPLATE(ALmulaw)
1112
1113 #undef DECL_TEMPLATE
1114
1115 #define DECL_TEMPLATE(T1, T2) \
1116 static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint len) \
1117 { \
1118 ALuint i; \
1119 for(i = 0;i < len;i++) \
1120 *(dst++) = Conv_##T1##_##T2(*(src++)); \
1121 }
1122
1123 DECL_TEMPLATE(ALbyte, ALbyte)
1124 DECL_TEMPLATE(ALbyte, ALubyte)
1125 DECL_TEMPLATE(ALbyte, ALshort)
1126 DECL_TEMPLATE(ALbyte, ALushort)
1127 DECL_TEMPLATE(ALbyte, ALint)
1128 DECL_TEMPLATE(ALbyte, ALuint)
1129 DECL_TEMPLATE(ALbyte, ALfloat)
1130 DECL_TEMPLATE(ALbyte, ALdouble)
1131 DECL_TEMPLATE(ALbyte, ALmulaw)
1132
1133 DECL_TEMPLATE(ALubyte, ALbyte)
1134 DECL_TEMPLATE(ALubyte, ALubyte)
1135 DECL_TEMPLATE(ALubyte, ALshort)
1136 DECL_TEMPLATE(ALubyte, ALushort)
1137 DECL_TEMPLATE(ALubyte, ALint)
1138 DECL_TEMPLATE(ALubyte, ALuint)
1139 DECL_TEMPLATE(ALubyte, ALfloat)
1140 DECL_TEMPLATE(ALubyte, ALdouble)
1141 DECL_TEMPLATE(ALubyte, ALmulaw)
1142
1143 DECL_TEMPLATE(ALshort, ALbyte)
1144 DECL_TEMPLATE(ALshort, ALubyte)
1145 DECL_TEMPLATE(ALshort, ALshort)
1146 DECL_TEMPLATE(ALshort, ALushort)
1147 DECL_TEMPLATE(ALshort, ALint)
1148 DECL_TEMPLATE(ALshort, ALuint)
1149 DECL_TEMPLATE(ALshort, ALfloat)
1150 DECL_TEMPLATE(ALshort, ALdouble)
1151 DECL_TEMPLATE(ALshort, ALmulaw)
1152
1153 DECL_TEMPLATE(ALushort, ALbyte)
1154 DECL_TEMPLATE(ALushort, ALubyte)
1155 DECL_TEMPLATE(ALushort, ALshort)
1156 DECL_TEMPLATE(ALushort, ALushort)
1157 DECL_TEMPLATE(ALushort, ALint)
1158 DECL_TEMPLATE(ALushort, ALuint)
1159 DECL_TEMPLATE(ALushort, ALfloat)
1160 DECL_TEMPLATE(ALushort, ALdouble)
1161 DECL_TEMPLATE(ALushort, ALmulaw)
1162
1163 DECL_TEMPLATE(ALint, ALbyte)
1164 DECL_TEMPLATE(ALint, ALubyte)
1165 DECL_TEMPLATE(ALint, ALshort)
1166 DECL_TEMPLATE(ALint, ALushort)
1167 DECL_TEMPLATE(ALint, ALint)
1168 DECL_TEMPLATE(ALint, ALuint)
1169 DECL_TEMPLATE(ALint, ALfloat)
1170 DECL_TEMPLATE(ALint, ALdouble)
1171 DECL_TEMPLATE(ALint, ALmulaw)
1172
1173 DECL_TEMPLATE(ALuint, ALbyte)
1174 DECL_TEMPLATE(ALuint, ALubyte)
1175 DECL_TEMPLATE(ALuint, ALshort)
1176 DECL_TEMPLATE(ALuint, ALushort)
1177 DECL_TEMPLATE(ALuint, ALint)
1178 DECL_TEMPLATE(ALuint, ALuint)
1179 DECL_TEMPLATE(ALuint, ALfloat)
1180 DECL_TEMPLATE(ALuint, ALdouble)
1181 DECL_TEMPLATE(ALuint, ALmulaw)
1182
1183 DECL_TEMPLATE(ALfloat, ALbyte)
1184 DECL_TEMPLATE(ALfloat, ALubyte)
1185 DECL_TEMPLATE(ALfloat, ALshort)
1186 DECL_TEMPLATE(ALfloat, ALushort)
1187 DECL_TEMPLATE(ALfloat, ALint)
1188 DECL_TEMPLATE(ALfloat, ALuint)
1189 DECL_TEMPLATE(ALfloat, ALfloat)
1190 DECL_TEMPLATE(ALfloat, ALdouble)
1191 DECL_TEMPLATE(ALfloat, ALmulaw)
1192
1193 DECL_TEMPLATE(ALdouble, ALbyte)
1194 DECL_TEMPLATE(ALdouble, ALubyte)
1195 DECL_TEMPLATE(ALdouble, ALshort)
1196 DECL_TEMPLATE(ALdouble, ALushort)
1197 DECL_TEMPLATE(ALdouble, ALint)
1198 DECL_TEMPLATE(ALdouble, ALuint)
1199 DECL_TEMPLATE(ALdouble, ALfloat)
1200 DECL_TEMPLATE(ALdouble, ALdouble)
1201 DECL_TEMPLATE(ALdouble, ALmulaw)
1202
1203 DECL_TEMPLATE(ALmulaw, ALbyte)
1204 DECL_TEMPLATE(ALmulaw, ALubyte)
1205 DECL_TEMPLATE(ALmulaw, ALshort)
1206 DECL_TEMPLATE(ALmulaw, ALushort)
1207 DECL_TEMPLATE(ALmulaw, ALint)
1208 DECL_TEMPLATE(ALmulaw, ALuint)
1209 DECL_TEMPLATE(ALmulaw, ALfloat)
1210 DECL_TEMPLATE(ALmulaw, ALdouble)
1211 DECL_TEMPLATE(ALmulaw, ALmulaw)
1212
1213 #undef DECL_TEMPLATE
1214
1215 #define DECL_TEMPLATE(T) \
1216 static void Convert_##T##_IMA4(T *dst, const ALubyte *src, ALuint numchans, \
1217 ALuint numblocks) \
1218 { \
1219 ALshort tmp[65*2]; /* Max samples an IMA4 frame can be */ \
1220 ALuint i, j; \
1221 for(i = 0;i < numblocks;i++) \
1222 { \
1223 DecodeIMA4Block(tmp, src, numchans); \
1224 src += 36*numchans; \
1225 for(j = 0;j < 65*numchans;j++) \
1226 *(dst++) = Conv_##T##_ALshort(tmp[j]); \
1227 } \
1228 }
1229
1230 DECL_TEMPLATE(ALbyte)
1231 DECL_TEMPLATE(ALubyte)
1232 DECL_TEMPLATE(ALshort)
1233 DECL_TEMPLATE(ALushort)
1234 DECL_TEMPLATE(ALint)
1235 DECL_TEMPLATE(ALuint)
1236 DECL_TEMPLATE(ALfloat)
1237 DECL_TEMPLATE(ALdouble)
1238 DECL_TEMPLATE(ALmulaw)
1239
1240 #undef DECL_TEMPLATE
1241
1242 #define DECL_TEMPLATE(T) \
1243 static void Convert_##T(T *dst, const ALvoid *src, enum SrcFmtType srcType, \
1244 ALsizei len) \
1245 { \
1246 switch(srcType) \
1247 { \
1248 case SrcFmtByte: \
1249 Convert_##T##_ALbyte(dst, src, len); \
1250 break; \
1251 case SrcFmtUByte: \
1252 Convert_##T##_ALubyte(dst, src, len); \
1253 break; \
1254 case SrcFmtShort: \
1255 Convert_##T##_ALshort(dst, src, len); \
1256 break; \
1257 case SrcFmtUShort: \
1258 Convert_##T##_ALushort(dst, src, len); \
1259 break; \
1260 case SrcFmtInt: \
1261 Convert_##T##_ALint(dst, src, len); \
1262 break; \
1263 case SrcFmtUInt: \
1264 Convert_##T##_ALuint(dst, src, len); \
1265 break; \
1266 case SrcFmtFloat: \
1267 Convert_##T##_ALfloat(dst, src, len); \
1268 break; \
1269 case SrcFmtDouble: \
1270 Convert_##T##_ALdouble(dst, src, len); \
1271 break; \
1272 case SrcFmtMulaw: \
1273 Convert_##T##_ALmulaw(dst, src, len); \
1274 break; \
1275 case SrcFmtIMA4: \
1276 break; /* not handled here */ \
1277 } \
1278 }
1279
1280 DECL_TEMPLATE(ALbyte)
1281 DECL_TEMPLATE(ALubyte)
1282 DECL_TEMPLATE(ALshort)
1283 DECL_TEMPLATE(ALushort)
1284 DECL_TEMPLATE(ALint)
1285 DECL_TEMPLATE(ALuint)
1286 DECL_TEMPLATE(ALfloat)
1287 DECL_TEMPLATE(ALdouble)
1288 DECL_TEMPLATE(ALmulaw)
1289
1290 #undef DECL_TEMPLATE
1291
1292
1293 static void ConvertData(ALvoid *dst, enum FmtType dstType, const ALvoid *src, enum SrcFmtType srcType, ALsizei len)
1294 {
1295 switch(dstType)
1296 {
1297 (void)Convert_ALbyte;
1298 case FmtUByte:
1299 Convert_ALubyte(dst, src, srcType, len);
1300 break;
1301 case FmtShort:
1302 Convert_ALshort(dst, src, srcType, len);
1303 break;
1304 (void)Convert_ALushort;
1305 (void)Convert_ALint;
1306 (void)Convert_ALuint;
1307 case FmtFloat:
1308 Convert_ALfloat(dst, src, srcType, len);
1309 break;
1310 (void)Convert_ALdouble;
1311 (void)Convert_ALmulaw;
1312 }
1313 }
1314
1315 static void ConvertDataIMA4(ALvoid *dst, enum FmtType dstType, const ALvoid *src, ALint chans, ALsizei len)
1316 {
1317 switch(dstType)
1318 {
1319 (void)Convert_ALbyte_IMA4;
1320 case FmtUByte:
1321 Convert_ALubyte_IMA4(dst, src, chans, len);
1322 break;
1323 case FmtShort:
1324 Convert_ALshort_IMA4(dst, src, chans, len);
1325 break;
1326 (void)Convert_ALushort_IMA4;
1327 (void)Convert_ALint_IMA4;
1328 (void)Convert_ALuint_IMA4;
1329 case FmtFloat:
1330 Convert_ALfloat_IMA4(dst, src, chans, len);
1331 break;
1332 (void)Convert_ALdouble_IMA4;
1333 (void)Convert_ALmulaw_IMA4;
1334 }
1335 }
1336
1337
1338 /*
1339 * LoadData
1340 *
1341 * Loads the specified data into the buffer, using the specified formats.
1342 * Currently, the new format must have the same channel configuration as the
1343 * original format.
1344 */
1345 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei size, enum SrcFmtChannels SrcChannels, enum SrcFmtType SrcType, const ALvoid *data)
1346 {
1347 ALuint NewChannels, NewBytes;
1348 enum FmtChannels DstChannels;
1349 enum FmtType DstType;
1350 ALuint64 newsize;
1351 ALvoid *temp;
1352
1353 DecomposeFormat(NewFormat, &DstChannels, &DstType);
1354 NewChannels = ChannelsFromFmt(DstChannels);
1355 NewBytes = BytesFromFmt(DstType);
1356
1357 assert(SrcChannels == DstChannels);
1358
1359 if(SrcType == SrcFmtIMA4)
1360 {
1361 ALuint OrigChannels = ChannelsFromSrcFmt(SrcChannels);
1362
1363 /* Here is where things vary:
1364 * nVidia and Apple use 64+1 sample frames per block => block_size=36*chans bytes
1365 * Most PC sound software uses 2040+1 sample frames per block -> block_size=1024*chans bytes
1366 */
1367 if((size%(36*OrigChannels)) != 0)
1368 return AL_INVALID_VALUE;
1369
1370 newsize = size / 36;
1371 newsize *= 65;
1372 newsize *= NewBytes;
1373 if(newsize > INT_MAX)
1374 return AL_OUT_OF_MEMORY;
1375
1376 temp = realloc(ALBuf->data, newsize);
1377 if(!temp) return AL_OUT_OF_MEMORY;
1378 ALBuf->data = temp;
1379 ALBuf->size = newsize;
1380
1381 if(data != NULL)
1382 ConvertDataIMA4(ALBuf->data, DstType, data, OrigChannels,
1383 newsize/(65*NewChannels*NewBytes));
1384
1385 ALBuf->OriginalChannels = SrcChannels;
1386 ALBuf->OriginalType = SrcType;
1387 ALBuf->OriginalSize = size;
1388 ALBuf->OriginalAlign = 36 * OrigChannels;
1389 }
1390 else
1391 {
1392 ALuint OrigBytes = BytesFromSrcFmt(SrcType);
1393 ALuint OrigChannels = ChannelsFromSrcFmt(SrcChannels);
1394
1395 if((size%(OrigBytes*OrigChannels)) != 0)
1396 return AL_INVALID_VALUE;
1397
1398 newsize = size / OrigBytes;
1399 newsize *= NewBytes;
1400 if(newsize > INT_MAX)
1401 return AL_OUT_OF_MEMORY;
1402
1403 temp = realloc(ALBuf->data, newsize);
1404 if(!temp) return AL_OUT_OF_MEMORY;
1405 ALBuf->data = temp;
1406 ALBuf->size = newsize;
1407
1408 if(data != NULL)
1409 ConvertData(ALBuf->data, DstType, data, SrcType, newsize/NewBytes);
1410
1411 ALBuf->OriginalChannels = SrcChannels;
1412 ALBuf->OriginalType = SrcType;
1413 ALBuf->OriginalSize = size;
1414 ALBuf->OriginalAlign = OrigBytes * OrigChannels;
1415 }
1416
1417 ALBuf->Frequency = freq;
1418 ALBuf->FmtChannels = DstChannels;
1419 ALBuf->FmtType = DstType;
1420
1421 ALBuf->LoopStart = 0;
1422 ALBuf->LoopEnd = newsize / NewChannels / NewBytes;
1423
1424 return AL_NO_ERROR;
1425 }
1426
1427
1428 ALuint BytesFromSrcFmt(enum SrcFmtType type)
1429 {
1430 switch(type)
1431 {
1432 case SrcFmtByte: return sizeof(ALbyte);
1433 case SrcFmtUByte: return sizeof(ALubyte);
1434 case SrcFmtShort: return sizeof(ALshort);
1435 case SrcFmtUShort: return sizeof(ALushort);
1436 case SrcFmtInt: return sizeof(ALint);
1437 case SrcFmtUInt: return sizeof(ALuint);
1438 case SrcFmtFloat: return sizeof(ALfloat);
1439 case SrcFmtDouble: return sizeof(ALdouble);
1440 case SrcFmtMulaw: return sizeof(ALubyte);
1441 case SrcFmtIMA4: break; /* not handled here */
1442 }
1443 return 0;
1444 }
1445 ALuint ChannelsFromSrcFmt(enum SrcFmtChannels chans)
1446 {
1447 switch(chans)
1448 {
1449 case SrcFmtMono: return 1;
1450 case SrcFmtStereo: return 2;
1451 case SrcFmtRear: return 2;
1452 case SrcFmtQuad: return 4;
1453 case SrcFmtX51: return 6;
1454 case SrcFmtX61: return 7;
1455 case SrcFmtX71: return 8;
1456 }
1457 return 0;
1458 }
1459 ALboolean DecomposeInputFormat(ALenum format, enum SrcFmtChannels *chans,
1460 enum SrcFmtType *type)
1461 {
1462 switch(format)
1463 {
1464 case AL_FORMAT_MONO8:
1465 *chans = SrcFmtMono;
1466 *type = SrcFmtUByte;
1467 return AL_TRUE;
1468 case AL_FORMAT_MONO16:
1469 *chans = SrcFmtMono;
1470 *type = SrcFmtShort;
1471 return AL_TRUE;
1472 case AL_FORMAT_MONO_FLOAT32:
1473 *chans = SrcFmtMono;
1474 *type = SrcFmtFloat;
1475 return AL_TRUE;
1476 case AL_FORMAT_MONO_DOUBLE_EXT:
1477 *chans = SrcFmtMono;
1478 *type = SrcFmtDouble;
1479 return AL_TRUE;
1480 case AL_FORMAT_MONO_IMA4:
1481 *chans = SrcFmtMono;
1482 *type = SrcFmtIMA4;
1483 return AL_TRUE;
1484 case AL_FORMAT_STEREO8:
1485 *chans = SrcFmtStereo;
1486 *type = SrcFmtUByte;
1487 return AL_TRUE;
1488 case AL_FORMAT_STEREO16:
1489 *chans = SrcFmtStereo;
1490 *type = SrcFmtShort;
1491 return AL_TRUE;
1492 case AL_FORMAT_STEREO_FLOAT32:
1493 *chans = SrcFmtStereo;
1494 *type = SrcFmtFloat;
1495 return AL_TRUE;
1496 case AL_FORMAT_STEREO_DOUBLE_EXT:
1497 *chans = SrcFmtStereo;
1498 *type = SrcFmtDouble;
1499 return AL_TRUE;
1500 case AL_FORMAT_STEREO_IMA4:
1501 *chans = SrcFmtStereo;
1502 *type = SrcFmtIMA4;
1503 return AL_TRUE;
1504 case AL_FORMAT_QUAD8_LOKI:
1505 case AL_FORMAT_QUAD8:
1506 *chans = SrcFmtQuad;
1507 *type = SrcFmtUByte;
1508 return AL_TRUE;
1509 case AL_FORMAT_QUAD16_LOKI:
1510 case AL_FORMAT_QUAD16:
1511 *chans = SrcFmtQuad;
1512 *type = SrcFmtShort;
1513 return AL_TRUE;
1514 case AL_FORMAT_QUAD32:
1515 *chans = SrcFmtQuad;
1516 *type = SrcFmtFloat;
1517 return AL_TRUE;
1518 case AL_FORMAT_REAR8:
1519 *chans = SrcFmtRear;
1520 *type = SrcFmtUByte;
1521 return AL_TRUE;
1522 case AL_FORMAT_REAR16:
1523 *chans = SrcFmtRear;
1524 *type = SrcFmtShort;
1525 return AL_TRUE;
1526 case AL_FORMAT_REAR32:
1527 *chans = SrcFmtRear;
1528 *type = SrcFmtFloat;
1529 return AL_TRUE;
1530 case AL_FORMAT_51CHN8:
1531 *chans = SrcFmtX51;
1532 *type = SrcFmtUByte;
1533 return AL_TRUE;
1534 case AL_FORMAT_51CHN16:
1535 *chans = SrcFmtX51;
1536 *type = SrcFmtShort;
1537 return AL_TRUE;
1538 case AL_FORMAT_51CHN32:
1539 *chans = SrcFmtX51;
1540 *type = SrcFmtFloat;
1541 return AL_TRUE;
1542 case AL_FORMAT_61CHN8:
1543 *chans = SrcFmtX61;
1544 *type = SrcFmtUByte;
1545 return AL_TRUE;
1546 case AL_FORMAT_61CHN16:
1547 *chans = SrcFmtX61;
1548 *type = SrcFmtShort;
1549 return AL_TRUE;
1550 case AL_FORMAT_61CHN32:
1551 *chans = SrcFmtX61;
1552 *type = SrcFmtFloat;
1553 return AL_TRUE;
1554 case AL_FORMAT_71CHN8:
1555 *chans = SrcFmtX71;
1556 *type = SrcFmtUByte;
1557 return AL_TRUE;
1558 case AL_FORMAT_71CHN16:
1559 *chans = SrcFmtX71;
1560 *type = SrcFmtShort;
1561 return AL_TRUE;
1562 case AL_FORMAT_71CHN32:
1563 *chans = SrcFmtX71;
1564 *type = SrcFmtFloat;
1565 return AL_TRUE;
1566 case AL_FORMAT_MONO_MULAW:
1567 *chans = SrcFmtMono;
1568 *type = SrcFmtMulaw;
1569 return AL_TRUE;
1570 case AL_FORMAT_STEREO_MULAW:
1571 *chans = SrcFmtStereo;
1572 *type = SrcFmtMulaw;
1573 return AL_TRUE;
1574 case AL_FORMAT_QUAD_MULAW:
1575 *chans = SrcFmtQuad;
1576 *type = SrcFmtMulaw;
1577 return AL_TRUE;
1578 case AL_FORMAT_REAR_MULAW:
1579 *chans = SrcFmtRear;
1580 *type = SrcFmtMulaw;
1581 return AL_TRUE;
1582 case AL_FORMAT_51CHN_MULAW:
1583 *chans = SrcFmtX51;
1584 *type = SrcFmtMulaw;
1585 return AL_TRUE;
1586 case AL_FORMAT_61CHN_MULAW:
1587 *chans = SrcFmtX61;
1588 *type = SrcFmtMulaw;
1589 return AL_TRUE;
1590 case AL_FORMAT_71CHN_MULAW:
1591 *chans = SrcFmtX71;
1592 *type = SrcFmtMulaw;
1593 return AL_TRUE;
1594 }
1595 return AL_FALSE;
1596 }
1597
1598 ALuint BytesFromFmt(enum FmtType type)
1599 {
1600 switch(type)
1601 {
1602 case FmtUByte: return sizeof(ALubyte);
1603 case FmtShort: return sizeof(ALshort);
1604 case FmtFloat: return sizeof(ALfloat);
1605 }
1606 return 0;
1607 }
1608 ALuint ChannelsFromFmt(enum FmtChannels chans)
1609 {
1610 switch(chans)
1611 {
1612 case FmtMono: return 1;
1613 case FmtStereo: return 2;
1614 case FmtRear: return 2;
1615 case FmtQuad: return 4;
1616 case FmtX51: return 6;
1617 case FmtX61: return 7;
1618 case FmtX71: return 8;
1619 }
1620 return 0;
1621 }
1622 ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
1623 {
1624 switch(format)
1625 {
1626 case AL_FORMAT_MONO8:
1627 *chans = FmtMono;
1628 *type = FmtUByte;
1629 return AL_TRUE;
1630 case AL_FORMAT_MONO16:
1631 *chans = FmtMono;
1632 *type = FmtShort;
1633 return AL_TRUE;
1634 case AL_FORMAT_MONO_FLOAT32:
1635 *chans = FmtMono;
1636 *type = FmtFloat;
1637 return AL_TRUE;
1638 case AL_FORMAT_STEREO8:
1639 *chans = FmtStereo;
1640 *type = FmtUByte;
1641 return AL_TRUE;
1642 case AL_FORMAT_STEREO16:
1643 *chans = FmtStereo;
1644 *type = FmtShort;
1645 return AL_TRUE;
1646 case AL_FORMAT_STEREO_FLOAT32:
1647 *chans = FmtStereo;
1648 *type = FmtFloat;
1649 return AL_TRUE;
1650 case AL_FORMAT_QUAD8_LOKI:
1651 case AL_FORMAT_QUAD8:
1652 *chans = FmtQuad;
1653 *type = FmtUByte;
1654 return AL_TRUE;
1655 case AL_FORMAT_QUAD16_LOKI:
1656 case AL_FORMAT_QUAD16:
1657 *chans = FmtQuad;
1658 *type = FmtShort;
1659 return AL_TRUE;
1660 case AL_FORMAT_QUAD32:
1661 *chans = FmtQuad;
1662 *type = FmtFloat;
1663 return AL_TRUE;
1664 case AL_FORMAT_REAR8:
1665 *chans = FmtRear;
1666 *type = FmtUByte;
1667 return AL_TRUE;
1668 case AL_FORMAT_REAR16:
1669 *chans = FmtRear;
1670 *type = FmtShort;
1671 return AL_TRUE;
1672 case AL_FORMAT_REAR32:
1673 *chans = FmtRear;
1674 *type = FmtFloat;
1675 return AL_TRUE;
1676 case AL_FORMAT_51CHN8:
1677 *chans = FmtX51;
1678 *type = FmtUByte;
1679 return AL_TRUE;
1680 case AL_FORMAT_51CHN16:
1681 *chans = FmtX51;
1682 *type = FmtShort;
1683 return AL_TRUE;
1684 case AL_FORMAT_51CHN32:
1685 *chans = FmtX51;
1686 *type = FmtFloat;
1687 return AL_TRUE;
1688 case AL_FORMAT_61CHN8:
1689 *chans = FmtX61;
1690 *type = FmtUByte;
1691 return AL_TRUE;
1692 case AL_FORMAT_61CHN16:
1693 *chans = FmtX61;
1694 *type = FmtShort;
1695 return AL_TRUE;
1696 case AL_FORMAT_61CHN32:
1697 *chans = FmtX61;
1698 *type = FmtFloat;
1699 return AL_TRUE;
1700 case AL_FORMAT_71CHN8:
1701 *chans = FmtX71;
1702 *type = FmtUByte;
1703 return AL_TRUE;
1704 case AL_FORMAT_71CHN16:
1705 *chans = FmtX71;
1706 *type = FmtShort;
1707 return AL_TRUE;
1708 case AL_FORMAT_71CHN32:
1709 *chans = FmtX71;
1710 *type = FmtFloat;
1711 return AL_TRUE;
1712 }
1713 return AL_FALSE;
1714 }
1715
1716
1717 /*
1718 * ReleaseALBuffers()
1719 *
1720 * INTERNAL FN : Called by alcCloseDevice to destroy any buffers that still exist
1721 */
1722 ALvoid ReleaseALBuffers(ALCdevice *device)
1723 {
1724 ALsizei i;
1725 for(i = 0;i < device->BufferMap.size;i++)
1726 {
1727 ALbuffer *temp = device->BufferMap.array[i].value;
1728 device->BufferMap.array[i].value = NULL;
1729
1730 // Release sample data
1731 free(temp->data);
1732
1733 // Release Buffer structure
1734 ALTHUNK_REMOVEENTRY(temp->buffer);
1735 memset(temp, 0, sizeof(ALbuffer));
1736 free(temp);
1737 }
1738 }
Software OpenAL implementation