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