?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Get rid of more alIs* calls
[openal-soft.git] / OpenAL32 / alBuffer.c
blobb1f21b3e4efebfd153eaa711be779e62afe2b3e5
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 assert(aluBytesFromFormat(NewFormat) == 2);
325
326 if((size%(OrigBytes*2)) != 0)
327 {
328 alSetError(Context, AL_INVALID_VALUE);
329 break;
330 }
331
332 size /= OrigBytes;
333 size *= 2;
334
335 // Samples are converted here
336 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size) * NewBytes);
337 if(temp)
338 {
339 ALBuf->data = temp;
340 ConvertDataRear(ALBuf->data, data, OrigBytes, size);
341
342 ALBuf->format = NewFormat;
343 ALBuf->eOriginalFormat = format;
344 ALBuf->size = size*NewBytes;
345 ALBuf->frequency = freq;
346 }
347 else
348 alSetError(Context, AL_OUT_OF_MEMORY);
349 } break;
350
351 case AL_FORMAT_QUAD8_LOKI:
352 case AL_FORMAT_QUAD16_LOKI:
353 case AL_FORMAT_QUAD8:
354 case AL_FORMAT_QUAD16:
355 case AL_FORMAT_QUAD32:
356 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_QUAD32);
357 if(err != AL_NO_ERROR)
358 alSetError(Context, err);
359 break;
360
361 case AL_FORMAT_51CHN8:
362 case AL_FORMAT_51CHN16:
363 case AL_FORMAT_51CHN32:
364 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_51CHN32);
365 if(err != AL_NO_ERROR)
366 alSetError(Context, err);
367 break;
368
369 case AL_FORMAT_61CHN8:
370 case AL_FORMAT_61CHN16:
371 case AL_FORMAT_61CHN32:
372 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_61CHN32);
373 if(err != AL_NO_ERROR)
374 alSetError(Context, err);
375 break;
376
377 case AL_FORMAT_71CHN8:
378 case AL_FORMAT_71CHN16:
379 case AL_FORMAT_71CHN32:
380 err = LoadData(ALBuf, data, size, freq, format, AL_FORMAT_71CHN32);
381 if(err != AL_NO_ERROR)
382 alSetError(Context, err);
383 break;
384
385 case AL_FORMAT_MONO_IMA4:
386 case AL_FORMAT_STEREO_IMA4: {
387 int OrigChans = ((format==AL_FORMAT_MONO_IMA4) ? 1 : 2);
388 ALuint NewFormat = ((OrigChans==1) ? AL_FORMAT_MONO_FLOAT32 :
389 AL_FORMAT_STEREO_FLOAT32);
390 ALuint NewBytes = aluBytesFromFormat(NewFormat);
391
392 // Here is where things vary:
393 // nVidia and Apple use 64+1 samples per channel per block => block_size=36*chans bytes
394 // Most PC sound software uses 2040+1 samples per channel per block -> block_size=1024*chans bytes
395 if((size%(36*OrigChans)) != 0)
396 {
397 alSetError(Context, AL_INVALID_VALUE);
398 break;
399 }
400
401 size /= 36;
402 size *= 65;
403
404 // Allocate extra padding samples
405 temp = realloc(ALBuf->data, (BUFFER_PADDING*OrigChans + size)*NewBytes);
406 if(temp)
407 {
408 ALBuf->data = temp;
409 ConvertDataIMA4(ALBuf->data, data, OrigChans, size/65);
410
411 ALBuf->format = NewFormat;
412 ALBuf->eOriginalFormat = format;
413 ALBuf->size = size*NewBytes;
414 ALBuf->frequency = freq;
415 }
416 else
417 alSetError(Context, AL_OUT_OF_MEMORY);
418 } break;
419
420 case AL_FORMAT_MONO_MULAW:
421 case AL_FORMAT_STEREO_MULAW:
422 case AL_FORMAT_QUAD_MULAW:
423 case AL_FORMAT_51CHN_MULAW:
424 case AL_FORMAT_61CHN_MULAW:
425 case AL_FORMAT_71CHN_MULAW: {
426 int Channels = ((format==AL_FORMAT_MONO_MULAW) ? 1 :
427 ((format==AL_FORMAT_STEREO_MULAW) ? 2 :
428 ((format==AL_FORMAT_QUAD_MULAW) ? 4 :
429 ((format==AL_FORMAT_51CHN_MULAW) ? 6 :
430 ((format==AL_FORMAT_61CHN_MULAW) ? 7 : 8)))));
431 ALuint NewFormat = ((Channels==1) ? AL_FORMAT_MONO_FLOAT32 :
432 ((Channels==2) ? AL_FORMAT_STEREO_FLOAT32 :
433 ((Channels==4) ? AL_FORMAT_QUAD32 :
434 ((Channels==6) ? AL_FORMAT_51CHN32 :
435 ((Channels==7) ? AL_FORMAT_61CHN32 :
436 AL_FORMAT_71CHN32)))));
437 ALuint NewBytes = aluBytesFromFormat(NewFormat);
438
439 if((size%(1*Channels)) != 0)
440 {
441 alSetError(Context, AL_INVALID_VALUE);
442 break;
443 }
444
445 // Allocate extra padding samples
446 temp = realloc(ALBuf->data, (BUFFER_PADDING*Channels + size)*NewBytes);
447 if(temp)
448 {
449 ALBuf->data = temp;
450 ConvertDataMULaw(ALBuf->data, data, size);
451
452 ALBuf->format = NewFormat;
453 ALBuf->eOriginalFormat = format;
454 ALBuf->size = size*NewBytes;
455 ALBuf->frequency = freq;
456 }
457 else
458 alSetError(Context, AL_OUT_OF_MEMORY);
459 } break;
460
461 case AL_FORMAT_REAR_MULAW: {
462 int OrigChans = 2;
463 ALuint NewFormat = AL_FORMAT_QUAD32;
464 ALuint NewBytes = aluBytesFromFormat(NewFormat);
465 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
466
467 if((size%(1*OrigChans)) != 0)
468 {
469 alSetError(Context, AL_INVALID_VALUE);
470 break;
471 }
472
473 size *= 2;
474
475 // Allocate extra padding samples
476 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size)*NewBytes);
477 if(temp)
478 {
479 ALBuf->data = temp;
480 ConvertDataMULawRear(ALBuf->data, data, size);
481
482 ALBuf->format = NewFormat;
483 ALBuf->eOriginalFormat = format;
484 ALBuf->size = size*NewBytes;
485 ALBuf->frequency = freq;
486 }
487 else
488 alSetError(Context, AL_OUT_OF_MEMORY);
489 } break;
490
491 default:
492 alSetError(Context, AL_INVALID_ENUM);
493 break;
494 }
495 }
496 else
497 {
498 // Buffer is in use, or data is a NULL pointer
499 alSetError(Context, AL_INVALID_VALUE);
500 }
501 }
502 else
503 {
504 // Invalid Buffer Name
505 alSetError(Context, AL_INVALID_NAME);
506 }
507
508 ProcessContext(Context);
509 }
510
511 /*
512 * alBufferSubDataEXT(ALuint buffer,ALenum format,ALvoid *data,ALsizei offset,ALsizei length)
513 *
514 * Fill buffer with audio data
515 */
516 ALvoid ALAPIENTRY alBufferSubDataEXT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
517 {
518 ALCcontext *Context;
519 ALCdevice *device;
520 ALbuffer *ALBuf;
521
522 Context = GetContextSuspended();
523 if(!Context) return;
524
525 device = Context->Device;
526 if((ALBuf=VerifyBuffer(device->BufferList, buffer)) != NULL)
527 {
528 if(Context->SampleSource)
529 {
530 ALuint offset;
531
532 if(Context->SampleSource->state == MAPPED)
533 {
534 alSetError(Context, AL_INVALID_OPERATION);
535 ProcessContext(Context);
536 return;
537 }
538
539 offset = (ALuint)data;
540 data = Context->SampleSource->data + offset;
541 }
542
543 if(ALBuf->data == NULL)
544 {
545 // buffer does not have any data
546 alSetError(Context, AL_INVALID_NAME);
547 }
548 else if(length < 0 || offset < 0 || (length > 0 && data == NULL))
549 {
550 // data is NULL or offset/length is negative
551 alSetError(Context, AL_INVALID_VALUE);
552 }
553 else
554 {
555 switch(format)
556 {
557 case AL_FORMAT_REAR8:
558 case AL_FORMAT_REAR16:
559 case AL_FORMAT_REAR32: {
560 ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
561 ((format==AL_FORMAT_REAR16) ? 2 :
562 4));
563 ALuint NewBytes = aluBytesFromFormat(ALBuf->format);
564
565 if(ALBuf->eOriginalFormat != AL_FORMAT_REAR8 &&
566 ALBuf->eOriginalFormat != AL_FORMAT_REAR16 &&
567 ALBuf->eOriginalFormat != AL_FORMAT_REAR32)
568 {
569 alSetError(Context, AL_INVALID_ENUM);
570 break;
571 }
572
573 if(ALBuf->size/4/NewBytes < (ALuint)offset+length)
574 {
575 alSetError(Context, AL_INVALID_VALUE);
576 break;
577 }
578
579 ConvertDataRear(&ALBuf->data[offset*4], data, OrigBytes, length*2);
580 } break;
581
582 case AL_FORMAT_MONO_IMA4:
583 case AL_FORMAT_STEREO_IMA4: {
584 int Channels = aluChannelsFromFormat(ALBuf->format);
585 ALuint Bytes = aluBytesFromFormat(ALBuf->format);
586
587 if(ALBuf->eOriginalFormat != format)
588 {
589 alSetError(Context, AL_INVALID_ENUM);
590 break;
591 }
592
593 if((offset%65) != 0 || (length%65) != 0 ||
594 ALBuf->size/Channels/Bytes < (ALuint)offset+length)
595 {
596 alSetError(Context, AL_INVALID_VALUE);
597 break;
598 }
599
600 ConvertDataIMA4(&ALBuf->data[offset*Channels], data, Channels, length/65*Channels);
601 } break;
602
603 case AL_FORMAT_MONO_MULAW:
604 case AL_FORMAT_STEREO_MULAW:
605 case AL_FORMAT_QUAD_MULAW:
606 case AL_FORMAT_REAR_MULAW:
607 case AL_FORMAT_51CHN_MULAW:
608 case AL_FORMAT_61CHN_MULAW:
609 case AL_FORMAT_71CHN_MULAW: {
610 int Channels = aluChannelsFromFormat(ALBuf->format);
611 ALuint Bytes = aluBytesFromFormat(ALBuf->format);
612
613 if(ALBuf->eOriginalFormat != format)
614 {
615 alSetError(Context, AL_INVALID_ENUM);
616 break;
617 }
618
619 if(ALBuf->size/Channels/Bytes < (ALuint)offset+length)
620 {
621 alSetError(Context, AL_INVALID_VALUE);
622 break;
623 }
624
625 if(ALBuf->eOriginalFormat == AL_FORMAT_REAR_MULAW)
626 ConvertDataMULawRear(&ALBuf->data[offset*Channels], data, length*2);
627 else
628 ConvertDataMULaw(&ALBuf->data[offset*Channels], data, length*Channels);
629 } break;
630
631 default: {
632 ALuint Channels = aluChannelsFromFormat(format);
633 ALuint Bytes = aluBytesFromFormat(format);
634 ALuint NewBytes = aluBytesFromFormat(ALBuf->format);
635
636 if(Channels != aluChannelsFromFormat(ALBuf->format))
637 {
638 alSetError(Context, AL_INVALID_ENUM);
639 break;
640 }
641
642 if(ALBuf->size/Channels/NewBytes < (ALuint)offset+length)
643 {
644 alSetError(Context, AL_INVALID_VALUE);
645 break;
646 }
647
648 ConvertData(&ALBuf->data[offset*Channels], data, Bytes, length*Channels);
649 } break;
650 }
651 }
652 }
653 else
654 {
655 // Invalid Buffer Name
656 alSetError(Context, AL_INVALID_NAME);
657 }
658
659 ProcessContext(Context);
660 }
661
662
663 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
664 {
665 ALCcontext *pContext;
666 ALCdevice *device;
667
668 (void)flValue;
669
670 pContext = GetContextSuspended();
671 if(!pContext) return;
672
673 device = pContext->Device;
674 if(VerifyBuffer(device->BufferList, buffer) != NULL)
675 {
676 switch(eParam)
677 {
678 default:
679 alSetError(pContext, AL_INVALID_ENUM);
680 break;
681 }
682 }
683 else
684 {
685 alSetError(pContext, AL_INVALID_NAME);
686 }
687
688 ProcessContext(pContext);
689 }
690
691
692 ALAPI void ALAPIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
693 {
694 ALCcontext *pContext;
695 ALCdevice *device;
696
697 (void)flValue1;
698 (void)flValue2;
699 (void)flValue3;
700
701 pContext = GetContextSuspended();
702 if(!pContext) return;
703
704 device = pContext->Device;
705 if(VerifyBuffer(device->BufferList, buffer) != NULL)
706 {
707 switch(eParam)
708 {
709 default:
710 alSetError(pContext, AL_INVALID_ENUM);
711 break;
712 }
713 }
714 else
715 {
716 alSetError(pContext, AL_INVALID_NAME);
717 }
718
719 ProcessContext(pContext);
720 }
721
722
723 ALAPI void ALAPIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
724 {
725 ALCcontext *pContext;
726 ALCdevice *device;
727
728 (void)flValues;
729
730 pContext = GetContextSuspended();
731 if(!pContext) return;
732
733 device = pContext->Device;
734 if(VerifyBuffer(device->BufferList, buffer) != NULL)
735 {
736 switch(eParam)
737 {
738 default:
739 alSetError(pContext, AL_INVALID_ENUM);
740 break;
741 }
742 }
743 else
744 {
745 alSetError(pContext, AL_INVALID_NAME);
746 }
747
748 ProcessContext(pContext);
749 }
750
751
752 ALAPI void ALAPIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
753 {
754 ALCcontext *pContext;
755 ALCdevice *device;
756
757 (void)lValue;
758
759 pContext = GetContextSuspended();
760 if(!pContext) return;
761
762 device = pContext->Device;
763 if(VerifyBuffer(device->BufferList, buffer) != NULL)
764 {
765 switch(eParam)
766 {
767 default:
768 alSetError(pContext, AL_INVALID_ENUM);
769 break;
770 }
771 }
772 else
773 {
774 alSetError(pContext, AL_INVALID_NAME);
775 }
776
777 ProcessContext(pContext);
778 }
779
780
781 ALAPI void ALAPIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
782 {
783 ALCcontext *pContext;
784 ALCdevice *device;
785
786 (void)lValue1;
787 (void)lValue2;
788 (void)lValue3;
789
790 pContext = GetContextSuspended();
791 if(!pContext) return;
792
793 device = pContext->Device;
794 if(VerifyBuffer(device->BufferList, buffer) != NULL)
795 {
796 switch(eParam)
797 {
798 default:
799 alSetError(pContext, AL_INVALID_ENUM);
800 break;
801 }
802 }
803 else
804 {
805 alSetError(pContext, AL_INVALID_NAME);
806 }
807
808 ProcessContext(pContext);
809 }
810
811
812 ALAPI void ALAPIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
813 {
814 ALCcontext *pContext;
815 ALCdevice *device;
816
817 (void)plValues;
818
819 pContext = GetContextSuspended();
820 if(!pContext) return;
821
822 device = pContext->Device;
823 if(VerifyBuffer(device->BufferList, buffer) != NULL)
824 {
825 switch(eParam)
826 {
827 default:
828 alSetError(pContext, AL_INVALID_ENUM);
829 break;
830 }
831 }
832 else
833 {
834 alSetError(pContext, AL_INVALID_NAME);
835 }
836
837 ProcessContext(pContext);
838 }
839
840
841 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
842 {
843 ALCcontext *pContext;
844 ALCdevice *device;
845
846 pContext = GetContextSuspended();
847 if(!pContext) return;
848
849 if (pflValue)
850 {
851 device = pContext->Device;
852 if(VerifyBuffer(device->BufferList, buffer) != NULL)
853 {
854 switch(eParam)
855 {
856 default:
857 alSetError(pContext, AL_INVALID_ENUM);
858 break;
859 }
860 }
861 else
862 {
863 alSetError(pContext, AL_INVALID_NAME);
864 }
865 }
866 else
867 {
868 alSetError(pContext, AL_INVALID_VALUE);
869 }
870
871 ProcessContext(pContext);
872 }
873
874
875 ALAPI void ALAPIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
876 {
877 ALCcontext *pContext;
878 ALCdevice *device;
879
880 pContext = GetContextSuspended();
881 if(!pContext) return;
882
883 if ((pflValue1) && (pflValue2) && (pflValue3))
884 {
885 device = pContext->Device;
886 if(VerifyBuffer(device->BufferList, buffer) != NULL)
887 {
888 switch(eParam)
889 {
890 default:
891 alSetError(pContext, AL_INVALID_ENUM);
892 break;
893 }
894 }
895 else
896 {
897 alSetError(pContext, AL_INVALID_NAME);
898 }
899 }
900 else
901 {
902 alSetError(pContext, AL_INVALID_VALUE);
903 }
904
905 ProcessContext(pContext);
906 }
907
908
909 ALAPI void ALAPIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
910 {
911 ALCcontext *pContext;
912 ALCdevice *device;
913
914 pContext = GetContextSuspended();
915 if(!pContext) return;
916
917 if (pflValues)
918 {
919 device = pContext->Device;
920 if(VerifyBuffer(device->BufferList, buffer) != NULL)
921 {
922 switch(eParam)
923 {
924 default:
925 alSetError(pContext, AL_INVALID_ENUM);
926 break;
927 }
928 }
929 else
930 {
931 alSetError(pContext, AL_INVALID_NAME);
932 }
933 }
934 else
935 {
936 alSetError(pContext, AL_INVALID_VALUE);
937 }
938
939 ProcessContext(pContext);
940 }
941
942
943 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
944 {
945 ALCcontext *pContext;
946 ALbuffer *pBuffer;
947 ALCdevice *device;
948
949 pContext = GetContextSuspended();
950 if(!pContext) return;
951
952 if (plValue)
953 {
954 device = pContext->Device;
955 if((pBuffer=VerifyBuffer(device->BufferList, buffer)) != NULL)
956 {
957 switch (eParam)
958 {
959 case AL_FREQUENCY:
960 *plValue = pBuffer->frequency;
961 break;
962
963 case AL_BITS:
964 *plValue = aluBytesFromFormat(pBuffer->format) * 8;
965 break;
966
967 case AL_CHANNELS:
968 *plValue = aluChannelsFromFormat(pBuffer->format);
969 break;
970
971 case AL_SIZE:
972 *plValue = pBuffer->size;
973 break;
974
975 default:
976 alSetError(pContext, AL_INVALID_ENUM);
977 break;
978 }
979 }
980 else
981 {
982 alSetError(pContext, AL_INVALID_NAME);
983 }
984 }
985 else
986 {
987 alSetError(pContext, AL_INVALID_VALUE);
988 }
989
990 ProcessContext(pContext);
991 }
992
993
994 ALAPI void ALAPIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
995 {
996 ALCcontext *pContext;
997 ALCdevice *device;
998
999 pContext = GetContextSuspended();
1000 if(!pContext) return;
1001
1002 if ((plValue1) && (plValue2) && (plValue3))
1003 {
1004 device = pContext->Device;
1005 if(VerifyBuffer(device->BufferList, buffer) != NULL)
1006 {
1007 switch(eParam)
1008 {
1009 default:
1010 alSetError(pContext, AL_INVALID_ENUM);
1011 break;
1012 }
1013 }
1014 else
1015 {
1016 alSetError(pContext, AL_INVALID_NAME);
1017 }
1018 }
1019 else
1020 {
1021 alSetError(pContext, AL_INVALID_VALUE);
1022 }
1023
1024 ProcessContext(pContext);
1025 }
1026
1027
1028 ALAPI void ALAPIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
1029 {
1030 ALCcontext *pContext;
1031 ALCdevice *device;
1032
1033 pContext = GetContextSuspended();
1034 if(!pContext) return;
1035
1036 if (plValues)
1037 {
1038 device = pContext->Device;
1039 if(VerifyBuffer(device->BufferList, buffer) != NULL)
1040 {
1041 switch (eParam)
1042 {
1043 case AL_FREQUENCY:
1044 case AL_BITS:
1045 case AL_CHANNELS:
1046 case AL_SIZE:
1047 alGetBufferi(buffer, eParam, plValues);
1048 break;
1049
1050 default:
1051 alSetError(pContext, AL_INVALID_ENUM);
1052 break;
1053 }
1054 }
1055 else
1056 {
1057 alSetError(pContext, AL_INVALID_NAME);
1058 }
1059 }
1060 else
1061 {
1062 alSetError(pContext, AL_INVALID_VALUE);
1063 }
1064
1065 ProcessContext(pContext);
1066 }
1067
1068 /*
1069 * LoadData
1070 *
1071 * Loads the specified data into the buffer, using the specified formats.
1072 * Currently, the new format must be 32-bit float, and must have the same
1073 * channel configuration as the original format. This does NOT handle
1074 * compressed formats (eg. IMA4).
1075 */
1076 static ALenum LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
1077 {
1078 ALuint NewBytes = aluBytesFromFormat(NewFormat);
1079 ALuint NewChannels = aluChannelsFromFormat(NewFormat);
1080 ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
1081 ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
1082 ALvoid *temp;
1083
1084 assert(NewBytes == 4);
1085 assert(NewChannels == OrigChannels);
1086
1087 if ((size%(OrigBytes*OrigChannels)) != 0)
1088 return AL_INVALID_VALUE;
1089
1090 // Samples are converted here
1091 size /= OrigBytes;
1092 temp = realloc(ALBuf->data, (BUFFER_PADDING*NewChannels + size) * NewBytes);
1093 if(!temp) return AL_OUT_OF_MEMORY;
1094 ALBuf->data = temp;
1095 ConvertData(ALBuf->data, data, OrigBytes, size);
1096
1097 ALBuf->format = NewFormat;
1098 ALBuf->eOriginalFormat = OrigFormat;
1099 ALBuf->size = size*NewBytes;
1100 ALBuf->frequency = freq;
1101
1102 return AL_NO_ERROR;
1103 }
1104
1105 static void ConvertData(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len)
1106 {
1107 ALsizei i;
1108 ALint smp;
1109 switch(origBytes)
1110 {
1111 case 1:
1112 for(i = 0;i < len;i++)
1113 {
1114 smp = ((ALubyte*)src)[i];
1115 dst[i] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1116 }
1117 break;
1118
1119 case 2:
1120 for(i = 0;i < len;i++)
1121 {
1122 smp = ((ALshort*)src)[i];
1123 dst[i] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1124 }
1125 break;
1126
1127 case 4:
1128 for(i = 0;i < len;i++)
1129 dst[i] = ((ALfloat*)src)[i];
1130 break;
1131
1132 case 8:
1133 for(i = 0;i < len;i++)
1134 dst[i] = ((ALdouble*)src)[i];
1135 break;
1136
1137 default:
1138 assert(0);
1139 }
1140 }
1141
1142 static void ConvertDataRear(ALfloat *dst, const ALvoid *src, ALint origBytes, ALsizei len)
1143 {
1144 ALsizei i;
1145 ALint smp;
1146 switch(origBytes)
1147 {
1148 case 1:
1149 for(i = 0;i < len;i+=4)
1150 {
1151 dst[i+0] = 0;
1152 dst[i+1] = 0;
1153 smp = ((ALubyte*)src)[i/2+0];
1154 dst[i+2] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1155 smp = ((ALubyte*)src)[i/2+1];
1156 dst[i+3] = ((smp < 0x80) ? ((smp-128)/128.0f) : ((smp-128)/127.0f));
1157 }
1158 break;
1159
1160 case 2:
1161 for(i = 0;i < len;i+=4)
1162 {
1163 dst[i+0] = 0;
1164 dst[i+1] = 0;
1165 smp = ((ALshort*)src)[i/2+0];
1166 dst[i+2] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1167 smp = ((ALshort*)src)[i/2+1];
1168 dst[i+3] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1169 }
1170 break;
1171
1172 case 4:
1173 for(i = 0;i < len;i+=4)
1174 {
1175 dst[i+0] = 0;
1176 dst[i+1] = 0;
1177 dst[i+2] = ((ALfloat*)src)[i/2+0];
1178 dst[i+3] = ((ALfloat*)src)[i/2+1];
1179 }
1180 break;
1181
1182 default:
1183 assert(0);
1184 }
1185 }
1186
1187 static void ConvertDataIMA4(ALfloat *dst, const ALvoid *src, ALint origChans, ALsizei len)
1188 {
1189 const ALuint *IMAData;
1190 ALint Sample[2],Index[2];
1191 ALuint IMACode[2];
1192 ALsizei i,j,k,c;
1193
1194 assert(origChans <= 2);
1195
1196 IMAData = src;
1197 for(i = 0;i < len/origChans;i++)
1198 {
1199 for(c = 0;c < origChans;c++)
1200 {
1201 Sample[c] = ((ALshort*)IMAData)[0];
1202 Index[c] = ((ALshort*)IMAData)[1];
1203
1204 Index[c] = ((Index[c]<0) ? 0 : Index[c]);
1205 Index[c] = ((Index[c]>88) ? 88 : Index[c]);
1206
1207 dst[i*65*origChans + c] = ((Sample[c] < 0) ? (Sample[c]/32768.0f) : (Sample[c]/32767.0f));
1208
1209 IMAData++;
1210 }
1211
1212 for(j = 1;j < 65;j += 8)
1213 {
1214 for(c = 0;c < origChans;c++)
1215 IMACode[c] = *(IMAData++);
1216
1217 for(k = 0;k < 8;k++)
1218 {
1219 for(c = 0;c < origChans;c++)
1220 {
1221 Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
1222 Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
1223
1224 if(Sample[c] < -32768) Sample[c] = -32768;
1225 else if(Sample[c] > 32767) Sample[c] = 32767;
1226
1227 if(Index[c]<0) Index[c] = 0;
1228 else if(Index[c]>88) Index[c] = 88;
1229
1230 dst[(i*65+j+k)*origChans + c] = ((Sample[c] < 0) ? (Sample[c]/32768.0f) : (Sample[c]/32767.0f));
1231 IMACode[c] >>= 4;
1232 }
1233 }
1234 }
1235 }
1236 }
1237
1238 static void ConvertDataMULaw(ALfloat *dst, const ALvoid *src, ALsizei len)
1239 {
1240 ALsizei i;
1241 ALint smp;
1242 for(i = 0;i < len;i++)
1243 {
1244 smp = muLawDecompressionTable[((ALubyte*)src)[i]];
1245 dst[i] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1246 }
1247 }
1248
1249 static void ConvertDataMULawRear(ALfloat *dst, const ALvoid *src, ALsizei len)
1250 {
1251 ALsizei i;
1252 ALint smp;
1253 for(i = 0;i < len;i+=4)
1254 {
1255 dst[i+0] = 0;
1256 dst[i+1] = 0;
1257 smp = muLawDecompressionTable[((ALubyte*)src)[i/2+0]];
1258 dst[i+2] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1259 smp = muLawDecompressionTable[((ALubyte*)src)[i/2+1]];
1260 dst[i+3] = ((smp < 0) ? (smp/32768.0f) : (smp/32767.0f));
1261 }
1262 }
1263
1264 /*
1265 * ReleaseALBuffers()
1266 *
1267 * INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
1268 */
1269 ALvoid ReleaseALBuffers(ALCdevice *device)
1270 {
1271 ALbuffer *ALBuffer;
1272 ALbuffer *ALBufferTemp;
1273
1274 ALBuffer = device->BufferList;
1275 while(ALBuffer)
1276 {
1277 // Release sample data
1278 free(ALBuffer->data);
1279
1280 // Release Buffer structure
1281 ALBufferTemp = ALBuffer;
1282 ALBuffer = ALBuffer->next;
1283 memset(ALBufferTemp, 0, sizeof(ALbuffer));
1284 free(ALBufferTemp);
1285 }
1286 device->BufferList = NULL;
1287 device->BufferCount = 0;
1288 }
Software OpenAL implementation