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