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