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