OpenAL32/alBuffer.c

   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.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 #ifdef HAVE_MALLOC_H
  28 #include <malloc.h>
  29 #endif
  30
  31 #include "alMain.h"
  32 #include "alu.h"
  33 #include "alError.h"
  34 #include "alBuffer.h"
  35 #include "alThunk.h"
  36 #include "sample_cvt.h"
  37
  38
  39 extern inline void LockBuffersRead(ALCdevice *device);
  40 extern inline void UnlockBuffersRead(ALCdevice *device);
  41 extern inline void LockBuffersWrite(ALCdevice *device);
  42 extern inline void UnlockBuffersWrite(ALCdevice *device);
  43 extern inline struct ALbuffer *LookupBuffer(ALCdevice *device, ALuint id);
  44 extern inline struct ALbuffer *RemoveBuffer(ALCdevice *device, ALuint id);
  45 extern inline ALuint FrameSizeFromUserFmt(enum UserFmtChannels chans, enum UserFmtType type);
  46 extern inline ALuint FrameSizeFromFmt(enum FmtChannels chans, enum FmtType type);
  47
  48 static ALboolean IsValidType(ALenum type) DECL_CONST;
  49 static ALboolean IsValidChannels(ALenum channels) DECL_CONST;
  50 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans, enum UserFmtType *type) DECL_CONST;
  51 static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type) DECL_CONST;
  52 static ALboolean SanitizeAlignment(enum UserFmtType type, ALsizei *align);
  53
  54
  55 AL_API ALvoid AL_APIENTRY alGenBuffers(ALsizei n, ALuint *buffers)
  56 {
  57     ALCcontext *context;
  58     ALsizei cur = 0;
  59
  60     context = GetContextRef();
  61     if(!context) return;
  62
  63     if(!(n >= 0))
  64         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  65
  66     for(cur = 0;cur < n;cur++)
  67     {
  68         ALbuffer *buffer = NewBuffer(context);
  69         if(!buffer)
  70         {
  71             alDeleteBuffers(cur, buffers);
  72             break;
  73         }
  74
  75         buffers[cur] = buffer->id;
  76     }
  77
  78 done:
  79     ALCcontext_DecRef(context);
  80 }
  81
  82 AL_API ALvoid AL_APIENTRY alDeleteBuffers(ALsizei n, const ALuint *buffers)
  83 {
  84     ALCdevice *device;
  85     ALCcontext *context;
  86     ALbuffer *ALBuf;
  87     ALsizei i;
  88
  89     context = GetContextRef();
  90     if(!context) return;
  91
  92     device = context->Device;
  93
  94     LockBuffersWrite(device);
  95     if(!(n >= 0))
  96         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
  97
  98     for(i = 0;i < n;i++)
  99     {
 100         if(!buffers[i])
 101             continue;
 102
 103         /* Check for valid Buffer ID */
 104         if((ALBuf=LookupBuffer(device, buffers[i])) == NULL)
 105             SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 106         if(ReadRef(&ALBuf->ref) != 0)
 107             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 108     }
 109
 110     for(i = 0;i < n;i++)
 111     {
 112         if((ALBuf=LookupBuffer(device, buffers[i])) != NULL)
 113             DeleteBuffer(device, ALBuf);
 114     }
 115
 116 done:
 117     UnlockBuffersWrite(device);
 118     ALCcontext_DecRef(context);
 119 }
 120
 121 AL_API ALboolean AL_APIENTRY alIsBuffer(ALuint buffer)
 122 {
 123     ALCcontext *context;
 124     ALboolean ret;
 125
 126     context = GetContextRef();
 127     if(!context) return AL_FALSE;
 128
 129     LockBuffersRead(context->Device);
 130     ret = ((!buffer || LookupBuffer(context->Device, buffer)) ?
 131            AL_TRUE : AL_FALSE);
 132     UnlockBuffersRead(context->Device);
 133
 134     ALCcontext_DecRef(context);
 135
 136     return ret;
 137 }
 138
 139
 140 AL_API ALvoid AL_APIENTRY alBufferData(ALuint buffer, ALenum format, const ALvoid *data, ALsizei size, ALsizei freq)
 141 {
 142     enum UserFmtChannels srcchannels;
 143     enum UserFmtType srctype;
 144     ALCdevice *device;
 145     ALCcontext *context;
 146     ALbuffer *albuf;
 147     ALenum newformat = AL_NONE;
 148     ALuint framesize;
 149     ALsizei align;
 150     ALenum err;
 151
 152     context = GetContextRef();
 153     if(!context) return;
 154
 155     device = context->Device;
 156     LockBuffersRead(device);
 157     if((albuf=LookupBuffer(device, buffer)) == NULL)
 158         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 159     if(!(size >= 0 && freq > 0))
 160         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 161     if(DecomposeUserFormat(format, &srcchannels, &srctype) == AL_FALSE)
 162         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 163
 164     align = ATOMIC_LOAD(&albuf->UnpackAlign);
 165     if(SanitizeAlignment(srctype, &align) == AL_FALSE)
 166         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 167     switch(srctype)
 168     {
 169         case UserFmtByte:
 170         case UserFmtUByte:
 171         case UserFmtShort:
 172         case UserFmtUShort:
 173         case UserFmtFloat:
 174             framesize = FrameSizeFromUserFmt(srcchannels, srctype) * align;
 175             if((size%framesize) != 0)
 176                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 177
 178             err = LoadData(albuf, freq, format, size/framesize*align,
 179                            srcchannels, srctype, data, align, AL_TRUE);
 180             if(err != AL_NO_ERROR)
 181                 SET_ERROR_AND_GOTO(context, err, done);
 182             break;
 183
 184         case UserFmtInt:
 185         case UserFmtUInt:
 186         case UserFmtByte3:
 187         case UserFmtUByte3:
 188         case UserFmtDouble:
 189             framesize = FrameSizeFromUserFmt(srcchannels, srctype) * align;
 190             if((size%framesize) != 0)
 191                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 192
 193             switch(srcchannels)
 194             {
 195                 case UserFmtMono: newformat = AL_FORMAT_MONO_FLOAT32; break;
 196                 case UserFmtStereo: newformat = AL_FORMAT_STEREO_FLOAT32; break;
 197                 case UserFmtRear: newformat = AL_FORMAT_REAR32; break;
 198                 case UserFmtQuad: newformat = AL_FORMAT_QUAD32; break;
 199                 case UserFmtX51: newformat = AL_FORMAT_51CHN32; break;
 200                 case UserFmtX61: newformat = AL_FORMAT_61CHN32; break;
 201                 case UserFmtX71: newformat = AL_FORMAT_71CHN32; break;
 202                 case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_FLOAT32; break;
 203                 case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_FLOAT32; break;
 204             }
 205             err = LoadData(albuf, freq, newformat, size/framesize*align,
 206                            srcchannels, srctype, data, align, AL_TRUE);
 207             if(err != AL_NO_ERROR)
 208                 SET_ERROR_AND_GOTO(context, err, done);
 209             break;
 210
 211         case UserFmtMulaw:
 212         case UserFmtAlaw:
 213             framesize = FrameSizeFromUserFmt(srcchannels, srctype) * align;
 214             if((size%framesize) != 0)
 215                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 216
 217             switch(srcchannels)
 218             {
 219                 case UserFmtMono: newformat = AL_FORMAT_MONO16; break;
 220                 case UserFmtStereo: newformat = AL_FORMAT_STEREO16; break;
 221                 case UserFmtRear: newformat = AL_FORMAT_REAR16; break;
 222                 case UserFmtQuad: newformat = AL_FORMAT_QUAD16; break;
 223                 case UserFmtX51: newformat = AL_FORMAT_51CHN16; break;
 224                 case UserFmtX61: newformat = AL_FORMAT_61CHN16; break;
 225                 case UserFmtX71: newformat = AL_FORMAT_71CHN16; break;
 226                 case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_16; break;
 227                 case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_16; break;
 228             }
 229             err = LoadData(albuf, freq, newformat, size/framesize*align,
 230                            srcchannels, srctype, data, align, AL_TRUE);
 231             if(err != AL_NO_ERROR)
 232                 SET_ERROR_AND_GOTO(context, err, done);
 233             break;
 234
 235         case UserFmtIMA4:
 236             framesize  = (align-1)/2 + 4;
 237             framesize *= ChannelsFromUserFmt(srcchannels);
 238             if((size%framesize) != 0)
 239                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 240
 241             switch(srcchannels)
 242             {
 243                 case UserFmtMono: newformat = AL_FORMAT_MONO16; break;
 244                 case UserFmtStereo: newformat = AL_FORMAT_STEREO16; break;
 245                 case UserFmtRear: newformat = AL_FORMAT_REAR16; break;
 246                 case UserFmtQuad: newformat = AL_FORMAT_QUAD16; break;
 247                 case UserFmtX51: newformat = AL_FORMAT_51CHN16; break;
 248                 case UserFmtX61: newformat = AL_FORMAT_61CHN16; break;
 249                 case UserFmtX71: newformat = AL_FORMAT_71CHN16; break;
 250                 case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_16; break;
 251                 case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_16; break;
 252             }
 253             err = LoadData(albuf, freq, newformat, size/framesize*align,
 254                            srcchannels, srctype, data, align, AL_TRUE);
 255             if(err != AL_NO_ERROR)
 256                 SET_ERROR_AND_GOTO(context, err, done);
 257             break;
 258
 259         case UserFmtMSADPCM:
 260             framesize  = (align-2)/2 + 7;
 261             framesize *= ChannelsFromUserFmt(srcchannels);
 262             if((size%framesize) != 0)
 263                 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 264
 265             switch(srcchannels)
 266             {
 267                 case UserFmtMono: newformat = AL_FORMAT_MONO16; break;
 268                 case UserFmtStereo: newformat = AL_FORMAT_STEREO16; break;
 269                 case UserFmtRear: newformat = AL_FORMAT_REAR16; break;
 270                 case UserFmtQuad: newformat = AL_FORMAT_QUAD16; break;
 271                 case UserFmtX51: newformat = AL_FORMAT_51CHN16; break;
 272                 case UserFmtX61: newformat = AL_FORMAT_61CHN16; break;
 273                 case UserFmtX71: newformat = AL_FORMAT_71CHN16; break;
 274                 case UserFmtBFormat2D: newformat = AL_FORMAT_BFORMAT2D_16; break;
 275                 case UserFmtBFormat3D: newformat = AL_FORMAT_BFORMAT3D_16; break;
 276             }
 277             err = LoadData(albuf, freq, newformat, size/framesize*align,
 278                            srcchannels, srctype, data, align, AL_TRUE);
 279             if(err != AL_NO_ERROR)
 280                 SET_ERROR_AND_GOTO(context, err, done);
 281             break;
 282     }
 283
 284 done:
 285     UnlockBuffersRead(device);
 286     ALCcontext_DecRef(context);
 287 }
 288
 289 AL_API ALvoid AL_APIENTRY alBufferSubDataSOFT(ALuint buffer, ALenum format, const ALvoid *data, ALsizei offset, ALsizei length)
 290 {
 291     enum UserFmtChannels srcchannels;
 292     enum UserFmtType srctype;
 293     ALCdevice *device;
 294     ALCcontext *context;
 295     ALbuffer *albuf;
 296     ALuint byte_align;
 297     ALuint channels;
 298     ALuint bytes;
 299     ALsizei align;
 300
 301     context = GetContextRef();
 302     if(!context) return;
 303
 304     device = context->Device;
 305     LockBuffersRead(device);
 306     if((albuf=LookupBuffer(device, buffer)) == NULL)
 307         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 308     if(!(length >= 0 && offset >= 0))
 309         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 310     if(DecomposeUserFormat(format, &srcchannels, &srctype) == AL_FALSE)
 311         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 312
 313     WriteLock(&albuf->lock);
 314     align = ATOMIC_LOAD(&albuf->UnpackAlign);
 315     if(SanitizeAlignment(srctype, &align) == AL_FALSE)
 316     {
 317         WriteUnlock(&albuf->lock);
 318         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 319     }
 320     if(srcchannels != albuf->OriginalChannels || srctype != albuf->OriginalType)
 321     {
 322         WriteUnlock(&albuf->lock);
 323         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 324     }
 325     if(align != albuf->OriginalAlign)
 326     {
 327         WriteUnlock(&albuf->lock);
 328         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 329     }
 330
 331     if(albuf->OriginalType == UserFmtIMA4)
 332     {
 333         byte_align  = (albuf->OriginalAlign-1)/2 + 4;
 334         byte_align *= ChannelsFromUserFmt(albuf->OriginalChannels);
 335     }
 336     else if(albuf->OriginalType == UserFmtMSADPCM)
 337     {
 338         byte_align  = (albuf->OriginalAlign-2)/2 + 7;
 339         byte_align *= ChannelsFromUserFmt(albuf->OriginalChannels);
 340     }
 341     else
 342     {
 343         byte_align  = albuf->OriginalAlign;
 344         byte_align *= FrameSizeFromUserFmt(albuf->OriginalChannels,
 345                                            albuf->OriginalType);
 346     }
 347
 348     if(offset > albuf->OriginalSize || length > albuf->OriginalSize-offset ||
 349        (offset%byte_align) != 0 || (length%byte_align) != 0)
 350     {
 351         WriteUnlock(&albuf->lock);
 352         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 353     }
 354
 355     channels = ChannelsFromFmt(albuf->FmtChannels);
 356     bytes = BytesFromFmt(albuf->FmtType);
 357     /* offset -> byte offset, length -> sample count */
 358     offset = offset/byte_align * channels*bytes;
 359     length = length/byte_align * albuf->OriginalAlign;
 360
 361     ConvertData((char*)albuf->data+offset, (enum UserFmtType)albuf->FmtType,
 362                 data, srctype, channels, length, align);
 363     WriteUnlock(&albuf->lock);
 364
 365 done:
 366     UnlockBuffersRead(device);
 367     ALCcontext_DecRef(context);
 368 }
 369
 370
 371 AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer,
 372   ALuint samplerate, ALenum internalformat, ALsizei samples,
 373   ALenum channels, ALenum type, const ALvoid *data)
 374 {
 375     ALCdevice *device;
 376     ALCcontext *context;
 377     ALbuffer *albuf;
 378     ALsizei align;
 379     ALenum err;
 380
 381     context = GetContextRef();
 382     if(!context) return;
 383
 384     device = context->Device;
 385     LockBuffersRead(device);
 386     if((albuf=LookupBuffer(device, buffer)) == NULL)
 387         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 388     if(!(samples >= 0 && samplerate != 0))
 389         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 390     if(IsValidType(type) == AL_FALSE || IsValidChannels(channels) == AL_FALSE)
 391         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 392
 393     align = ATOMIC_LOAD(&albuf->UnpackAlign);
 394     if(SanitizeAlignment(type, &align) == AL_FALSE)
 395         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 396     if((samples%align) != 0)
 397         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 398
 399     err = LoadData(albuf, samplerate, internalformat, samples,
 400                    channels, type, data, align, AL_FALSE);
 401     if(err != AL_NO_ERROR)
 402         SET_ERROR_AND_GOTO(context, err, done);
 403
 404 done:
 405     UnlockBuffersRead(device);
 406     ALCcontext_DecRef(context);
 407 }
 408
 409 AL_API void AL_APIENTRY alBufferSubSamplesSOFT(ALuint buffer,
 410   ALsizei offset, ALsizei samples,
 411   ALenum channels, ALenum type, const ALvoid *data)
 412 {
 413     ALCdevice *device;
 414     ALCcontext *context;
 415     ALbuffer *albuf;
 416     ALsizei align;
 417
 418     context = GetContextRef();
 419     if(!context) return;
 420
 421     device = context->Device;
 422     LockBuffersRead(device);
 423     if((albuf=LookupBuffer(device, buffer)) == NULL)
 424         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 425     if(!(samples >= 0 && offset >= 0))
 426         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 427     if(IsValidType(type) == AL_FALSE)
 428         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 429
 430     WriteLock(&albuf->lock);
 431     align = ATOMIC_LOAD(&albuf->UnpackAlign);
 432     if(SanitizeAlignment(type, &align) == AL_FALSE)
 433     {
 434         WriteUnlock(&albuf->lock);
 435         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 436     }
 437     if(channels != (ALenum)albuf->FmtChannels)
 438     {
 439         WriteUnlock(&albuf->lock);
 440         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 441     }
 442     if(offset > albuf->SampleLen || samples > albuf->SampleLen-offset)
 443     {
 444         WriteUnlock(&albuf->lock);
 445         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 446     }
 447     if((samples%align) != 0)
 448     {
 449         WriteUnlock(&albuf->lock);
 450         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 451     }
 452
 453     /* offset -> byte offset */
 454     offset *= FrameSizeFromFmt(albuf->FmtChannels, albuf->FmtType);
 455     ConvertData((char*)albuf->data+offset, (enum UserFmtType)albuf->FmtType,
 456                 data, type, ChannelsFromFmt(albuf->FmtChannels), samples, align);
 457     WriteUnlock(&albuf->lock);
 458
 459 done:
 460     UnlockBuffersRead(device);
 461     ALCcontext_DecRef(context);
 462 }
 463
 464 AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer,
 465   ALsizei offset, ALsizei samples,
 466   ALenum channels, ALenum type, ALvoid *data)
 467 {
 468     ALCdevice *device;
 469     ALCcontext *context;
 470     ALbuffer *albuf;
 471     ALsizei align;
 472
 473     context = GetContextRef();
 474     if(!context) return;
 475
 476     device = context->Device;
 477     LockBuffersRead(device);
 478     if((albuf=LookupBuffer(device, buffer)) == NULL)
 479         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 480     if(!(samples >= 0 && offset >= 0))
 481         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 482     if(IsValidType(type) == AL_FALSE)
 483         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 484
 485     ReadLock(&albuf->lock);
 486     align = ATOMIC_LOAD(&albuf->PackAlign);
 487     if(SanitizeAlignment(type, &align) == AL_FALSE)
 488     {
 489         ReadUnlock(&albuf->lock);
 490         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 491     }
 492     if(channels != (ALenum)albuf->FmtChannels)
 493     {
 494         ReadUnlock(&albuf->lock);
 495         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 496     }
 497     if(offset > albuf->SampleLen || samples > albuf->SampleLen-offset)
 498     {
 499         ReadUnlock(&albuf->lock);
 500         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 501     }
 502     if((samples%align) != 0)
 503     {
 504         ReadUnlock(&albuf->lock);
 505         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 506     }
 507
 508     /* offset -> byte offset */
 509     offset *= FrameSizeFromFmt(albuf->FmtChannels, albuf->FmtType);
 510     ConvertData(data, type, (char*)albuf->data+offset, (enum UserFmtType)albuf->FmtType,
 511                 ChannelsFromFmt(albuf->FmtChannels), samples, align);
 512     ReadUnlock(&albuf->lock);
 513
 514 done:
 515     UnlockBuffersRead(device);
 516     ALCcontext_DecRef(context);
 517 }
 518
 519 AL_API ALboolean AL_APIENTRY alIsBufferFormatSupportedSOFT(ALenum format)
 520 {
 521     enum FmtChannels dstchannels;
 522     enum FmtType dsttype;
 523     ALCcontext *context;
 524     ALboolean ret;
 525
 526     context = GetContextRef();
 527     if(!context) return AL_FALSE;
 528
 529     ret = DecomposeFormat(format, &dstchannels, &dsttype);
 530
 531     ALCcontext_DecRef(context);
 532
 533     return ret;
 534 }
 535
 536
 537 AL_API void AL_APIENTRY alBufferf(ALuint buffer, ALenum param, ALfloat UNUSED(value))
 538 {
 539     ALCdevice *device;
 540     ALCcontext *context;
 541
 542     context = GetContextRef();
 543     if(!context) return;
 544
 545     device = context->Device;
 546     LockBuffersRead(device);
 547     if(LookupBuffer(device, buffer) == NULL)
 548         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 549
 550     switch(param)
 551     {
 552     default:
 553         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 554     }
 555
 556 done:
 557     UnlockBuffersRead(device);
 558     ALCcontext_DecRef(context);
 559 }
 560
 561
 562 AL_API void AL_APIENTRY alBuffer3f(ALuint buffer, ALenum param, ALfloat UNUSED(value1), ALfloat UNUSED(value2), ALfloat UNUSED(value3))
 563 {
 564     ALCdevice *device;
 565     ALCcontext *context;
 566
 567     context = GetContextRef();
 568     if(!context) return;
 569
 570     device = context->Device;
 571     LockBuffersRead(device);
 572     if(LookupBuffer(device, buffer) == NULL)
 573         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 574
 575     switch(param)
 576     {
 577     default:
 578         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 579     }
 580
 581 done:
 582     UnlockBuffersRead(device);
 583     ALCcontext_DecRef(context);
 584 }
 585
 586
 587 AL_API void AL_APIENTRY alBufferfv(ALuint buffer, ALenum param, const ALfloat *values)
 588 {
 589     ALCdevice *device;
 590     ALCcontext *context;
 591
 592     context = GetContextRef();
 593     if(!context) return;
 594
 595     device = context->Device;
 596     LockBuffersRead(device);
 597     if(LookupBuffer(device, buffer) == NULL)
 598         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 599
 600     if(!(values))
 601         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 602     switch(param)
 603     {
 604     default:
 605         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 606     }
 607
 608 done:
 609     UnlockBuffersRead(device);
 610     ALCcontext_DecRef(context);
 611 }
 612
 613
 614 AL_API void AL_APIENTRY alBufferi(ALuint buffer, ALenum param, ALint value)
 615 {
 616     ALCdevice *device;
 617     ALCcontext *context;
 618     ALbuffer *albuf;
 619
 620     context = GetContextRef();
 621     if(!context) return;
 622
 623     device = context->Device;
 624     LockBuffersRead(device);
 625     if((albuf=LookupBuffer(device, buffer)) == NULL)
 626         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 627
 628     switch(param)
 629     {
 630     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 631         if(!(value >= 0))
 632             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 633         ATOMIC_STORE(&albuf->UnpackAlign, value);
 634         break;
 635
 636     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 637         if(!(value >= 0))
 638             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 639         ATOMIC_STORE(&albuf->PackAlign, value);
 640         break;
 641
 642     default:
 643         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 644     }
 645
 646 done:
 647     UnlockBuffersRead(device);
 648     ALCcontext_DecRef(context);
 649 }
 650
 651
 652 AL_API void AL_APIENTRY alBuffer3i(ALuint buffer, ALenum param, ALint UNUSED(value1), ALint UNUSED(value2), ALint UNUSED(value3))
 653 {
 654     ALCdevice *device;
 655     ALCcontext *context;
 656
 657     context = GetContextRef();
 658     if(!context) return;
 659
 660     device = context->Device;
 661     if(LookupBuffer(device, buffer) == NULL)
 662         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 663
 664     switch(param)
 665     {
 666     default:
 667         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 668     }
 669
 670 done:
 671     ALCcontext_DecRef(context);
 672 }
 673
 674
 675 AL_API void AL_APIENTRY alBufferiv(ALuint buffer, ALenum param, const ALint *values)
 676 {
 677     ALCdevice *device;
 678     ALCcontext *context;
 679     ALbuffer *albuf;
 680
 681     if(values)
 682     {
 683         switch(param)
 684         {
 685             case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 686             case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 687                 alBufferi(buffer, param, values[0]);
 688                 return;
 689         }
 690     }
 691
 692     context = GetContextRef();
 693     if(!context) return;
 694
 695     device = context->Device;
 696     LockBuffersRead(device);
 697     if((albuf=LookupBuffer(device, buffer)) == NULL)
 698         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 699
 700     if(!(values))
 701         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 702     switch(param)
 703     {
 704     case AL_LOOP_POINTS_SOFT:
 705         WriteLock(&albuf->lock);
 706         if(ReadRef(&albuf->ref) != 0)
 707         {
 708             WriteUnlock(&albuf->lock);
 709             SET_ERROR_AND_GOTO(context, AL_INVALID_OPERATION, done);
 710         }
 711         if(values[0] >= values[1] || values[0] < 0 ||
 712            values[1] > albuf->SampleLen)
 713         {
 714             WriteUnlock(&albuf->lock);
 715             SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 716         }
 717
 718         albuf->LoopStart = values[0];
 719         albuf->LoopEnd = values[1];
 720         WriteUnlock(&albuf->lock);
 721         break;
 722
 723     default:
 724         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 725     }
 726
 727 done:
 728     UnlockBuffersRead(device);
 729     ALCcontext_DecRef(context);
 730 }
 731
 732
 733 AL_API ALvoid AL_APIENTRY alGetBufferf(ALuint buffer, ALenum param, ALfloat *value)
 734 {
 735     ALCdevice *device;
 736     ALCcontext *context;
 737     ALbuffer *albuf;
 738
 739     context = GetContextRef();
 740     if(!context) return;
 741
 742     device = context->Device;
 743     LockBuffersRead(device);
 744     if((albuf=LookupBuffer(device, buffer)) == NULL)
 745         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 746
 747     if(!(value))
 748         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 749     switch(param)
 750     {
 751     case AL_SEC_LENGTH_SOFT:
 752         ReadLock(&albuf->lock);
 753         if(albuf->SampleLen != 0)
 754             *value = albuf->SampleLen / (ALfloat)albuf->Frequency;
 755         else
 756             *value = 0.0f;
 757         ReadUnlock(&albuf->lock);
 758         break;
 759
 760     default:
 761         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 762     }
 763
 764 done:
 765     UnlockBuffersRead(device);
 766     ALCcontext_DecRef(context);
 767 }
 768
 769
 770 AL_API void AL_APIENTRY alGetBuffer3f(ALuint buffer, ALenum param, ALfloat *value1, ALfloat *value2, ALfloat *value3)
 771 {
 772     ALCdevice *device;
 773     ALCcontext *context;
 774
 775     context = GetContextRef();
 776     if(!context) return;
 777
 778     device = context->Device;
 779     LockBuffersRead(device);
 780     if(LookupBuffer(device, buffer) == NULL)
 781         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 782
 783     if(!(value1 && value2 && value3))
 784         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 785     switch(param)
 786     {
 787     default:
 788         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 789     }
 790
 791 done:
 792     UnlockBuffersRead(device);
 793     ALCcontext_DecRef(context);
 794 }
 795
 796
 797 AL_API void AL_APIENTRY alGetBufferfv(ALuint buffer, ALenum param, ALfloat *values)
 798 {
 799     ALCdevice *device;
 800     ALCcontext *context;
 801
 802     switch(param)
 803     {
 804     case AL_SEC_LENGTH_SOFT:
 805         alGetBufferf(buffer, param, values);
 806         return;
 807     }
 808
 809     context = GetContextRef();
 810     if(!context) return;
 811
 812     device = context->Device;
 813     LockBuffersRead(device);
 814     if(LookupBuffer(device, buffer) == NULL)
 815         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 816
 817     if(!(values))
 818         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 819     switch(param)
 820     {
 821     default:
 822         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 823     }
 824
 825 done:
 826     UnlockBuffersRead(device);
 827     ALCcontext_DecRef(context);
 828 }
 829
 830
 831 AL_API ALvoid AL_APIENTRY alGetBufferi(ALuint buffer, ALenum param, ALint *value)
 832 {
 833     ALCdevice *device;
 834     ALCcontext *context;
 835     ALbuffer *albuf;
 836
 837     context = GetContextRef();
 838     if(!context) return;
 839
 840     device = context->Device;
 841     LockBuffersRead(device);
 842     if((albuf=LookupBuffer(device, buffer)) == NULL)
 843         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 844
 845     if(!(value))
 846         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 847     switch(param)
 848     {
 849     case AL_FREQUENCY:
 850         *value = albuf->Frequency;
 851         break;
 852
 853     case AL_BITS:
 854         *value = BytesFromFmt(albuf->FmtType) * 8;
 855         break;
 856
 857     case AL_CHANNELS:
 858         *value = ChannelsFromFmt(albuf->FmtChannels);
 859         break;
 860
 861     case AL_SIZE:
 862         ReadLock(&albuf->lock);
 863         *value = albuf->SampleLen * FrameSizeFromFmt(albuf->FmtChannels,
 864                                                      albuf->FmtType);
 865         ReadUnlock(&albuf->lock);
 866         break;
 867
 868     case AL_INTERNAL_FORMAT_SOFT:
 869         *value = albuf->Format;
 870         break;
 871
 872     case AL_BYTE_LENGTH_SOFT:
 873         *value = albuf->OriginalSize;
 874         break;
 875
 876     case AL_SAMPLE_LENGTH_SOFT:
 877         *value = albuf->SampleLen;
 878         break;
 879
 880     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 881         *value = ATOMIC_LOAD(&albuf->UnpackAlign);
 882         break;
 883
 884     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 885         *value = ATOMIC_LOAD(&albuf->PackAlign);
 886         break;
 887
 888     default:
 889         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 890     }
 891
 892 done:
 893     UnlockBuffersRead(device);
 894     ALCcontext_DecRef(context);
 895 }
 896
 897
 898 AL_API void AL_APIENTRY alGetBuffer3i(ALuint buffer, ALenum param, ALint *value1, ALint *value2, ALint *value3)
 899 {
 900     ALCdevice *device;
 901     ALCcontext *context;
 902
 903     context = GetContextRef();
 904     if(!context) return;
 905
 906     device = context->Device;
 907     LockBuffersRead(device);
 908     if(LookupBuffer(device, buffer) == NULL)
 909         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 910
 911     if(!(value1 && value2 && value3))
 912         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 913     switch(param)
 914     {
 915     default:
 916         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 917     }
 918
 919 done:
 920     UnlockBuffersRead(device);
 921     ALCcontext_DecRef(context);
 922 }
 923
 924
 925 AL_API void AL_APIENTRY alGetBufferiv(ALuint buffer, ALenum param, ALint *values)
 926 {
 927     ALCdevice *device;
 928     ALCcontext *context;
 929     ALbuffer   *albuf;
 930
 931     switch(param)
 932     {
 933     case AL_FREQUENCY:
 934     case AL_BITS:
 935     case AL_CHANNELS:
 936     case AL_SIZE:
 937     case AL_INTERNAL_FORMAT_SOFT:
 938     case AL_BYTE_LENGTH_SOFT:
 939     case AL_SAMPLE_LENGTH_SOFT:
 940     case AL_UNPACK_BLOCK_ALIGNMENT_SOFT:
 941     case AL_PACK_BLOCK_ALIGNMENT_SOFT:
 942         alGetBufferi(buffer, param, values);
 943         return;
 944     }
 945
 946     context = GetContextRef();
 947     if(!context) return;
 948
 949     device = context->Device;
 950     LockBuffersRead(device);
 951     if((albuf=LookupBuffer(device, buffer)) == NULL)
 952         SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
 953
 954     if(!(values))
 955         SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
 956     switch(param)
 957     {
 958     case AL_LOOP_POINTS_SOFT:
 959         ReadLock(&albuf->lock);
 960         values[0] = albuf->LoopStart;
 961         values[1] = albuf->LoopEnd;
 962         ReadUnlock(&albuf->lock);
 963         break;
 964
 965     default:
 966         SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
 967     }
 968
 969 done:
 970     UnlockBuffersRead(device);
 971     ALCcontext_DecRef(context);
 972 }
 973
 974
 975 /*
 976  * LoadData
 977  *
 978  * Loads the specified data into the buffer, using the specified formats.
 979  * Currently, the new format must have the same channel configuration as the
 980  * original format.
 981  */
 982 ALenum LoadData(ALbuffer *ALBuf, ALuint freq, ALenum NewFormat, ALsizei frames, enum UserFmtChannels SrcChannels, enum UserFmtType SrcType, const ALvoid *data, ALsizei align, ALboolean storesrc)
 983 {
 984     ALuint NewChannels, NewBytes;
 985     enum FmtChannels DstChannels;
 986     enum FmtType DstType;
 987     ALuint64 newsize;
 988     ALvoid *temp;
 989
 990     if(DecomposeFormat(NewFormat, &DstChannels, &DstType) == AL_FALSE ||
 991        (long)SrcChannels != (long)DstChannels)
 992         return AL_INVALID_ENUM;
 993
 994     NewChannels = ChannelsFromFmt(DstChannels);
 995     NewBytes = BytesFromFmt(DstType);
 996
 997     newsize = frames;
 998     newsize *= NewBytes;
 999     newsize *= NewChannels;
1000     if(newsize > INT_MAX)
1001         return AL_OUT_OF_MEMORY;
1002
1003     WriteLock(&ALBuf->lock);
1004     if(ReadRef(&ALBuf->ref) != 0)
1005     {
1006         WriteUnlock(&ALBuf->lock);
1007         return AL_INVALID_OPERATION;
1008     }
1009
1010     temp = realloc(ALBuf->data, (size_t)newsize);
1011     if(!temp && newsize)
1012     {
1013         WriteUnlock(&ALBuf->lock);
1014         return AL_OUT_OF_MEMORY;
1015     }
1016     ALBuf->data = temp;
1017
1018     if(data != NULL)
1019         ConvertData(ALBuf->data, (enum UserFmtType)DstType, data, SrcType, NewChannels, frames, align);
1020
1021     if(storesrc)
1022     {
1023         ALBuf->OriginalChannels = SrcChannels;
1024         ALBuf->OriginalType     = SrcType;
1025         if(SrcType == UserFmtIMA4)
1026         {
1027             ALsizei byte_align = ((align-1)/2 + 4) * ChannelsFromUserFmt(SrcChannels);
1028             ALBuf->OriginalSize  = frames / align * byte_align;
1029             ALBuf->OriginalAlign = align;
1030         }
1031         else if(SrcType == UserFmtMSADPCM)
1032         {
1033             ALsizei byte_align = ((align-2)/2 + 7) * ChannelsFromUserFmt(SrcChannels);
1034             ALBuf->OriginalSize  = frames / align * byte_align;
1035             ALBuf->OriginalAlign = align;
1036         }
1037         else
1038         {
1039             ALBuf->OriginalSize  = frames * FrameSizeFromUserFmt(SrcChannels, SrcType);
1040             ALBuf->OriginalAlign = 1;
1041         }
1042     }
1043     else
1044     {
1045         ALBuf->OriginalChannels = (enum UserFmtChannels)DstChannels;
1046         ALBuf->OriginalType     = (enum UserFmtType)DstType;
1047         ALBuf->OriginalSize     = frames * NewBytes * NewChannels;
1048         ALBuf->OriginalAlign    = 1;
1049     }
1050
1051     ALBuf->Frequency = freq;
1052     ALBuf->FmtChannels = DstChannels;
1053     ALBuf->FmtType = DstType;
1054     ALBuf->Format = NewFormat;
1055
1056     ALBuf->SampleLen = frames;
1057     ALBuf->LoopStart = 0;
1058     ALBuf->LoopEnd = ALBuf->SampleLen;
1059
1060     WriteUnlock(&ALBuf->lock);
1061     return AL_NO_ERROR;
1062 }
1063
1064
1065 ALuint BytesFromUserFmt(enum UserFmtType type)
1066 {
1067     switch(type)
1068     {
1069     case UserFmtByte: return sizeof(ALbyte);
1070     case UserFmtUByte: return sizeof(ALubyte);
1071     case UserFmtShort: return sizeof(ALshort);
1072     case UserFmtUShort: return sizeof(ALushort);
1073     case UserFmtInt: return sizeof(ALint);
1074     case UserFmtUInt: return sizeof(ALuint);
1075     case UserFmtFloat: return sizeof(ALfloat);
1076     case UserFmtDouble: return sizeof(ALdouble);
1077     case UserFmtByte3: return sizeof(ALbyte[3]);
1078     case UserFmtUByte3: return sizeof(ALubyte[3]);
1079     case UserFmtMulaw: return sizeof(ALubyte);
1080     case UserFmtAlaw: return sizeof(ALubyte);
1081     case UserFmtIMA4: break; /* not handled here */
1082     case UserFmtMSADPCM: break; /* not handled here */
1083     }
1084     return 0;
1085 }
1086 ALuint ChannelsFromUserFmt(enum UserFmtChannels chans)
1087 {
1088     switch(chans)
1089     {
1090     case UserFmtMono: return 1;
1091     case UserFmtStereo: return 2;
1092     case UserFmtRear: return 2;
1093     case UserFmtQuad: return 4;
1094     case UserFmtX51: return 6;
1095     case UserFmtX61: return 7;
1096     case UserFmtX71: return 8;
1097     case UserFmtBFormat2D: return 3;
1098     case UserFmtBFormat3D: return 4;
1099     }
1100     return 0;
1101 }
1102 static ALboolean DecomposeUserFormat(ALenum format, enum UserFmtChannels *chans,
1103                                      enum UserFmtType *type)
1104 {
1105     static const struct {
1106         ALenum format;
1107         enum UserFmtChannels channels;
1108         enum UserFmtType type;
1109     } list[] = {
1110         { AL_FORMAT_MONO8,             UserFmtMono, UserFmtUByte   },
1111         { AL_FORMAT_MONO16,            UserFmtMono, UserFmtShort   },
1112         { AL_FORMAT_MONO_FLOAT32,      UserFmtMono, UserFmtFloat   },
1113         { AL_FORMAT_MONO_DOUBLE_EXT,   UserFmtMono, UserFmtDouble  },
1114         { AL_FORMAT_MONO_IMA4,         UserFmtMono, UserFmtIMA4    },
1115         { AL_FORMAT_MONO_MSADPCM_SOFT, UserFmtMono, UserFmtMSADPCM },
1116         { AL_FORMAT_MONO_MULAW,        UserFmtMono, UserFmtMulaw   },
1117         { AL_FORMAT_MONO_ALAW_EXT,     UserFmtMono, UserFmtAlaw    },
1118
1119         { AL_FORMAT_STEREO8,             UserFmtStereo, UserFmtUByte   },
1120         { AL_FORMAT_STEREO16,            UserFmtStereo, UserFmtShort   },
1121         { AL_FORMAT_STEREO_FLOAT32,      UserFmtStereo, UserFmtFloat   },
1122         { AL_FORMAT_STEREO_DOUBLE_EXT,   UserFmtStereo, UserFmtDouble  },
1123         { AL_FORMAT_STEREO_IMA4,         UserFmtStereo, UserFmtIMA4    },
1124         { AL_FORMAT_STEREO_MSADPCM_SOFT, UserFmtStereo, UserFmtMSADPCM },
1125         { AL_FORMAT_STEREO_MULAW,        UserFmtStereo, UserFmtMulaw   },
1126         { AL_FORMAT_STEREO_ALAW_EXT,     UserFmtStereo, UserFmtAlaw    },
1127
1128         { AL_FORMAT_REAR8,      UserFmtRear, UserFmtUByte },
1129         { AL_FORMAT_REAR16,     UserFmtRear, UserFmtShort },
1130         { AL_FORMAT_REAR32,     UserFmtRear, UserFmtFloat },
1131         { AL_FORMAT_REAR_MULAW, UserFmtRear, UserFmtMulaw },
1132
1133         { AL_FORMAT_QUAD8_LOKI,  UserFmtQuad, UserFmtUByte },
1134         { AL_FORMAT_QUAD16_LOKI, UserFmtQuad, UserFmtShort },
1135
1136         { AL_FORMAT_QUAD8,      UserFmtQuad, UserFmtUByte },
1137         { AL_FORMAT_QUAD16,     UserFmtQuad, UserFmtShort },
1138         { AL_FORMAT_QUAD32,     UserFmtQuad, UserFmtFloat },
1139         { AL_FORMAT_QUAD_MULAW, UserFmtQuad, UserFmtMulaw },
1140
1141         { AL_FORMAT_51CHN8,      UserFmtX51, UserFmtUByte },
1142         { AL_FORMAT_51CHN16,     UserFmtX51, UserFmtShort },
1143         { AL_FORMAT_51CHN32,     UserFmtX51, UserFmtFloat },
1144         { AL_FORMAT_51CHN_MULAW, UserFmtX51, UserFmtMulaw },
1145
1146         { AL_FORMAT_61CHN8,      UserFmtX61, UserFmtUByte },
1147         { AL_FORMAT_61CHN16,     UserFmtX61, UserFmtShort },
1148         { AL_FORMAT_61CHN32,     UserFmtX61, UserFmtFloat },
1149         { AL_FORMAT_61CHN_MULAW, UserFmtX61, UserFmtMulaw },
1150
1151         { AL_FORMAT_71CHN8,      UserFmtX71, UserFmtUByte },
1152         { AL_FORMAT_71CHN16,     UserFmtX71, UserFmtShort },
1153         { AL_FORMAT_71CHN32,     UserFmtX71, UserFmtFloat },
1154         { AL_FORMAT_71CHN_MULAW, UserFmtX71, UserFmtMulaw },
1155
1156         { AL_FORMAT_BFORMAT2D_8,       UserFmtBFormat2D, UserFmtUByte },
1157         { AL_FORMAT_BFORMAT2D_16,      UserFmtBFormat2D, UserFmtShort },
1158         { AL_FORMAT_BFORMAT2D_FLOAT32, UserFmtBFormat2D, UserFmtFloat },
1159         { AL_FORMAT_BFORMAT2D_MULAW,   UserFmtBFormat2D, UserFmtMulaw },
1160
1161         { AL_FORMAT_BFORMAT3D_8,       UserFmtBFormat3D, UserFmtUByte },
1162         { AL_FORMAT_BFORMAT3D_16,      UserFmtBFormat3D, UserFmtShort },
1163         { AL_FORMAT_BFORMAT3D_FLOAT32, UserFmtBFormat3D, UserFmtFloat },
1164         { AL_FORMAT_BFORMAT3D_MULAW,   UserFmtBFormat3D, UserFmtMulaw },
1165     };
1166     ALuint i;
1167
1168     for(i = 0;i < COUNTOF(list);i++)
1169     {
1170         if(list[i].format == format)
1171         {
1172             *chans = list[i].channels;
1173             *type  = list[i].type;
1174             return AL_TRUE;
1175         }
1176     }
1177
1178     return AL_FALSE;
1179 }
1180
1181 ALuint BytesFromFmt(enum FmtType type)
1182 {
1183     switch(type)
1184     {
1185     case FmtByte: return sizeof(ALbyte);
1186     case FmtShort: return sizeof(ALshort);
1187     case FmtFloat: return sizeof(ALfloat);
1188     }
1189     return 0;
1190 }
1191 ALuint ChannelsFromFmt(enum FmtChannels chans)
1192 {
1193     switch(chans)
1194     {
1195     case FmtMono: return 1;
1196     case FmtStereo: return 2;
1197     case FmtRear: return 2;
1198     case FmtQuad: return 4;
1199     case FmtX51: return 6;
1200     case FmtX61: return 7;
1201     case FmtX71: return 8;
1202     case FmtBFormat2D: return 3;
1203     case FmtBFormat3D: return 4;
1204     }
1205     return 0;
1206 }
1207 static ALboolean DecomposeFormat(ALenum format, enum FmtChannels *chans, enum FmtType *type)
1208 {
1209     static const struct {
1210         ALenum format;
1211         enum FmtChannels channels;
1212         enum FmtType type;
1213     } list[] = {
1214         { AL_MONO8_SOFT,   FmtMono, FmtByte  },
1215         { AL_MONO16_SOFT,  FmtMono, FmtShort },
1216         { AL_MONO32F_SOFT, FmtMono, FmtFloat },
1217
1218         { AL_STEREO8_SOFT,   FmtStereo, FmtByte  },
1219         { AL_STEREO16_SOFT,  FmtStereo, FmtShort },
1220         { AL_STEREO32F_SOFT, FmtStereo, FmtFloat },
1221
1222         { AL_REAR8_SOFT,   FmtRear, FmtByte  },
1223         { AL_REAR16_SOFT,  FmtRear, FmtShort },
1224         { AL_REAR32F_SOFT, FmtRear, FmtFloat },
1225
1226         { AL_FORMAT_QUAD8_LOKI,  FmtQuad, FmtByte  },
1227         { AL_FORMAT_QUAD16_LOKI, FmtQuad, FmtShort },
1228
1229         { AL_QUAD8_SOFT,   FmtQuad, FmtByte  },
1230         { AL_QUAD16_SOFT,  FmtQuad, FmtShort },
1231         { AL_QUAD32F_SOFT, FmtQuad, FmtFloat },
1232
1233         { AL_5POINT1_8_SOFT,   FmtX51, FmtByte  },
1234         { AL_5POINT1_16_SOFT,  FmtX51, FmtShort },
1235         { AL_5POINT1_32F_SOFT, FmtX51, FmtFloat },
1236
1237         { AL_6POINT1_8_SOFT,   FmtX61, FmtByte  },
1238         { AL_6POINT1_16_SOFT,  FmtX61, FmtShort },
1239         { AL_6POINT1_32F_SOFT, FmtX61, FmtFloat },
1240
1241         { AL_7POINT1_8_SOFT,   FmtX71, FmtByte  },
1242         { AL_7POINT1_16_SOFT,  FmtX71, FmtShort },
1243         { AL_7POINT1_32F_SOFT, FmtX71, FmtFloat },
1244
1245         { AL_BFORMAT2D_8_SOFT,   FmtBFormat2D, FmtByte },
1246         { AL_BFORMAT2D_16_SOFT,  FmtBFormat2D, FmtShort },
1247         { AL_BFORMAT2D_32F_SOFT, FmtBFormat2D, FmtFloat },
1248
1249         { AL_BFORMAT3D_8_SOFT,   FmtBFormat3D, FmtByte },
1250         { AL_BFORMAT3D_16_SOFT,  FmtBFormat3D, FmtShort },
1251         { AL_BFORMAT3D_32F_SOFT, FmtBFormat3D, FmtFloat },
1252     };
1253     ALuint i;
1254
1255     for(i = 0;i < COUNTOF(list);i++)
1256     {
1257         if(list[i].format == format)
1258         {
1259             *chans = list[i].channels;
1260             *type  = list[i].type;
1261             return AL_TRUE;
1262         }
1263     }
1264
1265     return AL_FALSE;
1266 }
1267
1268 static ALboolean SanitizeAlignment(enum UserFmtType type, ALsizei *align)
1269 {
1270     if(*align < 0)
1271         return AL_FALSE;
1272
1273     if(*align == 0)
1274     {
1275         if(type == UserFmtIMA4)
1276         {
1277             /* Here is where things vary:
1278              * nVidia and Apple use 64+1 sample frames per block -> block_size=36 bytes per channel
1279              * Most PC sound software uses 2040+1 sample frames per block -> block_size=1024 bytes per channel
1280              */
1281             *align = 65;
1282         }
1283         else if(type == UserFmtMSADPCM)
1284             *align = 64;
1285         else
1286             *align = 1;
1287         return AL_TRUE;
1288     }
1289
1290     if(type == UserFmtIMA4)
1291     {
1292         /* IMA4 block alignment must be a multiple of 8, plus 1. */
1293         return ((*align)&7) == 1;
1294     }
1295     if(type == UserFmtMSADPCM)
1296     {
1297         /* MSADPCM block alignment must be a multiple of 2. */
1298         /* FIXME: Too strict? Might only require align*channels to be a
1299          * multiple of 2. */
1300         return ((*align)&1) == 0;
1301     }
1302
1303     return AL_TRUE;
1304 }
1305
1306
1307 static ALboolean IsValidType(ALenum type)
1308 {
1309     switch(type)
1310     {
1311         case AL_BYTE_SOFT:
1312         case AL_UNSIGNED_BYTE_SOFT:
1313         case AL_SHORT_SOFT:
1314         case AL_UNSIGNED_SHORT_SOFT:
1315         case AL_INT_SOFT:
1316         case AL_UNSIGNED_INT_SOFT:
1317         case AL_FLOAT_SOFT:
1318         case AL_DOUBLE_SOFT:
1319         case AL_BYTE3_SOFT:
1320         case AL_UNSIGNED_BYTE3_SOFT:
1321         case AL_MULAW_SOFT:
1322             return AL_TRUE;
1323     }
1324     return AL_FALSE;
1325 }
1326
1327 static ALboolean IsValidChannels(ALenum channels)
1328 {
1329     switch(channels)
1330     {
1331         case AL_MONO_SOFT:
1332         case AL_STEREO_SOFT:
1333         case AL_REAR_SOFT:
1334         case AL_QUAD_SOFT:
1335         case AL_5POINT1_SOFT:
1336         case AL_6POINT1_SOFT:
1337         case AL_7POINT1_SOFT:
1338         case AL_BFORMAT2D_SOFT:
1339         case AL_BFORMAT3D_SOFT:
1340             return AL_TRUE;
1341     }
1342     return AL_FALSE;
1343 }
1344
1345
1346 ALbuffer *NewBuffer(ALCcontext *context)
1347 {
1348     ALCdevice *device = context->Device;
1349     ALbuffer *buffer;
1350     ALenum err;
1351
1352     buffer = calloc(1, sizeof(ALbuffer));
1353     if(!buffer)
1354         SET_ERROR_AND_RETURN_VALUE(context, AL_OUT_OF_MEMORY, NULL);
1355     RWLockInit(&buffer->lock);
1356
1357     err = NewThunkEntry(&buffer->id);
1358     if(err == AL_NO_ERROR)
1359         err = InsertUIntMapEntry(&device->BufferMap, buffer->id, buffer);
1360     if(err != AL_NO_ERROR)
1361     {
1362         FreeThunkEntry(buffer->id);
1363         memset(buffer, 0, sizeof(ALbuffer));
1364         free(buffer);
1365
1366         SET_ERROR_AND_RETURN_VALUE(context, err, NULL);
1367     }
1368
1369     return buffer;
1370 }
1371
1372 void DeleteBuffer(ALCdevice *device, ALbuffer *buffer)
1373 {
1374     RemoveBuffer(device, buffer->id);
1375     FreeThunkEntry(buffer->id);
1376
1377     free(buffer->data);
1378
1379     memset(buffer, 0, sizeof(*buffer));
1380     free(buffer);
1381 }
1382
1383
1384 /*
1385  *    ReleaseALBuffers()
1386  *
1387  *    INTERNAL: Called to destroy any buffers that still exist on the device
1388  */
1389 ALvoid ReleaseALBuffers(ALCdevice *device)
1390 {
1391     ALsizei i;
1392     for(i = 0;i < device->BufferMap.size;i++)
1393     {
1394         ALbuffer *temp = device->BufferMap.array[i].value;
1395         device->BufferMap.array[i].value = NULL;
1396
1397         free(temp->data);
1398
1399         FreeThunkEntry(temp->id);
1400         memset(temp, 0, sizeof(ALbuffer));
1401         free(temp);
1402     }
1403 }