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