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