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