?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don'f fail if realloc returns NULL for 0 sizes
[openal-soft.git] / OpenAL32 / alBuffer.c
blob3cde56981acf015114b83b02968d9e066a17a74e
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 g_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 g_IMACodeword_4[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 g_IMAIndex_adjust_4[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) val = (ALshort)-val;
842
843 val = min(val, muLawClip);
844 val += muLawBias;
845
846 exp = muLawCompressTable[(val>>7) & 0xff];
847 mant = (val >> (exp+3)) & 0x0f;
848
849 return ~(sign | (exp<<4) | mant);
850 }
851
852 static void DecodeIMA4Block(ALshort *dst, const ALubyte *IMAData, ALint numchans)
853 {
854 ALint Sample[2],Index[2];
855 ALuint IMACode[2];
856 ALsizei j,k,c;
857
858 for(c = 0;c < numchans;c++)
859 {
860 Sample[c] = *(IMAData++);
861 Sample[c] |= *(IMAData++) << 8;
862 Sample[c] = (Sample[c]^0x8000) - 32768;
863 Index[c] = *(IMAData++);
864 Index[c] |= *(IMAData++) << 8;
865 Index[c] = (Index[c]^0x8000) - 32768;
866
867 Index[c] = ((Index[c]<0) ? 0 : Index[c]);
868 Index[c] = ((Index[c]>88) ? 88 : Index[c]);
869
870 dst[c] = Sample[c];
871 }
872
873 j = 1;
874 while(j < 65)
875 {
876 for(c = 0;c < numchans;c++)
877 {
878 IMACode[c] = *(IMAData++);
879 IMACode[c] |= *(IMAData++) << 8;
880 IMACode[c] |= *(IMAData++) << 16;
881 IMACode[c] |= *(IMAData++) << 24;
882 }
883
884 for(k = 0;k < 8;k++,j++)
885 {
886 for(c = 0;c < numchans;c++)
887 {
888 Sample[c] += g_IMAStep_size[Index[c]] *
889 g_IMACodeword_4[IMACode[c]&15] / 8;
890 Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
891
892 if(Sample[c] < -32768) Sample[c] = -32768;
893 else if(Sample[c] > 32767) Sample[c] = 32767;
894
895 if(Index[c] < 0) Index[c] = 0;
896 else if(Index[c] > 88) Index[c] = 88;
897
898 dst[j*numchans + c] = Sample[c];
899 IMACode[c] >>= 4;
900 }
901 }
902 }
903 }
904
905
906 static __inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
907 { return val; }
908 static __inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
909 { return val^0x80; }
910 static __inline ALbyte Conv_ALbyte_ALshort(ALshort val)
911 { return val>>8; }
912 static __inline ALbyte Conv_ALbyte_ALushort(ALushort val)
913 { return (val>>8)-128; }
914 static __inline ALbyte Conv_ALbyte_ALint(ALint val)
915 { return val>>24; }
916 static __inline ALbyte Conv_ALbyte_ALuint(ALuint val)
917 { return (val>>24)-128; }
918 static __inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
919 {
920 if(val >= 1.0f) return 127;
921 if(val <= -1.0f) return -128;
922 return (ALint)(val * 127.0f);
923 }
924 static __inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
925 {
926 if(val >= 1.0) return 127;
927 if(val <= -1.0) return -128;
928 return (ALint)(val * 127.0);
929 }
930 static __inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
931 { return Conv_ALbyte_ALshort(DecodeMuLaw(val)); }
932
933 static __inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
934 { return val^0x80; }
935 static __inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
936 { return val; }
937 static __inline ALubyte Conv_ALubyte_ALshort(ALshort val)
938 { return (val>>8)+128; }
939 static __inline ALubyte Conv_ALubyte_ALushort(ALushort val)
940 { return val>>8; }
941 static __inline ALubyte Conv_ALubyte_ALint(ALint val)
942 { return (val>>24)+128; }
943 static __inline ALubyte Conv_ALubyte_ALuint(ALuint val)
944 { return val>>24; }
945 static __inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
946 {
947 if(val >= 1.0f) return 255;
948 if(val <= -1.0f) return 0;
949 return (ALint)(val * 127.0f) + 128;
950 }
951 static __inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
952 {
953 if(val >= 1.0) return 255;
954 if(val <= -1.0) return 0;
955 return (ALint)(val * 127.0) + 128;
956 }
957 static __inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
958 { return Conv_ALubyte_ALshort(DecodeMuLaw(val)); }
959
960 static __inline ALshort Conv_ALshort_ALbyte(ALbyte val)
961 { return val<<8; }
962 static __inline ALshort Conv_ALshort_ALubyte(ALubyte val)
963 { return (val-128)<<8; }
964 static __inline ALshort Conv_ALshort_ALshort(ALshort val)
965 { return val; }
966 static __inline ALshort Conv_ALshort_ALushort(ALushort val)
967 { return val^0x8000; }
968 static __inline ALshort Conv_ALshort_ALint(ALint val)
969 { return val>>16; }
970 static __inline ALshort Conv_ALshort_ALuint(ALuint val)
971 { return (val>>16)-32768; }
972 static __inline ALshort Conv_ALshort_ALfloat(ALfloat val)
973 {
974 if(val >= 1.0f) return 32767;
975 if(val <= -1.0f) return -32768;
976 return (ALint)(val * 32767.0f);
977 }
978 static __inline ALshort Conv_ALshort_ALdouble(ALdouble val)
979 {
980 if(val >= 1.0) return 32767;
981 if(val <= -1.0) return -32768;
982 return (ALint)(val * 32767.0);
983 }
984 static __inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
985 { return Conv_ALshort_ALshort(DecodeMuLaw(val)); }
986
987 static __inline ALushort Conv_ALushort_ALbyte(ALbyte val)
988 { return (val+128)<<8; }
989 static __inline ALushort Conv_ALushort_ALubyte(ALubyte val)
990 { return val<<8; }
991 static __inline ALushort Conv_ALushort_ALshort(ALshort val)
992 { return val^0x8000; }
993 static __inline ALushort Conv_ALushort_ALushort(ALushort val)
994 { return val; }
995 static __inline ALushort Conv_ALushort_ALint(ALint val)
996 { return (val>>16)+32768; }
997 static __inline ALushort Conv_ALushort_ALuint(ALuint val)
998 { return val>>16; }
999 static __inline ALushort Conv_ALushort_ALfloat(ALfloat val)
1000 {
1001 if(val >= 1.0f) return 65535;
1002 if(val <= -1.0f) return 0;
1003 return (ALint)(val * 32767.0f) + 32768;
1004 }
1005 static __inline ALushort Conv_ALushort_ALdouble(ALdouble val)
1006 {
1007 if(val >= 1.0) return 65535;
1008 if(val <= -1.0) return 0;
1009 return (ALint)(val * 32767.0) + 32768;
1010 }
1011 static __inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
1012 { return Conv_ALushort_ALshort(DecodeMuLaw(val)); }
1013
1014 static __inline ALint Conv_ALint_ALbyte(ALbyte val)
1015 { return val<<24; }
1016 static __inline ALint Conv_ALint_ALubyte(ALubyte val)
1017 { return (val-128)<<24; }
1018 static __inline ALint Conv_ALint_ALshort(ALshort val)
1019 { return val<<16; }
1020 static __inline ALint Conv_ALint_ALushort(ALushort val)
1021 { return (val-32768)<<16; }
1022 static __inline ALint Conv_ALint_ALint(ALint val)
1023 { return val; }
1024 static __inline ALint Conv_ALint_ALuint(ALuint val)
1025 { return val-2147483648u; }
1026 static __inline ALint Conv_ALint_ALfloat(ALfloat val)
1027 {
1028 if(val >= 1.0f) return 2147483647;
1029 if(val <= -1.0f) return -2147483648u;
1030 return (ALint)(val * 2147483647.0);
1031 }
1032 static __inline ALint Conv_ALint_ALdouble(ALdouble val)
1033 {
1034 if(val >= 1.0) return 2147483647;
1035 if(val <= -1.0) return -2147483648u;
1036 return (ALint)(val * 2147483647.0);
1037 }
1038 static __inline ALint Conv_ALint_ALmulaw(ALmulaw val)
1039 { return Conv_ALint_ALshort(DecodeMuLaw(val)); }
1040
1041 static __inline ALuint Conv_ALuint_ALbyte(ALbyte val)
1042 { return (val+128)<<24; }
1043 static __inline ALuint Conv_ALuint_ALubyte(ALubyte val)
1044 { return val<<24; }
1045 static __inline ALuint Conv_ALuint_ALshort(ALshort val)
1046 { return (val+32768)<<16; }
1047 static __inline ALuint Conv_ALuint_ALushort(ALushort val)
1048 { return val<<16; }
1049 static __inline ALuint Conv_ALuint_ALint(ALint val)
1050 { return val+2147483648u; }
1051 static __inline ALuint Conv_ALuint_ALuint(ALuint val)
1052 { return val; }
1053 static __inline ALuint Conv_ALuint_ALfloat(ALfloat val)
1054 {
1055 if(val >= 1.0f) return 4294967295u;
1056 if(val <= -1.0f) return 0;
1057 return (ALint)(val * 2147483647.0) + 2147483648u;
1058 }
1059 static __inline ALuint Conv_ALuint_ALdouble(ALdouble val)
1060 {
1061 if(val >= 1.0) return 4294967295u;
1062 if(val <= -1.0) return 0;
1063 return (ALint)(val * 2147483647.0) + 2147483648u;
1064 }
1065 static __inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
1066 { return Conv_ALuint_ALshort(DecodeMuLaw(val)); }
1067
1068 static __inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
1069 { return val * (1.0f/127.0f); }
1070 static __inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
1071 { return (val-128) * (1.0f/127.0f); }
1072 static __inline ALfloat Conv_ALfloat_ALshort(ALshort val)
1073 { return val * (1.0f/32767.0f); }
1074 static __inline ALfloat Conv_ALfloat_ALushort(ALushort val)
1075 { return (val-32768) * (1.0f/32767.0f); }
1076 static __inline ALfloat Conv_ALfloat_ALint(ALint val)
1077 { return val * (1.0/2147483647.0); }
1078 static __inline ALfloat Conv_ALfloat_ALuint(ALuint val)
1079 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1080 static __inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
1081 { return val; }
1082 static __inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
1083 { return val; }
1084 static __inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
1085 { return Conv_ALfloat_ALshort(DecodeMuLaw(val)); }
1086
1087 static __inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
1088 { return val * (1.0/127.0); }
1089 static __inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
1090 { return (val-128) * (1.0/127.0); }
1091 static __inline ALdouble Conv_ALdouble_ALshort(ALshort val)
1092 { return val * (1.0/32767.0); }
1093 static __inline ALdouble Conv_ALdouble_ALushort(ALushort val)
1094 { return (val-32768) * (1.0/32767.0); }
1095 static __inline ALdouble Conv_ALdouble_ALint(ALint val)
1096 { return val * (1.0/2147483647.0); }
1097 static __inline ALdouble Conv_ALdouble_ALuint(ALuint val)
1098 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1099 static __inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
1100 { return val; }
1101 static __inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
1102 { return val; }
1103 static __inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
1104 { return Conv_ALdouble_ALshort(DecodeMuLaw(val)); }
1105
1106 #define DECL_TEMPLATE(T) \
1107 static __inline ALmulaw Conv_ALmulaw_##T(T val) \
1108 { return EncodeMuLaw(Conv_ALshort_##T(val)); }
1109
1110 DECL_TEMPLATE(ALbyte)
1111 DECL_TEMPLATE(ALubyte)
1112 DECL_TEMPLATE(ALshort)
1113 DECL_TEMPLATE(ALushort)
1114 DECL_TEMPLATE(ALint)
1115 DECL_TEMPLATE(ALuint)
1116 DECL_TEMPLATE(ALfloat)
1117 DECL_TEMPLATE(ALdouble)
1118 DECL_TEMPLATE(ALmulaw)
1119
1120 #undef DECL_TEMPLATE
1121
1122 #define DECL_TEMPLATE(T1, T2) \
1123 static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint len) \
1124 { \
1125 ALuint i; \
1126 for(i = 0;i < len;i++) \
1127 *(dst++) = Conv_##T1##_##T2(*(src++)); \
1128 }
1129
1130 DECL_TEMPLATE(ALbyte, ALbyte)
1131 DECL_TEMPLATE(ALbyte, ALubyte)
1132 DECL_TEMPLATE(ALbyte, ALshort)
1133 DECL_TEMPLATE(ALbyte, ALushort)
1134 DECL_TEMPLATE(ALbyte, ALint)
1135 DECL_TEMPLATE(ALbyte, ALuint)
1136 DECL_TEMPLATE(ALbyte, ALfloat)
1137 DECL_TEMPLATE(ALbyte, ALdouble)
1138 DECL_TEMPLATE(ALbyte, ALmulaw)
1139
1140 DECL_TEMPLATE(ALubyte, ALbyte)
1141 DECL_TEMPLATE(ALubyte, ALubyte)
1142 DECL_TEMPLATE(ALubyte, ALshort)
1143 DECL_TEMPLATE(ALubyte, ALushort)
1144 DECL_TEMPLATE(ALubyte, ALint)
1145 DECL_TEMPLATE(ALubyte, ALuint)
1146 DECL_TEMPLATE(ALubyte, ALfloat)
1147 DECL_TEMPLATE(ALubyte, ALdouble)
1148 DECL_TEMPLATE(ALubyte, ALmulaw)
1149
1150 DECL_TEMPLATE(ALshort, ALbyte)
1151 DECL_TEMPLATE(ALshort, ALubyte)
1152 DECL_TEMPLATE(ALshort, ALshort)
1153 DECL_TEMPLATE(ALshort, ALushort)
1154 DECL_TEMPLATE(ALshort, ALint)
1155 DECL_TEMPLATE(ALshort, ALuint)
1156 DECL_TEMPLATE(ALshort, ALfloat)
1157 DECL_TEMPLATE(ALshort, ALdouble)
1158 DECL_TEMPLATE(ALshort, ALmulaw)
1159
1160 DECL_TEMPLATE(ALushort, ALbyte)
1161 DECL_TEMPLATE(ALushort, ALubyte)
1162 DECL_TEMPLATE(ALushort, ALshort)
1163 DECL_TEMPLATE(ALushort, ALushort)
1164 DECL_TEMPLATE(ALushort, ALint)
1165 DECL_TEMPLATE(ALushort, ALuint)
1166 DECL_TEMPLATE(ALushort, ALfloat)
1167 DECL_TEMPLATE(ALushort, ALdouble)
1168 DECL_TEMPLATE(ALushort, ALmulaw)
1169
1170 DECL_TEMPLATE(ALint, ALbyte)
1171 DECL_TEMPLATE(ALint, ALubyte)
1172 DECL_TEMPLATE(ALint, ALshort)
1173 DECL_TEMPLATE(ALint, ALushort)
1174 DECL_TEMPLATE(ALint, ALint)
1175 DECL_TEMPLATE(ALint, ALuint)
1176 DECL_TEMPLATE(ALint, ALfloat)
1177 DECL_TEMPLATE(ALint, ALdouble)
1178 DECL_TEMPLATE(ALint, ALmulaw)
1179
1180 DECL_TEMPLATE(ALuint, ALbyte)
1181 DECL_TEMPLATE(ALuint, ALubyte)
1182 DECL_TEMPLATE(ALuint, ALshort)
1183 DECL_TEMPLATE(ALuint, ALushort)
1184 DECL_TEMPLATE(ALuint, ALint)
1185 DECL_TEMPLATE(ALuint, ALuint)
1186 DECL_TEMPLATE(ALuint, ALfloat)
1187 DECL_TEMPLATE(ALuint, ALdouble)
1188 DECL_TEMPLATE(ALuint, ALmulaw)
1189
1190 DECL_TEMPLATE(ALfloat, ALbyte)
1191 DECL_TEMPLATE(ALfloat, ALubyte)
1192 DECL_TEMPLATE(ALfloat, ALshort)
1193 DECL_TEMPLATE(ALfloat, ALushort)
1194 DECL_TEMPLATE(ALfloat, ALint)
1195 DECL_TEMPLATE(ALfloat, ALuint)
1196 DECL_TEMPLATE(ALfloat, ALfloat)
1197 DECL_TEMPLATE(ALfloat, ALdouble)
1198 DECL_TEMPLATE(ALfloat, ALmulaw)
1199
1200 DECL_TEMPLATE(ALdouble, ALbyte)
1201 DECL_TEMPLATE(ALdouble, ALubyte)
1202 DECL_TEMPLATE(ALdouble, ALshort)
1203 DECL_TEMPLATE(ALdouble, ALushort)
1204 DECL_TEMPLATE(ALdouble, ALint)
1205 DECL_TEMPLATE(ALdouble, ALuint)
1206 DECL_TEMPLATE(ALdouble, ALfloat)
1207 DECL_TEMPLATE(ALdouble, ALdouble)
1208 DECL_TEMPLATE(ALdouble, ALmulaw)
1209
1210 DECL_TEMPLATE(ALmulaw, ALbyte)
1211 DECL_TEMPLATE(ALmulaw, ALubyte)
1212 DECL_TEMPLATE(ALmulaw, ALshort)
1213 DECL_TEMPLATE(ALmulaw, ALushort)
1214 DECL_TEMPLATE(ALmulaw, ALint)
1215 DECL_TEMPLATE(ALmulaw, ALuint)
1216 DECL_TEMPLATE(ALmulaw, ALfloat)
1217 DECL_TEMPLATE(ALmulaw, ALdouble)
1218 DECL_TEMPLATE(ALmulaw, ALmulaw)
1219
1220 #undef DECL_TEMPLATE
1221
1222 #define DECL_TEMPLATE(T) \
1223 static void Convert_##T##_IMA4(T *dst, const ALubyte *src, ALuint numchans, \
1224 ALuint numblocks) \
1225 { \
1226 ALshort tmp[65*2]; /* Max samples an IMA4 frame can be */ \
1227 ALuint i, j; \
1228 for(i = 0;i < numblocks;i++) \
1229 { \
1230 DecodeIMA4Block(tmp, src, numchans); \
1231 src += 36*numchans; \
1232 for(j = 0;j < 65*numchans;j++) \
1233 *(dst++) = Conv_##T##_ALshort(tmp[j]); \
1234 } \
1235 }
1236
1237 DECL_TEMPLATE(ALbyte)
1238 DECL_TEMPLATE(ALubyte)
1239 DECL_TEMPLATE(ALshort)
1240 DECL_TEMPLATE(ALushort)
1241 DECL_TEMPLATE(ALint)
1242 DECL_TEMPLATE(ALuint)
1243 DECL_TEMPLATE(ALfloat)
1244 DECL_TEMPLATE(ALdouble)
1245 DECL_TEMPLATE(ALmulaw)
1246
1247 #undef DECL_TEMPLATE
1248
1249 #define DECL_TEMPLATE(T) \
1250 static void Convert_##T(T *dst, const ALvoid *src, enum SrcFmtType srcType, \
1251 ALsizei len) \
1252 { \
1253 switch(srcType) \
1254 { \
1255 case SrcFmtByte: \
1256 Convert_##T##_ALbyte(dst, src, len); \
1257 break; \
1258 case SrcFmtUByte: \
1259 Convert_##T##_ALubyte(dst, src, len); \
1260 break; \
1261 case SrcFmtShort: \
1262 Convert_##T##_ALshort(dst, src, len); \
1263 break; \
1264 case SrcFmtUShort: \
1265 Convert_##T##_ALushort(dst, src, len); \
1266 break; \
1267 case SrcFmtInt: \
1268 Convert_##T##_ALint(dst, src, len); \
1269 break; \
1270 case SrcFmtUInt: \
1271 Convert_##T##_ALuint(dst, src, len); \
1272 break; \
1273 case SrcFmtFloat: \
1274 Convert_##T##_ALfloat(dst, src, len); \
1275 break; \
1276 case SrcFmtDouble: \
1277 Convert_##T##_ALdouble(dst, src, len); \
1278 break; \
1279 case SrcFmtMulaw: \
1280 Convert_##T##_ALmulaw(dst, src, len); \
1281 break; \
1282 case SrcFmtIMA4: \
1283 break; /* not handled here */ \
1284 } \
1285 }
1286
1287 DECL_TEMPLATE(ALbyte)
1288 DECL_TEMPLATE(ALubyte)
1289 DECL_TEMPLATE(ALshort)
1290 DECL_TEMPLATE(ALushort)
1291 DECL_TEMPLATE(ALint)
1292 DECL_TEMPLATE(ALuint)
1293 DECL_TEMPLATE(ALfloat)
1294 DECL_TEMPLATE(ALdouble)
1295 DECL_TEMPLATE(ALmulaw)
1296
1297 #undef DECL_TEMPLATE
1298
1299
1300 static void ConvertData(ALvoid *dst, enum FmtType dstType, const ALvoid *src, enum SrcFmtType srcType, ALsizei len)
1301 {
1302 switch(dstType)
1303 {
1304 (void)Convert_ALbyte;
1305 case FmtUByte:
1306 Convert_ALubyte(dst, src, srcType, len);
1307 break;
1308 case FmtShort:
1309 Convert_ALshort(dst, src, srcType, len);
1310 break;
1311 (void)Convert_ALushort;
1312 (void)Convert_ALint;
1313 (void)Convert_ALuint;
1314 case FmtFloat:
1315 Convert_ALfloat(dst, src, srcType, len);
1316 break;
1317 (void)Convert_ALdouble;
1318 (void)Convert_ALmulaw;
1319 }
1320 }
1321
1322 static void ConvertDataIMA4(ALvoid *dst, enum FmtType dstType, const ALvoid *src, ALint chans, ALsizei len)
1323 {
1324 switch(dstType)
1325 {
1326 (void)Convert_ALbyte_IMA4;
1327 case FmtUByte:
1328 Convert_ALubyte_IMA4(dst, src, chans, len);
1329 break;
1330 case FmtShort:
1331 Convert_ALshort_IMA4(dst, src, chans, len);
1332 break;
1333 (void)Convert_ALushort_IMA4;
1334 (void)Convert_ALint_IMA4;
1335 (void)Convert_ALuint_IMA4;
1336 case FmtFloat:
1337 Convert_ALfloat_IMA4(dst, src, chans, len);
1338 break;
1339 (void)Convert_ALdouble_IMA4;
1340 (void)Convert_ALmulaw_IMA4;
1341 }
1342 }
1343
1344
1345 /*
1346 * LoadData
1347 *
1348 * Loads the specified data into the buffer, using the specified formats.
1349 * Currently, the new format must have the same channel configuration as the
1350 * original format.
1351 */
1352 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei size, enum SrcFmtChannels SrcChannels, enum SrcFmtType SrcType, const ALvoid *data)
1353 {
1354 ALuint NewChannels, NewBytes;
1355 enum FmtChannels DstChannels;
1356 enum FmtType DstType;
1357 ALuint64 newsize;
1358 ALvoid *temp;
1359
1360 DecomposeFormat(NewFormat, &DstChannels, &DstType);
1361 NewChannels = ChannelsFromFmt(DstChannels);
1362 NewBytes = BytesFromFmt(DstType);
1363
1364 assert(SrcChannels == DstChannels);
1365
1366 if(SrcType == SrcFmtIMA4)
1367 {
1368 ALuint OrigChannels = ChannelsFromSrcFmt(SrcChannels);
1369
1370 /* Here is where things vary:
1371 * nVidia and Apple use 64+1 sample frames per block => block_size=36*chans bytes
1372 * Most PC sound software uses 2040+1 sample frames per block -> block_size=1024*chans bytes
1373 */
1374 if((size%(36*OrigChannels)) != 0)
1375 return AL_INVALID_VALUE;
1376
1377 newsize = size / 36;
1378 newsize *= 65;
1379 newsize *= NewBytes;
1380 if(newsize > INT_MAX)
1381 return AL_OUT_OF_MEMORY;
1382
1383 temp = realloc(ALBuf->data, newsize);
1384 if(!temp && newsize) return AL_OUT_OF_MEMORY;
1385 ALBuf->data = temp;
1386 ALBuf->size = newsize;
1387
1388 if(data != NULL)
1389 ConvertDataIMA4(ALBuf->data, DstType, data, OrigChannels,
1390 newsize/(65*NewChannels*NewBytes));
1391
1392 ALBuf->OriginalChannels = SrcChannels;
1393 ALBuf->OriginalType = SrcType;
1394 ALBuf->OriginalSize = size;
1395 ALBuf->OriginalAlign = 36 * OrigChannels;
1396 }
1397 else
1398 {
1399 ALuint OrigBytes = BytesFromSrcFmt(SrcType);
1400 ALuint OrigChannels = ChannelsFromSrcFmt(SrcChannels);
1401
1402 if((size%(OrigBytes*OrigChannels)) != 0)
1403 return AL_INVALID_VALUE;
1404
1405 newsize = size / OrigBytes;
1406 newsize *= NewBytes;
1407 if(newsize > INT_MAX)
1408 return AL_OUT_OF_MEMORY;
1409
1410 temp = realloc(ALBuf->data, newsize);
1411 if(!temp && newsize) return AL_OUT_OF_MEMORY;
1412 ALBuf->data = temp;
1413 ALBuf->size = newsize;
1414
1415 if(data != NULL)
1416 ConvertData(ALBuf->data, DstType, data, SrcType, newsize/NewBytes);
1417
1418 ALBuf->OriginalChannels = SrcChannels;
1419 ALBuf->OriginalType = SrcType;
1420 ALBuf->OriginalSize = size;
1421 ALBuf->OriginalAlign = OrigBytes * OrigChannels;
1422 }
1423
1424 ALBuf->Frequency = freq;
1425 ALBuf->FmtChannels = DstChannels;
1426 ALBuf->FmtType = DstType;
1427
1428 ALBuf->LoopStart = 0;
1429 ALBuf->LoopEnd = newsize / NewChannels / NewBytes;
1430
1431 return AL_NO_ERROR;
1432 }
1433
1434
1435 ALuint BytesFromSrcFmt(enum SrcFmtType type)
1436 {
1437 switch(type)
1438 {
1439 case SrcFmtByte: return sizeof(ALbyte);
1440 case SrcFmtUByte: return sizeof(ALubyte);
1441 case SrcFmtShort: return sizeof(ALshort);
1442 case SrcFmtUShort: return sizeof(ALushort);
1443 case SrcFmtInt: return sizeof(ALint);
1444 case SrcFmtUInt: return sizeof(ALuint);
1445 case SrcFmtFloat: return sizeof(ALfloat);
1446 case SrcFmtDouble: return sizeof(ALdouble);
1447 case SrcFmtMulaw: return sizeof(ALubyte);
1448 case SrcFmtIMA4: break; /* not handled here */
1449 }
1450 return 0;
1451 }
1452 ALuint ChannelsFromSrcFmt(enum SrcFmtChannels chans)
1453 {
1454 switch(chans)
1455 {
1456 case SrcFmtMono: return 1;
1457 case SrcFmtStereo: return 2;
1458 case SrcFmtRear: return 2;
1459 case SrcFmtQuad: return 4;
1460 case SrcFmtX51: return 6;
1461 case SrcFmtX61: return 7;
1462 case SrcFmtX71: return 8;
1463 }
1464 return 0;
1465 }
1466 ALboolean DecomposeInputFormat(ALenum format, enum SrcFmtChannels *chans,
1467 enum SrcFmtType *type)
1468 {
1469 switch(format)
1470 {
1471 case AL_FORMAT_MONO8:
1472 *chans = SrcFmtMono;
1473 *type = SrcFmtUByte;
1474 return AL_TRUE;
1475 case AL_FORMAT_MONO16:
1476 *chans = SrcFmtMono;
1477 *type = SrcFmtShort;
1478 return AL_TRUE;
1479 case AL_FORMAT_MONO_FLOAT32:
1480 *chans = SrcFmtMono;
1481 *type = SrcFmtFloat;
1482 return AL_TRUE;
1483 case AL_FORMAT_MONO_DOUBLE_EXT:
1484 *chans = SrcFmtMono;
1485 *type = SrcFmtDouble;
1486 return AL_TRUE;
1487 case AL_FORMAT_MONO_IMA4:
1488 *chans = SrcFmtMono;
1489 *type = SrcFmtIMA4;
1490 return AL_TRUE;
1491 case AL_FORMAT_STEREO8:
1492 *chans = SrcFmtStereo;
1493 *type = SrcFmtUByte;
1494 return AL_TRUE;
1495 case AL_FORMAT_STEREO16:
1496 *chans = SrcFmtStereo;
1497 *type = SrcFmtShort;
1498 return AL_TRUE;
1499 case AL_FORMAT_STEREO_FLOAT32:
1500 *chans = SrcFmtStereo;
1501 *type = SrcFmtFloat;
1502 return AL_TRUE;
1503 case AL_FORMAT_STEREO_DOUBLE_EXT:
1504 *chans = SrcFmtStereo;
1505 *type = SrcFmtDouble;
1506 return AL_TRUE;
1507 case AL_FORMAT_STEREO_IMA4:
1508 *chans = SrcFmtStereo;
1509 *type = SrcFmtIMA4;
1510 return AL_TRUE;
1511 case AL_FORMAT_QUAD8_LOKI:
1512 case AL_FORMAT_QUAD8:
1513 *chans = SrcFmtQuad;
1514 *type = SrcFmtUByte;
1515 return AL_TRUE;
1516 case AL_FORMAT_QUAD16_LOKI:
1517 case AL_FORMAT_QUAD16:
1518 *chans = SrcFmtQuad;
1519 *type = SrcFmtShort;
1520 return AL_TRUE;
1521 case AL_FORMAT_QUAD32:
1522 *chans = SrcFmtQuad;
1523 *type = SrcFmtFloat;
1524 return AL_TRUE;
1525 case AL_FORMAT_REAR8:
1526 *chans = SrcFmtRear;
1527 *type = SrcFmtUByte;
1528 return AL_TRUE;
1529 case AL_FORMAT_REAR16:
1530 *chans = SrcFmtRear;
1531 *type = SrcFmtShort;
1532 return AL_TRUE;
1533 case AL_FORMAT_REAR32:
1534 *chans = SrcFmtRear;
1535 *type = SrcFmtFloat;
1536 return AL_TRUE;
1537 case AL_FORMAT_51CHN8:
1538 *chans = SrcFmtX51;
1539 *type = SrcFmtUByte;
1540 return AL_TRUE;
1541 case AL_FORMAT_51CHN16:
1542 *chans = SrcFmtX51;
1543 *type = SrcFmtShort;
1544 return AL_TRUE;
1545 case AL_FORMAT_51CHN32:
1546 *chans = SrcFmtX51;
1547 *type = SrcFmtFloat;
1548 return AL_TRUE;
1549 case AL_FORMAT_61CHN8:
1550 *chans = SrcFmtX61;
1551 *type = SrcFmtUByte;
1552 return AL_TRUE;
1553 case AL_FORMAT_61CHN16:
1554 *chans = SrcFmtX61;
1555 *type = SrcFmtShort;
1556 return AL_TRUE;
1557 case AL_FORMAT_61CHN32:
1558 *chans = SrcFmtX61;
1559 *type = SrcFmtFloat;
1560 return AL_TRUE;
1561 case AL_FORMAT_71CHN8:
1562 *chans = SrcFmtX71;
1563 *type = SrcFmtUByte;
1564 return AL_TRUE;
1565 case AL_FORMAT_71CHN16:
1566 *chans = SrcFmtX71;
1567 *type = SrcFmtShort;
1568 return AL_TRUE;
1569 case AL_FORMAT_71CHN32:
1570 *chans = SrcFmtX71;
1571 *type = SrcFmtFloat;
1572 return AL_TRUE;
1573 case AL_FORMAT_MONO_MULAW:
1574 *chans = SrcFmtMono;
1575 *type = SrcFmtMulaw;
1576 return AL_TRUE;
1577 case AL_FORMAT_STEREO_MULAW:
1578 *chans = SrcFmtStereo;
1579 *type = SrcFmtMulaw;
1580 return AL_TRUE;
1581 case AL_FORMAT_QUAD_MULAW:
1582 *chans = SrcFmtQuad;
1583 *type = SrcFmtMulaw;
1584 return AL_TRUE;
1585 case AL_FORMAT_REAR_MULAW:
1586 *chans = SrcFmtRear;
1587 *type = SrcFmtMulaw;
1588 return AL_TRUE;
1589 case AL_FORMAT_51CHN_MULAW:
1590 *chans = SrcFmtX51;
1591 *type = SrcFmtMulaw;
1592 return AL_TRUE;
1593 case AL_FORMAT_61CHN_MULAW:
1594 *chans = SrcFmtX61;
1595 *type = SrcFmtMulaw;
1596 return AL_TRUE;
1597 case AL_FORMAT_71CHN_MULAW:
1598 *chans = SrcFmtX71;
1599 *type = SrcFmtMulaw;
1600 return AL_TRUE;
1601 }
1602 return AL_FALSE;
1603 }
1604
1605 ALuint BytesFromFmt(enum FmtType type)
1606 {
1607 switch(type)
1608 {
1609 case FmtUByte: return sizeof(ALubyte);
1610 case FmtShort: return sizeof(ALshort);
1611 case FmtFloat: return sizeof(ALfloat);
1612 }
1613 return 0;
1614 }
1615 ALuint ChannelsFromFmt(enum FmtChannels chans)
1616 {
1617 switch(chans)
1618 {
1619 case FmtMono: return 1;
1620 case FmtStereo: return 2;
1621 case FmtRear: return 2;
1622 case FmtQuad: return 4;
1623 case FmtX51: return 6;
1624 case FmtX61: return 7;
1625 case FmtX71: return 8;
1626 }
1627 return 0;
1628 }
1629 ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
1630 {
1631 switch(format)
1632 {
1633 case AL_FORMAT_MONO8:
1634 *chans = FmtMono;
1635 *type = FmtUByte;
1636 return AL_TRUE;
1637 case AL_FORMAT_MONO16:
1638 *chans = FmtMono;
1639 *type = FmtShort;
1640 return AL_TRUE;
1641 case AL_FORMAT_MONO_FLOAT32:
1642 *chans = FmtMono;
1643 *type = FmtFloat;
1644 return AL_TRUE;
1645 case AL_FORMAT_STEREO8:
1646 *chans = FmtStereo;
1647 *type = FmtUByte;
1648 return AL_TRUE;
1649 case AL_FORMAT_STEREO16:
1650 *chans = FmtStereo;
1651 *type = FmtShort;
1652 return AL_TRUE;
1653 case AL_FORMAT_STEREO_FLOAT32:
1654 *chans = FmtStereo;
1655 *type = FmtFloat;
1656 return AL_TRUE;
1657 case AL_FORMAT_QUAD8_LOKI:
1658 case AL_FORMAT_QUAD8:
1659 *chans = FmtQuad;
1660 *type = FmtUByte;
1661 return AL_TRUE;
1662 case AL_FORMAT_QUAD16_LOKI:
1663 case AL_FORMAT_QUAD16:
1664 *chans = FmtQuad;
1665 *type = FmtShort;
1666 return AL_TRUE;
1667 case AL_FORMAT_QUAD32:
1668 *chans = FmtQuad;
1669 *type = FmtFloat;
1670 return AL_TRUE;
1671 case AL_FORMAT_REAR8:
1672 *chans = FmtRear;
1673 *type = FmtUByte;
1674 return AL_TRUE;
1675 case AL_FORMAT_REAR16:
1676 *chans = FmtRear;
1677 *type = FmtShort;
1678 return AL_TRUE;
1679 case AL_FORMAT_REAR32:
1680 *chans = FmtRear;
1681 *type = FmtFloat;
1682 return AL_TRUE;
1683 case AL_FORMAT_51CHN8:
1684 *chans = FmtX51;
1685 *type = FmtUByte;
1686 return AL_TRUE;
1687 case AL_FORMAT_51CHN16:
1688 *chans = FmtX51;
1689 *type = FmtShort;
1690 return AL_TRUE;
1691 case AL_FORMAT_51CHN32:
1692 *chans = FmtX51;
1693 *type = FmtFloat;
1694 return AL_TRUE;
1695 case AL_FORMAT_61CHN8:
1696 *chans = FmtX61;
1697 *type = FmtUByte;
1698 return AL_TRUE;
1699 case AL_FORMAT_61CHN16:
1700 *chans = FmtX61;
1701 *type = FmtShort;
1702 return AL_TRUE;
1703 case AL_FORMAT_61CHN32:
1704 *chans = FmtX61;
1705 *type = FmtFloat;
1706 return AL_TRUE;
1707 case AL_FORMAT_71CHN8:
1708 *chans = FmtX71;
1709 *type = FmtUByte;
1710 return AL_TRUE;
1711 case AL_FORMAT_71CHN16:
1712 *chans = FmtX71;
1713 *type = FmtShort;
1714 return AL_TRUE;
1715 case AL_FORMAT_71CHN32:
1716 *chans = FmtX71;
1717 *type = FmtFloat;
1718 return AL_TRUE;
1719 }
1720 return AL_FALSE;
1721 }
1722
1723
1724 /*
1725 * ReleaseALBuffers()
1726 *
1727 * INTERNAL FN : Called by alcCloseDevice to destroy any buffers that still exist
1728 */
1729 ALvoid ReleaseALBuffers(ALCdevice *device)
1730 {
1731 ALsizei i;
1732 for(i = 0;i < device->BufferMap.size;i++)
1733 {
1734 ALbuffer *temp = device->BufferMap.array[i].value;
1735 device->BufferMap.array[i].value = NULL;
1736
1737 // Release sample data
1738 free(temp->data);
1739
1740 // Release Buffer structure
1741 ALTHUNK_REMOVEENTRY(temp->buffer);
1742 memset(temp, 0, sizeof(ALbuffer));
1743 free(temp);
1744 }
1745 }
Software OpenAL implementation