?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Avoid a bit of code duplication
[openal-soft/android.git] / OpenAL32 / alBuffer.c
bloba803eea7bc5428a07486a2138d78bb0134c01dd8
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 "alThunk.h"
34
35
36 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels chans, enum UserFmtType type, const ALvoid *data, ALboolean storesrc);
37 static void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len);
38 static ALboolean IsValidType(ALenum type);
39 static ALboolean IsValidChannels(ALenum channels);
40 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, enum UserFmtType *type);
41 static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type);
42
43
44 /*
45 * Global Variables
46 */
47
48 /* IMA ADPCM Stepsize table */
49 static const long IMAStep_size[89] = {
50 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19,
51 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55,
52 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157,
53 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449,
54 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
55 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327, 3660,
56 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,
57 11487,12635,13899,15289,16818,18500,20350,22358,24633,27086,29794,
58 32767
59 };
60
61 /* IMA4 ADPCM Codeword decode table */
62 static const long IMA4Codeword[16] = {
63 1, 3, 5, 7, 9, 11, 13, 15,
64 -1,-3,-5,-7,-9,-11,-13,-15,
65 };
66
67 /* IMA4 ADPCM Step index adjust decode table */
68 static const long IMA4Index_adjust[16] = {
69 -1,-1,-1,-1, 2, 4, 6, 8,
70 -1,-1,-1,-1, 2, 4, 6, 8
71 };
72
73 /* A quick'n'dirty lookup table to decode a muLaw-encoded byte sample into a
74 * signed 16-bit sample */
75 static const ALshort muLawDecompressionTable[256] = {
76 -32124,-31100,-30076,-29052,-28028,-27004,-25980,-24956,
77 -23932,-22908,-21884,-20860,-19836,-18812,-17788,-16764,
78 -15996,-15484,-14972,-14460,-13948,-13436,-12924,-12412,
79 -11900,-11388,-10876,-10364, -9852, -9340, -8828, -8316,
80 -7932, -7676, -7420, -7164, -6908, -6652, -6396, -6140,
81 -5884, -5628, -5372, -5116, -4860, -4604, -4348, -4092,
82 -3900, -3772, -3644, -3516, -3388, -3260, -3132, -3004,
83 -2876, -2748, -2620, -2492, -2364, -2236, -2108, -1980,
84 -1884, -1820, -1756, -1692, -1628, -1564, -1500, -1436,
85 -1372, -1308, -1244, -1180, -1116, -1052, -988, -924,
86 -876, -844, -812, -780, -748, -716, -684, -652,
87 -620, -588, -556, -524, -492, -460, -428, -396,
88 -372, -356, -340, -324, -308, -292, -276, -260,
89 -244, -228, -212, -196, -180, -164, -148, -132,
90 -120, -112, -104, -96, -88, -80, -72, -64,
91 -56, -48, -40, -32, -24, -16, -8, 0,
92 32124, 31100, 30076, 29052, 28028, 27004, 25980, 24956,
93 23932, 22908, 21884, 20860, 19836, 18812, 17788, 16764,
94 15996, 15484, 14972, 14460, 13948, 13436, 12924, 12412,
95 11900, 11388, 10876, 10364, 9852, 9340, 8828, 8316,
96 7932, 7676, 7420, 7164, 6908, 6652, 6396, 6140,
97 5884, 5628, 5372, 5116, 4860, 4604, 4348, 4092,
98 3900, 3772, 3644, 3516, 3388, 3260, 3132, 3004,
99 2876, 2748, 2620, 2492, 2364, 2236, 2108, 1980,
100 1884, 1820, 1756, 1692, 1628, 1564, 1500, 1436,
101 1372, 1308, 1244, 1180, 1116, 1052, 988, 924,
102 876, 844, 812, 780, 748, 716, 684, 652,
103 620, 588, 556, 524, 492, 460, 428, 396,
104 372, 356, 340, 324, 308, 292, 276, 260,
105 244, 228, 212, 196, 180, 164, 148, 132,
106 120, 112, 104, 96, 88, 80, 72, 64,
107 56, 48, 40, 32, 24, 16, 8, 0
108 };
109
110 /* Values used when encoding a muLaw sample */
111 static const int muLawBias = 0x84;
112 static const int muLawClip = 32635;
113 static const char muLawCompressTable[256] = {
114 0,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3,
115 4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
116 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
117 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
118 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
119 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
120 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
121 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
122 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
123 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
124 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
125 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
126 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
127 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
128 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
129 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
130 };
131
132
133 /* A quick'n'dirty lookup table to decode an aLaw-encoded byte sample into a
134 * signed 16-bit sample */
135 static const ALshort aLawDecompressionTable[256] = {
136 -5504, -5248, -6016, -5760, -4480, -4224, -4992, -4736,
137 -7552, -7296, -8064, -7808, -6528, -6272, -7040, -6784,
138 -2752, -2624, -3008, -2880, -2240, -2112, -2496, -2368,
139 -3776, -3648, -4032, -3904, -3264, -3136, -3520, -3392,
140 -22016,-20992,-24064,-23040,-17920,-16896,-19968,-18944,
141 -30208,-29184,-32256,-31232,-26112,-25088,-28160,-27136,
142 -11008,-10496,-12032,-11520, -8960, -8448, -9984, -9472,
143 -15104,-14592,-16128,-15616,-13056,-12544,-14080,-13568,
144 -344, -328, -376, -360, -280, -264, -312, -296,
145 -472, -456, -504, -488, -408, -392, -440, -424,
146 -88, -72, -120, -104, -24, -8, -56, -40,
147 -216, -200, -248, -232, -152, -136, -184, -168,
148 -1376, -1312, -1504, -1440, -1120, -1056, -1248, -1184,
149 -1888, -1824, -2016, -1952, -1632, -1568, -1760, -1696,
150 -688, -656, -752, -720, -560, -528, -624, -592,
151 -944, -912, -1008, -976, -816, -784, -880, -848,
152 5504, 5248, 6016, 5760, 4480, 4224, 4992, 4736,
153 7552, 7296, 8064, 7808, 6528, 6272, 7040, 6784,
154 2752, 2624, 3008, 2880, 2240, 2112, 2496, 2368,
155 3776, 3648, 4032, 3904, 3264, 3136, 3520, 3392,
156 22016, 20992, 24064, 23040, 17920, 16896, 19968, 18944,
157 30208, 29184, 32256, 31232, 26112, 25088, 28160, 27136,
158 11008, 10496, 12032, 11520, 8960, 8448, 9984, 9472,
159 15104, 14592, 16128, 15616, 13056, 12544, 14080, 13568,
160 344, 328, 376, 360, 280, 264, 312, 296,
161 472, 456, 504, 488, 408, 392, 440, 424,
162 88, 72, 120, 104, 24, 8, 56, 40,
163 216, 200, 248, 232, 152, 136, 184, 168,
164 1376, 1312, 1504, 1440, 1120, 1056, 1248, 1184,
165 1888, 1824, 2016, 1952, 1632, 1568, 1760, 1696,
166 688, 656, 752, 720, 560, 528, 624, 592,
167 944, 912, 1008, 976, 816, 784, 880, 848
168 };
169
170 /* Values used when encoding an aLaw sample */
171 static const int aLawClip = 32635;
172 static const char aLawCompressTable[128] = {
173 1,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,
174 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
175 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
176 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
177 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
178 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
179 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
180 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7
181 };
182
183
184 /*
185 * alGenBuffers(ALsizei n, ALuint *buffers)
186 *
187 * Generates n AL Buffers, and stores the Buffers Names in the array pointed
188 * to by buffers
189 */
190 AL_API ALvoid AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
191 {
192 ALCcontext *Context;
193 ALsizei i=0;
194
195 Context = GetContextRef();
196 if(!Context) return;
197
198 /* Check that we are actually generating some Buffers */
199 if(n < 0 || IsBadWritePtr((void*)buffers, n * sizeof(ALuint)))
200 alSetError(Context, AL_INVALID_VALUE);
201 else
202 {
203 ALCdevice *device = Context->Device;
204 ALenum err;
205
206 // Create all the new Buffers
207 while(i < n)
208 {
209 ALbuffer *buffer = calloc(1, sizeof(ALbuffer));
210 if(!buffer)
211 {
212 alSetError(Context, AL_OUT_OF_MEMORY);
213 alDeleteBuffers(i, buffers);
214 break;
215 }
216 RWLockInit(&buffer->lock);
217
218 err = NewThunkEntry(&buffer->buffer);
219 if(err == AL_NO_ERROR)
220 err = InsertUIntMapEntry(&device->BufferMap, buffer->buffer, buffer);
221 if(err != AL_NO_ERROR)
222 {
223 FreeThunkEntry(buffer->buffer);
224 memset(buffer, 0, sizeof(ALbuffer));
225 free(buffer);
226
227 alSetError(Context, err);
228 alDeleteBuffers(i, buffers);
229 break;
230 }
231
232 buffers[i++] = buffer->buffer;
233 }
234 }
235
236 ALCcontext_DecRef(Context);
237 }
238
239 /*
240 * alDeleteBuffers(ALsizei n, ALuint *buffers)
241 *
242 * Deletes the n AL Buffers pointed to by buffers
243 */
244 AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
245 {
246 ALCcontext *Context;
247 ALCdevice *device;
248 ALbuffer *ALBuf;
249 ALsizei i;
250
251 Context = GetContextRef();
252 if(!Context) return;
253
254 device = Context->Device;
255 /* Check we are actually Deleting some Buffers */
256 if(n < 0)
257 alSetError(Context, AL_INVALID_VALUE);
258 else
259 {
260 /* Check that all the buffers are valid and can actually be deleted */
261 for(i = 0;i < n;i++)
262 {
263 if(!buffers[i])
264 continue;
265
266 /* Check for valid Buffer ID */
267 if((ALBuf=LookupBuffer(device, buffers[i])) == NULL)
268 {
269 alSetError(Context, AL_INVALID_NAME);
270 n = 0;
271 break;
272 }
273 else if(ALBuf->ref != 0)
274 {
275 /* Buffer still in use, cannot be deleted */
276 alSetError(Context, AL_INVALID_OPERATION);
277 n = 0;
278 break;
279 }
280 }
281
282 for(i = 0;i < n;i++)
283 {
284 if((ALBuf=RemoveBuffer(device, buffers[i])) == NULL)
285 continue;
286 FreeThunkEntry(ALBuf->buffer);
287
288 /* Release the memory used to store audio data */
289 free(ALBuf->data);
290
291 /* Release buffer structure */
292 memset(ALBuf, 0, sizeof(ALbuffer));
293 free(ALBuf);
294 }
295 }
296
297 ALCcontext_DecRef(Context);
298 }
299
300 /*
301 * alIsBuffer(ALuint buffer)
302 *
303 * Checks if buffer is a valid Buffer Name
304 */
305 AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer)
306 {
307 ALCcontext *Context;
308 ALboolean result;
309
310 Context = GetContextRef();
311 if(!Context) return AL_FALSE;
312
313 result = ((!buffer || LookupBuffer(Context->Device, buffer)) ?
314 AL_TRUE : AL_FALSE);
315
316 ALCcontext_DecRef(Context);
317
318 return result;
319 }
320
321 /*
322 * alBufferData(ALuint buffer, ALenum format, const ALvoid *data,
323 * ALsizei size, ALsizei freq)
324 *
325 * Fill buffer with audio data
326 */
327 AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
328 {
329 enum UserFmtChannels SrcChannels;
330 enum UserFmtType SrcType;
331 ALCcontext *Context;
332 ALCdevice *device;
333 ALbuffer *ALBuf;
334 ALenum err;
335
336 Context = GetContextRef();
337 if(!Context) return;
338
339 device = Context->Device;
340 if((ALBuf=LookupBuffer(device, buffer)) == NULL)
341 alSetError(Context, AL_INVALID_NAME);
342 else if(size < 0 || freq < 0)
343 alSetError(Context, AL_INVALID_VALUE);
344 else if(DecomposeUserFormat(format, &SrcChannels, &SrcType) == AL_FALSE)
345 alSetError(Context, AL_INVALID_ENUM);
346 else switch(SrcType)
347 {
348 case UserFmtByte:
349 case UserFmtUByte:
350 case UserFmtShort:
351 case UserFmtUShort:
352 case UserFmtInt:
353 case UserFmtUInt:
354 case UserFmtFloat: {
355 ALuint FrameSize = FrameSizeFromUserFmt(SrcChannels, SrcType);
356 if((size%FrameSize) != 0)
357 err = AL_INVALID_VALUE;
358 else
359 err = LoadData(ALBuf, freq, format, size/FrameSize,
360 SrcChannels, SrcType, data, AL_TRUE);
361 if(err != AL_NO_ERROR)
362 alSetError(Context, err);
363 } break;
364
365 case UserFmtByte3:
366 case UserFmtUByte3:
367 case UserFmtDouble: {
368 ALuint FrameSize = FrameSizeFromUserFmt(SrcChannels, SrcType);
369 ALenum NewFormat = AL_FORMAT_MONO_FLOAT32;
370 switch(SrcChannels)
371 {
372 case UserFmtMono: NewFormat = AL_FORMAT_MONO_FLOAT32; break;
373 case UserFmtStereo: NewFormat = AL_FORMAT_STEREO_FLOAT32; break;
374 case UserFmtRear: NewFormat = AL_FORMAT_REAR32; break;
375 case UserFmtQuad: NewFormat = AL_FORMAT_QUAD32; break;
376 case UserFmtX51: NewFormat = AL_FORMAT_51CHN32; break;
377 case UserFmtX61: NewFormat = AL_FORMAT_61CHN32; break;
378 case UserFmtX71: NewFormat = AL_FORMAT_71CHN32; break;
379 }
380 if((size%FrameSize) != 0)
381 err = AL_INVALID_VALUE;
382 else
383 err = LoadData(ALBuf, freq, NewFormat, size/FrameSize,
384 SrcChannels, SrcType, data, AL_TRUE);
385 if(err != AL_NO_ERROR)
386 alSetError(Context, err);
387 } break;
388
389 case UserFmtMulaw:
390 case UserFmtAlaw:
391 case UserFmtIMA4: {
392 /* Here is where things vary:
393 * nVidia and Apple use 64+1 sample frames per block -> block_size=36 bytes per channel
394 * Most PC sound software uses 2040+1 sample frames per block -> block_size=1024 bytes per channel
395 */
396 ALuint FrameSize = (SrcType == UserFmtIMA4) ?
397 (ChannelsFromUserFmt(SrcChannels) * 36) :
398 FrameSizeFromUserFmt(SrcChannels, SrcType);
399 ALenum NewFormat = AL_FORMAT_MONO16;
400 switch(SrcChannels)
401 {
402 case UserFmtMono: NewFormat = AL_FORMAT_MONO16; break;
403 case UserFmtStereo: NewFormat = AL_FORMAT_STEREO16; break;
404 case UserFmtRear: NewFormat = AL_FORMAT_REAR16; break;
405 case UserFmtQuad: NewFormat = AL_FORMAT_QUAD16; break;
406 case UserFmtX51: NewFormat = AL_FORMAT_51CHN16; break;
407 case UserFmtX61: NewFormat = AL_FORMAT_61CHN16; break;
408 case UserFmtX71: NewFormat = AL_FORMAT_71CHN16; break;
409 }
410 if((size%FrameSize) != 0)
411 err = AL_INVALID_VALUE;
412 else
413 err = LoadData(ALBuf, freq, NewFormat, size/FrameSize,
414 SrcChannels, SrcType, data, AL_TRUE);
415 if(err != AL_NO_ERROR)
416 alSetError(Context, err);
417 } break;
418 }
419
420 ALCcontext_DecRef(Context);
421 }
422
423 /*
424 * alBufferSubDataSOFT(ALuint buffer, ALenum format, const ALvoid *data,
425 * ALsizei offset, ALsizei length)
426 *
427 * Update buffer's audio data
428 */
429 AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer,ALenum format,const ALvoid *data,ALsizei offset,ALsizei length)
430 {
431 enum UserFmtChannels SrcChannels;
432 enum UserFmtType SrcType;
433 ALCcontext *Context;
434 ALCdevice *device;
435 ALbuffer *ALBuf;
436
437 Context = GetContextRef();
438 if(!Context) return;
439
440 device = Context->Device;
441 if((ALBuf=LookupBuffer(device, 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(DecomposeUserFormat(format, &SrcChannels, &SrcType) == AL_FALSE)
446 alSetError(Context, AL_INVALID_ENUM);
447 else
448 {
449 ALuint original_align;
450
451 WriteLock(&ALBuf->lock);
452
453 original_align = ((ALBuf->OriginalType == UserFmtIMA4) ?
454 (ChannelsFromUserFmt(ALBuf->OriginalChannels)*36) :
455 FrameSizeFromUserFmt(ALBuf->OriginalChannels,
456 ALBuf->OriginalType));
457
458 if(SrcChannels != ALBuf->OriginalChannels || SrcType != ALBuf->OriginalType)
459 alSetError(Context, AL_INVALID_ENUM);
460 else if(offset > ALBuf->OriginalSize ||
461 length > ALBuf->OriginalSize-offset ||
462 (offset%original_align) != 0 ||
463 (length%original_align) != 0)
464 alSetError(Context, AL_INVALID_VALUE);
465 else
466 {
467 ALuint Channels = ChannelsFromFmt(ALBuf->FmtChannels);
468 ALuint Bytes = BytesFromFmt(ALBuf->FmtType);
469 if(SrcType == UserFmtIMA4)
470 {
471 /* offset -> byte offset, length -> block count */
472 offset /= 36;
473 offset *= 65;
474 offset *= Bytes;
475 length /= original_align;
476 }
477 else
478 {
479 ALuint OldBytes = BytesFromUserFmt(SrcType);
480
481 offset /= OldBytes;
482 offset *= Bytes;
483 length /= OldBytes * Channels;
484 }
485 ConvertData(&((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
486 data, SrcType, Channels, length);
487 }
488 WriteUnlock(&ALBuf->lock);
489 }
490
491 ALCcontext_DecRef(Context);
492 }
493
494
495 AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer,
496 ALuint samplerate, ALenum internalformat, ALsizei samples,
497 ALenum channels, ALenum type, const ALvoid *data)
498 {
499 ALCcontext *Context;
500 ALCdevice *device;
501 ALbuffer *ALBuf;
502 ALenum err;
503
504 Context = GetContextRef();
505 if(!Context) return;
506
507 device = Context->Device;
508 if((ALBuf=LookupBuffer(device, buffer)) == NULL)
509 alSetError(Context, AL_INVALID_NAME);
510 else if(samples < 0 || samplerate == 0)
511 alSetError(Context, AL_INVALID_VALUE);
512 else if(IsValidType(type) == AL_FALSE || IsValidChannels(channels) == AL_FALSE)
513 alSetError(Context, AL_INVALID_ENUM);
514 else
515 {
516 err = AL_NO_ERROR;
517 if(type == UserFmtIMA4)
518 {
519 if((samples%65) == 0) samples /= 65;
520 else err = AL_INVALID_VALUE;
521 }
522 if(err == AL_NO_ERROR)
523 err = LoadData(ALBuf, samplerate, internalformat, samples,
524 channels, type, data, AL_FALSE);
525 if(err != AL_NO_ERROR)
526 alSetError(Context, err);
527 }
528
529 ALCcontext_DecRef(Context);
530 }
531
532 AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer,
533 ALsizei offset, ALsizei samples,
534 ALenum channels, ALenum type, const ALvoid *data)
535 {
536 ALCcontext *Context;
537 ALCdevice *device;
538 ALbuffer *ALBuf;
539
540 Context = GetContextRef();
541 if(!Context) return;
542
543 device = Context->Device;
544 if((ALBuf=LookupBuffer(device, buffer)) == NULL)
545 alSetError(Context, AL_INVALID_NAME);
546 else if(samples < 0 || offset < 0 || (samples > 0 && data == NULL))
547 alSetError(Context, AL_INVALID_VALUE);
548 else if(IsValidType(type) == AL_FALSE)
549 alSetError(Context, AL_INVALID_ENUM);
550 else
551 {
552 ALuint FrameSize;
553
554 WriteLock(&ALBuf->lock);
555 FrameSize = FrameSizeFromFmt(ALBuf->FmtChannels, ALBuf->FmtType);
556 if(channels != (ALenum)ALBuf->FmtChannels)
557 alSetError(Context, AL_INVALID_ENUM);
558 else if(offset > ALBuf->SampleLen || samples > ALBuf->SampleLen-offset)
559 alSetError(Context, AL_INVALID_VALUE);
560 else if(type == UserFmtIMA4 && (samples%65) != 0)
561 alSetError(Context, AL_INVALID_VALUE);
562 else
563 {
564 /* offset -> byte offset */
565 offset *= FrameSize;
566 /* samples -> IMA4 block count */
567 if(type == UserFmtIMA4) samples /= 65;
568 ConvertData(&((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
569 data, type,
570 ChannelsFromFmt(ALBuf->FmtChannels), samples);
571 }
572 WriteUnlock(&ALBuf->lock);
573 }
574
575 ALCcontext_DecRef(Context);
576 }
577
578 AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer,
579 ALsizei offset, ALsizei samples,
580 ALenum channels, ALenum type, ALvoid *data)
581 {
582 ALCcontext *Context;
583 ALCdevice *device;
584 ALbuffer *ALBuf;
585
586 Context = GetContextRef();
587 if(!Context) return;
588
589 device = Context->Device;
590 if((ALBuf=LookupBuffer(device, buffer)) == NULL)
591 alSetError(Context, AL_INVALID_NAME);
592 else if(samples < 0 || offset < 0 || (samples > 0 && data == NULL))
593 alSetError(Context, AL_INVALID_VALUE);
594 else if(IsValidType(type) == AL_FALSE)
595 alSetError(Context, AL_INVALID_ENUM);
596 else
597 {
598 ALuint FrameSize;
599
600 ReadLock(&ALBuf->lock);
601 FrameSize = FrameSizeFromFmt(ALBuf->FmtChannels, ALBuf->FmtType);
602 if(channels != (ALenum)ALBuf->FmtChannels)
603 alSetError(Context, AL_INVALID_ENUM);
604 else if(offset > ALBuf->SampleLen || samples > ALBuf->SampleLen-offset)
605 alSetError(Context, AL_INVALID_VALUE);
606 else if(type == UserFmtIMA4 && (samples%65) != 0)
607 alSetError(Context, AL_INVALID_VALUE);
608 else
609 {
610 /* offset -> byte offset */
611 offset *= FrameSize;
612 /* samples -> IMA4 block count */
613 if(type == UserFmtIMA4) samples /= 65;
614 ConvertData(data, type,
615 &((ALubyte*)ALBuf->data)[offset], ALBuf->FmtType,
616 ChannelsFromFmt(ALBuf->FmtChannels), samples);
617 }
618 ReadUnlock(&ALBuf->lock);
619 }
620
621 ALCcontext_DecRef(Context);
622 }
623
624 AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format)
625 {
626 enum FmtChannels DstChannels;
627 enum FmtType DstType;
628 ALCcontext *Context;
629 ALboolean ret;
630
631 Context = GetContextRef();
632 if(!Context) return AL_FALSE;
633
634 ret = DecomposeFormat(format, &DstChannels, &DstType);
635
636 ALCcontext_DecRef(Context);
637
638 return ret;
639 }
640
641
642 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
643 {
644 ALCcontext *pContext;
645 ALCdevice *device;
646
647 (void)flValue;
648
649 pContext = GetContextRef();
650 if(!pContext) return;
651
652 device = pContext->Device;
653 if(LookupBuffer(device, buffer) == NULL)
654 alSetError(pContext, AL_INVALID_NAME);
655 else
656 {
657 switch(eParam)
658 {
659 default:
660 alSetError(pContext, AL_INVALID_ENUM);
661 break;
662 }
663 }
664
665 ALCcontext_DecRef(pContext);
666 }
667
668
669 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
670 {
671 ALCcontext *pContext;
672 ALCdevice *device;
673
674 (void)flValue1;
675 (void)flValue2;
676 (void)flValue3;
677
678 pContext = GetContextRef();
679 if(!pContext) return;
680
681 device = pContext->Device;
682 if(LookupBuffer(device, buffer) == NULL)
683 alSetError(pContext, AL_INVALID_NAME);
684 else
685 {
686 switch(eParam)
687 {
688 default:
689 alSetError(pContext, AL_INVALID_ENUM);
690 break;
691 }
692 }
693
694 ALCcontext_DecRef(pContext);
695 }
696
697
698 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
699 {
700 ALCcontext *pContext;
701 ALCdevice *device;
702
703 pContext = GetContextRef();
704 if(!pContext) return;
705
706 device = pContext->Device;
707 if(!flValues)
708 alSetError(pContext, AL_INVALID_VALUE);
709 else if(LookupBuffer(device, buffer) == NULL)
710 alSetError(pContext, AL_INVALID_NAME);
711 else
712 {
713 switch(eParam)
714 {
715 default:
716 alSetError(pContext, AL_INVALID_ENUM);
717 break;
718 }
719 }
720
721 ALCcontext_DecRef(pContext);
722 }
723
724
725 AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
726 {
727 ALCcontext *pContext;
728 ALCdevice *device;
729
730 (void)lValue;
731
732 pContext = GetContextRef();
733 if(!pContext) return;
734
735 device = pContext->Device;
736 if(LookupBuffer(device, buffer) == NULL)
737 alSetError(pContext, AL_INVALID_NAME);
738 else
739 {
740 switch(eParam)
741 {
742 default:
743 alSetError(pContext, AL_INVALID_ENUM);
744 break;
745 }
746 }
747
748 ALCcontext_DecRef(pContext);
749 }
750
751
752 AL_API void AL_APIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
753 {
754 ALCcontext *pContext;
755 ALCdevice *device;
756
757 (void)lValue1;
758 (void)lValue2;
759 (void)lValue3;
760
761 pContext = GetContextRef();
762 if(!pContext) return;
763
764 device = pContext->Device;
765 if(LookupBuffer(device, buffer) == NULL)
766 alSetError(pContext, AL_INVALID_NAME);
767 else
768 {
769 switch(eParam)
770 {
771 default:
772 alSetError(pContext, AL_INVALID_ENUM);
773 break;
774 }
775 }
776
777 ALCcontext_DecRef(pContext);
778 }
779
780
781 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
782 {
783 ALCcontext *pContext;
784 ALCdevice *device;
785 ALbuffer *ALBuf;
786
787 pContext = GetContextRef();
788 if(!pContext) return;
789
790 device = pContext->Device;
791 if(!plValues)
792 alSetError(pContext, AL_INVALID_VALUE);
793 else if((ALBuf=LookupBuffer(device, buffer)) == NULL)
794 alSetError(pContext, AL_INVALID_NAME);
795 else
796 {
797 switch(eParam)
798 {
799 case AL_LOOP_POINTS_SOFT:
800 WriteLock(&ALBuf->lock);
801 if(ALBuf->ref != 0)
802 alSetError(pContext, AL_INVALID_OPERATION);
803 else if(plValues[0] >= plValues[1] || plValues[0] < 0 ||
804 plValues[1] > ALBuf->SampleLen)
805 alSetError(pContext, AL_INVALID_VALUE);
806 else
807 {
808 ALBuf->LoopStart = plValues[0];
809 ALBuf->LoopEnd = plValues[1];
810 }
811 WriteUnlock(&ALBuf->lock);
812 break;
813
814 default:
815 alSetError(pContext, AL_INVALID_ENUM);
816 break;
817 }
818 }
819
820 ALCcontext_DecRef(pContext);
821 }
822
823
824 AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
825 {
826 ALCcontext *pContext;
827 ALCdevice *device;
828 ALbuffer *pBuffer;
829
830 pContext = GetContextRef();
831 if(!pContext) return;
832
833 device = pContext->Device;
834 if(!pflValue)
835 alSetError(pContext, AL_INVALID_VALUE);
836 else if((pBuffer=LookupBuffer(device, buffer)) == NULL)
837 alSetError(pContext, AL_INVALID_NAME);
838 else
839 {
840 switch(eParam)
841 {
842 case AL_SEC_LENGTH_SOFT:
843 ReadLock(&pBuffer->lock);
844 if(pBuffer->SampleLen != 0)
845 *pflValue = pBuffer->SampleLen / (ALfloat)pBuffer->Frequency;
846 else
847 *pflValue = 0.0f;
848 ReadUnlock(&pBuffer->lock);
849 break;
850
851 default:
852 alSetError(pContext, AL_INVALID_ENUM);
853 break;
854 }
855 }
856
857 ALCcontext_DecRef(pContext);
858 }
859
860
861 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
862 {
863 ALCcontext *pContext;
864 ALCdevice *device;
865
866 pContext = GetContextRef();
867 if(!pContext) return;
868
869 device = pContext->Device;
870 if(!pflValue1 || !pflValue2 || !pflValue3)
871 alSetError(pContext, AL_INVALID_VALUE);
872 else if(LookupBuffer(device, buffer) == NULL)
873 alSetError(pContext, AL_INVALID_NAME);
874 else
875 {
876 switch(eParam)
877 {
878 default:
879 alSetError(pContext, AL_INVALID_ENUM);
880 break;
881 }
882 }
883
884 ALCcontext_DecRef(pContext);
885 }
886
887
888 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
889 {
890 ALCcontext *pContext;
891 ALCdevice *device;
892
893 switch(eParam)
894 {
895 case AL_SEC_LENGTH_SOFT:
896 alGetBufferf(buffer, eParam, pflValues);
897 return;
898 }
899
900 pContext = GetContextRef();
901 if(!pContext) return;
902
903 device = pContext->Device;
904 if(!pflValues)
905 alSetError(pContext, AL_INVALID_VALUE);
906 else if(LookupBuffer(device, buffer) == NULL)
907 alSetError(pContext, AL_INVALID_NAME);
908 else
909 {
910 switch(eParam)
911 {
912 default:
913 alSetError(pContext, AL_INVALID_ENUM);
914 break;
915 }
916 }
917
918 ALCcontext_DecRef(pContext);
919 }
920
921
922 AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
923 {
924 ALCcontext *pContext;
925 ALbuffer *pBuffer;
926 ALCdevice *device;
927
928 pContext = GetContextRef();
929 if(!pContext) return;
930
931 device = pContext->Device;
932 if(!plValue)
933 alSetError(pContext, AL_INVALID_VALUE);
934 else if((pBuffer=LookupBuffer(device, buffer)) == NULL)
935 alSetError(pContext, AL_INVALID_NAME);
936 else
937 {
938 switch(eParam)
939 {
940 case AL_FREQUENCY:
941 *plValue = pBuffer->Frequency;
942 break;
943
944 case AL_BITS:
945 *plValue = BytesFromFmt(pBuffer->FmtType) * 8;
946 break;
947
948 case AL_CHANNELS:
949 *plValue = ChannelsFromFmt(pBuffer->FmtChannels);
950 break;
951
952 case AL_SIZE:
953 ReadLock(&pBuffer->lock);
954 *plValue = pBuffer->SampleLen *
955 FrameSizeFromFmt(pBuffer->FmtChannels, pBuffer->FmtType);
956 ReadUnlock(&pBuffer->lock);
957 break;
958
959 case AL_INTERNAL_FORMAT_SOFT:
960 *plValue = pBuffer->Format;
961 break;
962
963 case AL_BYTE_LENGTH_SOFT:
964 *plValue = pBuffer->OriginalSize;
965 break;
966
967 case AL_SAMPLE_LENGTH_SOFT:
968 *plValue = pBuffer->SampleLen;
969 break;
970
971 default:
972 alSetError(pContext, AL_INVALID_ENUM);
973 break;
974 }
975 }
976
977 ALCcontext_DecRef(pContext);
978 }
979
980
981 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
982 {
983 ALCcontext *pContext;
984 ALCdevice *device;
985
986 pContext = GetContextRef();
987 if(!pContext) return;
988
989 device = pContext->Device;
990 if(!plValue1 || !plValue2 || !plValue3)
991 alSetError(pContext, AL_INVALID_VALUE);
992 else if(LookupBuffer(device, buffer) == NULL)
993 alSetError(pContext, AL_INVALID_NAME);
994 else
995 {
996 switch(eParam)
997 {
998 default:
999 alSetError(pContext, AL_INVALID_ENUM);
1000 break;
1001 }
1002 }
1003
1004 ALCcontext_DecRef(pContext);
1005 }
1006
1007
1008 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
1009 {
1010 ALCcontext *pContext;
1011 ALCdevice *device;
1012 ALbuffer *ALBuf;
1013
1014 switch(eParam)
1015 {
1016 case AL_FREQUENCY:
1017 case AL_BITS:
1018 case AL_CHANNELS:
1019 case AL_SIZE:
1020 case AL_INTERNAL_FORMAT_SOFT:
1021 case AL_BYTE_LENGTH_SOFT:
1022 case AL_SAMPLE_LENGTH_SOFT:
1023 alGetBufferi(buffer, eParam, plValues);
1024 return;
1025 }
1026
1027 pContext = GetContextRef();
1028 if(!pContext) return;
1029
1030 device = pContext->Device;
1031 if(!plValues)
1032 alSetError(pContext, AL_INVALID_VALUE);
1033 else if((ALBuf=LookupBuffer(device, buffer)) == NULL)
1034 alSetError(pContext, AL_INVALID_NAME);
1035 else
1036 {
1037 switch(eParam)
1038 {
1039 case AL_LOOP_POINTS_SOFT:
1040 ReadLock(&ALBuf->lock);
1041 plValues[0] = ALBuf->LoopStart;
1042 plValues[1] = ALBuf->LoopEnd;
1043 ReadUnlock(&ALBuf->lock);
1044 break;
1045
1046 default:
1047 alSetError(pContext, AL_INVALID_ENUM);
1048 break;
1049 }
1050 }
1051
1052 ALCcontext_DecRef(pContext);
1053 }
1054
1055
1056 typedef ALubyte ALmulaw;
1057 typedef ALubyte ALalaw;
1058 typedef ALubyte ALima4;
1059 typedef struct {
1060 ALbyte b[3];
1061 } ALbyte3;
1062 typedef struct {
1063 ALubyte b[3];
1064 } ALubyte3;
1065
1066 static __inline ALshort DecodeMuLaw(ALmulaw val)
1067 { return muLawDecompressionTable[val]; }
1068
1069 static ALmulaw EncodeMuLaw(ALshort val)
1070 {
1071 ALint mant, exp, sign;
1072
1073 sign = (val>>8) & 0x80;
1074 if(sign)
1075 {
1076 /* -32768 doesn't properly negate on a short; it results in itself.
1077 * So clamp to -32767 */
1078 val = maxi(val, -32767);
1079 val = -val;
1080 }
1081
1082 val = mini(val, muLawClip);
1083 val += muLawBias;
1084
1085 exp = muLawCompressTable[(val>>7) & 0xff];
1086 mant = (val >> (exp+3)) & 0x0f;
1087
1088 return ~(sign | (exp<<4) | mant);
1089 }
1090
1091 static __inline ALshort DecodeALaw(ALalaw val)
1092 { return aLawDecompressionTable[val]; }
1093
1094 static ALalaw EncodeALaw(ALshort val)
1095 {
1096 ALint mant, exp, sign;
1097
1098 sign = ((~val) >> 8) & 0x80;
1099 if(!sign)
1100 {
1101 val = maxi(val, -32767);
1102 val = -val;
1103 }
1104 val = mini(val, aLawClip);
1105
1106 if(val >= 256)
1107 {
1108 exp = aLawCompressTable[(val>>8) & 0x7f];
1109 mant = (val >> (exp+3)) & 0x0f;
1110 }
1111 else
1112 {
1113 exp = 0;
1114 mant = val >> 4;
1115 }
1116
1117 return ((exp<<4) | mant) ^ (sign^0x55);
1118 }
1119
1120 static void DecodeIMA4Block(ALshort *dst, const ALima4 *src, ALint numchans)
1121 {
1122 ALint sample[MAXCHANNELS], index[MAXCHANNELS];
1123 ALuint code[MAXCHANNELS];
1124 ALsizei j,k,c;
1125
1126 for(c = 0;c < numchans;c++)
1127 {
1128 sample[c] = *(src++);
1129 sample[c] |= *(src++) << 8;
1130 sample[c] = (sample[c]^0x8000) - 32768;
1131 index[c] = *(src++);
1132 index[c] |= *(src++) << 8;
1133 index[c] = (index[c]^0x8000) - 32768;
1134
1135 index[c] = clampi(index[c], 0, 88);
1136
1137 dst[c] = sample[c];
1138 }
1139
1140 j = 1;
1141 while(j < 65)
1142 {
1143 for(c = 0;c < numchans;c++)
1144 {
1145 code[c] = *(src++);
1146 code[c] |= *(src++) << 8;
1147 code[c] |= *(src++) << 16;
1148 code[c] |= *(src++) << 24;
1149 }
1150
1151 for(k = 0;k < 8;k++,j++)
1152 {
1153 for(c = 0;c < numchans;c++)
1154 {
1155 int nibble = code[c]&0xf;
1156 code[c] >>= 4;
1157
1158 sample[c] += IMA4Codeword[nibble] * IMAStep_size[index[c]] / 8;
1159 sample[c] = clampi(sample[c], -32768, 32767);
1160
1161 index[c] += IMA4Index_adjust[nibble];
1162 index[c] = clampi(index[c], 0, 88);
1163
1164 dst[j*numchans + c] = sample[c];
1165 }
1166 }
1167 }
1168 }
1169
1170 static void EncodeIMA4Block(ALima4 *dst, const ALshort *src, ALint *sample, ALint *index, ALint numchans)
1171 {
1172 ALsizei j,k,c;
1173
1174 for(c = 0;c < numchans;c++)
1175 {
1176 int diff = src[c] - sample[c];
1177 int step = IMAStep_size[index[c]];
1178 int nibble;
1179
1180 nibble = 0;
1181 if(diff < 0)
1182 {
1183 nibble = 0x8;
1184 diff = -diff;
1185 }
1186
1187 diff = mini(step*2, diff);
1188 nibble |= (diff*8/step - 1) / 2;
1189
1190 sample[c] += IMA4Codeword[nibble] * step / 8;
1191 sample[c] = clampi(sample[c], -32768, 32767);
1192
1193 index[c] += IMA4Index_adjust[nibble];
1194 index[c] = clampi(index[c], 0, 88);
1195
1196 *(dst++) = sample[c] & 0xff;
1197 *(dst++) = (sample[c]>>8) & 0xff;
1198 *(dst++) = index[c] & 0xff;
1199 *(dst++) = (index[c]>>8) & 0xff;
1200 }
1201
1202 j = 1;
1203 while(j < 65)
1204 {
1205 for(c = 0;c < numchans;c++)
1206 {
1207 for(k = 0;k < 8;k++)
1208 {
1209 int diff = src[(j+k)*numchans + c] - sample[c];
1210 int step = IMAStep_size[index[c]];
1211 int nibble;
1212
1213 nibble = 0;
1214 if(diff < 0)
1215 {
1216 nibble = 0x8;
1217 diff = -diff;
1218 }
1219
1220 diff = mini(step*2, diff);
1221 nibble |= (diff*8/step - 1) / 2;
1222
1223 sample[c] += IMA4Codeword[nibble] * step / 8;
1224 sample[c] = clampi(sample[c], -32768, 32767);
1225
1226 index[c] += IMA4Index_adjust[nibble];
1227 index[c] = clampi(index[c], 0, 88);
1228
1229 if(!(k&1)) *dst = nibble;
1230 else *(dst++) |= nibble<<4;
1231 }
1232 }
1233 j += 8;
1234 }
1235 }
1236
1237 static const union {
1238 ALuint u;
1239 ALubyte b[sizeof(ALuint)];
1240 } EndianTest = { 1 };
1241 #define IS_LITTLE_ENDIAN (EndianTest.b[0] == 1)
1242
1243 static __inline ALint DecodeByte3(ALbyte3 val)
1244 {
1245 if(IS_LITTLE_ENDIAN)
1246 return (val.b[2]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[0]);
1247 return (val.b[0]<<16) | (((ALubyte)val.b[1])<<8) | ((ALubyte)val.b[2]);
1248 }
1249
1250 static __inline ALbyte3 EncodeByte3(ALint val)
1251 {
1252 if(IS_LITTLE_ENDIAN)
1253 {
1254 ALbyte3 ret = {{ val, val>>8, val>>16 }};
1255 return ret;
1256 }
1257 else
1258 {
1259 ALbyte3 ret = {{ val>>16, val>>8, val }};
1260 return ret;
1261 }
1262 }
1263
1264 static __inline ALint DecodeUByte3(ALubyte3 val)
1265 {
1266 if(IS_LITTLE_ENDIAN)
1267 return (val.b[2]<<16) | (val.b[1]<<8) | (val.b[0]);
1268 return (val.b[0]<<16) | (val.b[1]<<8) | val.b[2];
1269 }
1270
1271 static __inline ALubyte3 EncodeUByte3(ALint val)
1272 {
1273 if(IS_LITTLE_ENDIAN)
1274 {
1275 ALubyte3 ret = {{ val, val>>8, val>>16 }};
1276 return ret;
1277 }
1278 else
1279 {
1280 ALubyte3 ret = {{ val>>16, val>>8, val }};
1281 return ret;
1282 }
1283 }
1284
1285
1286 static __inline ALbyte Conv_ALbyte_ALbyte(ALbyte val)
1287 { return val; }
1288 static __inline ALbyte Conv_ALbyte_ALubyte(ALubyte val)
1289 { return val-128; }
1290 static __inline ALbyte Conv_ALbyte_ALshort(ALshort val)
1291 { return val>>8; }
1292 static __inline ALbyte Conv_ALbyte_ALushort(ALushort val)
1293 { return (val>>8)-128; }
1294 static __inline ALbyte Conv_ALbyte_ALint(ALint val)
1295 { return val>>24; }
1296 static __inline ALbyte Conv_ALbyte_ALuint(ALuint val)
1297 { return (val>>24)-128; }
1298 static __inline ALbyte Conv_ALbyte_ALfloat(ALfloat val)
1299 {
1300 if(val > 1.0f) return 127;
1301 if(val < -1.0f) return -128;
1302 return (ALint)(val * 127.0f);
1303 }
1304 static __inline ALbyte Conv_ALbyte_ALdouble(ALdouble val)
1305 {
1306 if(val > 1.0) return 127;
1307 if(val < -1.0) return -128;
1308 return (ALint)(val * 127.0);
1309 }
1310 static __inline ALbyte Conv_ALbyte_ALmulaw(ALmulaw val)
1311 { return Conv_ALbyte_ALshort(DecodeMuLaw(val)); }
1312 static __inline ALbyte Conv_ALbyte_ALalaw(ALalaw val)
1313 { return Conv_ALbyte_ALshort(DecodeALaw(val)); }
1314 static __inline ALbyte Conv_ALbyte_ALbyte3(ALbyte3 val)
1315 { return DecodeByte3(val)>>16; }
1316 static __inline ALbyte Conv_ALbyte_ALubyte3(ALubyte3 val)
1317 { return (DecodeUByte3(val)>>16)-128; }
1318
1319 static __inline ALubyte Conv_ALubyte_ALbyte(ALbyte val)
1320 { return val+128; }
1321 static __inline ALubyte Conv_ALubyte_ALubyte(ALubyte val)
1322 { return val; }
1323 static __inline ALubyte Conv_ALubyte_ALshort(ALshort val)
1324 { return (val>>8)+128; }
1325 static __inline ALubyte Conv_ALubyte_ALushort(ALushort val)
1326 { return val>>8; }
1327 static __inline ALubyte Conv_ALubyte_ALint(ALint val)
1328 { return (val>>24)+128; }
1329 static __inline ALubyte Conv_ALubyte_ALuint(ALuint val)
1330 { return val>>24; }
1331 static __inline ALubyte Conv_ALubyte_ALfloat(ALfloat val)
1332 {
1333 if(val > 1.0f) return 255;
1334 if(val < -1.0f) return 0;
1335 return (ALint)(val * 127.0f) + 128;
1336 }
1337 static __inline ALubyte Conv_ALubyte_ALdouble(ALdouble val)
1338 {
1339 if(val > 1.0) return 255;
1340 if(val < -1.0) return 0;
1341 return (ALint)(val * 127.0) + 128;
1342 }
1343 static __inline ALubyte Conv_ALubyte_ALmulaw(ALmulaw val)
1344 { return Conv_ALubyte_ALshort(DecodeMuLaw(val)); }
1345 static __inline ALubyte Conv_ALubyte_ALalaw(ALalaw val)
1346 { return Conv_ALubyte_ALshort(DecodeALaw(val)); }
1347 static __inline ALubyte Conv_ALubyte_ALbyte3(ALbyte3 val)
1348 { return (DecodeByte3(val)>>16)+128; }
1349 static __inline ALubyte Conv_ALubyte_ALubyte3(ALubyte3 val)
1350 { return DecodeUByte3(val)>>16; }
1351
1352 static __inline ALshort Conv_ALshort_ALbyte(ALbyte val)
1353 { return val<<8; }
1354 static __inline ALshort Conv_ALshort_ALubyte(ALubyte val)
1355 { return (val-128)<<8; }
1356 static __inline ALshort Conv_ALshort_ALshort(ALshort val)
1357 { return val; }
1358 static __inline ALshort Conv_ALshort_ALushort(ALushort val)
1359 { return val-32768; }
1360 static __inline ALshort Conv_ALshort_ALint(ALint val)
1361 { return val>>16; }
1362 static __inline ALshort Conv_ALshort_ALuint(ALuint val)
1363 { return (val>>16)-32768; }
1364 static __inline ALshort Conv_ALshort_ALfloat(ALfloat val)
1365 {
1366 if(val > 1.0f) return 32767;
1367 if(val < -1.0f) return -32768;
1368 return (ALint)(val * 32767.0f);
1369 }
1370 static __inline ALshort Conv_ALshort_ALdouble(ALdouble val)
1371 {
1372 if(val > 1.0) return 32767;
1373 if(val < -1.0) return -32768;
1374 return (ALint)(val * 32767.0);
1375 }
1376 static __inline ALshort Conv_ALshort_ALmulaw(ALmulaw val)
1377 { return Conv_ALshort_ALshort(DecodeMuLaw(val)); }
1378 static __inline ALshort Conv_ALshort_ALalaw(ALalaw val)
1379 { return Conv_ALshort_ALshort(DecodeALaw(val)); }
1380 static __inline ALshort Conv_ALshort_ALbyte3(ALbyte3 val)
1381 { return DecodeByte3(val)>>8; }
1382 static __inline ALshort Conv_ALshort_ALubyte3(ALubyte3 val)
1383 { return (DecodeUByte3(val)>>8)-32768; }
1384
1385 static __inline ALushort Conv_ALushort_ALbyte(ALbyte val)
1386 { return (val+128)<<8; }
1387 static __inline ALushort Conv_ALushort_ALubyte(ALubyte val)
1388 { return val<<8; }
1389 static __inline ALushort Conv_ALushort_ALshort(ALshort val)
1390 { return val+32768; }
1391 static __inline ALushort Conv_ALushort_ALushort(ALushort val)
1392 { return val; }
1393 static __inline ALushort Conv_ALushort_ALint(ALint val)
1394 { return (val>>16)+32768; }
1395 static __inline ALushort Conv_ALushort_ALuint(ALuint val)
1396 { return val>>16; }
1397 static __inline ALushort Conv_ALushort_ALfloat(ALfloat val)
1398 {
1399 if(val > 1.0f) return 65535;
1400 if(val < -1.0f) return 0;
1401 return (ALint)(val * 32767.0f) + 32768;
1402 }
1403 static __inline ALushort Conv_ALushort_ALdouble(ALdouble val)
1404 {
1405 if(val > 1.0) return 65535;
1406 if(val < -1.0) return 0;
1407 return (ALint)(val * 32767.0) + 32768;
1408 }
1409 static __inline ALushort Conv_ALushort_ALmulaw(ALmulaw val)
1410 { return Conv_ALushort_ALshort(DecodeMuLaw(val)); }
1411 static __inline ALushort Conv_ALushort_ALalaw(ALalaw val)
1412 { return Conv_ALushort_ALshort(DecodeALaw(val)); }
1413 static __inline ALushort Conv_ALushort_ALbyte3(ALbyte3 val)
1414 { return (DecodeByte3(val)>>8)+32768; }
1415 static __inline ALushort Conv_ALushort_ALubyte3(ALubyte3 val)
1416 { return DecodeUByte3(val)>>8; }
1417
1418 static __inline ALint Conv_ALint_ALbyte(ALbyte val)
1419 { return val<<24; }
1420 static __inline ALint Conv_ALint_ALubyte(ALubyte val)
1421 { return (val-128)<<24; }
1422 static __inline ALint Conv_ALint_ALshort(ALshort val)
1423 { return val<<16; }
1424 static __inline ALint Conv_ALint_ALushort(ALushort val)
1425 { return (val-32768)<<16; }
1426 static __inline ALint Conv_ALint_ALint(ALint val)
1427 { return val; }
1428 static __inline ALint Conv_ALint_ALuint(ALuint val)
1429 { return val-2147483648u; }
1430 static __inline ALint Conv_ALint_ALfloat(ALfloat val)
1431 {
1432 if(val > 1.0f) return 2147483647;
1433 if(val < -1.0f) return -2147483647-1;
1434 return (ALint)(val * 2147483647.0);
1435 }
1436 static __inline ALint Conv_ALint_ALdouble(ALdouble val)
1437 {
1438 if(val > 1.0) return 2147483647;
1439 if(val < -1.0) return -2147483647-1;
1440 return (ALint)(val * 2147483647.0);
1441 }
1442 static __inline ALint Conv_ALint_ALmulaw(ALmulaw val)
1443 { return Conv_ALint_ALshort(DecodeMuLaw(val)); }
1444 static __inline ALint Conv_ALint_ALalaw(ALalaw val)
1445 { return Conv_ALint_ALshort(DecodeALaw(val)); }
1446 static __inline ALint Conv_ALint_ALbyte3(ALbyte3 val)
1447 { return DecodeByte3(val)<<8; }
1448 static __inline ALint Conv_ALint_ALubyte3(ALubyte3 val)
1449 { return (DecodeUByte3(val)-8388608)<<8; }
1450
1451 static __inline ALuint Conv_ALuint_ALbyte(ALbyte val)
1452 { return (val+128)<<24; }
1453 static __inline ALuint Conv_ALuint_ALubyte(ALubyte val)
1454 { return val<<24; }
1455 static __inline ALuint Conv_ALuint_ALshort(ALshort val)
1456 { return (val+32768)<<16; }
1457 static __inline ALuint Conv_ALuint_ALushort(ALushort val)
1458 { return val<<16; }
1459 static __inline ALuint Conv_ALuint_ALint(ALint val)
1460 { return val+2147483648u; }
1461 static __inline ALuint Conv_ALuint_ALuint(ALuint val)
1462 { return val; }
1463 static __inline ALuint Conv_ALuint_ALfloat(ALfloat val)
1464 {
1465 if(val > 1.0f) return 4294967295u;
1466 if(val < -1.0f) return 0;
1467 return (ALint)(val * 2147483647.0) + 2147483648u;
1468 }
1469 static __inline ALuint Conv_ALuint_ALdouble(ALdouble val)
1470 {
1471 if(val > 1.0) return 4294967295u;
1472 if(val < -1.0) return 0;
1473 return (ALint)(val * 2147483647.0) + 2147483648u;
1474 }
1475 static __inline ALuint Conv_ALuint_ALmulaw(ALmulaw val)
1476 { return Conv_ALuint_ALshort(DecodeMuLaw(val)); }
1477 static __inline ALuint Conv_ALuint_ALalaw(ALalaw val)
1478 { return Conv_ALuint_ALshort(DecodeALaw(val)); }
1479 static __inline ALuint Conv_ALuint_ALbyte3(ALbyte3 val)
1480 { return (DecodeByte3(val)+8388608)<<8; }
1481 static __inline ALuint Conv_ALuint_ALubyte3(ALubyte3 val)
1482 { return DecodeUByte3(val)<<8; }
1483
1484 static __inline ALfloat Conv_ALfloat_ALbyte(ALbyte val)
1485 { return val * (1.0f/127.0f); }
1486 static __inline ALfloat Conv_ALfloat_ALubyte(ALubyte val)
1487 { return (val-128) * (1.0f/127.0f); }
1488 static __inline ALfloat Conv_ALfloat_ALshort(ALshort val)
1489 { return val * (1.0f/32767.0f); }
1490 static __inline ALfloat Conv_ALfloat_ALushort(ALushort val)
1491 { return (val-32768) * (1.0f/32767.0f); }
1492 static __inline ALfloat Conv_ALfloat_ALint(ALint val)
1493 { return (ALfloat)(val * (1.0/2147483647.0)); }
1494 static __inline ALfloat Conv_ALfloat_ALuint(ALuint val)
1495 { return (ALfloat)((ALint)(val-2147483648u) * (1.0/2147483647.0)); }
1496 static __inline ALfloat Conv_ALfloat_ALfloat(ALfloat val)
1497 { return (val==val) ? val : 0.0f; }
1498 static __inline ALfloat Conv_ALfloat_ALdouble(ALdouble val)
1499 { return (val==val) ? (ALfloat)val : 0.0f; }
1500 static __inline ALfloat Conv_ALfloat_ALmulaw(ALmulaw val)
1501 { return Conv_ALfloat_ALshort(DecodeMuLaw(val)); }
1502 static __inline ALfloat Conv_ALfloat_ALalaw(ALalaw val)
1503 { return Conv_ALfloat_ALshort(DecodeALaw(val)); }
1504 static __inline ALfloat Conv_ALfloat_ALbyte3(ALbyte3 val)
1505 { return (ALfloat)(DecodeByte3(val) * (1.0/8388607.0)); }
1506 static __inline ALfloat Conv_ALfloat_ALubyte3(ALubyte3 val)
1507 { return (ALfloat)((DecodeUByte3(val)-8388608) * (1.0/8388607.0)); }
1508
1509 static __inline ALdouble Conv_ALdouble_ALbyte(ALbyte val)
1510 { return val * (1.0/127.0); }
1511 static __inline ALdouble Conv_ALdouble_ALubyte(ALubyte val)
1512 { return (val-128) * (1.0/127.0); }
1513 static __inline ALdouble Conv_ALdouble_ALshort(ALshort val)
1514 { return val * (1.0/32767.0); }
1515 static __inline ALdouble Conv_ALdouble_ALushort(ALushort val)
1516 { return (val-32768) * (1.0/32767.0); }
1517 static __inline ALdouble Conv_ALdouble_ALint(ALint val)
1518 { return val * (1.0/2147483647.0); }
1519 static __inline ALdouble Conv_ALdouble_ALuint(ALuint val)
1520 { return (ALint)(val-2147483648u) * (1.0/2147483647.0); }
1521 static __inline ALdouble Conv_ALdouble_ALfloat(ALfloat val)
1522 { return (val==val) ? val : 0.0f; }
1523 static __inline ALdouble Conv_ALdouble_ALdouble(ALdouble val)
1524 { return (val==val) ? val : 0.0; }
1525 static __inline ALdouble Conv_ALdouble_ALmulaw(ALmulaw val)
1526 { return Conv_ALdouble_ALshort(DecodeMuLaw(val)); }
1527 static __inline ALdouble Conv_ALdouble_ALalaw(ALalaw val)
1528 { return Conv_ALdouble_ALshort(DecodeALaw(val)); }
1529 static __inline ALdouble Conv_ALdouble_ALbyte3(ALbyte3 val)
1530 { return DecodeByte3(val) * (1.0/8388607.0); }
1531 static __inline ALdouble Conv_ALdouble_ALubyte3(ALubyte3 val)
1532 { return (DecodeUByte3(val)-8388608) * (1.0/8388607.0); }
1533
1534 #define DECL_TEMPLATE(T) \
1535 static __inline ALmulaw Conv_ALmulaw_##T(T val) \
1536 { return EncodeMuLaw(Conv_ALshort_##T(val)); }
1537
1538 DECL_TEMPLATE(ALbyte)
1539 DECL_TEMPLATE(ALubyte)
1540 DECL_TEMPLATE(ALshort)
1541 DECL_TEMPLATE(ALushort)
1542 DECL_TEMPLATE(ALint)
1543 DECL_TEMPLATE(ALuint)
1544 DECL_TEMPLATE(ALfloat)
1545 DECL_TEMPLATE(ALdouble)
1546 static __inline ALmulaw Conv_ALmulaw_ALmulaw(ALmulaw val)
1547 { return val; }
1548 DECL_TEMPLATE(ALalaw)
1549 DECL_TEMPLATE(ALbyte3)
1550 DECL_TEMPLATE(ALubyte3)
1551
1552 #undef DECL_TEMPLATE
1553
1554 #define DECL_TEMPLATE(T) \
1555 static __inline ALalaw Conv_ALalaw_##T(T val) \
1556 { return EncodeALaw(Conv_ALshort_##T(val)); }
1557
1558 DECL_TEMPLATE(ALbyte)
1559 DECL_TEMPLATE(ALubyte)
1560 DECL_TEMPLATE(ALshort)
1561 DECL_TEMPLATE(ALushort)
1562 DECL_TEMPLATE(ALint)
1563 DECL_TEMPLATE(ALuint)
1564 DECL_TEMPLATE(ALfloat)
1565 DECL_TEMPLATE(ALdouble)
1566 DECL_TEMPLATE(ALmulaw)
1567 static __inline ALalaw Conv_ALalaw_ALalaw(ALalaw val)
1568 { return val; }
1569 DECL_TEMPLATE(ALbyte3)
1570 DECL_TEMPLATE(ALubyte3)
1571
1572 #undef DECL_TEMPLATE
1573
1574 #define DECL_TEMPLATE(T) \
1575 static __inline ALbyte3 Conv_ALbyte3_##T(T val) \
1576 { return EncodeByte3(Conv_ALint_##T(val)>>8); }
1577
1578 DECL_TEMPLATE(ALbyte)
1579 DECL_TEMPLATE(ALubyte)
1580 DECL_TEMPLATE(ALshort)
1581 DECL_TEMPLATE(ALushort)
1582 DECL_TEMPLATE(ALint)
1583 DECL_TEMPLATE(ALuint)
1584 DECL_TEMPLATE(ALfloat)
1585 DECL_TEMPLATE(ALdouble)
1586 DECL_TEMPLATE(ALmulaw)
1587 DECL_TEMPLATE(ALalaw)
1588 static __inline ALbyte3 Conv_ALbyte3_ALbyte3(ALbyte3 val)
1589 { return val; }
1590 DECL_TEMPLATE(ALubyte3)
1591
1592 #undef DECL_TEMPLATE
1593
1594 #define DECL_TEMPLATE(T) \
1595 static __inline ALubyte3 Conv_ALubyte3_##T(T val) \
1596 { return EncodeUByte3(Conv_ALuint_##T(val)>>8); }
1597
1598 DECL_TEMPLATE(ALbyte)
1599 DECL_TEMPLATE(ALubyte)
1600 DECL_TEMPLATE(ALshort)
1601 DECL_TEMPLATE(ALushort)
1602 DECL_TEMPLATE(ALint)
1603 DECL_TEMPLATE(ALuint)
1604 DECL_TEMPLATE(ALfloat)
1605 DECL_TEMPLATE(ALdouble)
1606 DECL_TEMPLATE(ALmulaw)
1607 DECL_TEMPLATE(ALalaw)
1608 DECL_TEMPLATE(ALbyte3)
1609 static __inline ALubyte3 Conv_ALubyte3_ALubyte3(ALubyte3 val)
1610 { return val; }
1611
1612 #undef DECL_TEMPLATE
1613
1614
1615 #define DECL_TEMPLATE(T1, T2) \
1616 static void Convert_##T1##_##T2(T1 *dst, const T2 *src, ALuint numchans, \
1617 ALuint len) \
1618 { \
1619 ALuint i, j; \
1620 for(i = 0;i < len;i++) \
1621 { \
1622 for(j = 0;j < numchans;j++) \
1623 *(dst++) = Conv_##T1##_##T2(*(src++)); \
1624 } \
1625 }
1626
1627 DECL_TEMPLATE(ALbyte, ALbyte)
1628 DECL_TEMPLATE(ALbyte, ALubyte)
1629 DECL_TEMPLATE(ALbyte, ALshort)
1630 DECL_TEMPLATE(ALbyte, ALushort)
1631 DECL_TEMPLATE(ALbyte, ALint)
1632 DECL_TEMPLATE(ALbyte, ALuint)
1633 DECL_TEMPLATE(ALbyte, ALfloat)
1634 DECL_TEMPLATE(ALbyte, ALdouble)
1635 DECL_TEMPLATE(ALbyte, ALmulaw)
1636 DECL_TEMPLATE(ALbyte, ALalaw)
1637 DECL_TEMPLATE(ALbyte, ALbyte3)
1638 DECL_TEMPLATE(ALbyte, ALubyte3)
1639
1640 DECL_TEMPLATE(ALubyte, ALbyte)
1641 DECL_TEMPLATE(ALubyte, ALubyte)
1642 DECL_TEMPLATE(ALubyte, ALshort)
1643 DECL_TEMPLATE(ALubyte, ALushort)
1644 DECL_TEMPLATE(ALubyte, ALint)
1645 DECL_TEMPLATE(ALubyte, ALuint)
1646 DECL_TEMPLATE(ALubyte, ALfloat)
1647 DECL_TEMPLATE(ALubyte, ALdouble)
1648 DECL_TEMPLATE(ALubyte, ALmulaw)
1649 DECL_TEMPLATE(ALubyte, ALalaw)
1650 DECL_TEMPLATE(ALubyte, ALbyte3)
1651 DECL_TEMPLATE(ALubyte, ALubyte3)
1652
1653 DECL_TEMPLATE(ALshort, ALbyte)
1654 DECL_TEMPLATE(ALshort, ALubyte)
1655 DECL_TEMPLATE(ALshort, ALshort)
1656 DECL_TEMPLATE(ALshort, ALushort)
1657 DECL_TEMPLATE(ALshort, ALint)
1658 DECL_TEMPLATE(ALshort, ALuint)
1659 DECL_TEMPLATE(ALshort, ALfloat)
1660 DECL_TEMPLATE(ALshort, ALdouble)
1661 DECL_TEMPLATE(ALshort, ALmulaw)
1662 DECL_TEMPLATE(ALshort, ALalaw)
1663 DECL_TEMPLATE(ALshort, ALbyte3)
1664 DECL_TEMPLATE(ALshort, ALubyte3)
1665
1666 DECL_TEMPLATE(ALushort, ALbyte)
1667 DECL_TEMPLATE(ALushort, ALubyte)
1668 DECL_TEMPLATE(ALushort, ALshort)
1669 DECL_TEMPLATE(ALushort, ALushort)
1670 DECL_TEMPLATE(ALushort, ALint)
1671 DECL_TEMPLATE(ALushort, ALuint)
1672 DECL_TEMPLATE(ALushort, ALfloat)
1673 DECL_TEMPLATE(ALushort, ALdouble)
1674 DECL_TEMPLATE(ALushort, ALmulaw)
1675 DECL_TEMPLATE(ALushort, ALalaw)
1676 DECL_TEMPLATE(ALushort, ALbyte3)
1677 DECL_TEMPLATE(ALushort, ALubyte3)
1678
1679 DECL_TEMPLATE(ALint, ALbyte)
1680 DECL_TEMPLATE(ALint, ALubyte)
1681 DECL_TEMPLATE(ALint, ALshort)
1682 DECL_TEMPLATE(ALint, ALushort)
1683 DECL_TEMPLATE(ALint, ALint)
1684 DECL_TEMPLATE(ALint, ALuint)
1685 DECL_TEMPLATE(ALint, ALfloat)
1686 DECL_TEMPLATE(ALint, ALdouble)
1687 DECL_TEMPLATE(ALint, ALmulaw)
1688 DECL_TEMPLATE(ALint, ALalaw)
1689 DECL_TEMPLATE(ALint, ALbyte3)
1690 DECL_TEMPLATE(ALint, ALubyte3)
1691
1692 DECL_TEMPLATE(ALuint, ALbyte)
1693 DECL_TEMPLATE(ALuint, ALubyte)
1694 DECL_TEMPLATE(ALuint, ALshort)
1695 DECL_TEMPLATE(ALuint, ALushort)
1696 DECL_TEMPLATE(ALuint, ALint)
1697 DECL_TEMPLATE(ALuint, ALuint)
1698 DECL_TEMPLATE(ALuint, ALfloat)
1699 DECL_TEMPLATE(ALuint, ALdouble)
1700 DECL_TEMPLATE(ALuint, ALmulaw)
1701 DECL_TEMPLATE(ALuint, ALalaw)
1702 DECL_TEMPLATE(ALuint, ALbyte3)
1703 DECL_TEMPLATE(ALuint, ALubyte3)
1704
1705 DECL_TEMPLATE(ALfloat, ALbyte)
1706 DECL_TEMPLATE(ALfloat, ALubyte)
1707 DECL_TEMPLATE(ALfloat, ALshort)
1708 DECL_TEMPLATE(ALfloat, ALushort)
1709 DECL_TEMPLATE(ALfloat, ALint)
1710 DECL_TEMPLATE(ALfloat, ALuint)
1711 DECL_TEMPLATE(ALfloat, ALfloat)
1712 DECL_TEMPLATE(ALfloat, ALdouble)
1713 DECL_TEMPLATE(ALfloat, ALmulaw)
1714 DECL_TEMPLATE(ALfloat, ALalaw)
1715 DECL_TEMPLATE(ALfloat, ALbyte3)
1716 DECL_TEMPLATE(ALfloat, ALubyte3)
1717
1718 DECL_TEMPLATE(ALdouble, ALbyte)
1719 DECL_TEMPLATE(ALdouble, ALubyte)
1720 DECL_TEMPLATE(ALdouble, ALshort)
1721 DECL_TEMPLATE(ALdouble, ALushort)
1722 DECL_TEMPLATE(ALdouble, ALint)
1723 DECL_TEMPLATE(ALdouble, ALuint)
1724 DECL_TEMPLATE(ALdouble, ALfloat)
1725 DECL_TEMPLATE(ALdouble, ALdouble)
1726 DECL_TEMPLATE(ALdouble, ALmulaw)
1727 DECL_TEMPLATE(ALdouble, ALalaw)
1728 DECL_TEMPLATE(ALdouble, ALbyte3)
1729 DECL_TEMPLATE(ALdouble, ALubyte3)
1730
1731 DECL_TEMPLATE(ALmulaw, ALbyte)
1732 DECL_TEMPLATE(ALmulaw, ALubyte)
1733 DECL_TEMPLATE(ALmulaw, ALshort)
1734 DECL_TEMPLATE(ALmulaw, ALushort)
1735 DECL_TEMPLATE(ALmulaw, ALint)
1736 DECL_TEMPLATE(ALmulaw, ALuint)
1737 DECL_TEMPLATE(ALmulaw, ALfloat)
1738 DECL_TEMPLATE(ALmulaw, ALdouble)
1739 DECL_TEMPLATE(ALmulaw, ALmulaw)
1740 DECL_TEMPLATE(ALmulaw, ALalaw)
1741 DECL_TEMPLATE(ALmulaw, ALbyte3)
1742 DECL_TEMPLATE(ALmulaw, ALubyte3)
1743
1744 DECL_TEMPLATE(ALalaw, ALbyte)
1745 DECL_TEMPLATE(ALalaw, ALubyte)
1746 DECL_TEMPLATE(ALalaw, ALshort)
1747 DECL_TEMPLATE(ALalaw, ALushort)
1748 DECL_TEMPLATE(ALalaw, ALint)
1749 DECL_TEMPLATE(ALalaw, ALuint)
1750 DECL_TEMPLATE(ALalaw, ALfloat)
1751 DECL_TEMPLATE(ALalaw, ALdouble)
1752 DECL_TEMPLATE(ALalaw, ALmulaw)
1753 DECL_TEMPLATE(ALalaw, ALalaw)
1754 DECL_TEMPLATE(ALalaw, ALbyte3)
1755 DECL_TEMPLATE(ALalaw, ALubyte3)
1756
1757 DECL_TEMPLATE(ALbyte3, ALbyte)
1758 DECL_TEMPLATE(ALbyte3, ALubyte)
1759 DECL_TEMPLATE(ALbyte3, ALshort)
1760 DECL_TEMPLATE(ALbyte3, ALushort)
1761 DECL_TEMPLATE(ALbyte3, ALint)
1762 DECL_TEMPLATE(ALbyte3, ALuint)
1763 DECL_TEMPLATE(ALbyte3, ALfloat)
1764 DECL_TEMPLATE(ALbyte3, ALdouble)
1765 DECL_TEMPLATE(ALbyte3, ALmulaw)
1766 DECL_TEMPLATE(ALbyte3, ALalaw)
1767 DECL_TEMPLATE(ALbyte3, ALbyte3)
1768 DECL_TEMPLATE(ALbyte3, ALubyte3)
1769
1770 DECL_TEMPLATE(ALubyte3, ALbyte)
1771 DECL_TEMPLATE(ALubyte3, ALubyte)
1772 DECL_TEMPLATE(ALubyte3, ALshort)
1773 DECL_TEMPLATE(ALubyte3, ALushort)
1774 DECL_TEMPLATE(ALubyte3, ALint)
1775 DECL_TEMPLATE(ALubyte3, ALuint)
1776 DECL_TEMPLATE(ALubyte3, ALfloat)
1777 DECL_TEMPLATE(ALubyte3, ALdouble)
1778 DECL_TEMPLATE(ALubyte3, ALmulaw)
1779 DECL_TEMPLATE(ALubyte3, ALalaw)
1780 DECL_TEMPLATE(ALubyte3, ALbyte3)
1781 DECL_TEMPLATE(ALubyte3, ALubyte3)
1782
1783 #undef DECL_TEMPLATE
1784
1785 #define DECL_TEMPLATE(T) \
1786 static void Convert_##T##_ALima4(T *dst, const ALima4 *src, ALuint numchans, \
1787 ALuint numblocks) \
1788 { \
1789 ALuint i, j; \
1790 ALshort tmp[65*MAXCHANNELS]; /* Max samples an IMA4 frame can be */ \
1791 for(i = 0;i < numblocks;i++) \
1792 { \
1793 DecodeIMA4Block(tmp, src, numchans); \
1794 src += 36*numchans; \
1795 for(j = 0;j < 65*numchans;j++) \
1796 *(dst++) = Conv_##T##_ALshort(tmp[j]); \
1797 } \
1798 }
1799
1800 DECL_TEMPLATE(ALbyte)
1801 DECL_TEMPLATE(ALubyte)
1802 DECL_TEMPLATE(ALshort)
1803 DECL_TEMPLATE(ALushort)
1804 DECL_TEMPLATE(ALint)
1805 DECL_TEMPLATE(ALuint)
1806 DECL_TEMPLATE(ALfloat)
1807 DECL_TEMPLATE(ALdouble)
1808 DECL_TEMPLATE(ALmulaw)
1809 DECL_TEMPLATE(ALalaw)
1810 DECL_TEMPLATE(ALbyte3)
1811 DECL_TEMPLATE(ALubyte3)
1812
1813 #undef DECL_TEMPLATE
1814
1815 #define DECL_TEMPLATE(T) \
1816 static void Convert_ALima4_##T(ALima4 *dst, const T *src, ALuint numchans, \
1817 ALuint numblocks) \
1818 { \
1819 ALuint i, j; \
1820 ALshort tmp[65*MAXCHANNELS]; /* Max samples an IMA4 frame can be */ \
1821 ALint sample[MAXCHANNELS] = {0,0,0,0,0,0,0,0}; \
1822 ALint index[MAXCHANNELS] = {0,0,0,0,0,0,0,0}; \
1823 for(i = 0;i < numblocks;i++) \
1824 { \
1825 for(j = 0;j < 65*numchans;j++) \
1826 tmp[j] = Conv_ALshort_##T(*(src++)); \
1827 EncodeIMA4Block(dst, tmp, sample, index, numchans); \
1828 dst += 36*numchans; \
1829 } \
1830 }
1831
1832 DECL_TEMPLATE(ALbyte)
1833 DECL_TEMPLATE(ALubyte)
1834 DECL_TEMPLATE(ALshort)
1835 DECL_TEMPLATE(ALushort)
1836 DECL_TEMPLATE(ALint)
1837 DECL_TEMPLATE(ALuint)
1838 DECL_TEMPLATE(ALfloat)
1839 DECL_TEMPLATE(ALdouble)
1840 DECL_TEMPLATE(ALmulaw)
1841 DECL_TEMPLATE(ALalaw)
1842 static void Convert_ALima4_ALima4(ALima4 *dst, const ALima4 *src,
1843 ALuint numchans, ALuint numblocks)
1844 { memcpy(dst, src, numblocks*36*numchans); }
1845 DECL_TEMPLATE(ALbyte3)
1846 DECL_TEMPLATE(ALubyte3)
1847
1848 #undef DECL_TEMPLATE
1849
1850 #define DECL_TEMPLATE(T) \
1851 static void Convert_##T(T *dst, const ALvoid *src, enum UserFmtType srcType, \
1852 ALsizei numchans, ALsizei len) \
1853 { \
1854 switch(srcType) \
1855 { \
1856 case UserFmtByte: \
1857 Convert_##T##_ALbyte(dst, src, numchans, len); \
1858 break; \
1859 case UserFmtUByte: \
1860 Convert_##T##_ALubyte(dst, src, numchans, len); \
1861 break; \
1862 case UserFmtShort: \
1863 Convert_##T##_ALshort(dst, src, numchans, len); \
1864 break; \
1865 case UserFmtUShort: \
1866 Convert_##T##_ALushort(dst, src, numchans, len); \
1867 break; \
1868 case UserFmtInt: \
1869 Convert_##T##_ALint(dst, src, numchans, len); \
1870 break; \
1871 case UserFmtUInt: \
1872 Convert_##T##_ALuint(dst, src, numchans, len); \
1873 break; \
1874 case UserFmtFloat: \
1875 Convert_##T##_ALfloat(dst, src, numchans, len); \
1876 break; \
1877 case UserFmtDouble: \
1878 Convert_##T##_ALdouble(dst, src, numchans, len); \
1879 break; \
1880 case UserFmtMulaw: \
1881 Convert_##T##_ALmulaw(dst, src, numchans, len); \
1882 break; \
1883 case UserFmtAlaw: \
1884 Convert_##T##_ALalaw(dst, src, numchans, len); \
1885 break; \
1886 case UserFmtIMA4: \
1887 Convert_##T##_ALima4(dst, src, numchans, len); \
1888 break; \
1889 case UserFmtByte3: \
1890 Convert_##T##_ALbyte3(dst, src, numchans, len); \
1891 break; \
1892 case UserFmtUByte3: \
1893 Convert_##T##_ALubyte3(dst, src, numchans, len); \
1894 break; \
1895 } \
1896 }
1897
1898 DECL_TEMPLATE(ALbyte)
1899 DECL_TEMPLATE(ALubyte)
1900 DECL_TEMPLATE(ALshort)
1901 DECL_TEMPLATE(ALushort)
1902 DECL_TEMPLATE(ALint)
1903 DECL_TEMPLATE(ALuint)
1904 DECL_TEMPLATE(ALfloat)
1905 DECL_TEMPLATE(ALdouble)
1906 DECL_TEMPLATE(ALmulaw)
1907 DECL_TEMPLATE(ALalaw)
1908 DECL_TEMPLATE(ALima4)
1909 DECL_TEMPLATE(ALbyte3)
1910 DECL_TEMPLATE(ALubyte3)
1911
1912 #undef DECL_TEMPLATE
1913
1914
1915 static void ConvertData(ALvoid *dst, enum UserFmtType dstType, const ALvoid *src, enum UserFmtType srcType, ALsizei numchans, ALsizei len)
1916 {
1917 switch(dstType)
1918 {
1919 case UserFmtByte:
1920 Convert_ALbyte(dst, src, srcType, numchans, len);
1921 break;
1922 case UserFmtUByte:
1923 Convert_ALubyte(dst, src, srcType, numchans, len);
1924 break;
1925 case UserFmtShort:
1926 Convert_ALshort(dst, src, srcType, numchans, len);
1927 break;
1928 case UserFmtUShort:
1929 Convert_ALushort(dst, src, srcType, numchans, len);
1930 break;
1931 case UserFmtInt:
1932 Convert_ALint(dst, src, srcType, numchans, len);
1933 break;
1934 case UserFmtUInt:
1935 Convert_ALuint(dst, src, srcType, numchans, len);
1936 break;
1937 case UserFmtFloat:
1938 Convert_ALfloat(dst, src, srcType, numchans, len);
1939 break;
1940 case UserFmtDouble:
1941 Convert_ALdouble(dst, src, srcType, numchans, len);
1942 break;
1943 case UserFmtMulaw:
1944 Convert_ALmulaw(dst, src, srcType, numchans, len);
1945 break;
1946 case UserFmtAlaw:
1947 Convert_ALalaw(dst, src, srcType, numchans, len);
1948 break;
1949 case UserFmtIMA4:
1950 Convert_ALima4(dst, src, srcType, numchans, len);
1951 break;
1952 case UserFmtByte3:
1953 Convert_ALbyte3(dst, src, srcType, numchans, len);
1954 break;
1955 case UserFmtUByte3:
1956 Convert_ALubyte3(dst, src, srcType, numchans, len);
1957 break;
1958 }
1959 }
1960
1961
1962 /*
1963 * LoadData
1964 *
1965 * Loads the specified data into the buffer, using the specified formats.
1966 * Currently, the new format must have the same channel configuration as the
1967 * original format.
1968 */
1969 static ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALboolean storesrc)
1970 {
1971 ALuint NewChannels, NewBytes;
1972 enum FmtChannels DstChannels;
1973 enum FmtType DstType;
1974 ALuint64 newsize;
1975 ALvoid *temp;
1976
1977 if(DecomposeFormat(NewFormat, &DstChannels, &DstType) == AL_FALSE ||
1978 (long)SrcChannels != (long)DstChannels)
1979 return AL_INVALID_ENUM;
1980
1981 NewChannels = ChannelsFromFmt(DstChannels);
1982 NewBytes = BytesFromFmt(DstType);
1983
1984 newsize = frames;
1985 if(SrcType == UserFmtIMA4)
1986 newsize *= 65;
1987 newsize *= NewBytes;
1988 newsize *= NewChannels;
1989 if(newsize > INT_MAX)
1990 return AL_OUT_OF_MEMORY;
1991
1992 WriteLock(&ALBuf->lock);
1993 if(ALBuf->ref != 0)
1994 {
1995 WriteUnlock(&ALBuf->lock);
1996 return AL_INVALID_OPERATION;
1997 }
1998
1999 temp = realloc(ALBuf->data, (size_t)newsize);
2000 if(!temp && newsize)
2001 {
2002 WriteUnlock(&ALBuf->lock);
2003 return AL_OUT_OF_MEMORY;
2004 }
2005 ALBuf->data = temp;
2006
2007 if(data != NULL)
2008 ConvertData(ALBuf->data, DstType, data, SrcType, NewChannels, frames);
2009
2010 if(storesrc)
2011 {
2012 ALBuf->OriginalChannels = SrcChannels;
2013 ALBuf->OriginalType = SrcType;
2014 ALBuf->OriginalSize = frames * ((SrcType == UserFmtIMA4) ? 36 :
2015 BytesFromUserFmt(SrcType)) *
2016 ChannelsFromUserFmt(SrcChannels);
2017 }
2018 else
2019 {
2020 ALBuf->OriginalChannels = DstChannels;
2021 ALBuf->OriginalType = DstType;
2022 ALBuf->OriginalSize = frames * NewBytes * NewChannels;
2023 }
2024
2025 ALBuf->Frequency = freq;
2026 ALBuf->FmtChannels = DstChannels;
2027 ALBuf->FmtType = DstType;
2028 ALBuf->Format = NewFormat;
2029
2030 ALBuf->SampleLen = frames * ((SrcType == UserFmtIMA4) ? 65 : 1);
2031 ALBuf->LoopStart = 0;
2032 ALBuf->LoopEnd = ALBuf->SampleLen;
2033
2034 WriteUnlock(&ALBuf->lock);
2035 return AL_NO_ERROR;
2036 }
2037
2038
2039 ALuint BytesFromUserFmt(enum UserFmtType type)
2040 {
2041 switch(type)
2042 {
2043 case UserFmtByte: return sizeof(ALbyte);
2044 case UserFmtUByte: return sizeof(ALubyte);
2045 case UserFmtShort: return sizeof(ALshort);
2046 case UserFmtUShort: return sizeof(ALushort);
2047 case UserFmtInt: return sizeof(ALint);
2048 case UserFmtUInt: return sizeof(ALuint);
2049 case UserFmtFloat: return sizeof(ALfloat);
2050 case UserFmtDouble: return sizeof(ALdouble);
2051 case UserFmtByte3: return sizeof(ALbyte3);
2052 case UserFmtUByte3: return sizeof(ALubyte3);
2053 case UserFmtMulaw: return sizeof(ALubyte);
2054 case UserFmtAlaw: return sizeof(ALubyte);
2055 case UserFmtIMA4: break; /* not handled here */
2056 }
2057 return 0;
2058 }
2059 ALuint ChannelsFromUserFmt(enum UserFmtChannels chans)
2060 {
2061 switch(chans)
2062 {
2063 case UserFmtMono: return 1;
2064 case UserFmtStereo: return 2;
2065 case UserFmtRear: return 2;
2066 case UserFmtQuad: return 4;
2067 case UserFmtX51: return 6;
2068 case UserFmtX61: return 7;
2069 case UserFmtX71: return 8;
2070 }
2071 return 0;
2072 }
2073 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans,
2074 enum UserFmtType *type)
2075 {
2076 static const struct {
2077 ALenum format;
2078 enum UserFmtChannels channels;
2079 enum UserFmtType type;
2080 } list[] = {
2081 { AL_FORMAT_MONO8, UserFmtMono, UserFmtUByte },
2082 { AL_FORMAT_MONO16, UserFmtMono, UserFmtShort },
2083 { AL_FORMAT_MONO_FLOAT32, UserFmtMono, UserFmtFloat },
2084 { AL_FORMAT_MONO_DOUBLE_EXT, UserFmtMono, UserFmtDouble },
2085 { AL_FORMAT_MONO_IMA4, UserFmtMono, UserFmtIMA4 },
2086 { AL_FORMAT_MONO_MULAW, UserFmtMono, UserFmtMulaw },
2087 { AL_FORMAT_MONO_ALAW_EXT, UserFmtMono, UserFmtAlaw },
2088
2089 { AL_FORMAT_STEREO8, UserFmtStereo, UserFmtUByte },
2090 { AL_FORMAT_STEREO16, UserFmtStereo, UserFmtShort },
2091 { AL_FORMAT_STEREO_FLOAT32, UserFmtStereo, UserFmtFloat },
2092 { AL_FORMAT_STEREO_DOUBLE_EXT, UserFmtStereo, UserFmtDouble },
2093 { AL_FORMAT_STEREO_IMA4, UserFmtStereo, UserFmtIMA4 },
2094 { AL_FORMAT_STEREO_MULAW, UserFmtStereo, UserFmtMulaw },
2095 { AL_FORMAT_STEREO_ALAW_EXT, UserFmtStereo, UserFmtAlaw },
2096
2097 { AL_FORMAT_REAR8, UserFmtRear, UserFmtUByte },
2098 { AL_FORMAT_REAR16, UserFmtRear, UserFmtShort },
2099 { AL_FORMAT_REAR32, UserFmtRear, UserFmtFloat },
2100 { AL_FORMAT_REAR_MULAW, UserFmtRear, UserFmtMulaw },
2101
2102 { AL_FORMAT_QUAD8_LOKI, UserFmtQuad, UserFmtUByte },
2103 { AL_FORMAT_QUAD16_LOKI, UserFmtQuad, UserFmtShort },
2104
2105 { AL_FORMAT_QUAD8, UserFmtQuad, UserFmtUByte },
2106 { AL_FORMAT_QUAD16, UserFmtQuad, UserFmtShort },
2107 { AL_FORMAT_QUAD32, UserFmtQuad, UserFmtFloat },
2108 { AL_FORMAT_QUAD_MULAW, UserFmtQuad, UserFmtMulaw },
2109
2110 { AL_FORMAT_51CHN8, UserFmtX51, UserFmtUByte },
2111 { AL_FORMAT_51CHN16, UserFmtX51, UserFmtShort },
2112 { AL_FORMAT_51CHN32, UserFmtX51, UserFmtFloat },
2113 { AL_FORMAT_51CHN_MULAW, UserFmtX51, UserFmtMulaw },
2114
2115 { AL_FORMAT_61CHN8, UserFmtX61, UserFmtUByte },
2116 { AL_FORMAT_61CHN16, UserFmtX61, UserFmtShort },
2117 { AL_FORMAT_61CHN32, UserFmtX61, UserFmtFloat },
2118 { AL_FORMAT_61CHN_MULAW, UserFmtX61, UserFmtMulaw },
2119
2120 { AL_FORMAT_71CHN8, UserFmtX71, UserFmtUByte },
2121 { AL_FORMAT_71CHN16, UserFmtX71, UserFmtShort },
2122 { AL_FORMAT_71CHN32, UserFmtX71, UserFmtFloat },
2123 { AL_FORMAT_71CHN_MULAW, UserFmtX71, UserFmtMulaw },
2124 };
2125 ALuint i;
2126
2127 for(i = 0;i < sizeof(list)/sizeof(list[0]);i++)
2128 {
2129 if(list[i].format == format)
2130 {
2131 *chans = list[i].channels;
2132 *type = list[i].type;
2133 return AL_TRUE;
2134 }
2135 }
2136
2137 return AL_FALSE;
2138 }
2139
2140 ALuint BytesFromFmt(enum FmtType type)
2141 {
2142 switch(type)
2143 {
2144 case FmtByte: return sizeof(ALbyte);
2145 case FmtShort: return sizeof(ALshort);
2146 case FmtFloat: return sizeof(ALfloat);
2147 }
2148 return 0;
2149 }
2150 ALuint ChannelsFromFmt(enum FmtChannels chans)
2151 {
2152 switch(chans)
2153 {
2154 case FmtMono: return 1;
2155 case FmtStereo: return 2;
2156 case FmtRear: return 2;
2157 case FmtQuad: return 4;
2158 case FmtX51: return 6;
2159 case FmtX61: return 7;
2160 case FmtX71: return 8;
2161 }
2162 return 0;
2163 }
2164 static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
2165 {
2166 static const struct {
2167 ALenum format;
2168 enum FmtChannels channels;
2169 enum FmtType type;
2170 } list[] = {
2171 { AL_MONO8_SOFT, FmtMono, FmtByte },
2172 { AL_MONO16_SOFT, FmtMono, FmtShort },
2173 { AL_MONO32F_SOFT, FmtMono, FmtFloat },
2174
2175 { AL_STEREO8_SOFT, FmtStereo, FmtByte },
2176 { AL_STEREO16_SOFT, FmtStereo, FmtShort },
2177 { AL_STEREO32F_SOFT, FmtStereo, FmtFloat },
2178
2179 { AL_REAR8_SOFT, FmtRear, FmtByte },
2180 { AL_REAR16_SOFT, FmtRear, FmtShort },
2181 { AL_REAR32F_SOFT, FmtRear, FmtFloat },
2182
2183 { AL_FORMAT_QUAD8_LOKI, FmtQuad, FmtByte },
2184 { AL_FORMAT_QUAD16_LOKI, FmtQuad, FmtShort },
2185
2186 { AL_QUAD8_SOFT, FmtQuad, FmtByte },
2187 { AL_QUAD16_SOFT, FmtQuad, FmtShort },
2188 { AL_QUAD32F_SOFT, FmtQuad, FmtFloat },
2189
2190 { AL_5POINT1_8_SOFT, FmtX51, FmtByte },
2191 { AL_5POINT1_16_SOFT, FmtX51, FmtShort },
2192 { AL_5POINT1_32F_SOFT, FmtX51, FmtFloat },
2193
2194 { AL_6POINT1_8_SOFT, FmtX61, FmtByte },
2195 { AL_6POINT1_16_SOFT, FmtX61, FmtShort },
2196 { AL_6POINT1_32F_SOFT, FmtX61, FmtFloat },
2197
2198 { AL_7POINT1_8_SOFT, FmtX71, FmtByte },
2199 { AL_7POINT1_16_SOFT, FmtX71, FmtShort },
2200 { AL_7POINT1_32F_SOFT, FmtX71, FmtFloat },
2201 };
2202 ALuint i;
2203
2204 for(i = 0;i < sizeof(list)/sizeof(list[0]);i++)
2205 {
2206 if(list[i].format == format)
2207 {
2208 *chans = list[i].channels;
2209 *type = list[i].type;
2210 return AL_TRUE;
2211 }
2212 }
2213
2214 return AL_FALSE;
2215 }
2216
2217
2218 static ALboolean IsValidType(ALenum type)
2219 {
2220 switch(type)
2221 {
2222 case AL_BYTE_SOFT:
2223 case AL_UNSIGNED_BYTE_SOFT:
2224 case AL_SHORT_SOFT:
2225 case AL_UNSIGNED_SHORT_SOFT:
2226 case AL_INT_SOFT:
2227 case AL_UNSIGNED_INT_SOFT:
2228 case AL_FLOAT_SOFT:
2229 case AL_DOUBLE_SOFT:
2230 case AL_BYTE3_SOFT:
2231 case AL_UNSIGNED_BYTE3_SOFT:
2232 return AL_TRUE;
2233 }
2234 return AL_FALSE;
2235 }
2236
2237 static ALboolean IsValidChannels(ALenum channels)
2238 {
2239 switch(channels)
2240 {
2241 case AL_MONO_SOFT:
2242 case AL_STEREO_SOFT:
2243 case AL_REAR_SOFT:
2244 case AL_QUAD_SOFT:
2245 case AL_5POINT1_SOFT:
2246 case AL_6POINT1_SOFT:
2247 case AL_7POINT1_SOFT:
2248 return AL_TRUE;
2249 }
2250 return AL_FALSE;
2251 }
2252
2253
2254 /*
2255 * ReleaseALBuffers()
2256 *
2257 * INTERNAL: Called to destroy any buffers that still exist on the device
2258 */
2259 ALvoid ReleaseALBuffers(ALCdevice *device)
2260 {
2261 ALsizei i;
2262 for(i = 0;i < device->BufferMap.size;i++)
2263 {
2264 ALbuffer *temp = device->BufferMap.array[i].value;
2265 device->BufferMap.array[i].value = NULL;
2266
2267 free(temp->data);
2268
2269 FreeThunkEntry(temp->buffer);
2270 memset(temp, 0, sizeof(ALbuffer));
2271 free(temp);
2272 }
2273 }
Android backend