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