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 #define _CRT_SECURE_NO_DEPRECATE // get rid of sprintf security warnings on VS2005
  22
  23 #include "config.h"
  24
  25 #include <stdlib.h>
  26 #include <stdio.h>
  27 #include <assert.h>
  28 #include "alMain.h"
  29 #include "AL/al.h"
  30 #include "AL/alc.h"
  31 #include "alError.h"
  32 #include "alBuffer.h"
  33 #include "alThunk.h"
  34
  35
  36 static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat);
  37 static void ConvertData(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len);
  38 static void ConvertDataRear(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len);
  39 static void ConvertDataIMA4(ALshort *dst, const ALvoid *src, ALint origChans, ALsizei len);
  40
  41 /*
  42  *  AL Buffer Functions
  43  *
  44  *  AL Buffers are shared amoung Contexts, so we store the list of generated Buffers
  45  *  as a global variable in this module.   (A valid context is not required to make
  46  *  AL Buffer function calls
  47  *
  48  */
  49
  50 /*
  51 * Global Variables
  52 */
  53
  54 static ALbuffer *g_pBuffers = NULL;          // Linked List of Buffers
  55 static ALuint    g_uiBufferCount = 0;        // Buffer Count
  56
  57 static const long g_IMAStep_size[89]={            // IMA ADPCM Stepsize table
  58        7,    8,    9,   10,   11,   12,   13,   14,   16,   17,   19,   21,   23,   25,   28,   31,
  59       34,   37,   41,   45,   50,   55,   60,   66,   73,   80,   88,   97,  107,  118,  130,  143,
  60      157,  173,  190,  209,  230,  253,  279,  307,  337,  371,  408,  449,  494,  544,  598,  658,
  61      724,  796,  876,  963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024,
  62     3327, 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630, 9493,10442,11487,12635,13899,
  63    15289,16818,18500,20350,22358,24633,27086,29794,32767
  64 };
  65
  66 static const long g_IMACodeword_4[16]={            // IMA4 ADPCM Codeword decode table
  67     1, 3, 5, 7, 9, 11, 13, 15,
  68    -1,-3,-5,-7,-9,-11,-13,-15,
  69 };
  70
  71 static const long g_IMAIndex_adjust_4[16]={        // IMA4 ADPCM Step index adjust decode table
  72    -1,-1,-1,-1, 2, 4, 6, 8,
  73    -1,-1,-1,-1, 2, 4, 6, 8
  74 };
  75
  76 /*
  77 *    alGenBuffers(ALsizei n, ALuint *puiBuffers)
  78 *
  79 *    Generates n AL Buffers, and stores the Buffers Names in the array pointed to by puiBuffers
  80 */
  81 ALAPI ALvoid ALAPIENTRY alGenBuffers(ALsizei n,ALuint *puiBuffers)
  82 {
  83     ALCcontext *Context;
  84     ALsizei i=0;
  85
  86     Context = alcGetCurrentContext();
  87     SuspendContext(Context);
  88
  89     // Check that we are actually generation some Buffers
  90     if (n > 0)
  91     {
  92         // Check the pointer is valid (and points to enough memory to store Buffer Names)
  93         if (!IsBadWritePtr((void*)puiBuffers, n * sizeof(ALuint)))
  94         {
  95             ALbuffer **list = &g_pBuffers;
  96             while(*list)
  97                 list = &(*list)->next;
  98
  99             // Create all the new Buffers
 100             while(i < n)
 101             {
 102                 *list = calloc(1, sizeof(ALbuffer));
 103                 if(!(*list))
 104                 {
 105                     alDeleteBuffers(i, puiBuffers);
 106                     alSetError(AL_OUT_OF_MEMORY);
 107                     break;
 108                 }
 109
 110                 puiBuffers[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
 111                 (*list)->state = UNUSED;
 112                 g_uiBufferCount++;
 113                 i++;
 114
 115                 list = &(*list)->next;
 116             }
 117         }
 118         else
 119         {
 120             // Pointer does not point to enough memory to write Buffer names
 121             alSetError(AL_INVALID_VALUE);
 122         }
 123     }
 124
 125     ProcessContext(Context);
 126
 127     return;
 128 }
 129
 130 /*
 131 *    alDeleteBuffers(ALsizei n, ALuint *puiBuffers)
 132 *
 133 *    Deletes the n AL Buffers pointed to by puiBuffers
 134 */
 135 ALAPI ALvoid ALAPIENTRY alDeleteBuffers(ALsizei n, const ALuint *puiBuffers)
 136 {
 137     ALCcontext *Context;
 138     ALbuffer *ALBuf;
 139     ALsizei i;
 140     ALboolean bFailed = AL_FALSE;
 141
 142     Context = alcGetCurrentContext();
 143     SuspendContext(Context);
 144
 145     // Check we are actually Deleting some Buffers
 146     if (n >= 0)
 147     {
 148         // Check that all the buffers are valid and can actually be deleted
 149         for (i = 0; i < n; i++)
 150         {
 151             // Check for valid Buffer ID (can be NULL buffer)
 152             if (alIsBuffer(puiBuffers[i]))
 153             {
 154                 // If not the NULL buffer, check that the reference count is 0
 155                 ALBuf = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(puiBuffers[i]));
 156                 if (ALBuf)
 157                 {
 158                     if (ALBuf->refcount != 0)
 159                     {
 160                         // Buffer still in use, cannot be deleted
 161                         alSetError(AL_INVALID_OPERATION);
 162                         bFailed = AL_TRUE;
 163                     }
 164                 }
 165             }
 166             else
 167             {
 168                 // Invalid Buffer
 169                 alSetError(AL_INVALID_NAME);
 170                 bFailed = AL_TRUE;
 171             }
 172         }
 173
 174         // If all the Buffers were valid (and have Reference Counts of 0), then we can delete them
 175         if (!bFailed)
 176         {
 177             for (i = 0; i < n; i++)
 178             {
 179                 if (puiBuffers[i] && alIsBuffer(puiBuffers[i]))
 180                 {
 181                     ALbuffer **list = &g_pBuffers;
 182
 183                     ALBuf=((ALbuffer *)ALTHUNK_LOOKUPENTRY(puiBuffers[i]));
 184                     while(*list && *list != ALBuf)
 185                         list = &(*list)->next;
 186
 187                     if(*list)
 188                         *list = (*list)->next;
 189
 190                     // Release the memory used to store audio data
 191                     free(ALBuf->data);
 192
 193                     // Release buffer structure
 194                     ALTHUNK_REMOVEENTRY(puiBuffers[i]);
 195                     memset(ALBuf, 0, sizeof(ALbuffer));
 196                     g_uiBufferCount--;
 197                     free(ALBuf);
 198                 }
 199             }
 200         }
 201     }
 202     else
 203         alSetError(AL_INVALID_VALUE);
 204
 205     ProcessContext(Context);
 206
 207     return;
 208
 209 }
 210
 211 /*
 212 *    alIsBuffer(ALuint uiBuffer)
 213 *
 214 *    Checks if ulBuffer is a valid Buffer Name
 215 */
 216 ALAPI ALboolean ALAPIENTRY alIsBuffer(ALuint uiBuffer)
 217 {
 218     ALCcontext *Context;
 219     ALboolean result=AL_FALSE;
 220     ALbuffer *ALBuf;
 221     ALbuffer *TgtALBuf;
 222
 223     Context = alcGetCurrentContext();
 224     SuspendContext(Context);
 225
 226     if (uiBuffer)
 227     {
 228         TgtALBuf = (ALbuffer *)ALTHUNK_LOOKUPENTRY(uiBuffer);
 229
 230         // Check through list of generated buffers for uiBuffer
 231         ALBuf = g_pBuffers;
 232         while (ALBuf)
 233         {
 234             if (ALBuf == TgtALBuf)
 235             {
 236                 result = AL_TRUE;
 237                 break;
 238             }
 239
 240             ALBuf = ALBuf->next;
 241         }
 242     }
 243     else
 244     {
 245         result = AL_TRUE;
 246     }
 247
 248
 249     ProcessContext(Context);
 250
 251     return result;
 252 }
 253
 254 /*
 255 *    alBufferData(ALuint buffer,ALenum format,ALvoid *data,ALsizei size,ALsizei freq)
 256 *
 257 *    Fill buffer with audio data
 258 */
 259 ALAPI ALvoid ALAPIENTRY alBufferData(ALuint buffer,ALenum format,const ALvoid *data,ALsizei size,ALsizei freq)
 260 {
 261     ALCcontext *Context;
 262     ALsizei padding = 2;
 263     ALbuffer *ALBuf;
 264     ALvoid *temp;
 265
 266     Context = alcGetCurrentContext();
 267     SuspendContext(Context);
 268
 269     if (alIsBuffer(buffer) && (buffer != 0))
 270     {
 271         ALBuf=((ALbuffer *)ALTHUNK_LOOKUPENTRY(buffer));
 272         if ((ALBuf->refcount==0)&&(data))
 273         {
 274             switch(format)
 275             {
 276                 case AL_FORMAT_MONO8:
 277                 case AL_FORMAT_MONO16:
 278                 case AL_FORMAT_MONO_FLOAT32:
 279                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_MONO16);
 280                     break;
 281
 282                 case AL_FORMAT_STEREO8:
 283                 case AL_FORMAT_STEREO16:
 284                 case AL_FORMAT_STEREO_FLOAT32:
 285                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_STEREO16);
 286                     break;
 287
 288                 case AL_FORMAT_REAR8:
 289                 case AL_FORMAT_REAR16:
 290                 case AL_FORMAT_REAR32: {
 291                     ALuint NewFormat = AL_FORMAT_QUAD16;
 292                     ALuint NewChannels = aluChannelsFromFormat(NewFormat);
 293                     ALuint OrigBytes = ((format==AL_FORMAT_REAR8) ? 1 :
 294                                         ((format==AL_FORMAT_REAR16) ? 2 :
 295                                          4));
 296
 297                     assert(aluBytesFromFormat(NewFormat) == 2);
 298
 299                     if((size%(OrigBytes*2)) != 0)
 300                     {
 301                         alSetError(AL_INVALID_VALUE);
 302                         break;
 303                     }
 304
 305                     size /= OrigBytes;
 306                     size *= 2;
 307
 308                     // Samples are converted to 16 bit here
 309                     temp = realloc(ALBuf->data, (padding*NewChannels + size) * sizeof(ALshort));
 310                     if(temp)
 311                     {
 312                         ALBuf->data = temp;
 313                         ConvertDataRear(ALBuf->data, data, OrigBytes, size);
 314
 315                         memset(&(ALBuf->data[size]), 0, padding*NewChannels*sizeof(ALshort));
 316
 317                         ALBuf->format = NewFormat;
 318                         ALBuf->eOriginalFormat = format;
 319                         ALBuf->size = size*sizeof(ALshort);
 320                         ALBuf->frequency = freq;
 321                         ALBuf->padding = padding;
 322                     }
 323                     else
 324                         alSetError(AL_OUT_OF_MEMORY);
 325                 }   break;
 326
 327                 case AL_FORMAT_QUAD8_LOKI:
 328                 case AL_FORMAT_QUAD16_LOKI:
 329                 case AL_FORMAT_QUAD8:
 330                 case AL_FORMAT_QUAD16:
 331                 case AL_FORMAT_QUAD32:
 332                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_QUAD16);
 333                     break;
 334
 335                 case AL_FORMAT_51CHN8:
 336                 case AL_FORMAT_51CHN16:
 337                 case AL_FORMAT_51CHN32:
 338                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_51CHN16);
 339                     break;
 340
 341                 case AL_FORMAT_61CHN8:
 342                 case AL_FORMAT_61CHN16:
 343                 case AL_FORMAT_61CHN32:
 344                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_61CHN16);
 345                     break;
 346
 347                 case AL_FORMAT_71CHN8:
 348                 case AL_FORMAT_71CHN16:
 349                 case AL_FORMAT_71CHN32:
 350                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_71CHN16);
 351                     break;
 352
 353                 case AL_FORMAT_MONO_IMA4:
 354                 case AL_FORMAT_STEREO_IMA4: {
 355                     int OrigChans = ((format==AL_FORMAT_MONO_IMA4) ? 1 : 2);
 356
 357                     // Here is where things vary:
 358                     // nVidia and Apple use 64+1 samples per channel per block => block_size=36*chans bytes
 359                     // Most PC sound software uses 2040+1 samples per channel per block -> block_size=1024*chans bytes
 360                     if((size%(36*OrigChans)) != 0)
 361                     {
 362                         alSetError(AL_INVALID_VALUE);
 363                         break;
 364                     }
 365
 366                     size /= 36;
 367                     size *= 65;
 368
 369                     // Allocate extra padding samples
 370                     temp = realloc(ALBuf->data, (padding*OrigChans + size)*sizeof(ALshort));
 371                     if(temp)
 372                     {
 373                         ALBuf->data = temp;
 374                         ConvertDataIMA4(ALBuf->data, data, OrigChans, size/65);
 375
 376                         memset(&(ALBuf->data[size]), 0, padding*sizeof(ALshort)*OrigChans);
 377
 378                         ALBuf->format = ((OrigChans==1) ? AL_FORMAT_MONO16 : AL_FORMAT_STEREO16);
 379                         ALBuf->eOriginalFormat = format;
 380                         ALBuf->size = size*sizeof(ALshort);
 381                         ALBuf->frequency = freq;
 382                         ALBuf->padding = padding;
 383                     }
 384                     else
 385                         alSetError(AL_OUT_OF_MEMORY);
 386                 }   break;
 387
 388                 default:
 389                     alSetError(AL_INVALID_ENUM);
 390                     break;
 391             }
 392         }
 393         else
 394         {
 395             // Buffer is in use, or data is a NULL pointer
 396             alSetError(AL_INVALID_VALUE);
 397         }
 398     }
 399     else
 400     {
 401         // Invalid Buffer Name
 402         alSetError(AL_INVALID_NAME);
 403     }
 404
 405     ProcessContext(Context);
 406 }
 407
 408
 409 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
 410 {
 411     ALCcontext    *pContext;
 412
 413     (void)flValue;
 414
 415     pContext = alcGetCurrentContext();
 416     SuspendContext(pContext);
 417
 418     if (alIsBuffer(buffer) && (buffer != 0))
 419     {
 420         switch(eParam)
 421         {
 422         default:
 423             alSetError(AL_INVALID_ENUM);
 424             break;
 425         }
 426     }
 427     else
 428     {
 429         alSetError(AL_INVALID_NAME);
 430     }
 431
 432     ProcessContext(pContext);
 433 }
 434
 435
 436 ALAPI void ALAPIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
 437 {
 438     ALCcontext    *pContext;
 439
 440     (void)flValue1;
 441     (void)flValue2;
 442     (void)flValue3;
 443
 444     pContext = alcGetCurrentContext();
 445     SuspendContext(pContext);
 446
 447     if (alIsBuffer(buffer) && (buffer != 0))
 448     {
 449         switch(eParam)
 450         {
 451         default:
 452             alSetError(AL_INVALID_ENUM);
 453             break;
 454         }
 455     }
 456     else
 457     {
 458         alSetError(AL_INVALID_NAME);
 459     }
 460
 461     ProcessContext(pContext);
 462 }
 463
 464
 465 ALAPI void ALAPIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
 466 {
 467     ALCcontext    *pContext;
 468
 469     (void)flValues;
 470
 471     pContext = alcGetCurrentContext();
 472     SuspendContext(pContext);
 473
 474     if (alIsBuffer(buffer) && (buffer != 0))
 475     {
 476         switch(eParam)
 477         {
 478         default:
 479             alSetError(AL_INVALID_ENUM);
 480             break;
 481         }
 482     }
 483     else
 484     {
 485         alSetError(AL_INVALID_NAME);
 486     }
 487
 488     ProcessContext(pContext);
 489 }
 490
 491
 492 ALAPI void ALAPIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
 493 {
 494     ALCcontext    *pContext;
 495
 496     (void)lValue;
 497
 498     pContext = alcGetCurrentContext();
 499     SuspendContext(pContext);
 500
 501     if (alIsBuffer(buffer) && (buffer != 0))
 502     {
 503         switch(eParam)
 504         {
 505         default:
 506             alSetError(AL_INVALID_ENUM);
 507             break;
 508         }
 509     }
 510     else
 511     {
 512         alSetError(AL_INVALID_NAME);
 513     }
 514
 515     ProcessContext(pContext);
 516 }
 517
 518
 519 ALAPI void ALAPIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 520 {
 521     ALCcontext    *pContext;
 522
 523     (void)lValue1;
 524     (void)lValue2;
 525     (void)lValue3;
 526
 527     pContext = alcGetCurrentContext();
 528     SuspendContext(pContext);
 529
 530     if (alIsBuffer(buffer) && (buffer != 0))
 531     {
 532         switch(eParam)
 533         {
 534         default:
 535             alSetError(AL_INVALID_ENUM);
 536             break;
 537         }
 538     }
 539     else
 540     {
 541         alSetError(AL_INVALID_NAME);
 542     }
 543
 544     ProcessContext(pContext);
 545 }
 546
 547
 548 ALAPI void ALAPIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
 549 {
 550     ALCcontext    *pContext;
 551
 552     (void)plValues;
 553
 554     pContext = alcGetCurrentContext();
 555     SuspendContext(pContext);
 556
 557     if (alIsBuffer(buffer) && (buffer != 0))
 558     {
 559         switch(eParam)
 560         {
 561         default:
 562             alSetError(AL_INVALID_ENUM);
 563             break;
 564         }
 565     }
 566     else
 567     {
 568         alSetError(AL_INVALID_NAME);
 569     }
 570
 571     ProcessContext(pContext);
 572 }
 573
 574
 575 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
 576 {
 577     ALCcontext    *pContext;
 578
 579     pContext = alcGetCurrentContext();
 580     SuspendContext(pContext);
 581
 582     if (pflValue)
 583     {
 584         if (alIsBuffer(buffer) && (buffer != 0))
 585         {
 586             switch(eParam)
 587             {
 588             default:
 589                 alSetError(AL_INVALID_ENUM);
 590                 break;
 591             }
 592         }
 593         else
 594         {
 595             alSetError(AL_INVALID_NAME);
 596         }
 597     }
 598     else
 599     {
 600         alSetError(AL_INVALID_VALUE);
 601     }
 602
 603     ProcessContext(pContext);
 604 }
 605
 606
 607 ALAPI void ALAPIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 608 {
 609     ALCcontext    *pContext;
 610
 611     pContext = alcGetCurrentContext();
 612     SuspendContext(pContext);
 613
 614     if ((pflValue1) && (pflValue2) && (pflValue3))
 615     {
 616         if (alIsBuffer(buffer) && (buffer != 0))
 617         {
 618             switch(eParam)
 619             {
 620             default:
 621                 alSetError(AL_INVALID_ENUM);
 622                 break;
 623             }
 624         }
 625         else
 626         {
 627             alSetError(AL_INVALID_NAME);
 628         }
 629     }
 630     else
 631     {
 632         alSetError(AL_INVALID_VALUE);
 633     }
 634
 635     ProcessContext(pContext);
 636 }
 637
 638
 639 ALAPI void ALAPIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
 640 {
 641     ALCcontext    *pContext;
 642
 643     pContext = alcGetCurrentContext();
 644     SuspendContext(pContext);
 645
 646     if (pflValues)
 647     {
 648         if (alIsBuffer(buffer) && (buffer != 0))
 649         {
 650             switch(eParam)
 651             {
 652             default:
 653                 alSetError(AL_INVALID_ENUM);
 654                 break;
 655             }
 656         }
 657         else
 658         {
 659             alSetError(AL_INVALID_NAME);
 660         }
 661     }
 662     else
 663     {
 664         alSetError(AL_INVALID_VALUE);
 665     }
 666
 667     ProcessContext(pContext);
 668 }
 669
 670
 671 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
 672 {
 673     ALCcontext    *pContext;
 674     ALbuffer    *pBuffer;
 675
 676     pContext = alcGetCurrentContext();
 677     SuspendContext(pContext);
 678
 679     if (plValue)
 680     {
 681         if (alIsBuffer(buffer) && (buffer != 0))
 682         {
 683             pBuffer = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(buffer));
 684
 685             switch (eParam)
 686             {
 687             case AL_FREQUENCY:
 688                 *plValue = pBuffer->frequency;
 689                 break;
 690
 691             case AL_BITS:
 692                 *plValue = aluBytesFromFormat(pBuffer->format) * 8;
 693                 break;
 694
 695             case AL_CHANNELS:
 696                 *plValue = aluChannelsFromFormat(pBuffer->format);
 697                 break;
 698
 699             case AL_SIZE:
 700                 *plValue = pBuffer->size;
 701                 break;
 702
 703             default:
 704                 alSetError(AL_INVALID_ENUM);
 705                 break;
 706             }
 707         }
 708         else
 709         {
 710             alSetError(AL_INVALID_NAME);
 711         }
 712     }
 713     else
 714     {
 715         alSetError(AL_INVALID_VALUE);
 716     }
 717
 718     ProcessContext(pContext);
 719 }
 720
 721
 722 ALAPI void ALAPIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
 723 {
 724     ALCcontext    *pContext;
 725
 726     pContext = alcGetCurrentContext();
 727     SuspendContext(pContext);
 728
 729     if ((plValue1) && (plValue2) && (plValue3))
 730     {
 731         if (alIsBuffer(buffer) && (buffer != 0))
 732         {
 733             switch(eParam)
 734             {
 735             default:
 736                 alSetError(AL_INVALID_ENUM);
 737                 break;
 738             }
 739         }
 740         else
 741         {
 742             alSetError(AL_INVALID_NAME);
 743         }
 744     }
 745     else
 746     {
 747         alSetError(AL_INVALID_VALUE);
 748     }
 749
 750     ProcessContext(pContext);
 751 }
 752
 753
 754 ALAPI void ALAPIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
 755 {
 756     ALCcontext    *pContext;
 757
 758     pContext = alcGetCurrentContext();
 759     SuspendContext(pContext);
 760
 761     if (plValues)
 762     {
 763         if (alIsBuffer(buffer) && (buffer != 0))
 764         {
 765             switch (eParam)
 766             {
 767             case AL_FREQUENCY:
 768             case AL_BITS:
 769             case AL_CHANNELS:
 770             case AL_SIZE:
 771                 alGetBufferi(buffer, eParam, plValues);
 772                 break;
 773
 774             default:
 775                 alSetError(AL_INVALID_ENUM);
 776                 break;
 777             }
 778         }
 779         else
 780         {
 781             alSetError(AL_INVALID_NAME);
 782         }
 783     }
 784     else
 785     {
 786         alSetError(AL_INVALID_VALUE);
 787     }
 788
 789     ProcessContext(pContext);
 790 }
 791
 792 /*
 793  * LoadData
 794  *
 795  * Loads the specified data into the buffer, using the specified formats.
 796  * Currently, the new format must be 16-bit, and must have the same channel
 797  * configuration as the original format. This does NOT handle compressed
 798  * formats (eg. IMA4).
 799  */
 800 static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
 801 {
 802     ALuint NewChannels = aluChannelsFromFormat(NewFormat);
 803     ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
 804     ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
 805     ALsizei padding = 2;
 806     ALvoid *temp;
 807
 808     assert(aluBytesFromFormat(NewFormat) == 2);
 809     assert(NewChannels == OrigChannels);
 810
 811     if ((size%(OrigBytes*OrigChannels)) != 0)
 812     {
 813         alSetError(AL_INVALID_VALUE);
 814         return;
 815     }
 816
 817     // Samples are converted to 16 bit here
 818     size /= OrigBytes;
 819     temp = realloc(ALBuf->data, (padding*NewChannels + size) * sizeof(ALshort));
 820     if(temp)
 821     {
 822         ALBuf->data = temp;
 823         ConvertData(ALBuf->data, data, OrigBytes, size);
 824
 825         memset(&(ALBuf->data[size]), 0, padding*NewChannels*sizeof(ALshort));
 826
 827         ALBuf->format = NewFormat;
 828         ALBuf->eOriginalFormat = OrigFormat;
 829         ALBuf->size = size*sizeof(ALshort);
 830         ALBuf->frequency = freq;
 831         ALBuf->padding = padding;
 832     }
 833     else
 834         alSetError(AL_OUT_OF_MEMORY);
 835 }
 836
 837 static void ConvertData(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len)
 838 {
 839     ALsizei i;
 840     switch(origBytes)
 841     {
 842         case 1:
 843             for(i = 0;i < len;i++)
 844                 dst[i] = ((ALshort)((ALubyte*)src)[i] - 128) << 8;
 845             break;
 846
 847         case 2:
 848             memcpy(dst, src, len*sizeof(ALshort));
 849             break;
 850
 851         case 4:
 852             for(i = 0;i < len;i++)
 853             {
 854                 ALint smp;
 855                 smp = (((ALfloat*)src)[i] * 32767.5f - 0.5f);
 856                 smp = min(smp,  32767);
 857                 smp = max(smp, -32768);
 858                 dst[i] = (ALshort)smp;
 859             }
 860             break;
 861
 862         default:
 863             assert(0);
 864     }
 865 }
 866
 867 static void ConvertDataRear(ALshort *dst, const ALvoid *src, ALint origBytes, ALsizei len)
 868 {
 869     ALsizei i;
 870     switch(origBytes)
 871     {
 872         case 1:
 873             for(i = 0;i < len;i+=4)
 874             {
 875                 dst[i+0] = 0;
 876                 dst[i+1] = 0;
 877                 dst[i+2] = ((ALshort)((ALubyte*)src)[i/2+0] - 128) << 8;
 878                 dst[i+3] = ((ALshort)((ALubyte*)src)[i/2+1] - 128) << 8;
 879             }
 880             break;
 881
 882         case 2:
 883             for(i = 0;i < len;i+=4)
 884             {
 885                 dst[i+0] = 0;
 886                 dst[i+1] = 0;
 887                 dst[i+2] = ((ALshort*)src)[i/2+0];
 888                 dst[i+3] = ((ALshort*)src)[i/2+1];
 889             }
 890             break;
 891
 892         case 4:
 893             for(i = 0;i < len;i+=4)
 894             {
 895                 ALint smp;
 896                 dst[i+0] = 0;
 897                 dst[i+1] = 0;
 898                 smp = (((ALfloat*)src)[i/2+0] * 32767.5f - 0.5);
 899                 smp = min(smp,  32767);
 900                 smp = max(smp, -32768);
 901                 dst[i+2] = (ALshort)smp;
 902                 smp = (((ALfloat*)src)[i/2+1] * 32767.5f - 0.5);
 903                 smp = min(smp,  32767);
 904                 smp = max(smp, -32768);
 905                 dst[i+3] = (ALshort)smp;
 906             }
 907             break;
 908
 909         default:
 910             assert(0);
 911     }
 912 }
 913
 914 static void ConvertDataIMA4(ALshort *dst, const ALvoid *src, ALint origChans, ALsizei len)
 915 {
 916     const ALuint *IMAData;
 917     ALint Sample[2],Index[2];
 918     ALuint IMACode[2];
 919     ALsizei i,j,k,c;
 920
 921     assert(origChans <= 2);
 922
 923     IMAData = src;
 924     for(i = 0;i < len/origChans;i++)
 925     {
 926         for(c = 0;c < origChans;c++)
 927         {
 928             Sample[c] = ((ALshort*)IMAData)[0];
 929             Index[c] = ((ALshort*)IMAData)[1];
 930
 931             Index[c] = ((Index[c]<0) ? 0 : Index[c]);
 932             Index[c] = ((Index[c]>88) ? 88 : Index[c]);
 933
 934             dst[i*65*origChans + c] = (ALshort)Sample[c];
 935
 936             IMAData++;
 937         }
 938
 939         for(j = 1;j < 65;j += 8)
 940         {
 941             for(c = 0;c < origChans;c++)
 942                 IMACode[c] = *(IMAData++);
 943
 944             for(k = 0;k < 8;k++)
 945             {
 946                 for(c = 0;c < origChans;c++)
 947                 {
 948                     Sample[c] += ((g_IMAStep_size[Index[c]]*g_IMACodeword_4[IMACode[c]&15])/8);
 949                     Index[c] += g_IMAIndex_adjust_4[IMACode[c]&15];
 950
 951                     if(Sample[c] < -32768) Sample[c] = -32768;
 952                     else if(Sample[c] > 32767) Sample[c] = 32767;
 953
 954                     if(Index[c]<0) Index[c] = 0;
 955                     else if(Index[c]>88) Index[c] = 88;
 956
 957                     dst[(i*65+j+k)*origChans + c] = (ALshort)Sample[c];
 958                     IMACode[c] >>= 4;
 959                 }
 960             }
 961         }
 962     }
 963 }
 964
 965 /*
 966 *    ReleaseALBuffers()
 967 *
 968 *    INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
 969 */
 970 ALvoid ReleaseALBuffers(ALvoid)
 971 {
 972     ALbuffer *ALBuffer;
 973     ALbuffer *ALBufferTemp;
 974
 975 #ifdef _DEBUG
 976     if(g_uiBufferCount > 0)
 977         AL_PRINT("exit(): deleting %d Buffer(s)\n", g_uiBufferCount);
 978 #endif
 979
 980     ALBuffer = g_pBuffers;
 981     while(ALBuffer)
 982     {
 983         // Release sample data
 984         free(ALBuffer->data);
 985
 986         // Release Buffer structure
 987         ALBufferTemp = ALBuffer;
 988         ALBuffer = ALBuffer->next;
 989         memset(ALBufferTemp, 0, sizeof(ALbuffer));
 990         free(ALBufferTemp);
 991     }
 992     g_pBuffers = NULL;
 993     g_uiBufferCount = 0;
 994 }