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