?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't return unsupported effects from alGetEnumValue
[openal-soft.git] / OpenAL32 / alBuffer.c
blobb7650ec26c5e89a6ddf3dff0910e0e918856e489
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 "alMain.h"
27 #include "AL/al.h"
28 #include "AL/alc.h"
29 #include "alError.h"
30 #include "alBuffer.h"
31 #include "alDatabuffer.h"
32 #include "alThunk.h"
33
34
35 static ALenum LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat);
36 static void ConvertData(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len);
37 static void ConvertDataRear(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len);
38 static void ConvertDataIMA4(ALfloat *dst, const ALvoid *src, ALint origChans, ALsizei len);
39 static void ConvertDataMULaw(ALfloat *dst, const ALvoid *src, ALsizei len);
40 static void ConvertDataMULawRear(ALfloat *dst, const ALvoid *src, ALsizei len);
41
42 DECL_VERIFIER(Buffer, ALbuffer, buffer)
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 *puiBuffers)
104 *
105 * Generates n AL Buffers, and stores the Buffers Names in the array pointed to by puiBuffers
106 */
107 ALAPI ALvoid ALAPIENTRY alGenBuffers(ALsizei n,ALuint *puiBuffers)
108 {
109 ALCcontext *Context;
110 ALsizei i=0;
111
112 Context = GetContextSuspended();
113 if(!Context) return;
114
115 // Check that we are actually generation some Buffers
116 if (n > 0)
117 {
118 ALCdevice *device = Context->Device;
119
120 // Check the pointer is valid (and points to enough memory to store Buffer Names)
121 if (!IsBadWritePtr((void*)puiBuffers, n * sizeof(ALuint)))
122 {
123 ALbuffer **list = &device->BufferList;
124 while(*list)
125 list = &(*list)->next;
126
127 // Create all the new Buffers
128 while(i < n)
129 {
130 *list = calloc(1, sizeof(ALbuffer));
131 if(!(*list))
132 {
133 alDeleteBuffers(i, puiBuffers);
134 alSetError(Context, AL_OUT_OF_MEMORY);
135 break;
136 }
137
138 puiBuffers[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
139 (*list)->buffer = puiBuffers[i];
140
141 device->BufferCount++;
142 i++;
143
144 list = &(*list)->next;
145 }
146 }
147 else
148 {
149 // Pointer does not point to enough memory to write Buffer names
150 alSetError(Context, AL_INVALID_VALUE);
151 }
152 }
153
154 ProcessContext(Context);
155 }
156
157 /*
158 * alDeleteBuffers(ALsizei n, ALuint *puiBuffers)
159 *
160 * Deletes the n AL Buffers pointed to by puiBuffers
161 */
162 ALAPI ALvoid ALAPIENTRY alDeleteBuffers(ALsizei n, const ALuint *puiBuffers)
163 {
164 ALCcontext *Context;
165 ALbuffer *ALBuf;
166 ALsizei i;
167 ALboolean bFailed = AL_FALSE;
168
169 Context = GetContextSuspended();
170 if(!Context) return;
171
172 // Check we are actually Deleting some Buffers
173 if (n >= 0)
174 {
175 ALCdevice *device = Context->Device;
176
177 // Check that all the buffers are valid and can actually be deleted
178 for (i = 0; i < n; i++)
179 {
180 if(!puiBuffers[i])
181 continue;
182
183 // Check for valid Buffer ID (can be NULL buffer)
184 if((ALBuf=VerifyBuffer(device->BufferList, puiBuffers[i])) != NULL)
185 {
186 if(ALBuf->refcount != 0)
187 {
188 // Buffer still in use, cannot be deleted
189 alSetError(Context, AL_INVALID_OPERATION);
190 bFailed = AL_TRUE;
191 break;
192 }
193 }
194 else
195 {
196 // Invalid Buffer
197 alSetError(Context, AL_INVALID_NAME);
198 bFailed = AL_TRUE;
199 break;
200 }
201 }
202
203 // If all the Buffers were valid (and have Reference Counts of 0), then we can delete them
204 if (!bFailed)
205 {
206 for (i = 0; i < n; i++)
207 {
208 if((ALBuf=VerifyBuffer(device->BufferList, puiBuffers[i])) != NULL)
209 {
210 ALbuffer **list = &device->BufferList;
211
212 while(*list && *list != ALBuf)
213 list = &(*list)->next;
214
215 if(*list)
216 *list = (*list)->next;
217
218 // Release the memory used to store audio data
219 free(ALBuf->data);
220
221 // Release buffer structure
222 ALTHUNK_REMOVEENTRY(puiBuffers[i]);
223 memset(ALBuf, 0, sizeof(ALbuffer));
224 device->BufferCount--;
225 free(ALBuf);
226 }
227 }
228 }
229 }
230 else
231 alSetError(Context, AL_INVALID_VALUE);
232
233 ProcessContext(Context);
234 }
235
236 /*
237 * alIsBuffer(ALuint uiBuffer)
238 *
239 * Checks if ulBuffer is a valid Buffer Name
240 */
241 ALAPI ALboolean ALAPIENTRY alIsBuffer(ALuint uiBuffer)
242 {
243 ALCcontext *Context;
244 ALboolean result = AL_TRUE;
245
246 Context = GetContextSuspended();
247 if(!Context) return AL_FALSE;
248
249 if(uiBuffer)
250 result = (VerifyBuffer(Context->Device->BufferList, uiBuffer) ?
251 AL_TRUE : AL_FALSE);
252
253 ProcessContext(Context);
254
255 return result;
256 }
257
258 /*
259 * alBufferData(ALuint buffer,ALenum format,ALvoid *data,ALsizei size,ALsizei freq)
260 *
261 * Fill buffer with audio data
262 */
263 ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
264 {
265 ALCcontext *Context;
266 ALCdevice *device;
267 ALbuffer *ALBuf;
268 ALvoid *temp;
269 ALenum err;
270
271 Context = GetContextSuspended();
272 if(!Context) return;
273
274 device = Context->Device;
275 if((ALBuf=VerifyBuffer(device->BufferList, buffer)) != NULL)
276 {
277 if(Context->SampleSource)
278 {
279 ALuint offset;
280
281 if(Context->SampleSource->state == MAPPED)
282 {
283 alSetError(Context, AL_INVALID_OPERATION);
284 ProcessContext(Context);
285 return;
286 }
287
288 offset = (ALuint)data;
289 data = Context->SampleSource->data + offset;
290 }
291
292 if ((ALBuf->refcount==0)&&(data))
293 {
294 switch(format)
295 {
296 case AL_FORMAT_MONO8:
297 case AL_FORMAT_MONO16:
298 case AL_FORMAT_MONO_FLOAT32:
299 case AL_FORMAT_MONO_DOUBLE_EXT:
300 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_MONO_FLOAT32);
301 if(err != AL_NO_ERROR)
302 alSetError(Context, err);
303 break;
304
305 case AL_FORMAT_STEREO8:
306 case AL_FORMAT_STEREO16:
307 case AL_FORMAT_STEREO_FLOAT32:
308 case AL_FORMAT_STEREO_DOUBLE_EXT:
309 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_STEREO_FLOAT32);
310 if(err != AL_NO_ERROR)
311 alSetError(Context, err);
312 break;
313
314 case AL_FORMAT_REAR8:
315 case AL_FORMAT_REAR16:
316 case AL_FORMAT_REAR32: {
317 ALuint NewFormat = AL_FORMAT_QUAD32;
318 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
319 ALuint NewBytes = aluBytesFromFormat(NewFormat);
320 ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
321 ((format==AL_FORMAT_REAR16) ? 2 :
322 4));
323
324 if((size%(OrigBytes*2)) != 0)
325 {
326 alSetError(Context, AL_INVALID_VALUE);
327 break;
328 }
329
330 size /= OrigBytes;
331 size *= 2;
332
333 // Samples are converted here
334 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size) * NewBytes);
335 if(temp)
336 {
337 ALBuf->data = temp;
338 ConvertDataRear(ALBuf->data, data, OrigBytes, size);
339
340 ALBuf->format = NewFormat;
341 ALBuf->eOriginalFormat = format;
342 ALBuf->size = size*NewBytes;
343 ALBuf->frequency = freq;
344 }
345 else
346 alSetError(Context, AL_OUT_OF_MEMORY);
347 } break;
348
349 case AL_FORMAT_QUAD8_LOKI:
350 case AL_FORMAT_QUAD16_LOKI:
351 case AL_FORMAT_QUAD8:
352 case AL_FORMAT_QUAD16:
353 case AL_FORMAT_QUAD32:
354 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_QUAD32);
355 if(err != AL_NO_ERROR)
356 alSetError(Context, err);
357 break;
358
359 case AL_FORMAT_51CHN8:
360 case AL_FORMAT_51CHN16:
361 case AL_FORMAT_51CHN32:
362 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_51CHN32);
363 if(err != AL_NO_ERROR)
364 alSetError(Context, err);
365 break;
366
367 case AL_FORMAT_61CHN8:
368 case AL_FORMAT_61CHN16:
369 case AL_FORMAT_61CHN32:
370 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_61CHN32);
371 if(err != AL_NO_ERROR)
372 alSetError(Context, err);
373 break;
374
375 case AL_FORMAT_71CHN8:
376 case AL_FORMAT_71CHN16:
377 case AL_FORMAT_71CHN32:
378 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_71CHN32);
379 if(err != AL_NO_ERROR)
380 alSetError(Context, err);
381 break;
382
383 case AL_FORMAT_MONO_IMA4:
384 case AL_FORMAT_STEREO_IMA4: {
385 int OrigChans = ((format==AL_FORMAT_MONO_IMA4) ? 1 : 2);
386 ALuint NewFormat = ((OrigChans==1) ? AL_FORMAT_MONO_FLOAT32 :
387 AL_FORMAT_STEREO_FLOAT32);
388 ALuint NewBytes = aluBytesFromFormat(NewFormat);
389
390 // Here is where things vary:
391 // nVidia and Apple use 64+1 samples per channel per block => block_size=36*chans bytes
392 // Most PC sound software uses 2040+1 samples per channel per block -> block_size=1024*chans bytes
393 if((size%(36*OrigChans)) != 0)
394 {
395 alSetError(Context, AL_INVALID_VALUE);
396 break;
397 }
398
399 size /= 36;
400 size *= 65;
401
402 // Allocate extra padding samples
403 temp = realloc(ALBuf->data, (BUFFER_PADDING*OrigChans + size)*NewBytes);
404 if(temp)
405 {
406 ALBuf->data = temp;
407 ConvertDataIMA4(ALBuf->data, data, OrigChans, size/65);
408
409 ALBuf->format = NewFormat;
410 ALBuf->eOriginalFormat = format;
411 ALBuf->size = size*NewBytes;
412 ALBuf->frequency = freq;
413 }
414 else
415 alSetError(Context, AL_OUT_OF_MEMORY);
416 } break;
417
418 case AL_FORMAT_MONO_MULAW:
419 case AL_FORMAT_STEREO_MULAW:
420 case AL_FORMAT_QUAD_MULAW:
421 case AL_FORMAT_51CHN_MULAW:
422 case AL_FORMAT_61CHN_MULAW:
423 case AL_FORMAT_71CHN_MULAW: {
424 int Channels = ((format==AL_FORMAT_MONO_MULAW) ? 1 :
425 ((format==AL_FORMAT_STEREO_MULAW) ? 2 :
426 ((format==AL_FORMAT_QUAD_MULAW) ? 4 :
427 ((format==AL_FORMAT_51CHN_MULAW) ? 6 :
428 ((format==AL_FORMAT_61CHN_MULAW) ? 7 : 8)))));
429 ALuint NewFormat = ((Channels==1) ? AL_FORMAT_MONO_FLOAT32 :
430 ((Channels==2) ? AL_FORMAT_STEREO_FLOAT32 :
431 ((Channels==4) ? AL_FORMAT_QUAD32 :
432 ((Channels==6) ? AL_FORMAT_51CHN32 :
433 ((Channels==7) ? AL_FORMAT_61CHN32 :
434 AL_FORMAT_71CHN32)))));
435 ALuint NewBytes = aluBytesFromFormat(NewFormat);
436
437 if((size%(1*Channels)) != 0)
438 {
439 alSetError(Context, AL_INVALID_VALUE);
440 break;
441 }
442
443 // Allocate extra padding samples
444 temp = realloc(ALBuf->data, (BUFFER_PADDING*Channels + size)*NewBytes);
445 if(temp)
446 {
447 ALBuf->data = temp;
448 ConvertDataMULaw(ALBuf->data, data, size);
449
450 ALBuf->format = NewFormat;
451 ALBuf->eOriginalFormat = format;
452 ALBuf->size = size*NewBytes;
453 ALBuf->frequency = freq;
454 }
455 else
456 alSetError(Context, AL_OUT_OF_MEMORY);
457 } break;
458
459 case AL_FORMAT_REAR_MULAW: {
460 int OrigChans = 2;
461 ALuint NewFormat = AL_FORMAT_QUAD32;
462 ALuint NewBytes = aluBytesFromFormat(NewFormat);
463 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
464
465 if((size%(1*OrigChans)) != 0)
466 {
467 alSetError(Context, AL_INVALID_VALUE);
468 break;
469 }
470
471 size *= 2;
472
473 // Allocate extra padding samples
474 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size)*NewBytes);
475 if(temp)
476 {
477 ALBuf->data = temp;
478 ConvertDataMULawRear(ALBuf->data, data, size);
479
480 ALBuf->format = NewFormat;
481 ALBuf->eOriginalFormat = format;
482 ALBuf->size = size*NewBytes;
483 ALBuf->frequency = freq;
484 }
485 else
486 alSetError(Context, AL_OUT_OF_MEMORY);
487 } break;
488
489 default:
490 alSetError(Context, AL_INVALID_ENUM);
491 break;
492 }
493 }
494 else
495 {
496 // Buffer is in use, or data is a NULL pointer
497 alSetError(Context, AL_INVALID_VALUE);
498 }
499 }
500 else
501 {
502 // Invalid Buffer Name
503 alSetError(Context, AL_INVALID_NAME);
504 }
505
506 ProcessContext(Context);
507 }
508
509 /*
510 * alBufferSubDataEXT(ALuint buffer,ALenum format,ALvoid *data,ALsizei offset,ALsizei length)
511 *
512 * Fill buffer with audio data
513 */
514 ALvoid ALAPIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
515 {
516 ALCcontext *Context;
517 ALCdevice *device;
518 ALbuffer *ALBuf;
519
520 Context = GetContextSuspended();
521 if(!Context) return;
522
523 device = Context->Device;
524 if((ALBuf=VerifyBuffer(device->BufferList, buffer)) != NULL)
525 {
526 if(Context->SampleSource)
527 {
528 ALuint offset;
529
530 if(Context->SampleSource->state == MAPPED)
531 {
532 alSetError(Context, AL_INVALID_OPERATION);
533 ProcessContext(Context);
534 return;
535 }
536
537 offset = (ALuint)data;
538 data = Context->SampleSource->data + offset;
539 }
540
541 if(ALBuf->data == NULL)
542 {
543 // buffer does not have any data
544 alSetError(Context, AL_INVALID_NAME);
545 }
546 else if(length < 0 || offset < 0 || (length > 0 && data == NULL))
547 {
548 // data is NULL or offset/length is negative
549 alSetError(Context, AL_INVALID_VALUE);
550 }
551 else
552 {
553 switch(format)
554 {
555 case AL_FORMAT_REAR8:
556 case AL_FORMAT_REAR16:
557 case AL_FORMAT_REAR32: {
558 ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
559 ((format==AL_FORMAT_REAR16) ? 2 :
560 4));
561 ALuint NewBytes = aluBytesFromFormat(ALBuf->format);
562
563 if(ALBuf->eOriginalFormat != AL_FORMAT_REAR8 &&
564 ALBuf->eOriginalFormat != AL_FORMAT_REAR16 &&
565 ALBuf->eOriginalFormat != AL_FORMAT_REAR32)
566 {
567 alSetError(Context, AL_INVALID_ENUM);
568 break;
569 }
570
571 if(ALBuf->size/4/NewBytes < (ALuint)offset+length)
572 {
573 alSetError(Context, AL_INVALID_VALUE);
574 break;
575 }
576
577 ConvertDataRear(&ALBuf->data[offset*4], data, OrigBytes, length*2);
578 } break;
579
580 case AL_FORMAT_MONO_IMA4:
581 case AL_FORMAT_STEREO_IMA4: {
582 int Channels = aluChannelsFromFormat(ALBuf->format);
583 ALuint Bytes = aluBytesFromFormat(ALBuf->format);
584
585 if(ALBuf->eOriginalFormat != format)
586 {
587 alSetError(Context, AL_INVALID_ENUM);
588 break;
589 }
590
591 if((offset%65) != 0 || (length%65) != 0 ||
592 ALBuf->size/Channels/Bytes < (ALuint)offset+length)
593 {
594 alSetError(Context, AL_INVALID_VALUE);
595 break;
596 }
597
598 ConvertDataIMA4(&ALBuf->data[offset*Channels], data, Channels, length/65*Channels);
599 } break;
600
601 case AL_FORMAT_MONO_MULAW:
602 case AL_FORMAT_STEREO_MULAW:
603 case AL_FORMAT_QUAD_MULAW:
604 case AL_FORMAT_REAR_MULAW:
605 case AL_FORMAT_51CHN_MULAW:
606 case AL_FORMAT_61CHN_MULAW:
607 case AL_FORMAT_71CHN_MULAW: {
608 int Channels = aluChannelsFromFormat(ALBuf->format);
609 ALuint Bytes = aluBytesFromFormat(ALBuf->format);
610
611 if(ALBuf->eOriginalFormat != format)
612 {
613 alSetError(Context, AL_INVALID_ENUM);
614 break;
615 }
616
617 if(ALBuf->size/Channels/Bytes < (ALuint)offset+length)
618 {
619 alSetError(Context, AL_INVALID_VALUE);
620 break;
621 }
622
623 if(ALBuf->eOriginalFormat == AL_FORMAT_REAR_MULAW)
624 ConvertDataMULawRear(&ALBuf->data[offset*Channels], data, length*2);
625 else
626 ConvertDataMULaw(&ALBuf->data[offset*Channels], data, length*Channels);
627 } break;
628
629 default: {
630 ALuint Channels = aluChannelsFromFormat(format);
631 ALuint Bytes = aluBytesFromFormat(format);
632 ALuint NewBytes = aluBytesFromFormat(ALBuf->format);
633
634 if(Channels != aluChannelsFromFormat(ALBuf->format))
635 {
636 alSetError(Context, AL_INVALID_ENUM);
637 break;
638 }
639
640 if(ALBuf->size/Channels/NewBytes < (ALuint)offset+length)
641 {
642 alSetError(Context, AL_INVALID_VALUE);
643 break;
644 }
645
646 ConvertData(&ALBuf->data[offset*Channels], data, Bytes, length*Channels);
647 } break;
648 }
649 }
650 }
651 else
652 {
653 // Invalid Buffer Name
654 alSetError(Context, AL_INVALID_NAME);
655 }
656
657 ProcessContext(Context);
658 }
659
660
661 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
662 {
663 ALCcontext *pContext;
664 ALCdevice *device;
665
666 (void)flValue;
667
668 pContext = GetContextSuspended();
669 if(!pContext) return;
670
671 device = pContext->Device;
672 if(VerifyBuffer(device->BufferList, buffer) != NULL)
673 {
674 switch(eParam)
675 {
676 default:
677 alSetError(pContext, AL_INVALID_ENUM);
678 break;
679 }
680 }
681 else
682 {
683 alSetError(pContext, AL_INVALID_NAME);
684 }
685
686 ProcessContext(pContext);
687 }
688
689
690 ALAPI void ALAPIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
691 {
692 ALCcontext *pContext;
693 ALCdevice *device;
694
695 (void)flValue1;
696 (void)flValue2;
697 (void)flValue3;
698
699 pContext = GetContextSuspended();
700 if(!pContext) return;
701
702 device = pContext->Device;
703 if(VerifyBuffer(device->BufferList, buffer) != NULL)
704 {
705 switch(eParam)
706 {
707 default:
708 alSetError(pContext, AL_INVALID_ENUM);
709 break;
710 }
711 }
712 else
713 {
714 alSetError(pContext, AL_INVALID_NAME);
715 }
716
717 ProcessContext(pContext);
718 }
719
720
721 ALAPI void ALAPIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
722 {
723 ALCcontext *pContext;
724 ALCdevice *device;
725
726 (void)flValues;
727
728 pContext = GetContextSuspended();
729 if(!pContext) return;
730
731 device = pContext->Device;
732 if(VerifyBuffer(device->BufferList, buffer) != NULL)
733 {
734 switch(eParam)
735 {
736 default:
737 alSetError(pContext, AL_INVALID_ENUM);
738 break;
739 }
740 }
741 else
742 {
743 alSetError(pContext, AL_INVALID_NAME);
744 }
745
746 ProcessContext(pContext);
747 }
748
749
750 ALAPI void ALAPIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
751 {
752 ALCcontext *pContext;
753 ALCdevice *device;
754
755 (void)lValue;
756
757 pContext = GetContextSuspended();
758 if(!pContext) return;
759
760 device = pContext->Device;
761 if(VerifyBuffer(device->BufferList, buffer) != NULL)
762 {
763 switch(eParam)
764 {
765 default:
766 alSetError(pContext, AL_INVALID_ENUM);
767 break;
768 }
769 }
770 else
771 {
772 alSetError(pContext, AL_INVALID_NAME);
773 }
774
775 ProcessContext(pContext);
776 }
777
778
779 ALAPI void ALAPIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
780 {
781 ALCcontext *pContext;
782 ALCdevice *device;
783
784 (void)lValue1;
785 (void)lValue2;
786 (void)lValue3;
787
788 pContext = GetContextSuspended();
789 if(!pContext) return;
790
791 device = pContext->Device;
792 if(VerifyBuffer(device->BufferList, buffer) != NULL)
793 {
794 switch(eParam)
795 {
796 default:
797 alSetError(pContext, AL_INVALID_ENUM);
798 break;
799 }
800 }
801 else
802 {
803 alSetError(pContext, AL_INVALID_NAME);
804 }
805
806 ProcessContext(pContext);
807 }
808
809
810 ALAPI void ALAPIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
811 {
812 ALCcontext *pContext;
813 ALCdevice *device;
814
815 (void)plValues;
816
817 pContext = GetContextSuspended();
818 if(!pContext) return;
819
820 device = pContext->Device;
821 if(VerifyBuffer(device->BufferList, buffer) != NULL)
822 {
823 switch(eParam)
824 {
825 default:
826 alSetError(pContext, AL_INVALID_ENUM);
827 break;
828 }
829 }
830 else
831 {
832 alSetError(pContext, AL_INVALID_NAME);
833 }
834
835 ProcessContext(pContext);
836 }
837
838
839 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
840 {
841 ALCcontext *pContext;
842 ALCdevice *device;
843
844 pContext = GetContextSuspended();
845 if(!pContext) return;
846
847 if (pflValue)
848 {
849 device = pContext->Device;
850 if(VerifyBuffer(device->BufferList, buffer) != NULL)
851 {
852 switch(eParam)
853 {
854 default:
855 alSetError(pContext, AL_INVALID_ENUM);
856 break;
857 }
858 }
859 else
860 {
861 alSetError(pContext, AL_INVALID_NAME);
862 }
863 }
864 else
865 {
866 alSetError(pContext, AL_INVALID_VALUE);
867 }
868
869 ProcessContext(pContext);
870 }
871
872
873 ALAPI void ALAPIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
874 {
875 ALCcontext *pContext;
876 ALCdevice *device;
877
878 pContext = GetContextSuspended();
879 if(!pContext) return;
880
881 if ((pflValue1) && (pflValue2) && (pflValue3))
882 {
883 device = pContext->Device;
884 if(VerifyBuffer(device->BufferList, buffer) != NULL)
885 {
886 switch(eParam)
887 {
888 default:
889 alSetError(pContext, AL_INVALID_ENUM);
890 break;
891 }
892 }
893 else
894 {
895 alSetError(pContext, AL_INVALID_NAME);
896 }
897 }
898 else
899 {
900 alSetError(pContext, AL_INVALID_VALUE);
901 }
902
903 ProcessContext(pContext);
904 }
905
906
907 ALAPI void ALAPIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
908 {
909 ALCcontext *pContext;
910 ALCdevice *device;
911
912 pContext = GetContextSuspended();
913 if(!pContext) return;
914
915 if (pflValues)
916 {
917 device = pContext->Device;
918 if(VerifyBuffer(device->BufferList, buffer) != NULL)
919 {
920 switch(eParam)
921 {
922 default:
923 alSetError(pContext, AL_INVALID_ENUM);
924 break;
925 }
926 }
927 else
928 {
929 alSetError(pContext, AL_INVALID_NAME);
930 }
931 }
932 else
933 {
934 alSetError(pContext, AL_INVALID_VALUE);
935 }
936
937 ProcessContext(pContext);
938 }
939
940
941 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
942 {
943 ALCcontext *pContext;
944 ALbuffer *pBuffer;
945 ALCdevice *device;
946
947 pContext = GetContextSuspended();
948 if(!pContext) return;
949
950 if (plValue)
951 {
952 device = pContext->Device;
953 if((pBuffer=VerifyBuffer(device->BufferList, buffer)) != NULL)
954 {
955 switch (eParam)
956 {
957 case AL_FREQUENCY:
958 *plValue = pBuffer->frequency;
959 break;
960
961 case AL_BITS:
962 *plValue = aluBytesFromFormat(pBuffer->format) * 8;
963 break;
964
965 case AL_CHANNELS:
966 *plValue = aluChannelsFromFormat(pBuffer->format);
967 break;
968
969 case AL_SIZE:
970 *plValue = pBuffer->size;
971 break;
972
973 default:
974 alSetError(pContext, AL_INVALID_ENUM);
975 break;
976 }
977 }
978 else
979 {
980 alSetError(pContext, AL_INVALID_NAME);
981 }
982 }
983 else
984 {
985 alSetError(pContext, AL_INVALID_VALUE);
986 }
987
988 ProcessContext(pContext);
989 }
990
991
992 ALAPI void ALAPIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
993 {
994 ALCcontext *pContext;
995 ALCdevice *device;
996
997 pContext = GetContextSuspended();
998 if(!pContext) return;
999
1000 if ((plValue1) && (plValue2) && (plValue3))
1001 {
1002 device = pContext->Device;
1003 if(VerifyBuffer(device->BufferList, buffer) != NULL)
1004 {
1005 switch(eParam)
1006 {
1007 default:
1008 alSetError(pContext, AL_INVALID_ENUM);
1009 break;
1010 }
1011 }
1012 else
1013 {
1014 alSetError(pContext, AL_INVALID_NAME);
1015 }
1016 }
1017 else
1018 {
1019 alSetError(pContext, AL_INVALID_VALUE);
1020 }
1021
1022 ProcessContext(pContext);
1023 }
1024
1025
1026 ALAPI void ALAPIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
1027 {
1028 ALCcontext *pContext;
1029 ALCdevice *device;
1030
1031 pContext = GetContextSuspended();
1032 if(!pContext) return;
1033
1034 if (plValues)
1035 {
1036 device = pContext->Device;
1037 if(VerifyBuffer(device->BufferList, buffer) != NULL)
1038 {
1039 switch (eParam)
1040 {
1041 case AL_FREQUENCY:
1042 case AL_BITS:
1043 case AL_CHANNELS:
1044 case AL_SIZE:
1045 alGetBufferi(buffer, eParam, plValues);
1046 break;
1047
1048 default:
1049 alSetError(pContext, AL_INVALID_ENUM);
1050 break;
1051 }
1052 }
1053 else
1054 {
1055 alSetError(pContext, AL_INVALID_NAME);
1056 }
1057 }
1058 else
1059 {
1060 alSetError(pContext, AL_INVALID_VALUE);
1061 }
1062
1063 ProcessContext(pContext);
1064 }
1065
1066 /*
1067 * LoadData
1068 *
1069 * Loads the specified data into the buffer, using the specified formats.
1070 * Currently, the new format must be 32-bit float, and must have the same
1071 * channel configuration as the original format. This does NOT handle
1072 * compressed formats (eg. IMA4).
1073 */
1074 static ALenum LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
1075 {
1076 ALuint NewBytes = aluBytesFromFormat(NewFormat);
1077 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
1078 ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
1079 ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
1080 ALvoid *temp;
1081
1082 assert(NewBytes == 4);
1083 assert(NewChannels == OrigChannels);
1084
1085 if ((size%(OrigBytes*OrigChannels)) != 0)
1086 return AL_INVALID_VALUE;
1087
1088 // Samples are converted here
1089 size /= OrigBytes;
1090 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size) * NewBytes);
1091 if(!temp) return AL_OUT_OF_MEMORY;
1092 ALBuf->data = temp;
1093 ConvertData(ALBuf->data, data, OrigBytes, size);
1094
1095 ALBuf->format = NewFormat;
1096 ALBuf->eOriginalFormat = OrigFormat;
1097 ALBuf->size = size*NewBytes;
1098 ALBuf->frequency = freq;
1099
1100 return AL_NO_ERROR;
1101 }
1102
1103 static void ConvertData(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len)
1104 {
1105 ALsizei i;
1106 ALint smp;
1107 switch(origBytes)
1108 {
1109 case 1:
1110 for(i = 0;i < len;i++)
1111 {
1112 smp = ((ALubyte*)src)[i];
1113 dst[i] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1114 }
1115 break;
1116
1117 case 2:
1118 for(i = 0;i < len;i++)
1119 {
1120 smp = ((ALshort*)src)[i];
1121 dst[i] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1122 }
1123 break;
1124
1125 case 4:
1126 for(i = 0;i < len;i++)
1127 dst[i] = ((ALfloat*)src)[i];
1128 break;
1129
1130 case 8:
1131 for(i = 0;i < len;i++)
1132 dst[i] = ((ALdouble*)src)[i];
1133 break;
1134
1135 default:
1136 assert(0);
1137 }
1138 }
1139
1140 static void ConvertDataRear(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len)
1141 {
1142 ALsizei i;
1143 ALint smp;
1144 switch(origBytes)
1145 {
1146 case 1:
1147 for(i = 0;i < len;i+=4)
1148 {
1149 dst[i+0] = 0;
1150 dst[i+1] = 0;
1151 smp = ((ALubyte*)src)[i/2+0];
1152 dst[i+2] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1153 smp = ((ALubyte*)src)[i/2+1];
1154 dst[i+3] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1155 }
1156 break;
1157
1158 case 2:
1159 for(i = 0;i < len;i+=4)
1160 {
1161 dst[i+0] = 0;
1162 dst[i+1] = 0;
1163 smp = ((ALshort*)src)[i/2+0];
1164 dst[i+2] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1165 smp = ((ALshort*)src)[i/2+1];
1166 dst[i+3] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1167 }
1168 break;
1169
1170 case 4:
1171 for(i = 0;i < len;i+=4)
1172 {
1173 dst[i+0] = 0;
1174 dst[i+1] = 0;
1175 dst[i+2] = ((ALfloat*)src)[i/2+0];
1176 dst[i+3] = ((ALfloat*)src)[i/2+1];
1177 }
1178 break;
1179
1180 default:
1181 assert(0);
1182 }
1183 }
1184
1185 static void ConvertDataIMA4(ALfloat *dst, const ALvoid *src, ALint origChans, ALsizei len)
1186 {
1187 const ALuint *IMAData;
1188 ALint Sample[2],Index[2];
1189 ALuint IMACode[2];
1190 ALsizei i,j,k,c;
1191
1192 assert(origChans <= 2);
1193
1194 IMAData = src;
1195 for(i = 0;i < len/origChans;i++)
1196 {
1197 for(c = 0;c < origChans;c++)
1198 {
1199 Sample[c] = ((ALshort*)IMAData)[0];
1200 Index[c] = ((ALshort*)IMAData)[1];
1201
1202 Index[c] = ((Index[c]<0) ? 0 : Index[c]);
1203 Index[c] = ((Index[c]>88) ? 88 : Index[c]);
1204
1205 dst[i*65*origChans + c] = ((Sample[c] < 0) ? (Sample[c]/32768.0f) : (Sample[c]/32767.0f));
1206
1207 IMAData++;
1208 }
1209
1210 for(j = 1;j < 65;j += 8)
1211 {
1212 for(c = 0;c < origChans;c++)
1213 IMACode[c] = *(IMAData++);
1214
1215 for(k = 0;k < 8;k++)
1216 {
1217 for(c = 0;c < origChans;c++)
1218 {
1219 Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
1220 Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
1221
1222 if(Sample[c] < -32768) Sample[c] = -32768;
1223 else if(Sample[c] > 32767) Sample[c] = 32767;
1224
1225 if(Index[c]<0) Index[c] = 0;
1226 else if(Index[c]>88) Index[c] = 88;
1227
1228 dst[(i*65+j+k)*origChans + c] = ((Sample[c] < 0) ? (Sample[c]/32768.0f) : (Sample[c]/32767.0f));
1229 IMACode[c] >>= 4;
1230 }
1231 }
1232 }
1233 }
1234 }
1235
1236 static void ConvertDataMULaw(ALfloat *dst, const ALvoid *src, ALsizei len)
1237 {
1238 ALsizei i;
1239 ALint smp;
1240 for(i = 0;i < len;i++)
1241 {
1242 smp = muLawDecompressionTable[((ALubyte*)src)[i]];
1243 dst[i] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1244 }
1245 }
1246
1247 static void ConvertDataMULawRear(ALfloat *dst, const ALvoid *src, ALsizei len)
1248 {
1249 ALsizei i;
1250 ALint smp;
1251 for(i = 0;i < len;i+=4)
1252 {
1253 dst[i+0] = 0;
1254 dst[i+1] = 0;
1255 smp = muLawDecompressionTable[((ALubyte*)src)[i/2+0]];
1256 dst[i+2] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1257 smp = muLawDecompressionTable[((ALubyte*)src)[i/2+1]];
1258 dst[i+3] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1259 }
1260 }
1261
1262 /*
1263 * ReleaseALBuffers()
1264 *
1265 * INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
1266 */
1267 ALvoid ReleaseALBuffers(ALCdevice *device)
1268 {
1269 ALbuffer *ALBuffer;
1270 ALbuffer *ALBufferTemp;
1271
1272 ALBuffer = device->BufferList;
1273 while(ALBuffer)
1274 {
1275 // Release sample data
1276 free(ALBuffer->data);
1277
1278 // Release Buffer structure
1279 ALBufferTemp = ALBuffer;
1280 ALBuffer = ALBuffer->next;
1281 memset(ALBufferTemp, 0, sizeof(ALbuffer));
1282 free(ALBufferTemp);
1283 }
1284 device->BufferList = NULL;
1285 device->BufferCount = 0;
1286 }
Software OpenAL implementation