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                     alDeleteBuffers(i, puiBuffers);
 101                     alSetError(AL_OUT_OF_MEMORY);
 102                     break;
 103                 }
 104
 105                 puiBuffers[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
 106                 (*list)->state = UNUSED;
 107                 g_uiBufferCount++;
 108                 i++;
 109
 110                 list = &(*list)->next;
 111             }
 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_LOKI:
 396                 case AL_FORMAT_QUAD16_LOKI:
 397                 case AL_FORMAT_QUAD8:
 398                 case AL_FORMAT_QUAD16:
 399                 case AL_FORMAT_QUAD32:
 400                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_QUAD16);
 401                     break;
 402
 403                 case AL_FORMAT_51CHN8:
 404                 case AL_FORMAT_51CHN16:
 405                 case AL_FORMAT_51CHN32:
 406                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_51CHN16);
 407                     break;
 408
 409                 case AL_FORMAT_61CHN8:
 410                 case AL_FORMAT_61CHN16:
 411                 case AL_FORMAT_61CHN32:
 412                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_61CHN16);
 413                     break;
 414
 415                 case AL_FORMAT_71CHN8:
 416                 case AL_FORMAT_71CHN16:
 417                 case AL_FORMAT_71CHN32:
 418                     LoadData(ALBuf, data, size, freq, format, AL_FORMAT_71CHN16);
 419                     break;
 420
 421                 case AL_FORMAT_MONO_IMA4:
 422                     // Here is where things vary:
 423                     // nVidia and Apple use 64+1 samples per block => block_size=36 bytes
 424                     // Most PC sound software uses 2040+1 samples per block -> block_size=1024 bytes
 425                     if ((size%36) == 0)
 426                     {
 427                         // Allocate 8 extra samples (16 bytes)
 428                         ALBuf->data=realloc(ALBuf->data,16+(size/36)*(65*sizeof(ALshort)));
 429                         if (ALBuf->data)
 430                         {
 431                             ALBuf->format = AL_FORMAT_MONO16;
 432                             ALBuf->eOriginalFormat = AL_FORMAT_MONO_IMA4;
 433                             IMAData=(ALuint *)data;
 434                             for (i=0;i<size/36;i++)
 435                             {
 436                                 Sample=((ALshort *)IMAData)[0];
 437                                 Index=((ALshort *)IMAData)[1];
 438
 439                                 Index=Index<0?0:Index;
 440                                 Index=Index>88?88:Index;
 441
 442                                 ALBuf->data[i*65]=(short)Sample;
 443
 444                                 IMAData++;
 445
 446                                 for (j=1;j<65;j+=8)
 447                                 {
 448                                     IMACode=*IMAData;
 449                                     for (k=0;k<8;k+=2)
 450                                     {
 451                                         Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
 452                                         Index+=g_IMAIndex_adjust_4[IMACode&15];
 453                                         if (Sample<-32768) Sample=-32768;
 454                                         else if (Sample>32767) Sample=32767;
 455                                         if (Index<0) Index=0;
 456                                         else if (Index>88) Index=88;
 457                                         ALBuf->data[i*65+j+k]=(short)Sample;
 458                                         IMACode>>=4;
 459
 460                                         Sample+=((g_IMAStep_size[Index]*g_IMACodeword_4[IMACode&15])/8);
 461                                         Index+=g_IMAIndex_adjust_4[IMACode&15];
 462                                         if (Sample<-32768) Sample=-32768;
 463                                         else if (Sample>32767) Sample=32767;
 464                                         if (Index<0) Index=0;
 465                                         else if (Index>88) Index=88;
 466                                         ALBuf->data[i*65+j+k+1]=(short)Sample;
 467                                         IMACode>>=4;
 468                                     }
 469                                     IMAData++;
 470                                 }
 471                             }
 472                             memset(&(ALBuf->data[(size/36*65)]), 0, 16);
 473                             ALBuf->size=size/36*65*sizeof(ALshort);
 474                             ALBuf->frequency=freq;
 475                         }
 476                         else
 477                             alSetError(AL_OUT_OF_MEMORY);
 478                     }
 479                     else
 480                          alSetError(AL_INVALID_VALUE);
 481                     break;
 482
 483                 case AL_FORMAT_STEREO_IMA4:
 484                     // Here is where things vary:
 485                     // nVidia and Apple use 64+1 samples per channel per block => block_size=72 bytes
 486                     // Most PC sound software uses 2040+1 samples per channel per block -> block_size=2048 bytes
 487                     if ((size%72) == 0)
 488                     {
 489                         // Allocate 8 extra samples (32 bytes)
 490                         ALBuf->data=realloc(ALBuf->data,32+(size/72)*(2*65*sizeof(ALshort)));
 491                         if (ALBuf->data)
 492                         {
 493                             ALBuf->format = AL_FORMAT_STEREO16;
 494                             ALBuf->eOriginalFormat = AL_FORMAT_STEREO_IMA4;
 495                             IMAData=(ALuint *)data;
 496                             for (i=0;i<size/72;i++)
 497                             {
 498                                 LeftSample=((ALshort *)IMAData)[0];
 499                                 LeftIndex=((ALshort *)IMAData)[1];
 500
 501                                 LeftIndex=LeftIndex<0?0:LeftIndex;
 502                                 LeftIndex=LeftIndex>88?88:LeftIndex;
 503
 504                                 ALBuf->data[i*2*65]=(short)LeftSample;
 505
 506                                 IMAData++;
 507
 508                                 RightSample=((ALshort *)IMAData)[0];
 509                                 RightIndex=((ALshort *)IMAData)[1];
 510
 511                                 RightIndex=RightIndex<0?0:RightIndex;
 512                                 RightIndex=RightIndex>88?88:RightIndex;
 513
 514                                 ALBuf->data[i*2*65+1]=(short)RightSample;
 515
 516                                 IMAData++;
 517
 518                                 for (j=2;j<130;j+=16)
 519                                 {
 520                                     LeftIMACode=IMAData[0];
 521                                     RightIMACode=IMAData[1];
 522                                     for (k=0;k<16;k+=4)
 523                                     {
 524                                         LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
 525                                         LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
 526                                         if (LeftSample<-32768) LeftSample=-32768;
 527                                         else if (LeftSample>32767) LeftSample=32767;
 528                                         if (LeftIndex<0) LeftIndex=0;
 529                                         else if (LeftIndex>88) LeftIndex=88;
 530                                         ALBuf->data[i*2*65+j+k]=(short)LeftSample;
 531                                         LeftIMACode>>=4;
 532
 533                                         RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
 534                                         RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
 535                                         if (RightSample<-32768) RightSample=-32768;
 536                                         else if (RightSample>32767) RightSample=32767;
 537                                         if (RightIndex<0) RightIndex=0;
 538                                         else if (RightIndex>88) RightIndex=88;
 539                                         ALBuf->data[i*2*65+j+k+1]=(short)RightSample;
 540                                         RightIMACode>>=4;
 541
 542                                         LeftSample+=((g_IMAStep_size[LeftIndex]*g_IMACodeword_4[LeftIMACode&15])/8);
 543                                         LeftIndex+=g_IMAIndex_adjust_4[LeftIMACode&15];
 544                                         if (LeftSample<-32768) LeftSample=-32768;
 545                                         else if (LeftSample>32767) LeftSample=32767;
 546                                         if (LeftIndex<0) LeftIndex=0;
 547                                         else if (LeftIndex>88) LeftIndex=88;
 548                                         ALBuf->data[i*2*65+j+k+2]=(short)LeftSample;
 549                                         LeftIMACode>>=4;
 550
 551                                         RightSample+=((g_IMAStep_size[RightIndex]*g_IMACodeword_4[RightIMACode&15])/8);
 552                                         RightIndex+=g_IMAIndex_adjust_4[RightIMACode&15];
 553                                         if (RightSample<-32768) RightSample=-32768;
 554                                         else if (RightSample>32767) RightSample=32767;
 555                                         if (RightIndex<0) RightIndex=0;
 556                                         else if (RightIndex>88) RightIndex=88;
 557                                         ALBuf->data[i*2*65+j+k+3]=(short)RightSample;
 558                                         RightIMACode>>=4;
 559                                     }
 560                                     IMAData+=2;
 561                                 }
 562                             }
 563                             memset(&(ALBuf->data[(size/72*2*65)]), 0, 32);
 564                             ALBuf->size=size/72*2*65*sizeof(ALshort);
 565                             ALBuf->frequency=freq;
 566                         }
 567                         else
 568                             alSetError(AL_OUT_OF_MEMORY);
 569                     }
 570                     else
 571                         alSetError(AL_INVALID_VALUE);
 572                     break;
 573
 574                 default:
 575                     alSetError(AL_INVALID_ENUM);
 576                     break;
 577             }
 578         }
 579         else
 580         {
 581             // Buffer is in use, or data is a NULL pointer
 582             alSetError(AL_INVALID_VALUE);
 583         }
 584     }
 585     else
 586     {
 587         // Invalid Buffer Name
 588         alSetError(AL_INVALID_NAME);
 589     }
 590
 591     ProcessContext(Context);
 592 }
 593
 594
 595 ALAPI void ALAPIENTRY alBufferf(ALuint buffer, ALenum eParam, ALfloat flValue)
 596 {
 597     ALCcontext    *pContext;
 598
 599     (void)flValue;
 600
 601     pContext = alcGetCurrentContext();
 602     SuspendContext(pContext);
 603
 604     if (alIsBuffer(buffer) && (buffer != 0))
 605     {
 606         switch(eParam)
 607         {
 608         default:
 609             alSetError(AL_INVALID_ENUM);
 610             break;
 611         }
 612     }
 613     else
 614     {
 615         alSetError(AL_INVALID_NAME);
 616     }
 617
 618     ProcessContext(pContext);
 619 }
 620
 621
 622 ALAPI void ALAPIENTRY alBuffer3f(ALuint buffer, ALenum eParam, ALfloat flValue1, ALfloat flValue2, ALfloat flValue3)
 623 {
 624     ALCcontext    *pContext;
 625
 626     (void)flValue1;
 627     (void)flValue2;
 628     (void)flValue3;
 629
 630     pContext = alcGetCurrentContext();
 631     SuspendContext(pContext);
 632
 633     if (alIsBuffer(buffer) && (buffer != 0))
 634     {
 635         switch(eParam)
 636         {
 637         default:
 638             alSetError(AL_INVALID_ENUM);
 639             break;
 640         }
 641     }
 642     else
 643     {
 644         alSetError(AL_INVALID_NAME);
 645     }
 646
 647     ProcessContext(pContext);
 648 }
 649
 650
 651 ALAPI void ALAPIENTRY alBufferfv(ALuint buffer, ALenum eParam, const ALfloat* flValues)
 652 {
 653     ALCcontext    *pContext;
 654
 655     (void)flValues;
 656
 657     pContext = alcGetCurrentContext();
 658     SuspendContext(pContext);
 659
 660     if (alIsBuffer(buffer) && (buffer != 0))
 661     {
 662         switch(eParam)
 663         {
 664         default:
 665             alSetError(AL_INVALID_ENUM);
 666             break;
 667         }
 668     }
 669     else
 670     {
 671         alSetError(AL_INVALID_NAME);
 672     }
 673
 674     ProcessContext(pContext);
 675 }
 676
 677
 678 ALAPI void ALAPIENTRY alBufferi(ALuint buffer, ALenum eParam, ALint lValue)
 679 {
 680     ALCcontext    *pContext;
 681
 682     (void)lValue;
 683
 684     pContext = alcGetCurrentContext();
 685     SuspendContext(pContext);
 686
 687     if (alIsBuffer(buffer) && (buffer != 0))
 688     {
 689         switch(eParam)
 690         {
 691         default:
 692             alSetError(AL_INVALID_ENUM);
 693             break;
 694         }
 695     }
 696     else
 697     {
 698         alSetError(AL_INVALID_NAME);
 699     }
 700
 701     ProcessContext(pContext);
 702 }
 703
 704
 705 ALAPI void ALAPIENTRY alBuffer3i( ALuint buffer, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 706 {
 707     ALCcontext    *pContext;
 708
 709     (void)lValue1;
 710     (void)lValue2;
 711     (void)lValue3;
 712
 713     pContext = alcGetCurrentContext();
 714     SuspendContext(pContext);
 715
 716     if (alIsBuffer(buffer) && (buffer != 0))
 717     {
 718         switch(eParam)
 719         {
 720         default:
 721             alSetError(AL_INVALID_ENUM);
 722             break;
 723         }
 724     }
 725     else
 726     {
 727         alSetError(AL_INVALID_NAME);
 728     }
 729
 730     ProcessContext(pContext);
 731 }
 732
 733
 734 ALAPI void ALAPIENTRY alBufferiv(ALuint buffer, ALenum eParam, const ALint* plValues)
 735 {
 736     ALCcontext    *pContext;
 737
 738     (void)plValues;
 739
 740     pContext = alcGetCurrentContext();
 741     SuspendContext(pContext);
 742
 743     if (alIsBuffer(buffer) && (buffer != 0))
 744     {
 745         switch(eParam)
 746         {
 747         default:
 748             alSetError(AL_INVALID_ENUM);
 749             break;
 750         }
 751     }
 752     else
 753     {
 754         alSetError(AL_INVALID_NAME);
 755     }
 756
 757     ProcessContext(pContext);
 758 }
 759
 760
 761 ALAPI ALvoid ALAPIENTRY alGetBufferf(ALuint buffer, ALenum eParam, ALfloat *pflValue)
 762 {
 763     ALCcontext    *pContext;
 764
 765     pContext = alcGetCurrentContext();
 766     SuspendContext(pContext);
 767
 768     if (pflValue)
 769     {
 770         if (alIsBuffer(buffer) && (buffer != 0))
 771         {
 772             switch(eParam)
 773             {
 774             default:
 775                 alSetError(AL_INVALID_ENUM);
 776                 break;
 777             }
 778         }
 779         else
 780         {
 781             alSetError(AL_INVALID_NAME);
 782         }
 783     }
 784     else
 785     {
 786         alSetError(AL_INVALID_VALUE);
 787     }
 788
 789     ProcessContext(pContext);
 790 }
 791
 792
 793 ALAPI void ALAPIENTRY alGetBuffer3f(ALuint buffer, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 794 {
 795     ALCcontext    *pContext;
 796
 797     pContext = alcGetCurrentContext();
 798     SuspendContext(pContext);
 799
 800     if ((pflValue1) && (pflValue2) && (pflValue3))
 801     {
 802         if (alIsBuffer(buffer) && (buffer != 0))
 803         {
 804             switch(eParam)
 805             {
 806             default:
 807                 alSetError(AL_INVALID_ENUM);
 808                 break;
 809             }
 810         }
 811         else
 812         {
 813             alSetError(AL_INVALID_NAME);
 814         }
 815     }
 816     else
 817     {
 818         alSetError(AL_INVALID_VALUE);
 819     }
 820
 821     ProcessContext(pContext);
 822 }
 823
 824
 825 ALAPI void ALAPIENTRY alGetBufferfv(ALuint buffer, ALenum eParam, ALfloat* pflValues)
 826 {
 827     ALCcontext    *pContext;
 828
 829     pContext = alcGetCurrentContext();
 830     SuspendContext(pContext);
 831
 832     if (pflValues)
 833     {
 834         if (alIsBuffer(buffer) && (buffer != 0))
 835         {
 836             switch(eParam)
 837             {
 838             default:
 839                 alSetError(AL_INVALID_ENUM);
 840                 break;
 841             }
 842         }
 843         else
 844         {
 845             alSetError(AL_INVALID_NAME);
 846         }
 847     }
 848     else
 849     {
 850         alSetError(AL_INVALID_VALUE);
 851     }
 852
 853     ProcessContext(pContext);
 854 }
 855
 856
 857 ALAPI ALvoid ALAPIENTRY alGetBufferi(ALuint buffer, ALenum eParam, ALint *plValue)
 858 {
 859     ALCcontext    *pContext;
 860     ALbuffer    *pBuffer;
 861
 862     pContext = alcGetCurrentContext();
 863     SuspendContext(pContext);
 864
 865     if (plValue)
 866     {
 867         if (alIsBuffer(buffer) && (buffer != 0))
 868         {
 869             pBuffer = ((ALbuffer *)ALTHUNK_LOOKUPENTRY(buffer));
 870
 871             switch (eParam)
 872             {
 873             case AL_FREQUENCY:
 874                 *plValue = pBuffer->frequency;
 875                 break;
 876
 877             case AL_BITS:
 878                 *plValue = aluBytesFromFormat(pBuffer->format) * 8;
 879                 break;
 880
 881             case AL_CHANNELS:
 882                 *plValue = aluChannelsFromFormat(pBuffer->format);
 883                 break;
 884
 885             case AL_SIZE:
 886                 *plValue = pBuffer->size;
 887                 break;
 888
 889             default:
 890                 alSetError(AL_INVALID_ENUM);
 891                 break;
 892             }
 893         }
 894         else
 895         {
 896             alSetError(AL_INVALID_NAME);
 897         }
 898     }
 899     else
 900     {
 901         alSetError(AL_INVALID_VALUE);
 902     }
 903
 904     ProcessContext(pContext);
 905 }
 906
 907
 908 ALAPI void ALAPIENTRY alGetBuffer3i(ALuint buffer, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
 909 {
 910     ALCcontext    *pContext;
 911
 912     pContext = alcGetCurrentContext();
 913     SuspendContext(pContext);
 914
 915     if ((plValue1) && (plValue2) && (plValue3))
 916     {
 917         if (alIsBuffer(buffer) && (buffer != 0))
 918         {
 919             switch(eParam)
 920             {
 921             default:
 922                 alSetError(AL_INVALID_ENUM);
 923                 break;
 924             }
 925         }
 926         else
 927         {
 928             alSetError(AL_INVALID_NAME);
 929         }
 930     }
 931     else
 932     {
 933         alSetError(AL_INVALID_VALUE);
 934     }
 935
 936     ProcessContext(pContext);
 937 }
 938
 939
 940 ALAPI void ALAPIENTRY alGetBufferiv(ALuint buffer, ALenum eParam, ALint* plValues)
 941 {
 942     ALCcontext    *pContext;
 943
 944     pContext = alcGetCurrentContext();
 945     SuspendContext(pContext);
 946
 947     if (plValues)
 948     {
 949         if (alIsBuffer(buffer) && (buffer != 0))
 950         {
 951             switch (eParam)
 952             {
 953             case AL_FREQUENCY:
 954             case AL_BITS:
 955             case AL_CHANNELS:
 956             case AL_SIZE:
 957                 alGetBufferi(buffer, eParam, plValues);
 958                 break;
 959
 960             default:
 961                 alSetError(AL_INVALID_ENUM);
 962                 break;
 963             }
 964         }
 965         else
 966         {
 967             alSetError(AL_INVALID_NAME);
 968         }
 969     }
 970     else
 971     {
 972         alSetError(AL_INVALID_VALUE);
 973     }
 974
 975     ProcessContext(pContext);
 976 }
 977
 978 /*
 979  * LoadData
 980  *
 981  * Loads the specified data into the buffer, using the specified formats.
 982  * Currently, the new format must be 16-bit, and must have the same channel
 983  * configuration as the original format. This does NOT handle compressed
 984  * formats (eg. IMA4).
 985  */
 986 static void LoadData(ALbuffer *ALBuf, const ALubyte *data, ALsizei size, ALuint freq, ALenum OrigFormat, ALenum NewFormat)
 987 {
 988     ALuint NewChannels = aluChannelsFromFormat(NewFormat);
 989     ALuint OrigBytes = aluBytesFromFormat(OrigFormat);
 990     ALuint OrigChannels = aluChannelsFromFormat(OrigFormat);
 991     ALsizei i;
 992
 993     assert(aluBytesFromFormat(NewFormat) == 2);
 994     assert(NewChannels == OrigChannels);
 995
 996     if ((size%(OrigBytes*OrigChannels)) != 0)
 997     {
 998         alSetError(AL_INVALID_VALUE);
 999         return;
1000     }
1001
1002     switch(OrigBytes)
1003     {
1004     case 1:
1005         size /= sizeof(ALubyte);
1006
1007         // 8bit Samples are converted to 16 bit here
1008         // Allocate 8 extra samples
1009         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
1010         if (ALBuf->data)
1011         {
1012             for (i = 0;i < size;i++)
1013                 ALBuf->data[i] = (ALshort)((data[i]-128) << 8);
1014             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
1015
1016             ALBuf->format = NewFormat;
1017             ALBuf->eOriginalFormat = OrigFormat;
1018             ALBuf->size = size*1*sizeof(ALshort);
1019             ALBuf->frequency = freq;
1020         }
1021         else
1022             alSetError(AL_OUT_OF_MEMORY);
1023         break;
1024
1025     case 2:
1026         size /= sizeof(ALshort);
1027
1028         // Allocate 8 extra samples
1029         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
1030         if (ALBuf->data)
1031         {
1032             memcpy(ALBuf->data, data, size*1*sizeof(ALshort));
1033             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
1034
1035             ALBuf->format = NewFormat;
1036             ALBuf->eOriginalFormat = OrigFormat;
1037             ALBuf->size = size*1*sizeof(ALshort);
1038             ALBuf->frequency = freq;
1039         }
1040         else
1041             alSetError(AL_OUT_OF_MEMORY);
1042         break;
1043
1044     case 4:
1045         size /= sizeof(ALfloat);
1046
1047         // Allocate 8 extra samples
1048         ALBuf->data = realloc(ALBuf->data, (8*NewChannels + size) * (1*sizeof(ALshort)));
1049         if (ALBuf->data)
1050         {
1051             for (i = 0;i < size;i++)
1052                 ALBuf->data[i] = (ALshort)(((ALfloat*)data)[i] * 32767.5f - 0.5);
1053             memset(&(ALBuf->data[size]), 0, 16*NewChannels);
1054
1055             ALBuf->format = NewFormat;
1056             ALBuf->eOriginalFormat = OrigFormat;
1057             ALBuf->size = size*1*sizeof(ALshort);
1058             ALBuf->frequency = freq;
1059         }
1060         else
1061             alSetError(AL_OUT_OF_MEMORY);
1062         break;
1063
1064     default:
1065         assert(0);
1066     }
1067 }
1068
1069
1070 /*
1071 *    ReleaseALBuffers()
1072 *
1073 *    INTERNAL FN : Called by DLLMain on exit to destroy any buffers that still exist
1074 */
1075 ALvoid ReleaseALBuffers(ALvoid)
1076 {
1077     ALbuffer *ALBuffer;
1078     ALbuffer *ALBufferTemp;
1079
1080 #ifdef _DEBUG
1081     if(g_uiBufferCount > 0)
1082         AL_PRINT("exit() %d Buffer(s) NOT deleted\n", g_uiBufferCount);
1083 #endif
1084
1085     ALBuffer = g_pBuffers;
1086     while(ALBuffer)
1087     {
1088         // Release sample data
1089         free(ALBuffer->data);
1090
1091         // Release Buffer structure
1092         ALBufferTemp = ALBuffer;
1093         ALBuffer = ALBuffer->next;
1094         memset(ALBufferTemp, 0, sizeof(ALbuffer));
1095         free(ALBufferTemp);
1096     }
1097     g_pBuffers = NULL;
1098     g_uiBufferCount = 0;
1099 }