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