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