?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Reorder some parameters for consistency
[openal-soft/openal-hmr.git] / OpenAL32 / alBuffer.c
blobb6ded0273374c19781449b6a91b971c95b47fbae
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 ALCcontext *Context;
419 ALCdevice *device;
420 ALbuffer *ALBuf;
421
422 Context = GetContextSuspended();
423 if(!Context) return;
424
425 if(Context->SampleSource)
426 {
427 ALintptrEXT offset;
428
429 if(Context->SampleSource->state == MAPPED)
430 {
431 alSetError(Context, AL_INVALID_OPERATION);
432 ProcessContext(Context);
433 return;
434 }
435
436 offset = (const ALubyte*)data - (ALubyte*)NULL;
437 data = Context->SampleSource->data + offset;
438 }
439
440 device = Context->Device;
441 if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
442 alSetError(Context, AL_INVALID_NAME);
443 else if(length < 0 || offset < 0 || (length > 0 && data == NULL))
444 alSetError(Context, AL_INVALID_VALUE);
445 else if(offset > ALBuf->OriginalSize ||
446 length > ALBuf->OriginalSize-offset ||
447 (offset%ALBuf->OriginalAlign) != 0 ||
448 (length%ALBuf->OriginalAlign) != 0)
449 alSetError(Context, AL_INVALID_VALUE);
450 else switch(format)
451 {
452 case AL_FORMAT_MONO8:
453 case AL_FORMAT_MONO16:
454 case AL_FORMAT_MONO_FLOAT32:
455 case AL_FORMAT_MONO_DOUBLE_EXT:
456 case AL_FORMAT_MONO_MULAW:
457 case AL_FORMAT_STEREO8:
458 case AL_FORMAT_STEREO16:
459 case AL_FORMAT_STEREO_FLOAT32:
460 case AL_FORMAT_STEREO_DOUBLE_EXT:
461 case AL_FORMAT_STEREO_MULAW:
462 case AL_FORMAT_QUAD8_LOKI:
463 case AL_FORMAT_QUAD16_LOKI:
464 case AL_FORMAT_QUAD8:
465 case AL_FORMAT_QUAD16:
466 case AL_FORMAT_QUAD32:
467 case AL_FORMAT_QUAD_MULAW:
468 case AL_FORMAT_REAR8:
469 case AL_FORMAT_REAR16:
470 case AL_FORMAT_REAR32:
471 case AL_FORMAT_REAR_MULAW:
472 case AL_FORMAT_51CHN8:
473 case AL_FORMAT_51CHN16:
474 case AL_FORMAT_51CHN32:
475 case AL_FORMAT_51CHN_MULAW:
476 case AL_FORMAT_61CHN8:
477 case AL_FORMAT_61CHN16:
478 case AL_FORMAT_61CHN32:
479 case AL_FORMAT_61CHN_MULAW:
480 case AL_FORMAT_71CHN8:
481 case AL_FORMAT_71CHN16:
482 case AL_FORMAT_71CHN32:
483 case AL_FORMAT_71CHN_MULAW: {
484 enum SrcFmtChannels SrcChannels;
485 enum SrcFmtType SrcType;
486
487 DecomposeInputFormat(format, &SrcChannels, &SrcType);
488 if(SrcChannels != ALBuf->OriginalChannels || SrcType != ALBuf->OriginalType)
489 alSetError(Context, AL_INVALID_ENUM);
490 else
491 {
492 ALuint OldBytes = BytesFromFmt(SrcType);
493 ALuint Bytes = BytesFromFmt(ALBuf->FmtType);
494
495 offset /= OldBytes;
496 offset *= Bytes;
497 length /= OldBytes;
498
499 ConvertData(&((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
500 data, SrcType, length);
501 }
502 } break;
503
504 case AL_FORMAT_MONO_IMA4:
505 case AL_FORMAT_STEREO_IMA4: {
506 enum SrcFmtChannels SrcChannels;
507 enum SrcFmtType SrcType;
508
509 DecomposeInputFormat(format, &SrcChannels, &SrcType);
510 if(SrcChannels != ALBuf->OriginalChannels || SrcType != SrcFmtIMA4)
511 alSetError(Context, AL_INVALID_ENUM);
512 else
513 {
514 ALuint Channels = ChannelsFromFmt(ALBuf->FmtChannels);
515 ALuint Bytes = BytesFromFmt(ALBuf->FmtType);
516
517 /* offset -> byte offset, length -> block count */
518 offset /= 36;
519 offset *= 65;
520 offset *= Bytes;
521 length /= ALBuf->OriginalAlign;
522
523 ConvertDataIMA4(&((ALubyte*)ALBuf->data)[offset], data, Channels, length);
524 }
525 } break;
526
527 default:
528 alSetError(Context, AL_INVALID_ENUM);
529 break;
530 }
531
532 ProcessContext(Context);
533 }
534
535 AL_API ALvoid AL_APIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
536 {
537 alBufferSubDataSOFT(buffer, format, data, offset, length);
538 }
539
540
541 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
542 {
543 ALCcontext *pContext;
544 ALCdevice *device;
545
546 (void)flValue;
547
548 pContext = GetContextSuspended();
549 if(!pContext) return;
550
551 device = pContext->Device;
552 if(LookupBuffer(device->BufferMap, buffer) == NULL)
553 alSetError(pContext, AL_INVALID_NAME);
554 else
555 {
556 switch(eParam)
557 {
558 default:
559 alSetError(pContext, AL_INVALID_ENUM);
560 break;
561 }
562 }
563
564 ProcessContext(pContext);
565 }
566
567
568 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
569 {
570 ALCcontext *pContext;
571 ALCdevice *device;
572
573 (void)flValue1;
574 (void)flValue2;
575 (void)flValue3;
576
577 pContext = GetContextSuspended();
578 if(!pContext) return;
579
580 device = pContext->Device;
581 if(LookupBuffer(device->BufferMap, buffer) == NULL)
582 alSetError(pContext, AL_INVALID_NAME);
583 else
584 {
585 switch(eParam)
586 {
587 default:
588 alSetError(pContext, AL_INVALID_ENUM);
589 break;
590 }
591 }
592
593 ProcessContext(pContext);
594 }
595
596
597 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
598 {
599 ALCcontext *pContext;
600 ALCdevice *device;
601
602 pContext = GetContextSuspended();
603 if(!pContext) return;
604
605 device = pContext->Device;
606 if(!flValues)
607 alSetError(pContext, AL_INVALID_VALUE);
608 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
609 alSetError(pContext, AL_INVALID_NAME);
610 else
611 {
612 switch(eParam)
613 {
614 default:
615 alSetError(pContext, AL_INVALID_ENUM);
616 break;
617 }
618 }
619
620 ProcessContext(pContext);
621 }
622
623
624 AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
625 {
626 ALCcontext *pContext;
627 ALCdevice *device;
628
629 (void)lValue;
630
631 pContext = GetContextSuspended();
632 if(!pContext) return;
633
634 device = pContext->Device;
635 if(LookupBuffer(device->BufferMap, buffer) == NULL)
636 alSetError(pContext, AL_INVALID_NAME);
637 else
638 {
639 switch(eParam)
640 {
641 default:
642 alSetError(pContext, AL_INVALID_ENUM);
643 break;
644 }
645 }
646
647 ProcessContext(pContext);
648 }
649
650
651 AL_API void AL_APIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
652 {
653 ALCcontext *pContext;
654 ALCdevice *device;
655
656 (void)lValue1;
657 (void)lValue2;
658 (void)lValue3;
659
660 pContext = GetContextSuspended();
661 if(!pContext) return;
662
663 device = pContext->Device;
664 if(LookupBuffer(device->BufferMap, buffer) == NULL)
665 alSetError(pContext, AL_INVALID_NAME);
666 else
667 {
668 switch(eParam)
669 {
670 default:
671 alSetError(pContext, AL_INVALID_ENUM);
672 break;
673 }
674 }
675
676 ProcessContext(pContext);
677 }
678
679
680 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
681 {
682 ALCcontext *pContext;
683 ALCdevice *device;
684 ALbuffer *ALBuf;
685
686 pContext = GetContextSuspended();
687 if(!pContext) return;
688
689 device = pContext->Device;
690 if(!plValues)
691 alSetError(pContext, AL_INVALID_VALUE);
692 else if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
693 alSetError(pContext, AL_INVALID_NAME);
694 else
695 {
696 switch(eParam)
697 {
698 case AL_LOOP_POINTS:
699 if(ALBuf->refcount > 0)
700 alSetError(pContext, AL_INVALID_OPERATION);
701 else if(plValues[0] < 0 || plValues[1] < 0 ||
702 plValues[0] >= plValues[1] || ALBuf->size == 0)
703 alSetError(pContext, AL_INVALID_VALUE);
704 else
705 {
706 ALint maxlen = ALBuf->size /
707 FrameSizeFromFmt(ALBuf->FmtChannels, ALBuf->FmtType);
708 if(plValues[0] > maxlen || plValues[1] > maxlen)
709 alSetError(pContext, AL_INVALID_VALUE);
710 else
711 {
712 ALBuf->LoopStart = plValues[0];
713 ALBuf->LoopEnd = plValues[1];
714 }
715 }
716 break;
717
718 default:
719 alSetError(pContext, AL_INVALID_ENUM);
720 break;
721 }
722 }
723
724 ProcessContext(pContext);
725 }
726
727
728 AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
729 {
730 ALCcontext *pContext;
731 ALCdevice *device;
732
733 pContext = GetContextSuspended();
734 if(!pContext) return;
735
736 device = pContext->Device;
737 if(!pflValue)
738 alSetError(pContext, AL_INVALID_VALUE);
739 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
740 alSetError(pContext, AL_INVALID_NAME);
741 else
742 {
743 switch(eParam)
744 {
745 default:
746 alSetError(pContext, AL_INVALID_ENUM);
747 break;
748 }
749 }
750
751 ProcessContext(pContext);
752 }
753
754
755 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
756 {
757 ALCcontext *pContext;
758 ALCdevice *device;
759
760 pContext = GetContextSuspended();
761 if(!pContext) return;
762
763 device = pContext->Device;
764 if(!pflValue1 || !pflValue2 || !pflValue3)
765 alSetError(pContext, AL_INVALID_VALUE);
766 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
767 alSetError(pContext, AL_INVALID_NAME);
768 else
769 {
770 switch(eParam)
771 {
772 default:
773 alSetError(pContext, AL_INVALID_ENUM);
774 break;
775 }
776 }
777
778 ProcessContext(pContext);
779 }
780
781
782 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
783 {
784 ALCcontext *pContext;
785 ALCdevice *device;
786
787 pContext = GetContextSuspended();
788 if(!pContext) return;
789
790 device = pContext->Device;
791 if(!pflValues)
792 alSetError(pContext, AL_INVALID_VALUE);
793 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
794 alSetError(pContext, AL_INVALID_NAME);
795 else
796 {
797 switch(eParam)
798 {
799 default:
800 alSetError(pContext, AL_INVALID_ENUM);
801 break;
802 }
803 }
804
805 ProcessContext(pContext);
806 }
807
808
809 AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
810 {
811 ALCcontext *pContext;
812 ALbuffer *pBuffer;
813 ALCdevice *device;
814
815 pContext = GetContextSuspended();
816 if(!pContext) return;
817
818 device = pContext->Device;
819 if(!plValue)
820 alSetError(pContext, AL_INVALID_VALUE);
821 else if((pBuffer=LookupBuffer(device->BufferMap, buffer)) == NULL)
822 alSetError(pContext, AL_INVALID_NAME);
823 else
824 {
825 switch(eParam)
826 {
827 case AL_FREQUENCY:
828 *plValue = pBuffer->Frequency;
829 break;
830
831 case AL_BITS:
832 *plValue = BytesFromFmt(pBuffer->FmtType) * 8;
833 break;
834
835 case AL_CHANNELS:
836 *plValue = ChannelsFromFmt(pBuffer->FmtChannels);
837 break;
838
839 case AL_SIZE:
840 *plValue = pBuffer->size;
841 break;
842
843 default:
844 alSetError(pContext, AL_INVALID_ENUM);
845 break;
846 }
847 }
848
849 ProcessContext(pContext);
850 }
851
852
853 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
854 {
855 ALCcontext *pContext;
856 ALCdevice *device;
857
858 pContext = GetContextSuspended();
859 if(!pContext) return;
860
861 device = pContext->Device;
862 if(!plValue1 || !plValue2 || !plValue3)
863 alSetError(pContext, AL_INVALID_VALUE);
864 else if(LookupBuffer(device->BufferMap, buffer) == NULL)
865 alSetError(pContext, AL_INVALID_NAME);
866 else
867 {
868 switch(eParam)
869 {
870 default:
871 alSetError(pContext, AL_INVALID_ENUM);
872 break;
873 }
874 }
875
876 ProcessContext(pContext);
877 }
878
879
880 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
881 {
882 ALCcontext *pContext;
883 ALCdevice *device;
884 ALbuffer *ALBuf;
885
886 pContext = GetContextSuspended();
887 if(!pContext) return;
888
889 device = pContext->Device;
890 if(!plValues)
891 alSetError(pContext, AL_INVALID_VALUE);
892 else if((ALBuf=LookupBuffer(device->BufferMap, buffer)) == NULL)
893 alSetError(pContext, AL_INVALID_NAME);
894 else
895 {
896 switch(eParam)
897 {
898 case AL_FREQUENCY:
899 case AL_BITS:
900 case AL_CHANNELS:
901 case AL_SIZE:
902 alGetBufferi(buffer, eParam, plValues);
903 break;
904
905 case AL_LOOP_POINTS:
906 plValues[0] = ALBuf->LoopStart;
907 plValues[1] = ALBuf->LoopEnd;
908 break;
909
910 default:
911 alSetError(pContext, AL_INVALID_ENUM);
912 break;
913 }
914 }
915
916 ProcessContext(pContext);
917 }
918
919
920 static void ConvertDataIMA4(ALvoid *dst, const ALvoid *src, ALint chans, ALsizei len)
921 {
922 const ALubyte *IMAData;
923 ALint Sample[2],Index[2];
924 ALuint IMACode[2];
925 ALsizei i,j,k,c;
926
927 if(src == NULL)
928 return;
929
930 IMAData = src;
931 for(i = 0;i < len;i++)
932 {
933 for(c = 0;c < chans;c++)
934 {
935 Sample[c] = *(IMAData++);
936 Sample[c] |= *(IMAData++) << 8;
937 Sample[c] = (Sample[c]^0x8000) - 32768;
938 Index[c] = *(IMAData++);
939 Index[c] |= *(IMAData++) << 8;
940 Index[c] = (Index[c]^0x8000) - 32768;
941
942 Index[c] = ((Index[c]<0) ? 0 : Index[c]);
943 Index[c] = ((Index[c]>88) ? 88 : Index[c]);
944
945 ((ALshort*)dst)[i*65*chans + c] = Sample[c];
946 }
947
948 for(j = 1;j < 65;j += 8)
949 {
950 for(c = 0;c < chans;c++)
951 {
952 IMACode[c] = *(IMAData++);
953 IMACode[c] |= *(IMAData++) << 8;
954 IMACode[c] |= *(IMAData++) << 16;
955 IMACode[c] |= *(IMAData++) << 24;
956 }
957
958 for(k = 0;k < 8;k++)
959 {
960 for(c = 0;c < chans;c++)
961 {
962 Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
963 Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
964
965 if(Sample[c] < -32768) Sample[c] = -32768;
966 else if(Sample[c] > 32767) Sample[c] = 32767;
967
968 if(Index[c]<0) Index[c] = 0;
969 else if(Index[c]>88) Index[c] = 88;
970
971 ((ALshort*)dst)[(i*65+j+k)*chans + c] = Sample[c];
972 IMACode[c] >>= 4;
973 }
974 }
975 }
976 }
977 }
978
979
980 typedef ALubyte ALmulaw;
981
982 static __inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
983 { return val; }
984 static __inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
985 { return val^0x80; }
986 static __inline ALbyte Conv_ALbyte_ALshort(ALshort val)
987 { return val>>8; }
988 static __inline ALbyte Conv_ALbyte_ALushort(ALushort val)
989 { return (val>>8)-128; }
990 static __inline ALbyte Conv_ALbyte_ALint(ALint val)
991 { return val>>24; }
992 static __inline ALbyte Conv_ALbyte_ALuint(ALuint val)
993 { return (val>>24)-128; }
994 static __inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
995 {
996 if(val >= 1.0f) return 127;
997 if(val <= -1.0f) return -128;
998 return (ALint)(val * 127.0f);
999 }
1000 static __inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
1001 {
1002 if(val >= 1.0) return 127;
1003 if(val <= -1.0) return -128;
1004 return (ALint)(val * 127.0);
1005 }
1006 static __inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
1007 { return muLawDecompressionTable[val]>>8; }
1008
1009 static __inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
1010 { return val^0x80; }
1011 static __inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
1012 { return val; }
1013 static __inline ALubyte Conv_ALubyte_ALshort(ALshort val)
1014 { return (val>>8)+128; }
1015 static __inline ALubyte Conv_ALubyte_ALushort(ALushort val)
1016 { return val>>8; }
1017 static __inline ALubyte Conv_ALubyte_ALint(ALint val)
1018 { return (val>>24)+128; }
1019 static __inline ALubyte Conv_ALubyte_ALuint(ALuint val)
1020 { return val>>24; }
1021 static __inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
1022 {
1023 if(val >= 1.0f) return 255;
1024 if(val <= -1.0f) return 0;
1025 return (ALint)(val * 127.0f) + 128;
1026 }
1027 static __inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
1028 {
1029 if(val >= 1.0) return 255;
1030 if(val <= -1.0) return 0;
1031 return (ALint)(val * 127.0) + 128;
1032 }
1033 static __inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
1034 { return (muLawDecompressionTable[val]>>8)+128; }
1035
1036 static __inline ALshort Conv_ALshort_ALbyte(ALbyte val)
1037 { return val<<8; }
1038 static __inline ALshort Conv_ALshort_ALubyte(ALubyte val)
1039 { return (val-128)<<8; }
1040 static __inline ALshort Conv_ALshort_ALshort(ALshort val)
1041 { return val; }
1042 static __inline ALshort Conv_ALshort_ALushort(ALushort val)
1043 { return val^0x8000; }
1044 static __inline ALshort Conv_ALshort_ALint(ALint val)
1045 { return val>>16; }
1046 static __inline ALshort Conv_ALshort_ALuint(ALuint val)
1047 { return (val>>16)-32768; }
1048 static __inline ALshort Conv_ALshort_ALfloat(ALfloat val)
1049 {
1050 if(val >= 1.0f) return 32767;
1051 if(val <= -1.0f) return -32768;
1052 return (ALint)(val * 32767.0f);
1053 }
1054 static __inline ALshort Conv_ALshort_ALdouble(ALdouble val)
1055 {
1056 if(val >= 1.0) return 32767;
1057 if(val <= -1.0) return -32768;
1058 return (ALint)(val * 32767.0);
1059 }
1060 static __inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
1061 { return muLawDecompressionTable[val]; }
1062
1063 static __inline ALushort Conv_ALushort_ALbyte(ALbyte val)
1064 { return (val+128)<<8; }
1065 static __inline ALushort Conv_ALushort_ALubyte(ALubyte val)
1066 { return val<<8; }
1067 static __inline ALushort Conv_ALushort_ALshort(ALshort val)
1068 { return val^0x8000; }
1069 static __inline ALushort Conv_ALushort_ALushort(ALushort val)
1070 { return val; }
1071 static __inline ALushort Conv_ALushort_ALint(ALint val)
1072 { return (val>>16)+32768; }
1073 static __inline ALushort Conv_ALushort_ALuint(ALuint val)
1074 { return val>>16; }
1075 static __inline ALushort Conv_ALushort_ALfloat(ALfloat val)
1076 {
1077 if(val >= 1.0f) return 65535;
1078 if(val <= -1.0f) return 0;
1079 return (ALint)(val * 32767.0f) + 32768;
1080 }
1081 static __inline ALushort Conv_ALushort_ALdouble(ALdouble val)
1082 {
1083 if(val >= 1.0) return 65535;
1084 if(val <= -1.0) return 0;
1085 return (ALint)(val * 32767.0) + 32768;
1086 }
1087 static __inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
1088 { return muLawDecompressionTable[val]^0x8000; }
1089
1090 static __inline ALint Conv_ALint_ALbyte(ALbyte val)
1091 { return val<<24; }
1092 static __inline ALint Conv_ALint_ALubyte(ALubyte val)
1093 { return (val-128)<<24; }
1094 static __inline ALint Conv_ALint_ALshort(ALshort val)
1095 { return val<<16; }
1096 static __inline ALint Conv_ALint_ALushort(ALushort val)
1097 { return (val-32768)<<16; }
1098 static __inline ALint Conv_ALint_ALint(ALint val)
1099 { return val; }
1100 static __inline ALint Conv_ALint_ALuint(ALuint val)
1101 { return val-2147483648u; }
1102 static __inline ALint Conv_ALint_ALfloat(ALfloat val)
1103 {
1104 if(val >= 1.0f) return 2147483647;
1105 if(val <= -1.0f) return -2147483648u;
1106 return (ALint)(val * 2147483647.0);
1107 }
1108 static __inline ALint Conv_ALint_ALdouble(ALdouble val)
1109 {
1110 if(val >= 1.0) return 2147483647;
1111 if(val <= -1.0) return -2147483648u;
1112 return (ALint)(val * 2147483647.0);
1113 }
1114 static __inline ALint Conv_ALint_ALmulaw(ALmulaw val)
1115 { return muLawDecompressionTable[val]<<16; }
1116
1117 static __inline ALuint Conv_ALuint_ALbyte(ALbyte val)
1118 { return (val+128)<<24; }
1119 static __inline ALuint Conv_ALuint_ALubyte(ALubyte val)
1120 { return val<<24; }
1121 static __inline ALuint Conv_ALuint_ALshort(ALshort val)
1122 { return (val+32768)<<16; }
1123 static __inline ALuint Conv_ALuint_ALushort(ALushort val)
1124 { return val<<16; }
1125 static __inline ALuint Conv_ALuint_ALint(ALint val)
1126 { return val+2147483648u; }
1127 static __inline ALuint Conv_ALuint_ALuint(ALuint val)
1128 { return val; }
1129 static __inline ALuint Conv_ALuint_ALfloat(ALfloat val)
1130 {
1131 if(val >= 1.0f) return 4294967295u;
1132 if(val <= -1.0f) return 0;
1133 return (ALint)(val * 2147483647.0) + 2147483648u;
1134 }
1135 static __inline ALuint Conv_ALuint_ALdouble(ALdouble val)
1136 {
1137 if(val >= 1.0) return 4294967295u;
1138 if(val <= -1.0) return 0;
1139 return (ALint)(val * 2147483647.0) + 2147483648u;
1140 }
1141 static __inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
1142 { return (muLawDecompressionTable[val]+32768)<<16; }
1143
1144 static __inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
1145 { return val * (1.0f/127.0f); }
1146 static __inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
1147 { return (val-128) * (1.0f/127.0f); }
1148 static __inline ALfloat Conv_ALfloat_ALshort(ALshort val)
1149 { return val * (1.0f/32767.0f); }
1150 static __inline ALfloat Conv_ALfloat_ALushort(ALushort val)
1151 { return (val-32768) * (1.0f/32767.0f); }
1152 static __inline ALfloat Conv_ALfloat_ALint(ALint val)
1153 { return val * (1.0/2147483647.0); }
1154 static __inline ALfloat Conv_ALfloat_ALuint(ALuint val)
1155 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1156 static __inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
1157 { return val; }
1158 static __inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
1159 { return val; }
1160 static __inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
1161 { return muLawDecompressionTable[val] * (1.0f/32767.0f); }
1162
1163 static __inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
1164 { return val * (1.0/127.0); }
1165 static __inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
1166 { return (val-128) * (1.0/127.0); }
1167 static __inline ALdouble Conv_ALdouble_ALshort(ALshort val)
1168 { return val * (1.0/32767.0); }
1169 static __inline ALdouble Conv_ALdouble_ALushort(ALushort val)
1170 { return (val-32768) * (1.0/32767.0); }
1171 static __inline ALdouble Conv_ALdouble_ALint(ALint val)
1172 { return val * (1.0/214748364.0); }
1173 static __inline ALdouble Conv_ALdouble_ALuint(ALuint val)
1174 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1175 static __inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
1176 { return val; }
1177 static __inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
1178 { return val; }
1179 static __inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
1180 { return muLawDecompressionTable[val] * (1.0/32767.0); }
1181
1182
1183 #define DECL_TEMPLATE(T1, T2) \
1184 static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint len) \
1185 { \
1186 ALuint i; \
1187 for(i = 0;i < len;i++) \
1188 *(dst++) = Conv_##T1##_##T2(*(src++)); \
1189 }
1190
1191 DECL_TEMPLATE(ALbyte, ALbyte)
1192 DECL_TEMPLATE(ALbyte, ALubyte)
1193 DECL_TEMPLATE(ALbyte, ALshort)
1194 DECL_TEMPLATE(ALbyte, ALushort)
1195 DECL_TEMPLATE(ALbyte, ALint)
1196 DECL_TEMPLATE(ALbyte, ALuint)
1197 DECL_TEMPLATE(ALbyte, ALfloat)
1198 DECL_TEMPLATE(ALbyte, ALdouble)
1199 DECL_TEMPLATE(ALbyte, ALmulaw)
1200
1201 DECL_TEMPLATE(ALubyte, ALbyte)
1202 DECL_TEMPLATE(ALubyte, ALubyte)
1203 DECL_TEMPLATE(ALubyte, ALshort)
1204 DECL_TEMPLATE(ALubyte, ALushort)
1205 DECL_TEMPLATE(ALubyte, ALint)
1206 DECL_TEMPLATE(ALubyte, ALuint)
1207 DECL_TEMPLATE(ALubyte, ALfloat)
1208 DECL_TEMPLATE(ALubyte, ALdouble)
1209 DECL_TEMPLATE(ALubyte, ALmulaw)
1210
1211 DECL_TEMPLATE(ALshort, ALbyte)
1212 DECL_TEMPLATE(ALshort, ALubyte)
1213 DECL_TEMPLATE(ALshort, ALshort)
1214 DECL_TEMPLATE(ALshort, ALushort)
1215 DECL_TEMPLATE(ALshort, ALint)
1216 DECL_TEMPLATE(ALshort, ALuint)
1217 DECL_TEMPLATE(ALshort, ALfloat)
1218 DECL_TEMPLATE(ALshort, ALdouble)
1219 DECL_TEMPLATE(ALshort, ALmulaw)
1220
1221 DECL_TEMPLATE(ALushort, ALbyte)
1222 DECL_TEMPLATE(ALushort, ALubyte)
1223 DECL_TEMPLATE(ALushort, ALshort)
1224 DECL_TEMPLATE(ALushort, ALushort)
1225 DECL_TEMPLATE(ALushort, ALint)
1226 DECL_TEMPLATE(ALushort, ALuint)
1227 DECL_TEMPLATE(ALushort, ALfloat)
1228 DECL_TEMPLATE(ALushort, ALdouble)
1229 DECL_TEMPLATE(ALushort, ALmulaw)
1230
1231 DECL_TEMPLATE(ALint, ALbyte)
1232 DECL_TEMPLATE(ALint, ALubyte)
1233 DECL_TEMPLATE(ALint, ALshort)
1234 DECL_TEMPLATE(ALint, ALushort)
1235 DECL_TEMPLATE(ALint, ALint)
1236 DECL_TEMPLATE(ALint, ALuint)
1237 DECL_TEMPLATE(ALint, ALfloat)
1238 DECL_TEMPLATE(ALint, ALdouble)
1239 DECL_TEMPLATE(ALint, ALmulaw)
1240
1241 DECL_TEMPLATE(ALuint, ALbyte)
1242 DECL_TEMPLATE(ALuint, ALubyte)
1243 DECL_TEMPLATE(ALuint, ALshort)
1244 DECL_TEMPLATE(ALuint, ALushort)
1245 DECL_TEMPLATE(ALuint, ALint)
1246 DECL_TEMPLATE(ALuint, ALuint)
1247 DECL_TEMPLATE(ALuint, ALfloat)
1248 DECL_TEMPLATE(ALuint, ALdouble)
1249 DECL_TEMPLATE(ALuint, ALmulaw)
1250
1251 DECL_TEMPLATE(ALfloat, ALbyte)
1252 DECL_TEMPLATE(ALfloat, ALubyte)
1253 DECL_TEMPLATE(ALfloat, ALshort)
1254 DECL_TEMPLATE(ALfloat, ALushort)
1255 DECL_TEMPLATE(ALfloat, ALint)
1256 DECL_TEMPLATE(ALfloat, ALuint)
1257 DECL_TEMPLATE(ALfloat, ALfloat)
1258 DECL_TEMPLATE(ALfloat, ALdouble)
1259 DECL_TEMPLATE(ALfloat, ALmulaw)
1260
1261 DECL_TEMPLATE(ALdouble, ALbyte)
1262 DECL_TEMPLATE(ALdouble, ALubyte)
1263 DECL_TEMPLATE(ALdouble, ALshort)
1264 DECL_TEMPLATE(ALdouble, ALushort)
1265 DECL_TEMPLATE(ALdouble, ALint)
1266 DECL_TEMPLATE(ALdouble, ALuint)
1267 DECL_TEMPLATE(ALdouble, ALfloat)
1268 DECL_TEMPLATE(ALdouble, ALdouble)
1269 DECL_TEMPLATE(ALdouble, ALmulaw)
1270
1271 #undef DECL_TEMPLATE
1272
1273 #define DECL_TEMPLATE(T) \
1274 static void Convert_##T(T *dst, const ALvoid *src, enum SrcFmtType srcType, \
1275 ALsizei len) \
1276 { \
1277 switch(srcType) \
1278 { \
1279 case SrcFmtByte: \
1280 Convert_##T##_ALbyte(dst, src, len); \
1281 break; \
1282 case SrcFmtUByte: \
1283 Convert_##T##_ALubyte(dst, src, len); \
1284 break; \
1285 case SrcFmtShort: \
1286 Convert_##T##_ALshort(dst, src, len); \
1287 break; \
1288 case SrcFmtUShort: \
1289 Convert_##T##_ALushort(dst, src, len); \
1290 break; \
1291 case SrcFmtInt: \
1292 Convert_##T##_ALint(dst, src, len); \
1293 break; \
1294 case SrcFmtUInt: \
1295 Convert_##T##_ALuint(dst, src, len); \
1296 break; \
1297 case SrcFmtFloat: \
1298 Convert_##T##_ALfloat(dst, src, len); \
1299 break; \
1300 case SrcFmtDouble: \
1301 Convert_##T##_ALdouble(dst, src, len); \
1302 break; \
1303 case SrcFmtMulaw: \
1304 Convert_##T##_ALmulaw(dst, src, len); \
1305 break; \
1306 case SrcFmtIMA4: \
1307 break; /* not handled here */ \
1308 } \
1309 }
1310
1311 DECL_TEMPLATE(ALbyte)
1312 DECL_TEMPLATE(ALubyte)
1313 DECL_TEMPLATE(ALshort)
1314 DECL_TEMPLATE(ALushort)
1315 DECL_TEMPLATE(ALint)
1316 DECL_TEMPLATE(ALuint)
1317 DECL_TEMPLATE(ALfloat)
1318 DECL_TEMPLATE(ALdouble)
1319
1320 #undef DECL_TEMPLATE
1321
1322
1323 /*
1324 * LoadData
1325 *
1326 * Loads the specified data into the buffer, using the specified formats.
1327 * Currently, the new format must have the same channel configuration as the
1328 * original format. This does NOT handle compressed formats (eg. IMA4).
1329 */
1330 static ALenum LoadData(ALbuffer *ALBuf, const ALvoid *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
1331 {
1332 ALuint NewBytes = aluBytesFromFormat(NewFormat);
1333 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
1334 ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
1335 ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
1336 enum SrcFmtChannels SrcChannels;
1337 enum FmtChannels DstChannels;
1338 enum SrcFmtType SrcType;
1339 enum FmtType DstType;
1340 ALuint64 newsize;
1341 ALvoid *temp;
1342
1343 assert(NewChannels == OrigChannels);
1344
1345 DecomposeInputFormat(OrigFormat, &SrcChannels, &SrcType);
1346 DecomposeFormat(NewFormat, &DstChannels, &DstType);
1347
1348 if((size%(OrigBytes*OrigChannels)) != 0)
1349 return AL_INVALID_VALUE;
1350
1351 newsize = size / OrigBytes;
1352 newsize *= NewBytes;
1353 if(newsize > INT_MAX)
1354 return AL_OUT_OF_MEMORY;
1355
1356 temp = realloc(ALBuf->data, newsize);
1357 if(!temp) return AL_OUT_OF_MEMORY;
1358 ALBuf->data = temp;
1359 ALBuf->size = newsize;
1360
1361 if(data != NULL)
1362 {
1363 // Samples are converted here
1364 ConvertData(ALBuf->data, DstType, data, SrcType, newsize/NewBytes);
1365 }
1366
1367 ALBuf->Frequency = freq;
1368 ALBuf->FmtType = DstType;
1369 ALBuf->FmtChannels = DstChannels;
1370
1371 ALBuf->LoopStart = 0;
1372 ALBuf->LoopEnd = newsize / NewChannels / NewBytes;
1373
1374 ALBuf->OriginalChannels = SrcChannels;
1375 ALBuf->OriginalType = SrcType;
1376 ALBuf->OriginalSize = size;
1377 ALBuf->OriginalAlign = OrigBytes * OrigChannels;
1378
1379 return AL_NO_ERROR;
1380 }
1381
1382 static void ConvertData(ALvoid *dst, enum FmtType dstType, const ALvoid *src, enum SrcFmtType srcType, ALsizei len)
1383 {
1384 switch(dstType)
1385 {
1386 (void)Convert_ALbyte;
1387 case FmtUByte:
1388 Convert_ALubyte(dst, src, srcType, len);
1389 break;
1390 case FmtShort:
1391 Convert_ALshort(dst, src, srcType, len);
1392 break;
1393 (void)Convert_ALushort;
1394 (void)Convert_ALint;
1395 (void)Convert_ALuint;
1396 case FmtFloat:
1397 Convert_ALfloat(dst, src, srcType, len);
1398 break;
1399 (void)Convert_ALdouble;
1400 }
1401 }
1402
1403
1404 ALuint BytesFromSrcFmt(enum SrcFmtType type)
1405 {
1406 switch(type)
1407 {
1408 case SrcFmtByte: return sizeof(ALbyte);
1409 case SrcFmtUByte: return sizeof(ALubyte);
1410 case SrcFmtShort: return sizeof(ALshort);
1411 case SrcFmtUShort: return sizeof(ALushort);
1412 case SrcFmtInt: return sizeof(ALint);
1413 case SrcFmtUInt: return sizeof(ALuint);
1414 case SrcFmtFloat: return sizeof(ALfloat);
1415 case SrcFmtDouble: return sizeof(ALdouble);
1416 case SrcFmtMulaw: return sizeof(ALubyte);
1417 case SrcFmtIMA4: break; /* not handled here */
1418 }
1419 return 0;
1420 }
1421 ALuint ChannelsFromSrcFmt(enum SrcFmtChannels chans)
1422 {
1423 switch(chans)
1424 {
1425 case SrcFmtMono: return 1;
1426 case SrcFmtStereo: return 2;
1427 case SrcFmtRear: return 2;
1428 case SrcFmtQuad: return 4;
1429 case SrcFmtX51: return 6;
1430 case SrcFmtX61: return 7;
1431 case SrcFmtX71: return 8;
1432 }
1433 return 0;
1434 }
1435 void DecomposeInputFormat(ALenum format, enum SrcFmtChannels *chans,
1436 enum SrcFmtType *type)
1437 {
1438 switch(format)
1439 {
1440 case AL_FORMAT_MONO8:
1441 *chans = SrcFmtMono;
1442 *type = SrcFmtUByte;
1443 break;
1444 case AL_FORMAT_MONO16:
1445 *chans = SrcFmtMono;
1446 *type = SrcFmtShort;
1447 break;
1448 case AL_FORMAT_MONO_FLOAT32:
1449 *chans = SrcFmtMono;
1450 *type = SrcFmtFloat;
1451 break;
1452 case AL_FORMAT_MONO_DOUBLE_EXT:
1453 *chans = SrcFmtMono;
1454 *type = SrcFmtDouble;
1455 break;
1456 case AL_FORMAT_MONO_IMA4:
1457 *chans = SrcFmtMono;
1458 *type = SrcFmtIMA4;
1459 break;
1460 case AL_FORMAT_STEREO8:
1461 *chans = SrcFmtStereo;
1462 *type = SrcFmtUByte;
1463 break;
1464 case AL_FORMAT_STEREO16:
1465 *chans = SrcFmtStereo;
1466 *type = SrcFmtShort;
1467 break;
1468 case AL_FORMAT_STEREO_FLOAT32:
1469 *chans = SrcFmtStereo;
1470 *type = SrcFmtFloat;
1471 break;
1472 case AL_FORMAT_STEREO_DOUBLE_EXT:
1473 *chans = SrcFmtStereo;
1474 *type = SrcFmtDouble;
1475 break;
1476 case AL_FORMAT_STEREO_IMA4:
1477 *chans = SrcFmtStereo;
1478 *type = SrcFmtIMA4;
1479 break;
1480 case AL_FORMAT_QUAD8_LOKI:
1481 case AL_FORMAT_QUAD8:
1482 *chans = SrcFmtQuad;
1483 *type = SrcFmtUByte;
1484 break;
1485 case AL_FORMAT_QUAD16_LOKI:
1486 case AL_FORMAT_QUAD16:
1487 *chans = SrcFmtQuad;
1488 *type = SrcFmtShort;
1489 break;
1490 case AL_FORMAT_QUAD32:
1491 *chans = SrcFmtQuad;
1492 *type = SrcFmtFloat;
1493 break;
1494 case AL_FORMAT_REAR8:
1495 *chans = SrcFmtRear;
1496 *type = SrcFmtUByte;
1497 break;
1498 case AL_FORMAT_REAR16:
1499 *chans = SrcFmtRear;
1500 *type = SrcFmtShort;
1501 break;
1502 case AL_FORMAT_REAR32:
1503 *chans = SrcFmtRear;
1504 *type = SrcFmtFloat;
1505 break;
1506 case AL_FORMAT_51CHN8:
1507 *chans = SrcFmtX51;
1508 *type = SrcFmtUByte;
1509 break;
1510 case AL_FORMAT_51CHN16:
1511 *chans = SrcFmtX51;
1512 *type = SrcFmtShort;
1513 break;
1514 case AL_FORMAT_51CHN32:
1515 *chans = SrcFmtX51;
1516 *type = SrcFmtFloat;
1517 break;
1518 case AL_FORMAT_61CHN8:
1519 *chans = SrcFmtX61;
1520 *type = SrcFmtUByte;
1521 break;
1522 case AL_FORMAT_61CHN16:
1523 *chans = SrcFmtX61;
1524 *type = SrcFmtShort;
1525 break;
1526 case AL_FORMAT_61CHN32:
1527 *chans = SrcFmtX61;
1528 *type = SrcFmtFloat;
1529 break;
1530 case AL_FORMAT_71CHN8:
1531 *chans = SrcFmtX71;
1532 *type = SrcFmtUByte;
1533 break;
1534 case AL_FORMAT_71CHN16:
1535 *chans = SrcFmtX71;
1536 *type = SrcFmtShort;
1537 break;
1538 case AL_FORMAT_71CHN32:
1539 *chans = SrcFmtX71;
1540 *type = SrcFmtFloat;
1541 break;
1542 case AL_FORMAT_MONO_MULAW:
1543 *chans = SrcFmtMono;
1544 *type = SrcFmtMulaw;
1545 break;
1546 case AL_FORMAT_STEREO_MULAW:
1547 *chans = SrcFmtStereo;
1548 *type = SrcFmtMulaw;
1549 break;
1550 case AL_FORMAT_QUAD_MULAW:
1551 *chans = SrcFmtQuad;
1552 *type = SrcFmtMulaw;
1553 break;
1554 case AL_FORMAT_REAR_MULAW:
1555 *chans = SrcFmtRear;
1556 *type = SrcFmtMulaw;
1557 break;
1558 case AL_FORMAT_51CHN_MULAW:
1559 *chans = SrcFmtX51;
1560 *type = SrcFmtMulaw;
1561 break;
1562 case AL_FORMAT_61CHN_MULAW:
1563 *chans = SrcFmtX61;
1564 *type = SrcFmtMulaw;
1565 break;
1566 case AL_FORMAT_71CHN_MULAW:
1567 *chans = SrcFmtX71;
1568 *type = SrcFmtMulaw;
1569 break;
1570
1571 default:
1572 AL_PRINT("Unhandled format specified: 0x%X\n", format);
1573 abort();
1574 }
1575 }
1576
1577 ALuint BytesFromFmt(enum FmtType type)
1578 {
1579 switch(type)
1580 {
1581 case FmtUByte: return sizeof(ALubyte);
1582 case FmtShort: return sizeof(ALshort);
1583 case FmtFloat: return sizeof(ALfloat);
1584 }
1585 return 0;
1586 }
1587 ALuint ChannelsFromFmt(enum FmtChannels chans)
1588 {
1589 switch(chans)
1590 {
1591 case FmtMono: return 1;
1592 case FmtStereo: return 2;
1593 case FmtRear: return 2;
1594 case FmtQuad: return 4;
1595 case FmtX51: return 6;
1596 case FmtX61: return 7;
1597 case FmtX71: return 8;
1598 }
1599 return 0;
1600 }
1601 void DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
1602 {
1603 switch(format)
1604 {
1605 case AL_FORMAT_MONO8:
1606 *chans = FmtMono;
1607 *type = FmtUByte;
1608 break;
1609 case AL_FORMAT_MONO16:
1610 *chans = FmtMono;
1611 *type = FmtShort;
1612 break;
1613 case AL_FORMAT_MONO_FLOAT32:
1614 *chans = FmtMono;
1615 *type = FmtFloat;
1616 break;
1617 case AL_FORMAT_STEREO8:
1618 *chans = FmtStereo;
1619 *type = FmtUByte;
1620 break;
1621 case AL_FORMAT_STEREO16:
1622 *chans = FmtStereo;
1623 *type = FmtShort;
1624 break;
1625 case AL_FORMAT_STEREO_FLOAT32:
1626 *chans = FmtStereo;
1627 *type = FmtFloat;
1628 break;
1629 case AL_FORMAT_QUAD8_LOKI:
1630 case AL_FORMAT_QUAD8:
1631 *chans = FmtQuad;
1632 *type = FmtUByte;
1633 break;
1634 case AL_FORMAT_QUAD16_LOKI:
1635 case AL_FORMAT_QUAD16:
1636 *chans = FmtQuad;
1637 *type = FmtShort;
1638 break;
1639 case AL_FORMAT_QUAD32:
1640 *chans = FmtQuad;
1641 *type = FmtFloat;
1642 break;
1643 case AL_FORMAT_REAR8:
1644 *chans = FmtRear;
1645 *type = FmtUByte;
1646 break;
1647 case AL_FORMAT_REAR16:
1648 *chans = FmtRear;
1649 *type = FmtShort;
1650 break;
1651 case AL_FORMAT_REAR32:
1652 *chans = FmtRear;
1653 *type = FmtFloat;
1654 break;
1655 case AL_FORMAT_51CHN8:
1656 *chans = FmtX51;
1657 *type = FmtUByte;
1658 break;
1659 case AL_FORMAT_51CHN16:
1660 *chans = FmtX51;
1661 *type = FmtShort;
1662 break;
1663 case AL_FORMAT_51CHN32:
1664 *chans = FmtX51;
1665 *type = FmtFloat;
1666 break;
1667 case AL_FORMAT_61CHN8:
1668 *chans = FmtX61;
1669 *type = FmtUByte;
1670 break;
1671 case AL_FORMAT_61CHN16:
1672 *chans = FmtX61;
1673 *type = FmtShort;
1674 break;
1675 case AL_FORMAT_61CHN32:
1676 *chans = FmtX61;
1677 *type = FmtFloat;
1678 break;
1679 case AL_FORMAT_71CHN8:
1680 *chans = FmtX71;
1681 *type = FmtUByte;
1682 break;
1683 case AL_FORMAT_71CHN16:
1684 *chans = FmtX71;
1685 *type = FmtShort;
1686 break;
1687 case AL_FORMAT_71CHN32:
1688 *chans = FmtX71;
1689 *type = FmtFloat;
1690 break;
1691
1692 default:
1693 AL_PRINT("Unhandled format specified: 0x%X\n", format);
1694 abort();
1695 }
1696 }
1697
1698
1699 /*
1700 * ReleaseALBuffers()
1701 *
1702 * INTERNAL FN : Called by alcCloseDevice to destroy any buffers that still exist
1703 */
1704 ALvoid ReleaseALBuffers(ALCdevice *device)
1705 {
1706 ALsizei i;
1707 for(i = 0;i < device->BufferMap.size;i++)
1708 {
1709 ALbuffer *temp = device->BufferMap.array[i].value;
1710 device->BufferMap.array[i].value = NULL;
1711
1712 // Release sample data
1713 free(temp->data);
1714
1715 // Release Buffer structure
1716 ALTHUNK_REMOVEENTRY(temp->buffer);
1717 memset(temp, 0, sizeof(ALbuffer));
1718 free(temp);
1719 }
1720 }
fork of openal-soft for dark-hammer project