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