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                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_MONO16);
 279                     break;
 280
 281                 case AL_FORMAT_MONO16:
 282                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_MONO16);
 283                     break;
 284
 285                 case AL_FORMAT_MONO_FLOAT32:
 286                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_MONO16);
 287                     break;
 288
 289                 case AL_FORMAT_STEREO8:
 290                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_STEREO16);
 291                     break;
 292
 293                 case AL_FORMAT_STEREO16:
 294                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_STEREO16);
 295                     break;
 296
 297                 case AL_FORMAT_STEREO_FLOAT32:
 298                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_STEREO16);
 299                     break;
 300
 301                 case AL_FORMAT_MONO_IMA4:
 302                     // Here is where things vary:
 303                     // nVidia and Apple use 64+1 samples per block => block_size=36 bytes
 304                     // Most PC sound software uses 2040+1 samples per block -> block_size=1024 bytes
 305                     if ((size%36) == 0)
 306                     {
 307                         // Allocate 8 extra samples (16 bytes)
 308                         ALBuf->data=realloc(ALBuf->data,16+(size/36)*(65*sizeof(ALshort)));
 309                         if (ALBuf->data)
 310                         {
 311                             ALBuf->format = AL_FORMAT_MONO16;
 312                             ALBuf->eOriginalFormat = AL_FORMAT_MONO_IMA4;
 313                             IMAData=(ALuint *)data;
 314                             for (i=0;i<size/36;i++)
 315                             {
 316                                 Sample=((ALshort *)IMAData)[0];
 317                                 Index=((ALshort *)IMAData)[1];
 318
 319                                 Index=Index<0?0:Index;
 320                                 Index=Index>88?88:Index;
 321
 322                                 ALBuf->data[i*65]=(short)Sample;
 323
 324                                 IMAData++;
 325
 326                                 for (j=1;j<65;j+=8)
 327                                 {
 328                                     IMACode=*IMAData;
 329                                     for (k=0;k<8;k+=2)
 330                                     {
 331                                         Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
 332                                         Index+=g_IMAIndex_adjust_4[IMACode&15];
 333                                         if (Sample<-32768) Sample=-32768;
 334                                         else if (Sample>32767) Sample=32767;
 335                                         if (Index<0) Index=0;
 336                                         else if (Index>88) Index=88;
 337                                         ALBuf->data[i*65+j+k]=(short)Sample;
 338                                         IMACode>>=4;
 339
 340                                         Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
 341                                         Index+=g_IMAIndex_adjust_4[IMACode&15];
 342                                         if (Sample<-32768) Sample=-32768;
 343                                         else if (Sample>32767) Sample=32767;
 344                                         if (Index<0) Index=0;
 345                                         else if (Index>88) Index=88;
 346                                         ALBuf->data[i*65+j+k+1]=(short)Sample;
 347                                         IMACode>>=4;
 348                                     }
 349                                     IMAData++;
 350                                 }
 351                             }
 352                             memset(&(ALBuf->data[(size/36*65)]), 0, 16);
 353                             ALBuf->size=size/36*65*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_STEREO_IMA4:
 364                     // Here is where things vary:
 365                     // nVidia and Apple use 64+1 samples per channel per block => block_size=72 bytes
 366                     // Most PC sound software uses 2040+1 samples per channel per block -> block_size=2048 bytes
 367                     if ((size%72) == 0)
 368                     {
 369                         // Allocate 8 extra samples (32 bytes)
 370                         ALBuf->data=realloc(ALBuf->data,32+(size/72)*(2*65*sizeof(ALshort)));
 371                         if (ALBuf->data)
 372                         {
 373                             ALBuf->format = AL_FORMAT_STEREO16;
 374                             ALBuf->eOriginalFormat = AL_FORMAT_STEREO_IMA4;
 375                             IMAData=(ALuint *)data;
 376                             for (i=0;i<size/72;i++)
 377                             {
 378                                 LeftSample=((ALshort *)IMAData)[0];
 379                                 LeftIndex=((ALshort *)IMAData)[1];
 380
 381                                 LeftIndex=LeftIndex<0?0:LeftIndex;
 382                                 LeftIndex=LeftIndex>88?88:LeftIndex;
 383
 384                                 ALBuf->data[i*2*65]=(short)LeftSample;
 385
 386                                 IMAData++;
 387
 388                                 RightSample=((ALshort *)IMAData)[0];
 389                                 RightIndex=((ALshort *)IMAData)[1];
 390
 391                                 RightIndex=RightIndex<0?0:RightIndex;
 392                                 RightIndex=RightIndex>88?88:RightIndex;
 393
 394                                 ALBuf->data[i*2*65+1]=(short)RightSample;
 395
 396                                 IMAData++;
 397
 398                                 for (j=2;j<130;j+=16)
 399                                 {
 400                                     LeftIMACode=IMAData[0];
 401                                     RightIMACode=IMAData[1];
 402                                     for (k=0;k<16;k+=4)
 403                                     {
 404                                         LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
 405                                         LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
 406                                         if (LeftSample<-32768) LeftSample=-32768;
 407                                         else if (LeftSample>32767) LeftSample=32767;
 408                                         if (LeftIndex<0) LeftIndex=0;
 409                                         else if (LeftIndex>88) LeftIndex=88;
 410                                         ALBuf->data[i*2*65+j+k]=(short)LeftSample;
 411                                         LeftIMACode>>=4;
 412
 413                                         RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
 414                                         RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
 415                                         if (RightSample<-32768) RightSample=-32768;
 416                                         else if (RightSample>32767) RightSample=32767;
 417                                         if (RightIndex<0) RightIndex=0;
 418                                         else if (RightIndex>88) RightIndex=88;
 419                                         ALBuf->data[i*2*65+j+k+1]=(short)RightSample;
 420                                         RightIMACode>>=4;
 421
 422                                         LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
 423                                         LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
 424                                         if (LeftSample<-32768) LeftSample=-32768;
 425                                         else if (LeftSample>32767) LeftSample=32767;
 426                                         if (LeftIndex<0) LeftIndex=0;
 427                                         else if (LeftIndex>88) LeftIndex=88;
 428                                         ALBuf->data[i*2*65+j+k+2]=(short)LeftSample;
 429                                         LeftIMACode>>=4;
 430
 431                                         RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
 432                                         RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
 433                                         if (RightSample<-32768) RightSample=-32768;
 434                                         else if (RightSample>32767) RightSample=32767;
 435                                         if (RightIndex<0) RightIndex=0;
 436                                         else if (RightIndex>88) RightIndex=88;
 437                                         ALBuf->data[i*2*65+j+k+3]=(short)RightSample;
 438                                         RightIMACode>>=4;
 439                                     }
 440                                     IMAData+=2;
 441                                 }
 442                             }
 443                             memset(&(ALBuf->data[(size/72*2*65)]), 0, 32);
 444                             ALBuf->size=size/72*2*65*sizeof(ALshort);
 445                             ALBuf->frequency=freq;
 446                         }
 447                         else
 448                             alSetError(AL_OUT_OF_MEMORY);
 449                     }
 450                     else
 451                         alSetError(AL_INVALID_VALUE);
 452                     break;
 453
 454                 default:
 455                     alSetError(AL_INVALID_ENUM);
 456                     break;
 457             }
 458         }
 459         else
 460         {
 461             // Buffer is in use, or data is a NULL pointer
 462             alSetError(AL_INVALID_VALUE);
 463         }
 464     }
 465     else
 466     {
 467         // Invalid Buffer Name
 468         alSetError(AL_INVALID_NAME);
 469     }
 470
 471     ProcessContext(Context);
 472 }
 473
 474
 475 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
 476 {
 477     ALCcontext    *pContext;
 478
 479     (void)flValue;
 480
 481     pContext = alcGetCurrentContext();
 482     SuspendContext(pContext);
 483
 484     if (alIsBuffer(buffer) && (buffer != 0))
 485     {
 486         switch(eParam)
 487         {
 488         default:
 489             alSetError(AL_INVALID_ENUM);
 490             break;
 491         }
 492     }
 493     else
 494     {
 495         alSetError(AL_INVALID_NAME);
 496     }
 497
 498     ProcessContext(pContext);
 499 }
 500
 501
 502 ALAPI void ALAPIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
 503 {
 504     ALCcontext    *pContext;
 505
 506     (void)flValue1;
 507     (void)flValue2;
 508     (void)flValue3;
 509
 510     pContext = alcGetCurrentContext();
 511     SuspendContext(pContext);
 512
 513     if (alIsBuffer(buffer) && (buffer != 0))
 514     {
 515         switch(eParam)
 516         {
 517         default:
 518             alSetError(AL_INVALID_ENUM);
 519             break;
 520         }
 521     }
 522     else
 523     {
 524         alSetError(AL_INVALID_NAME);
 525     }
 526
 527     ProcessContext(pContext);
 528 }
 529
 530
 531 ALAPI void ALAPIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
 532 {
 533     ALCcontext    *pContext;
 534
 535     (void)flValues;
 536
 537     pContext = alcGetCurrentContext();
 538     SuspendContext(pContext);
 539
 540     if (alIsBuffer(buffer) && (buffer != 0))
 541     {
 542         switch(eParam)
 543         {
 544         default:
 545             alSetError(AL_INVALID_ENUM);
 546             break;
 547         }
 548     }
 549     else
 550     {
 551         alSetError(AL_INVALID_NAME);
 552     }
 553
 554     ProcessContext(pContext);
 555 }
 556
 557
 558 ALAPI void ALAPIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
 559 {
 560     ALCcontext    *pContext;
 561
 562     (void)lValue;
 563
 564     pContext = alcGetCurrentContext();
 565     SuspendContext(pContext);
 566
 567     if (alIsBuffer(buffer) && (buffer != 0))
 568     {
 569         switch(eParam)
 570         {
 571         default:
 572             alSetError(AL_INVALID_ENUM);
 573             break;
 574         }
 575     }
 576     else
 577     {
 578         alSetError(AL_INVALID_NAME);
 579     }
 580
 581     ProcessContext(pContext);
 582 }
 583
 584
 585 ALAPI void ALAPIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 586 {
 587     ALCcontext    *pContext;
 588
 589     (void)lValue1;
 590     (void)lValue2;
 591     (void)lValue3;
 592
 593     pContext = alcGetCurrentContext();
 594     SuspendContext(pContext);
 595
 596     if (alIsBuffer(buffer) && (buffer != 0))
 597     {
 598         switch(eParam)
 599         {
 600         default:
 601             alSetError(AL_INVALID_ENUM);
 602             break;
 603         }
 604     }
 605     else
 606     {
 607         alSetError(AL_INVALID_NAME);
 608     }
 609
 610     ProcessContext(pContext);
 611 }
 612
 613
 614 ALAPI void ALAPIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
 615 {
 616     ALCcontext    *pContext;
 617
 618     (void)plValues;
 619
 620     pContext = alcGetCurrentContext();
 621     SuspendContext(pContext);
 622
 623     if (alIsBuffer(buffer) && (buffer != 0))
 624     {
 625         switch(eParam)
 626         {
 627         default:
 628             alSetError(AL_INVALID_ENUM);
 629             break;
 630         }
 631     }
 632     else
 633     {
 634         alSetError(AL_INVALID_NAME);
 635     }
 636
 637     ProcessContext(pContext);
 638 }
 639
 640
 641 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
 642 {
 643     ALCcontext    *pContext;
 644
 645     pContext = alcGetCurrentContext();
 646     SuspendContext(pContext);
 647
 648     if (pflValue)
 649     {
 650         if (alIsBuffer(buffer) && (buffer != 0))
 651         {
 652             switch(eParam)
 653             {
 654             default:
 655                 alSetError(AL_INVALID_ENUM);
 656                 break;
 657             }
 658         }
 659         else
 660         {
 661             alSetError(AL_INVALID_NAME);
 662         }
 663     }
 664     else
 665     {
 666         alSetError(AL_INVALID_VALUE);
 667     }
 668
 669     ProcessContext(pContext);
 670 }
 671
 672
 673 ALAPI void ALAPIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 674 {
 675     ALCcontext    *pContext;
 676
 677     pContext = alcGetCurrentContext();
 678     SuspendContext(pContext);
 679
 680     if ((pflValue1) && (pflValue2) && (pflValue3))
 681     {
 682         if (alIsBuffer(buffer) && (buffer != 0))
 683         {
 684             switch(eParam)
 685             {
 686             default:
 687                 alSetError(AL_INVALID_ENUM);
 688                 break;
 689             }
 690         }
 691         else
 692         {
 693             alSetError(AL_INVALID_NAME);
 694         }
 695     }
 696     else
 697     {
 698         alSetError(AL_INVALID_VALUE);
 699     }
 700
 701     ProcessContext(pContext);
 702 }
 703
 704
 705 ALAPI void ALAPIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
 706 {
 707     ALCcontext    *pContext;
 708
 709     pContext = alcGetCurrentContext();
 710     SuspendContext(pContext);
 711
 712     if (pflValues)
 713     {
 714         if (alIsBuffer(buffer) && (buffer != 0))
 715         {
 716             switch(eParam)
 717             {
 718             default:
 719                 alSetError(AL_INVALID_ENUM);
 720                 break;
 721             }
 722         }
 723         else
 724         {
 725             alSetError(AL_INVALID_NAME);
 726         }
 727     }
 728     else
 729     {
 730         alSetError(AL_INVALID_VALUE);
 731     }
 732
 733     ProcessContext(pContext);
 734 }
 735
 736
 737 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
 738 {
 739     ALCcontext    *pContext;
 740     ALbuffer    *pBuffer;
 741
 742     pContext = alcGetCurrentContext();
 743     SuspendContext(pContext);
 744
 745     if (plValue)
 746     {
 747         if (alIsBuffer(buffer) && (buffer != 0))
 748         {
 749             pBuffer = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(buffer));
 750
 751             switch (eParam)
 752             {
 753             case AL_FREQUENCY:
 754                 *plValue = pBuffer->frequency;
 755                 break;
 756
 757             case AL_BITS:
 758                 *plValue = aluBytesFromFormat(pBuffer->format) * 8;
 759                 break;
 760
 761             case AL_CHANNELS:
 762                 *plValue = aluChannelsFromFormat(pBuffer->format);
 763                 break;
 764
 765             case AL_SIZE:
 766                 *plValue = pBuffer->size;
 767                 break;
 768
 769             default:
 770                 alSetError(AL_INVALID_ENUM);
 771                 break;
 772             }
 773         }
 774         else
 775         {
 776             alSetError(AL_INVALID_NAME);
 777         }
 778     }
 779     else
 780     {
 781         alSetError(AL_INVALID_VALUE);
 782     }
 783
 784     ProcessContext(pContext);
 785 }
 786
 787
 788 ALAPI void ALAPIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
 789 {
 790     ALCcontext    *pContext;
 791
 792     pContext = alcGetCurrentContext();
 793     SuspendContext(pContext);
 794
 795     if ((plValue1) && (plValue2) && (plValue3))
 796     {
 797         if (alIsBuffer(buffer) && (buffer != 0))
 798         {
 799             switch(eParam)
 800             {
 801             default:
 802                 alSetError(AL_INVALID_ENUM);
 803                 break;
 804             }
 805         }
 806         else
 807         {
 808             alSetError(AL_INVALID_NAME);
 809         }
 810     }
 811     else
 812     {
 813         alSetError(AL_INVALID_VALUE);
 814     }
 815
 816     ProcessContext(pContext);
 817 }
 818
 819
 820 ALAPI void ALAPIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
 821 {
 822     ALCcontext    *pContext;
 823
 824     pContext = alcGetCurrentContext();
 825     SuspendContext(pContext);
 826
 827     if (plValues)
 828     {
 829         if (alIsBuffer(buffer) && (buffer != 0))
 830         {
 831             switch (eParam)
 832             {
 833             case AL_FREQUENCY:
 834             case AL_BITS:
 835             case AL_CHANNELS:
 836             case AL_SIZE:
 837                 alGetBufferi(buffer, eParam, plValues);
 838                 break;
 839
 840             default:
 841                 alSetError(AL_INVALID_ENUM);
 842                 break;
 843             }
 844         }
 845         else
 846         {
 847             alSetError(AL_INVALID_NAME);
 848         }
 849     }
 850     else
 851     {
 852         alSetError(AL_INVALID_VALUE);
 853     }
 854
 855     ProcessContext(pContext);
 856 }
 857
 858 /*
 859  * LoadData
 860  *
 861  * Loads the specified data into the buffer, using the specified formats.
 862  * Currently, the new format must be 16-bit, and must have the same channel
 863  * configuration as the original format. This does NOT handle compressed
 864  * formats (eg. IMA4).
 865  */
 866 static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
 867 {
 868     ALuint NewChannels = aluChannelsFromFormat(NewFormat);
 869     ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
 870     ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
 871     ALsizei i;
 872
 873     assert(aluBytesFromFormat(NewFormat) == 2);
 874     assert(NewChannels == OrigChannels);
 875
 876     if ((size%(OrigBytes*OrigChannels)) != 0)
 877     {
 878         alSetError(AL_INVALID_VALUE);
 879         return;
 880     }
 881
 882     switch(OrigBytes)
 883     {
 884     case 1:
 885         size /= sizeof(ALubyte);
 886
 887         // 8bit Samples are converted to 16 bit here
 888         // Allocate 8 extra samples
 889         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
 890         if (ALBuf->data)
 891         {
 892             for (i = 0;i < size;i++)
 893                 ALBuf->data[i] = (ALshort)((data[i]-128) << 8);
 894             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
 895
 896             ALBuf->format = NewFormat;
 897             ALBuf->eOriginalFormat = OrigFormat;
 898             ALBuf->size = size*1*sizeof(ALshort);
 899             ALBuf->frequency = freq;
 900         }
 901         else
 902             alSetError(AL_OUT_OF_MEMORY);
 903         break;
 904
 905     case 2:
 906         size /= sizeof(ALshort);
 907
 908         // Allocate 8 extra samples
 909         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
 910         if (ALBuf->data)
 911         {
 912             memcpy(ALBuf->data, data, size*1*sizeof(ALshort));
 913             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
 914
 915             ALBuf->format = NewFormat;
 916             ALBuf->eOriginalFormat = OrigFormat;
 917             ALBuf->size = size*1*sizeof(ALshort);
 918             ALBuf->frequency = freq;
 919         }
 920         else
 921             alSetError(AL_OUT_OF_MEMORY);
 922         break;
 923
 924     case 4:
 925         size /= sizeof(ALfloat);
 926
 927         // Allocate 8 extra samples
 928         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
 929         if (ALBuf->data)
 930         {
 931             for (i = 0;i < size;i++)
 932                 ALBuf->data[i] = (ALshort)(((ALfloat*)data)[i] * 32767.5f - 0.5);
 933             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
 934
 935             ALBuf->format = NewFormat;
 936             ALBuf->eOriginalFormat = OrigFormat;
 937             ALBuf->size = size*1*sizeof(ALshort);
 938             ALBuf->frequency = freq;
 939         }
 940         else
 941             alSetError(AL_OUT_OF_MEMORY);
 942         break;
 943
 944     default:
 945         assert(0);
 946     }
 947 }
 948
 949
 950 /*
 951 *    ReleaseALBuffers()
 952 *
 953 *    INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
 954 */
 955 ALvoid ReleaseALBuffers(ALvoid)
 956 {
 957     ALbuffer *ALBuffer;
 958     ALbuffer *ALBufferTemp;
 959
 960 #ifdef _DEBUG
 961     if(g_uiBufferCount > 0)
 962         AL_PRINT("exit() %d Buffer(s) NOT deleted\n", g_uiBufferCount);
 963 #endif
 964
 965     ALBuffer = g_pBuffers;
 966     while(ALBuffer)
 967     {
 968         // Release sample data
 969         free(ALBuffer->data);
 970
 971         // Release Buffer structure
 972         ALBufferTemp = ALBuffer;
 973         ALBuffer = ALBuffer->next;
 974         memset(ALBufferTemp, 0, sizeof(ALbuffer));
 975         free(ALBufferTemp);
 976     }
 977     g_pBuffers = NULL;
 978     g_uiBufferCount = 0;
 979 }