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