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