OpenAL32/alSource.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 <math.h>
  25 #include <float.h>
  26 #include "alMain.h"
  27 #include "AL/al.h"
  28 #include "AL/alc.h"
  29 #include "alError.h"
  30 #include "alSource.h"
  31 #include "alBuffer.h"
  32 #include "alThunk.h"
  33 #include "alAuxEffectSlot.h"
  34
  35 static ALvoid InitSourceParams(ALCcontext *Context, ALsource *pSource);
  36 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset, ALuint updateSize);
  37 static ALvoid ApplyOffset(ALsource *pSource, ALboolean bUpdateContext);
  38 static ALint GetByteOffset(ALsource *pSource);
  39
  40 ALAPI ALvoid ALAPIENTRY alGenSources(ALsizei n,ALuint *sources)
  41 {
  42     ALCcontext *Context;
  43     ALCdevice *Device;
  44     ALsizei i=0;
  45
  46     Context = alcGetCurrentContext();
  47     if (Context)
  48     {
  49         SuspendContext(Context);
  50
  51         if (n > 0)
  52         {
  53             Device = alcGetContextsDevice(Context);
  54
  55             if (Device)
  56             {
  57                 // Check that enough memory has been allocted in the 'sources' array for n Sources
  58                 if (!IsBadWritePtr((void*)sources, n * sizeof(ALuint)))
  59                 {
  60                     // Check that the requested number of sources can be generated
  61                     if ((Context->SourceCount + n) <= Device->MaxNoOfSources)
  62                     {
  63                         ALsource **list = &Context->Source;
  64                         while(*list)
  65                             list = &(*list)->next;
  66
  67                         // Add additional sources to the list (Source->next points to the location for the next Source structure)
  68                         while(i < n)
  69                         {
  70                             *list = calloc(1, sizeof(ALsource));
  71                             if(!(*list))
  72                             {
  73                                 alDeleteSources(i, sources);
  74                                 alSetError(AL_OUT_OF_MEMORY);
  75                                 break;
  76                             }
  77
  78                             sources[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  79                             (*list)->source = sources[i];
  80
  81                             InitSourceParams(Context, *list);
  82                             Context->SourceCount++;
  83                             i++;
  84
  85                             list = &(*list)->next;
  86                         }
  87                     }
  88                     else
  89                     {
  90                         // Not enough resources to create the Sources
  91                         alSetError(AL_INVALID_VALUE);
  92                     }
  93                 }
  94                 else
  95                 {
  96                     // Bad pointer
  97                     alSetError(AL_INVALID_VALUE);
  98                 }
  99             }
 100             else
 101             {
 102                 // No Device created, or attached to Context
 103                 alSetError(AL_INVALID_OPERATION);
 104             }
 105         }
 106
 107         ProcessContext(Context);
 108     }
 109     else
 110     {
 111         // Invalid Context
 112         alSetError(AL_INVALID_OPERATION);
 113     }
 114
 115     return;
 116 }
 117
 118
 119 ALAPI ALvoid ALAPIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
 120 {
 121     ALCcontext *Context;
 122     ALCdevice  *Device;
 123     ALsource *ALSource;
 124     ALsource **list;
 125     ALsizei i, j;
 126     ALbufferlistitem *ALBufferList;
 127     ALboolean bSourcesValid = AL_TRUE;
 128
 129     Context = alcGetCurrentContext();
 130     if (Context)
 131     {
 132         SuspendContext(Context);
 133
 134         if (n >= 0)
 135         {
 136             Device = alcGetContextsDevice(Context);
 137
 138             if (Device)
 139             {
 140                 // Check that all Sources are valid (and can therefore be deleted)
 141                 for (i = 0; i < n; i++)
 142                 {
 143                     if (!alIsSource(sources[i]))
 144                     {
 145                         alSetError(AL_INVALID_NAME);
 146                         bSourcesValid = AL_FALSE;
 147                         break;
 148                     }
 149                 }
 150
 151                 if (bSourcesValid)
 152                 {
 153                     // All Sources are valid, and can be deleted
 154                     for (i = 0; i < n; i++)
 155                     {
 156                         // Recheck that the Source is valid, because there could be duplicated Source names
 157                         if (alIsSource(sources[i]))
 158                         {
 159                             ALSource=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
 160                             alSourceStop((ALuint)ALSource->source);
 161
 162                             // For each buffer in the source's queue, decrement its reference counter and remove it
 163                             while (ALSource->queue != NULL)
 164                             {
 165                                 ALBufferList = ALSource->queue;
 166                                 // Decrement buffer's reference counter
 167                                 if (ALBufferList->buffer != 0)
 168                                     ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
 169                                 // Update queue to point to next element in list
 170                                 ALSource->queue = ALBufferList->next;
 171                                 // Release memory allocated for buffer list item
 172                                 free(ALBufferList);
 173                             }
 174
 175                             for(j = 0;j < MAX_SENDS;++j)
 176                             {
 177                                 if(ALSource->Send[j].Slot)
 178                                     ALSource->Send[j].Slot->refcount--;
 179                                 ALSource->Send[j].Slot = NULL;
 180                             }
 181
 182                             // Decrement Source count
 183                             Context->SourceCount--;
 184
 185                             // Remove Source from list of Sources
 186                             list = &Context->Source;
 187                             while(*list && *list != ALSource)
 188                                 list = &(*list)->next;
 189
 190                             if(*list)
 191                                 *list = (*list)->next;
 192                             ALTHUNK_REMOVEENTRY(ALSource->source);
 193
 194                             memset(ALSource,0,sizeof(ALsource));
 195                             free(ALSource);
 196                         }
 197                     }
 198                 }
 199             }
 200             else
 201             {
 202                 // No Device created, or attached to Context
 203                 alSetError(AL_INVALID_OPERATION);
 204             }
 205         }
 206         else
 207             alSetError(AL_INVALID_VALUE);
 208
 209         ProcessContext(Context);
 210     }
 211     else
 212     {
 213         // Invalid Context
 214         alSetError(AL_INVALID_OPERATION);
 215     }
 216
 217     return;
 218 }
 219
 220
 221 ALAPI ALboolean ALAPIENTRY alIsSource(ALuint source)
 222 {
 223     ALboolean result=AL_FALSE;
 224     ALCcontext *Context;
 225     ALsource *Source;
 226
 227     Context=alcGetCurrentContext();
 228     if (Context)
 229     {
 230         SuspendContext(Context);
 231
 232         // To determine if this is a valid Source name, look through the list of generated Sources
 233         Source = Context->Source;
 234         while(Source)
 235         {
 236             if (Source == (ALsource*)ALTHUNK_LOOKUPENTRY(source))
 237             {
 238                 result = AL_TRUE;
 239                 break;
 240             }
 241
 242             Source = Source->next;
 243         }
 244
 245         ProcessContext(Context);
 246     }
 247     else
 248     {
 249         // Invalid Context
 250         alSetError(AL_INVALID_OPERATION);
 251     }
 252
 253     return result;
 254 }
 255
 256
 257 ALAPI ALvoid ALAPIENTRY alSourcef(ALuint source, ALenum eParam, ALfloat flValue)
 258 {
 259     ALCcontext    *pContext;
 260     ALsource    *pSource;
 261
 262     pContext = alcGetCurrentContext();
 263     if (pContext)
 264     {
 265         SuspendContext(pContext);
 266
 267         if (alIsSource(source))
 268         {
 269             pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 270
 271             switch (eParam)
 272             {
 273             case AL_PITCH:
 274                 if (flValue >= 0.0f)
 275                 {
 276                     pSource->flPitch = flValue;
 277                     if(pSource->flPitch < 0.001f)
 278                         pSource->flPitch = 0.001f;
 279                 }
 280                 else
 281                     alSetError(AL_INVALID_VALUE);
 282                 break;
 283
 284             case AL_CONE_INNER_ANGLE:
 285                 if ((flValue >= 0.0f) && (flValue <= 360.0f))
 286                     pSource->flInnerAngle = flValue;
 287                 else
 288                     alSetError(AL_INVALID_VALUE);
 289                 break;
 290
 291             case AL_CONE_OUTER_ANGLE:
 292                 if ((flValue >= 0.0f) && (flValue <= 360.0f))
 293                     pSource->flOuterAngle = flValue;
 294                 else
 295                     alSetError(AL_INVALID_VALUE);
 296                 break;
 297
 298             case AL_GAIN:
 299                 if (flValue >= 0.0f)
 300                     pSource->flGain = flValue;
 301                 else
 302                     alSetError(AL_INVALID_VALUE);
 303                 break;
 304
 305             case AL_MAX_DISTANCE:
 306                 if (flValue >= 0.0f)
 307                     pSource->flMaxDistance = flValue;
 308                 else
 309                     alSetError(AL_INVALID_VALUE);
 310                 break;
 311
 312             case AL_ROLLOFF_FACTOR:
 313                 if (flValue >= 0.0f)
 314                     pSource->flRollOffFactor = flValue;
 315                 else
 316                     alSetError(AL_INVALID_VALUE);
 317                 break;
 318
 319             case AL_REFERENCE_DISTANCE:
 320                 if (flValue >= 0.0f)
 321                     pSource->flRefDistance = flValue;
 322                 else
 323                     alSetError(AL_INVALID_VALUE);
 324                 break;
 325
 326             case AL_MIN_GAIN:
 327                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 328                     pSource->flMinGain = flValue;
 329                 else
 330                     alSetError(AL_INVALID_VALUE);
 331                 break;
 332
 333             case AL_MAX_GAIN:
 334                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 335                     pSource->flMaxGain = flValue;
 336                 else
 337                     alSetError(AL_INVALID_VALUE);
 338                 break;
 339
 340             case AL_CONE_OUTER_GAIN:
 341                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 342                     pSource->flOuterGain = flValue;
 343                 else
 344                     alSetError(AL_INVALID_VALUE);
 345                 break;
 346
 347             case AL_CONE_OUTER_GAINHF:
 348                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 349                     pSource->OuterGainHF = flValue;
 350                 else
 351                     alSetError(AL_INVALID_VALUE);
 352                 break;
 353
 354             case AL_AIR_ABSORPTION_FACTOR:
 355                 if (flValue >= 0.0f && flValue <= 10.0f)
 356                     pSource->AirAbsorptionFactor = flValue;
 357                 else
 358                     alSetError(AL_INVALID_VALUE);
 359                 break;
 360
 361             case AL_ROOM_ROLLOFF_FACTOR:
 362                 if (flValue >= 0.0f && flValue <= 10.0f)
 363                     pSource->RoomRolloffFactor = flValue;
 364                 else
 365                     alSetError(AL_INVALID_VALUE);
 366                 break;
 367
 368             case AL_DOPPLER_FACTOR:
 369                 if (flValue >= 0.0f && flValue <= 1.0f)
 370                     pSource->DopplerFactor = flValue;
 371                 else
 372                     alSetError(AL_INVALID_VALUE);
 373                 break;
 374
 375             case AL_SEC_OFFSET:
 376             case AL_SAMPLE_OFFSET:
 377             case AL_BYTE_OFFSET:
 378                 if (flValue >= 0.0f)
 379                 {
 380                     pSource->lOffsetType = eParam;
 381
 382                     // Store Offset (convert Seconds into Milliseconds)
 383                     if (eParam == AL_SEC_OFFSET)
 384                         pSource->lOffset = (ALint)(flValue * 1000.0f);
 385                     else
 386                         pSource->lOffset = (ALint)flValue;
 387
 388                     if ((pSource->state == AL_PLAYING) || (pSource->state == AL_PAUSED))
 389                         ApplyOffset(pSource, AL_TRUE);
 390                 }
 391                 else
 392                     alSetError(AL_INVALID_VALUE);
 393                 break;
 394
 395             default:
 396                 alSetError(AL_INVALID_ENUM);
 397                 break;
 398             }
 399         }
 400         else
 401         {
 402             // Invalid Source Name
 403             alSetError(AL_INVALID_NAME);
 404         }
 405
 406         ProcessContext(pContext);
 407     }
 408     else
 409     {
 410         // Invalid context
 411         alSetError(AL_INVALID_OPERATION);
 412     }
 413
 414     return;
 415 }
 416
 417
 418 ALAPI ALvoid ALAPIENTRY alSource3f(ALuint source, ALenum eParam, ALfloat flValue1,ALfloat flValue2,ALfloat flValue3)
 419 {
 420     ALCcontext    *pContext;
 421     ALsource    *pSource;
 422
 423     pContext = alcGetCurrentContext();
 424     if (pContext)
 425     {
 426         SuspendContext(pContext);
 427
 428         if (alIsSource(source))
 429         {
 430             pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 431             switch(eParam)
 432             {
 433             case AL_POSITION:
 434                 pSource->vPosition[0] = flValue1;
 435                 pSource->vPosition[1] = flValue2;
 436                 pSource->vPosition[2] = flValue3;
 437                 break;
 438
 439             case AL_VELOCITY:
 440                 pSource->vVelocity[0] = flValue1;
 441                 pSource->vVelocity[1] = flValue2;
 442                 pSource->vVelocity[2] = flValue3;
 443                 break;
 444
 445             case AL_DIRECTION:
 446                 pSource->vOrientation[0] = flValue1;
 447                 pSource->vOrientation[1] = flValue2;
 448                 pSource->vOrientation[2] = flValue3;
 449                 break;
 450
 451             default:
 452                 alSetError(AL_INVALID_ENUM);
 453                 break;
 454             }
 455         }
 456         else
 457             alSetError(AL_INVALID_NAME);
 458
 459         ProcessContext(pContext);
 460     }
 461     else
 462     {
 463         alSetError(AL_INVALID_OPERATION);
 464     }
 465
 466     return;
 467 }
 468
 469
 470 ALAPI ALvoid ALAPIENTRY alSourcefv(ALuint source, ALenum eParam, const ALfloat *pflValues)
 471 {
 472     ALCcontext    *pContext;
 473
 474     pContext = alcGetCurrentContext();
 475     if (pContext)
 476     {
 477         SuspendContext(pContext);
 478
 479         if (pflValues)
 480         {
 481             if (alIsSource(source))
 482             {
 483                 switch (eParam)
 484                 {
 485                 case AL_PITCH:
 486                 case AL_CONE_INNER_ANGLE:
 487                 case AL_CONE_OUTER_ANGLE:
 488                 case AL_GAIN:
 489                 case AL_MAX_DISTANCE:
 490                 case AL_ROLLOFF_FACTOR:
 491                 case AL_REFERENCE_DISTANCE:
 492                 case AL_MIN_GAIN:
 493                 case AL_MAX_GAIN:
 494                 case AL_CONE_OUTER_GAIN:
 495                 case AL_CONE_OUTER_GAINHF:
 496                 case AL_SEC_OFFSET:
 497                 case AL_SAMPLE_OFFSET:
 498                 case AL_BYTE_OFFSET:
 499                 case AL_AIR_ABSORPTION_FACTOR:
 500                 case AL_ROOM_ROLLOFF_FACTOR:
 501                     alSourcef(source, eParam, pflValues[0]);
 502                     break;
 503
 504                 case AL_POSITION:
 505                 case AL_VELOCITY:
 506                 case AL_DIRECTION:
 507                     alSource3f(source, eParam, pflValues[0], pflValues[1], pflValues[2]);
 508                     break;
 509
 510                 default:
 511                     alSetError(AL_INVALID_ENUM);
 512                     break;
 513                 }
 514             }
 515             else
 516                 alSetError(AL_INVALID_NAME);
 517         }
 518         else
 519             alSetError(AL_INVALID_VALUE);
 520
 521         ProcessContext(pContext);
 522     }
 523     else
 524         alSetError(AL_INVALID_OPERATION);
 525
 526     return;
 527 }
 528
 529
 530 ALAPI ALvoid ALAPIENTRY alSourcei(ALuint source,ALenum eParam,ALint lValue)
 531 {
 532     ALCcontext          *pContext;
 533     ALsource            *pSource;
 534     ALbufferlistitem    *pALBufferListItem;
 535     ALint                Counter = 0;
 536     ALint                DataSize = 0;
 537     ALint                BufferSize;
 538
 539     pContext = alcGetCurrentContext();
 540     if (pContext)
 541     {
 542         SuspendContext(pContext);
 543
 544         if (alIsSource(source))
 545         {
 546             pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 547
 548             switch(eParam)
 549             {
 550             case AL_MAX_DISTANCE:
 551             case AL_ROLLOFF_FACTOR:
 552             case AL_REFERENCE_DISTANCE:
 553                 alSourcef(source, eParam, (ALfloat)lValue);
 554                 break;
 555
 556             case AL_SOURCE_RELATIVE:
 557                 if ((lValue == AL_FALSE) || (lValue == AL_TRUE))
 558                     pSource->bHeadRelative = (ALboolean)lValue;
 559                 else
 560                     alSetError(AL_INVALID_VALUE);
 561                 break;
 562
 563             case AL_CONE_INNER_ANGLE:
 564                 if ((lValue >= 0) && (lValue <= 360))
 565                     pSource->flInnerAngle = (float)lValue;
 566                 else
 567                     alSetError(AL_INVALID_VALUE);
 568                 break;
 569
 570             case AL_CONE_OUTER_ANGLE:
 571                 if ((lValue >= 0) && (lValue <= 360))
 572                     pSource->flOuterAngle = (float)lValue;
 573                 else
 574                     alSetError(AL_INVALID_VALUE);
 575                 break;
 576
 577             case AL_LOOPING:
 578                 if ((lValue == AL_FALSE) || (lValue == AL_TRUE))
 579                     pSource->bLooping = (ALboolean)lValue;
 580                 else
 581                     alSetError(AL_INVALID_VALUE);
 582                 break;
 583
 584             case AL_BUFFER:
 585                 if ((pSource->state == AL_STOPPED) || (pSource->state == AL_INITIAL))
 586                 {
 587                     if (alIsBuffer(lValue))
 588                     {
 589                         // Remove all elements in the queue
 590                         while (pSource->queue != NULL)
 591                         {
 592                             pALBufferListItem = pSource->queue;
 593                             pSource->queue = pALBufferListItem->next;
 594                             // Decrement reference counter for buffer
 595                             if (pALBufferListItem->buffer)
 596                                 ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(pALBufferListItem->buffer)))->refcount--;
 597                             // Record size of buffer
 598                             BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pALBufferListItem->buffer))->size;
 599                             DataSize += BufferSize;
 600                             // Increment the number of buffers removed from queue
 601                             Counter++;
 602                             // Release memory for buffer list item
 603                             free(pALBufferListItem);
 604                             // Decrement the number of buffers in the queue
 605                             pSource->BuffersInQueue--;
 606                         }
 607
 608                         // Add the buffer to the queue (as long as it is NOT the NULL buffer)
 609                         if (lValue != 0)
 610                         {
 611                             // Source is now in STATIC mode
 612                             pSource->lSourceType = AL_STATIC;
 613
 614                             // Add the selected buffer to the queue
 615                             pALBufferListItem = malloc(sizeof(ALbufferlistitem));
 616                             pALBufferListItem->buffer = lValue;
 617                             pALBufferListItem->bufferstate = PENDING;
 618                             pALBufferListItem->flag = 0;
 619                             pALBufferListItem->next = NULL;
 620
 621                             pSource->queue = pALBufferListItem;
 622                             pSource->BuffersInQueue = 1;
 623
 624                             DataSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(lValue))->size;
 625
 626                             // Increment reference counter for buffer
 627                             ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(lValue)))->refcount++;
 628                         }
 629                         else
 630                         {
 631                             // Source is now in UNDETERMINED mode
 632                             pSource->lSourceType = AL_UNDETERMINED;
 633                         }
 634
 635                         // Update AL_BUFFER parameter
 636                         pSource->ulBufferID = lValue;
 637                     }
 638                     else
 639                         alSetError(AL_INVALID_VALUE);
 640                 }
 641                 else
 642                     alSetError(AL_INVALID_OPERATION);
 643                 break;
 644
 645             case AL_SOURCE_STATE:
 646                 // Query only
 647                 alSetError(AL_INVALID_OPERATION);
 648                 break;
 649
 650             case AL_SEC_OFFSET:
 651             case AL_SAMPLE_OFFSET:
 652             case AL_BYTE_OFFSET:
 653                 if (lValue >= 0)
 654                 {
 655                     pSource->lOffsetType = eParam;
 656
 657                     // Store Offset (convert Seconds into Milliseconds)
 658                     if (eParam == AL_SEC_OFFSET)
 659                         pSource->lOffset = lValue * 1000;
 660                     else
 661                         pSource->lOffset = lValue;
 662
 663                     if ((pSource->state == AL_PLAYING) || (pSource->state == AL_PAUSED))
 664                         ApplyOffset(pSource, AL_TRUE);
 665                 }
 666                 else
 667                     alSetError(AL_INVALID_VALUE);
 668                 break;
 669
 670             case AL_DIRECT_FILTER:
 671                 if(alIsFilter(lValue))
 672                 {
 673                     ALfilter *filter = (ALfilter*)ALTHUNK_LOOKUPENTRY(lValue);
 674                     if(!filter)
 675                     {
 676                         pSource->DirectFilter.type = AL_FILTER_NULL;
 677                         pSource->DirectFilter.filter = 0;
 678                     }
 679                     else
 680                         memcpy(&pSource->DirectFilter, filter, sizeof(*filter));
 681                 }
 682                 else
 683                     alSetError(AL_INVALID_VALUE);
 684                 break;
 685
 686             case AL_DIRECT_FILTER_GAINHF_AUTO:
 687                 if(lValue == AL_TRUE || lValue == AL_FALSE)
 688                     pSource->DryGainHFAuto = lValue;
 689                 else
 690                     alSetError(AL_INVALID_VALUE);
 691                 break;
 692
 693             case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
 694                 if(lValue == AL_TRUE || lValue == AL_FALSE)
 695                     pSource->WetGainAuto = lValue;
 696                 else
 697                     alSetError(AL_INVALID_VALUE);
 698                 break;
 699
 700             case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
 701                 if(lValue == AL_TRUE || lValue == AL_FALSE)
 702                     pSource->WetGainHFAuto = lValue;
 703                 else
 704                     alSetError(AL_INVALID_VALUE);
 705                 break;
 706
 707             case AL_DISTANCE_MODEL:
 708                 if(lValue == AL_NONE ||
 709                    lValue == AL_INVERSE_DISTANCE ||
 710                    lValue == AL_INVERSE_DISTANCE_CLAMPED ||
 711                    lValue == AL_LINEAR_DISTANCE ||
 712                    lValue == AL_LINEAR_DISTANCE_CLAMPED ||
 713                    lValue == AL_EXPONENT_DISTANCE ||
 714                    lValue == AL_EXPONENT_DISTANCE_CLAMPED)
 715                     pSource->DistanceModel = lValue;
 716                 else
 717                     alSetError(AL_INVALID_VALUE);
 718                 break;
 719
 720             default:
 721                 alSetError(AL_INVALID_ENUM);
 722                 break;
 723             }
 724         }
 725         else
 726             alSetError(AL_INVALID_NAME);
 727
 728         ProcessContext(pContext);
 729     }
 730     else
 731         alSetError(AL_INVALID_OPERATION);
 732
 733     return;
 734 }
 735
 736
 737 ALAPI void ALAPIENTRY alSource3i(ALuint source, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 738 {
 739     ALCcontext    *pContext;
 740
 741     pContext = alcGetCurrentContext();
 742     if (pContext)
 743     {
 744         SuspendContext(pContext);
 745
 746         if (alIsSource(source))
 747         {
 748             ALsource *pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 749
 750             switch (eParam)
 751             {
 752             case AL_POSITION:
 753             case AL_VELOCITY:
 754             case AL_DIRECTION:
 755                 alSource3f(source, eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
 756                 break;
 757
 758             case AL_AUXILIARY_SEND_FILTER:
 759                 if(lValue2 >= 0 && lValue2 < MAX_SENDS &&
 760                    (alIsAuxiliaryEffectSlot(lValue1) || lValue1 == 0) &&
 761                    alIsFilter(lValue3))
 762                 {
 763                     ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(lValue1);
 764                     ALfilter     *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(lValue3);
 765
 766                     /* Release refcount on the previous slot, and add one for
 767                      * the new slot */
 768                     if(pSource->Send[lValue2].Slot)
 769                         pSource->Send[lValue2].Slot->refcount--;
 770                     pSource->Send[lValue2].Slot = ALEffectSlot;
 771                     if(pSource->Send[lValue2].Slot)
 772                         pSource->Send[lValue2].Slot->refcount++;
 773
 774                     if(!ALFilter)
 775                     {
 776                         /* Disable filter */
 777                         pSource->Send[lValue2].WetFilter.type = 0;
 778                         pSource->Send[lValue2].WetFilter.filter = 0;
 779                     }
 780                     else
 781                         memcpy(&pSource->Send[lValue2].WetFilter, ALFilter, sizeof(*ALFilter));
 782                 }
 783                 else
 784                     alSetError(AL_INVALID_VALUE);
 785                 break;
 786
 787             default:
 788                 alSetError(AL_INVALID_ENUM);
 789                 break;
 790             }
 791         }
 792         else
 793             alSetError(AL_INVALID_NAME);
 794
 795         ProcessContext(pContext);
 796     }
 797     else
 798         alSetError(AL_INVALID_OPERATION);
 799
 800     return;
 801 }
 802
 803
 804 ALAPI void ALAPIENTRY alSourceiv(ALuint source, ALenum eParam, const ALint* plValues)
 805 {
 806     ALCcontext    *pContext;
 807
 808     pContext = alcGetCurrentContext();
 809     if (pContext)
 810     {
 811         SuspendContext(pContext);
 812
 813         if (plValues)
 814         {
 815             if (alIsSource(source))
 816             {
 817                 switch (eParam)
 818                 {
 819                 case AL_SOURCE_RELATIVE:
 820                 case AL_CONE_INNER_ANGLE:
 821                 case AL_CONE_OUTER_ANGLE:
 822                 case AL_LOOPING:
 823                 case AL_BUFFER:
 824                 case AL_SOURCE_STATE:
 825                 case AL_SEC_OFFSET:
 826                 case AL_SAMPLE_OFFSET:
 827                 case AL_BYTE_OFFSET:
 828                 case AL_MAX_DISTANCE:
 829                 case AL_ROLLOFF_FACTOR:
 830                 case AL_REFERENCE_DISTANCE:
 831                 case AL_DIRECT_FILTER:
 832                 case AL_DIRECT_FILTER_GAINHF_AUTO:
 833                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
 834                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
 835                 case AL_DISTANCE_MODEL:
 836                     alSourcei(source, eParam, plValues[0]);
 837                     break;
 838
 839                 case AL_POSITION:
 840                 case AL_VELOCITY:
 841                 case AL_DIRECTION:
 842                 case AL_AUXILIARY_SEND_FILTER:
 843                     alSource3i(source, eParam, plValues[0], plValues[1], plValues[2]);
 844                     break;
 845
 846                 default:
 847                     alSetError(AL_INVALID_ENUM);
 848                     break;
 849                 }
 850             }
 851             else
 852                 alSetError(AL_INVALID_NAME);
 853         }
 854         else
 855             alSetError(AL_INVALID_VALUE);
 856
 857         ProcessContext(pContext);
 858     }
 859     else
 860         alSetError(AL_INVALID_OPERATION);
 861
 862     return;
 863 }
 864
 865
 866 ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflValue)
 867 {
 868     ALCcontext    *pContext;
 869     ALsource    *pSource;
 870     ALfloat        flOffset[2];
 871
 872     pContext = alcGetCurrentContext();
 873     if (pContext)
 874     {
 875         SuspendContext(pContext);
 876
 877         if (pflValue)
 878         {
 879             if (alIsSource(source))
 880             {
 881                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 882
 883                 switch(eParam)
 884                 {
 885                 case AL_PITCH:
 886                     *pflValue = pSource->flPitch;
 887                     break;
 888
 889                 case AL_GAIN:
 890                     *pflValue = pSource->flGain;
 891                     break;
 892
 893                 case AL_MIN_GAIN:
 894                     *pflValue = pSource->flMinGain;
 895                     break;
 896
 897                 case AL_MAX_GAIN:
 898                     *pflValue = pSource->flMaxGain;
 899                     break;
 900
 901                 case AL_MAX_DISTANCE:
 902                     *pflValue = pSource->flMaxDistance;
 903                     break;
 904
 905                 case AL_ROLLOFF_FACTOR:
 906                     *pflValue = pSource->flRollOffFactor;
 907                     break;
 908
 909                 case AL_CONE_OUTER_GAIN:
 910                     *pflValue = pSource->flOuterGain;
 911                     break;
 912
 913                 case AL_CONE_OUTER_GAINHF:
 914                     *pflValue = pSource->OuterGainHF;
 915                     break;
 916
 917                 case AL_SEC_OFFSET:
 918                 case AL_SAMPLE_OFFSET:
 919                 case AL_BYTE_OFFSET:
 920                     if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
 921                         *pflValue = flOffset[0];
 922                     else
 923                         alSetError(AL_INVALID_OPERATION);
 924                     break;
 925
 926                 case AL_SEC_RW_OFFSETS_EXT:
 927                 case AL_SAMPLE_RW_OFFSETS_EXT:
 928                 case AL_BYTE_RW_OFFSETS_EXT:
 929                     if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
 930                     {
 931                         pflValue[0] = flOffset[0];
 932                         pflValue[1] = flOffset[1];
 933                     }
 934                     else
 935                         alSetError(AL_INVALID_OPERATION);
 936                     break;
 937
 938                 case AL_CONE_INNER_ANGLE:
 939                     *pflValue = pSource->flInnerAngle;
 940                     break;
 941
 942                 case AL_CONE_OUTER_ANGLE:
 943                     *pflValue = pSource->flOuterAngle;
 944                     break;
 945
 946                 case AL_REFERENCE_DISTANCE:
 947                     *pflValue = pSource->flRefDistance;
 948                     break;
 949
 950                 case AL_AIR_ABSORPTION_FACTOR:
 951                     *pflValue = pSource->AirAbsorptionFactor;
 952                     break;
 953
 954                 case AL_ROOM_ROLLOFF_FACTOR:
 955                     *pflValue = pSource->RoomRolloffFactor;
 956                     break;
 957
 958                 case AL_DOPPLER_FACTOR:
 959                     *pflValue = pSource->DopplerFactor;
 960                     break;
 961
 962                 default:
 963                     alSetError(AL_INVALID_ENUM);
 964                     break;
 965                 }
 966             }
 967             else
 968                 alSetError(AL_INVALID_NAME);
 969         }
 970         else
 971             alSetError(AL_INVALID_VALUE);
 972
 973         ProcessContext(pContext);
 974     }
 975     else
 976         alSetError(AL_INVALID_OPERATION);
 977
 978     return;
 979 }
 980
 981
 982 ALAPI ALvoid ALAPIENTRY alGetSource3f(ALuint source, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 983 {
 984     ALCcontext    *pContext;
 985     ALsource    *pSource;
 986
 987     pContext = alcGetCurrentContext();
 988     if (pContext)
 989     {
 990         SuspendContext(pContext);
 991
 992         if ((pflValue1) && (pflValue2) && (pflValue3))
 993         {
 994             if (alIsSource(source))
 995             {
 996                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 997
 998                 switch(eParam)
 999                 {
1000                 case AL_POSITION:
1001                     *pflValue1 = pSource->vPosition[0];
1002                     *pflValue2 = pSource->vPosition[1];
1003                     *pflValue3 = pSource->vPosition[2];
1004                     break;
1005
1006                 case AL_VELOCITY:
1007                     *pflValue1 = pSource->vVelocity[0];
1008                     *pflValue2 = pSource->vVelocity[1];
1009                     *pflValue3 = pSource->vVelocity[2];
1010                     break;
1011
1012                 case AL_DIRECTION:
1013                     *pflValue1 = pSource->vOrientation[0];
1014                     *pflValue2 = pSource->vOrientation[1];
1015                     *pflValue3 = pSource->vOrientation[2];
1016                     break;
1017
1018                 default:
1019                     alSetError(AL_INVALID_ENUM);
1020                     break;
1021                 }
1022             }
1023             else
1024                 alSetError(AL_INVALID_NAME);
1025         }
1026         else
1027             alSetError(AL_INVALID_VALUE);
1028
1029         ProcessContext(pContext);
1030     }
1031     else
1032         alSetError(AL_INVALID_OPERATION);
1033
1034     return;
1035 }
1036
1037
1038 ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pflValues)
1039 {
1040     ALCcontext    *pContext;
1041     ALsource    *pSource;
1042
1043     pContext = alcGetCurrentContext();
1044     if (pContext)
1045     {
1046         SuspendContext(pContext);
1047
1048         if (pflValues)
1049         {
1050             if (alIsSource(source))
1051             {
1052                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1053
1054                 switch(eParam)
1055                 {
1056                 case AL_PITCH:
1057                 case AL_GAIN:
1058                 case AL_MIN_GAIN:
1059                 case AL_MAX_GAIN:
1060                 case AL_MAX_DISTANCE:
1061                 case AL_ROLLOFF_FACTOR:
1062                 case AL_DOPPLER_FACTOR:
1063                 case AL_CONE_OUTER_GAIN:
1064                 case AL_SEC_OFFSET:
1065                 case AL_SAMPLE_OFFSET:
1066                 case AL_BYTE_OFFSET:
1067                 case AL_CONE_INNER_ANGLE:
1068                 case AL_CONE_OUTER_ANGLE:
1069                 case AL_REFERENCE_DISTANCE:
1070                 case AL_CONE_OUTER_GAINHF:
1071                 case AL_AIR_ABSORPTION_FACTOR:
1072                 case AL_ROOM_ROLLOFF_FACTOR:
1073                     alGetSourcef(source, eParam, pflValues);
1074                     break;
1075
1076                 case AL_POSITION:
1077                     pflValues[0] = pSource->vPosition[0];
1078                     pflValues[1] = pSource->vPosition[1];
1079                     pflValues[2] = pSource->vPosition[2];
1080                     break;
1081
1082                 case AL_VELOCITY:
1083                     pflValues[0] = pSource->vVelocity[0];
1084                     pflValues[1] = pSource->vVelocity[1];
1085                     pflValues[2] = pSource->vVelocity[2];
1086                     break;
1087
1088                 case AL_DIRECTION:
1089                     pflValues[0] = pSource->vOrientation[0];
1090                     pflValues[1] = pSource->vOrientation[1];
1091                     pflValues[2] = pSource->vOrientation[2];
1092                     break;
1093
1094                 default:
1095                     alSetError(AL_INVALID_ENUM);
1096                     break;
1097                 }
1098             }
1099             else
1100                 alSetError(AL_INVALID_NAME);
1101         }
1102         else
1103             alSetError(AL_INVALID_VALUE);
1104
1105         ProcessContext(pContext);
1106     }
1107     else
1108         alSetError(AL_INVALID_OPERATION);
1109
1110     return;
1111 }
1112
1113
1114 ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValue)
1115 {
1116     ALCcontext *pContext;
1117     ALsource   *pSource;
1118     ALfloat     flOffset[2];
1119
1120     pContext = alcGetCurrentContext();
1121     if (pContext)
1122     {
1123         SuspendContext(pContext);
1124
1125         if (plValue)
1126         {
1127             if (alIsSource(source))
1128             {
1129                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1130
1131                 switch(eParam)
1132                 {
1133                 case AL_MAX_DISTANCE:
1134                     *plValue = (ALint)pSource->flMaxDistance;
1135                     break;
1136
1137                 case AL_ROLLOFF_FACTOR:
1138                     *plValue = (ALint)pSource->flRollOffFactor;
1139                     break;
1140
1141                 case AL_REFERENCE_DISTANCE:
1142                     *plValue = (ALint)pSource->flRefDistance;
1143                     break;
1144
1145                 case AL_SOURCE_RELATIVE:
1146                     *plValue = pSource->bHeadRelative;
1147                     break;
1148
1149                 case AL_CONE_INNER_ANGLE:
1150                     *plValue = (ALint)pSource->flInnerAngle;
1151                     break;
1152
1153                 case AL_CONE_OUTER_ANGLE:
1154                     *plValue = (ALint)pSource->flOuterAngle;
1155                     break;
1156
1157                 case AL_LOOPING:
1158                     *plValue = pSource->bLooping;
1159                     break;
1160
1161                 case AL_BUFFER:
1162                     *plValue = pSource->ulBufferID;
1163                     break;
1164
1165                 case AL_SOURCE_STATE:
1166                     *plValue = pSource->state;
1167                     break;
1168
1169                 case AL_BUFFERS_QUEUED:
1170                     *plValue = pSource->BuffersInQueue;
1171                     break;
1172
1173                 case AL_BUFFERS_PROCESSED:
1174                     if(pSource->bLooping)
1175                     {
1176                         /* Buffers on a looping source are in a perpetual state
1177                          * of PENDING, so don't report any as PROCESSED */
1178                         *plValue = 0;
1179                     }
1180                     else
1181                         *plValue = pSource->BuffersPlayed;
1182                     break;
1183
1184                 case AL_SOURCE_TYPE:
1185                     *plValue = pSource->lSourceType;
1186                     break;
1187
1188                 case AL_SEC_OFFSET:
1189                 case AL_SAMPLE_OFFSET:
1190                 case AL_BYTE_OFFSET:
1191                     if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
1192                         *plValue = (ALint)flOffset[0];
1193                     else
1194                         alSetError(AL_INVALID_OPERATION);
1195                     break;
1196
1197                 case AL_SEC_RW_OFFSETS_EXT:
1198                 case AL_SAMPLE_RW_OFFSETS_EXT:
1199                 case AL_BYTE_RW_OFFSETS_EXT:
1200                     if(GetSourceOffset(pSource, eParam, flOffset, pContext->Device->UpdateSize))
1201                     {
1202                         plValue[0] = (ALint)flOffset[0];
1203                         plValue[1] = (ALint)flOffset[1];
1204                     }
1205                     else
1206                         alSetError(AL_INVALID_OPERATION);
1207                     break;
1208
1209                 case AL_DIRECT_FILTER:
1210                     *plValue = pSource->DirectFilter.filter;
1211                     break;
1212
1213                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1214                     *plValue = pSource->DryGainHFAuto;
1215                     break;
1216
1217                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1218                     *plValue = pSource->WetGainAuto;
1219                     break;
1220
1221                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1222                     *plValue = pSource->WetGainHFAuto;
1223                     break;
1224
1225                 case AL_DOPPLER_FACTOR:
1226                     *plValue = (ALint)pSource->DopplerFactor;
1227                     break;
1228
1229                 case AL_DISTANCE_MODEL:
1230                     *plValue = pSource->DistanceModel;
1231                     break;
1232
1233                 default:
1234                     alSetError(AL_INVALID_ENUM);
1235                     break;
1236                 }
1237             }
1238             else
1239                 alSetError(AL_INVALID_NAME);
1240         }
1241         else
1242             alSetError(AL_INVALID_VALUE);
1243
1244         ProcessContext(pContext);
1245     }
1246     else
1247         alSetError(AL_INVALID_OPERATION);
1248
1249     return;
1250 }
1251
1252
1253 ALAPI void ALAPIENTRY alGetSource3i(ALuint source, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
1254 {
1255     ALCcontext  *pContext;
1256     ALsource    *pSource;
1257
1258     pContext = alcGetCurrentContext();
1259     if (pContext)
1260     {
1261         SuspendContext(pContext);
1262
1263         if ((plValue1) && (plValue2) && (plValue3))
1264         {
1265             if (alIsSource(source))
1266             {
1267                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1268
1269                 switch(eParam)
1270                 {
1271                 case AL_POSITION:
1272                     *plValue1 = (ALint)pSource->vPosition[0];
1273                     *plValue2 = (ALint)pSource->vPosition[1];
1274                     *plValue3 = (ALint)pSource->vPosition[2];
1275                     break;
1276
1277                 case AL_VELOCITY:
1278                     *plValue1 = (ALint)pSource->vVelocity[0];
1279                     *plValue2 = (ALint)pSource->vVelocity[1];
1280                     *plValue3 = (ALint)pSource->vVelocity[2];
1281                     break;
1282
1283                 case AL_DIRECTION:
1284                     *plValue1 = (ALint)pSource->vOrientation[0];
1285                     *plValue2 = (ALint)pSource->vOrientation[1];
1286                     *plValue3 = (ALint)pSource->vOrientation[2];
1287                     break;
1288
1289                 default:
1290                     alSetError(AL_INVALID_ENUM);
1291                     break;
1292                 }
1293             }
1294             else
1295                 alSetError(AL_INVALID_NAME);
1296         }
1297         else
1298             alSetError(AL_INVALID_VALUE);
1299
1300         ProcessContext(pContext);
1301     }
1302     else
1303         alSetError(AL_INVALID_OPERATION);
1304
1305     return;
1306 }
1307
1308
1309 ALAPI void ALAPIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValues)
1310 {
1311     ALCcontext  *pContext;
1312     ALsource    *pSource;
1313
1314     pContext = alcGetCurrentContext();
1315     if (pContext)
1316     {
1317         SuspendContext(pContext);
1318
1319         if (plValues)
1320         {
1321             if (alIsSource(source))
1322             {
1323                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1324
1325                 switch (eParam)
1326                 {
1327                 case AL_SOURCE_RELATIVE:
1328                 case AL_CONE_INNER_ANGLE:
1329                 case AL_CONE_OUTER_ANGLE:
1330                 case AL_LOOPING:
1331                 case AL_BUFFER:
1332                 case AL_SOURCE_STATE:
1333                 case AL_BUFFERS_QUEUED:
1334                 case AL_BUFFERS_PROCESSED:
1335                 case AL_SEC_OFFSET:
1336                 case AL_SAMPLE_OFFSET:
1337                 case AL_BYTE_OFFSET:
1338                 case AL_MAX_DISTANCE:
1339                 case AL_ROLLOFF_FACTOR:
1340                 case AL_DOPPLER_FACTOR:
1341                 case AL_REFERENCE_DISTANCE:
1342                 case AL_SOURCE_TYPE:
1343                 case AL_DIRECT_FILTER:
1344                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1345                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1346                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1347                 case AL_DISTANCE_MODEL:
1348                     alGetSourcei(source, eParam, plValues);
1349                     break;
1350
1351                 case AL_POSITION:
1352                     plValues[0] = (ALint)pSource->vPosition[0];
1353                     plValues[1] = (ALint)pSource->vPosition[1];
1354                     plValues[2] = (ALint)pSource->vPosition[2];
1355                     break;
1356
1357                 case AL_VELOCITY:
1358                     plValues[0] = (ALint)pSource->vVelocity[0];
1359                     plValues[1] = (ALint)pSource->vVelocity[1];
1360                     plValues[2] = (ALint)pSource->vVelocity[2];
1361                     break;
1362
1363                 case AL_DIRECTION:
1364                     plValues[0] = (ALint)pSource->vOrientation[0];
1365                     plValues[1] = (ALint)pSource->vOrientation[1];
1366                     plValues[2] = (ALint)pSource->vOrientation[2];
1367                     break;
1368
1369                 default:
1370                     alSetError(AL_INVALID_ENUM);
1371                     break;
1372                 }
1373             }
1374             else
1375                 alSetError(AL_INVALID_NAME);
1376         }
1377         else
1378             alSetError(AL_INVALID_VALUE);
1379
1380         ProcessContext(pContext);
1381     }
1382     else
1383         alSetError(AL_INVALID_OPERATION);
1384
1385     return;
1386 }
1387
1388
1389 ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint source)
1390 {
1391     alSourcePlayv(1, &source);
1392     return;
1393 }
1394
1395 ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
1396 {
1397     ALCcontext          *pContext;
1398     ALsource            *pSource;
1399     ALbufferlistitem    *ALBufferList;
1400     ALboolean            bSourcesValid = AL_TRUE;
1401     ALboolean            bPlay;
1402     ALsizei              i, j;
1403
1404     pContext = alcGetCurrentContext();
1405     if (pContext)
1406     {
1407         SuspendContext(pContext);
1408
1409         if (pSourceList)
1410         {
1411             // Check that all the Sources are valid
1412             for (i = 0; i < n; i++)
1413             {
1414                 if (!alIsSource(pSourceList[i]))
1415                 {
1416                     alSetError(AL_INVALID_NAME);
1417                     bSourcesValid = AL_FALSE;
1418                     break;
1419                 }
1420             }
1421
1422             if (bSourcesValid)
1423             {
1424                 for (i = 0; i < n; i++)
1425                 {
1426                     // Assume Source won't need to play
1427                     bPlay = AL_FALSE;
1428
1429                     pSource = ((ALsource*)ALTHUNK_LOOKUPENTRY(pSourceList[i]));
1430
1431                     // Check that there is a queue containing at least one non-null, non zero length AL Buffer
1432                     ALBufferList = pSource->queue;
1433                     while (ALBufferList)
1434                     {
1435                         if ((ALBufferList->buffer != 0) && (((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size))
1436                         {
1437                             bPlay = AL_TRUE;
1438                             break;
1439                         }
1440                         ALBufferList = ALBufferList->next;
1441                     }
1442
1443                     if (bPlay)
1444                     {
1445                         for(j = 0;j < OUTPUTCHANNELS;j++)
1446                             pSource->DryGains[j] = 0.0f;
1447                         for(j = 0;j < MAX_SENDS;j++)
1448                             pSource->WetGains[j] = 0.0f;
1449
1450                         if (pSource->state != AL_PAUSED)
1451                         {
1452                             pSource->state = AL_PLAYING;
1453                             pSource->inuse = AL_TRUE;
1454                             pSource->play = AL_TRUE;
1455                             pSource->position = 0;
1456                             pSource->position_fraction = 0;
1457                             pSource->BuffersPlayed = 0;
1458                             pSource->FirstStart = AL_TRUE;
1459
1460                             pSource->ulBufferID = pSource->queue->buffer;
1461
1462                             // Make sure all the Buffers in the queue are marked as PENDING
1463                             ALBufferList = pSource->queue;
1464                             while (ALBufferList)
1465                             {
1466                                 ALBufferList->bufferstate = PENDING;
1467                                 ALBufferList = ALBufferList->next;
1468                             }
1469                         }
1470                         else
1471                         {
1472                             pSource->state = AL_PLAYING;
1473                             pSource->inuse = AL_TRUE;
1474                             pSource->play = AL_TRUE;
1475                             pSource->FirstStart = AL_FALSE;
1476                         }
1477
1478                         // Check if an Offset has been set
1479                         if (pSource->lOffset)
1480                             ApplyOffset(pSource, AL_FALSE);
1481                     }
1482                     else
1483                     {
1484                         // If there is a queue (must all be NULL or Zero length Buffers) mark them all as processed
1485                         ALBufferList = pSource->queue;
1486                         while (ALBufferList)
1487                         {
1488                             ALBufferList->bufferstate = PROCESSED;
1489                             ALBufferList = ALBufferList->next;
1490                         }
1491
1492                         pSource->BuffersPlayed = pSource->BuffersInQueue;
1493                     }
1494                 }
1495             }
1496         }
1497         else
1498         {
1499             // sources is a NULL pointer
1500             alSetError(AL_INVALID_VALUE);
1501         }
1502
1503         ProcessContext(pContext);
1504     }
1505     else
1506     {
1507         // Invalid Context
1508         alSetError(AL_INVALID_OPERATION);
1509     }
1510
1511     return;
1512 }
1513
1514 ALAPI ALvoid ALAPIENTRY alSourcePause(ALuint source)
1515 {
1516     alSourcePausev(1, &source);
1517     return;
1518 }
1519
1520 ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
1521 {
1522     ALCcontext *Context;
1523     ALsource *Source;
1524     ALsizei i;
1525     ALboolean bSourcesValid = AL_TRUE;
1526
1527     Context=alcGetCurrentContext();
1528     if (Context)
1529     {
1530         SuspendContext(Context);
1531
1532         if (sources)
1533         {
1534             // Check all the Sources are valid
1535             for (i=0;i<n;i++)
1536             {
1537                 if (!alIsSource(sources[i]))
1538                 {
1539                     alSetError(AL_INVALID_NAME);
1540                     bSourcesValid = AL_FALSE;
1541                     break;
1542                 }
1543             }
1544
1545             if (bSourcesValid)
1546             {
1547                 for (i=0;i<n;i++)
1548                 {
1549                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1550                     if (Source->state==AL_PLAYING)
1551                     {
1552                         Source->state=AL_PAUSED;
1553                         Source->inuse=AL_FALSE;
1554                     }
1555                 }
1556             }
1557         }
1558         else
1559         {
1560             // sources is a NULL pointer
1561             alSetError(AL_INVALID_VALUE);
1562         }
1563
1564         ProcessContext(Context);
1565     }
1566     else
1567     {
1568         // Invalid Context
1569         alSetError(AL_INVALID_OPERATION);
1570     }
1571
1572     return;
1573 }
1574
1575 ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint source)
1576 {
1577     alSourceStopv(1, &source);
1578     return;
1579 }
1580
1581 ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
1582 {
1583     ALCcontext *Context;
1584     ALsource *Source;
1585     ALsizei i;
1586     ALbufferlistitem *ALBufferListItem;
1587     ALboolean bSourcesValid = AL_TRUE;
1588
1589     Context=alcGetCurrentContext();
1590     if (Context)
1591     {
1592         SuspendContext(Context);
1593
1594         if (sources)
1595         {
1596             // Check all the Sources are valid
1597             for (i=0;i<n;i++)
1598             {
1599                 if (!alIsSource(sources[i]))
1600                 {
1601                     alSetError(AL_INVALID_NAME);
1602                     bSourcesValid = AL_FALSE;
1603                     break;
1604                 }
1605             }
1606
1607             if (bSourcesValid)
1608             {
1609                 for (i=0;i<n;i++)
1610                 {
1611                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1612                     if (Source->state!=AL_INITIAL)
1613                     {
1614                         Source->state=AL_STOPPED;
1615                         Source->inuse=AL_FALSE;
1616                         Source->BuffersPlayed = Source->BuffersInQueue;
1617                         ALBufferListItem= Source->queue;
1618                         while (ALBufferListItem != NULL)
1619                         {
1620                             ALBufferListItem->bufferstate = PROCESSED;
1621                             ALBufferListItem = ALBufferListItem->next;
1622                         }
1623                     }
1624                     Source->lOffset = 0;
1625                 }
1626             }
1627         }
1628         else
1629         {
1630             // sources is a NULL pointer
1631             alSetError(AL_INVALID_VALUE);
1632         }
1633
1634         ProcessContext(Context);
1635     }
1636     else
1637     {
1638         // Invalid Context
1639         alSetError(AL_INVALID_OPERATION);
1640     }
1641
1642     return;
1643 }
1644
1645 ALAPI ALvoid ALAPIENTRY alSourceRewind(ALuint source)
1646 {
1647     alSourceRewindv(1, &source);
1648     return;
1649 }
1650
1651 ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
1652 {
1653     ALCcontext *Context;
1654     ALsource *Source;
1655     ALsizei i;
1656     ALbufferlistitem *ALBufferListItem;
1657     ALboolean bSourcesValid = AL_TRUE;
1658
1659     Context=alcGetCurrentContext();
1660     if (Context)
1661     {
1662         SuspendContext(Context);
1663
1664         if (sources)
1665         {
1666             // Check all the Sources are valid
1667             for (i=0;i<n;i++)
1668             {
1669                 if (!alIsSource(sources[i]))
1670                 {
1671                     alSetError(AL_INVALID_NAME);
1672                     bSourcesValid = AL_FALSE;
1673                     break;
1674                 }
1675             }
1676
1677             if (bSourcesValid)
1678             {
1679                 for (i=0;i<n;i++)
1680                 {
1681                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1682                     if (Source->state!=AL_INITIAL)
1683                     {
1684                         Source->state=AL_INITIAL;
1685                         Source->inuse=AL_FALSE;
1686                         Source->position=0;
1687                         Source->position_fraction=0;
1688                         Source->BuffersPlayed = 0;
1689                         ALBufferListItem= Source->queue;
1690                         while (ALBufferListItem != NULL)
1691                         {
1692                             ALBufferListItem->bufferstate = PENDING;
1693                             ALBufferListItem = ALBufferListItem->next;
1694                         }
1695                         if (Source->queue)
1696                             Source->ulBufferID = Source->queue->buffer;
1697                     }
1698                     Source->lOffset = 0;
1699                 }
1700             }
1701         }
1702         else
1703         {
1704             // sources is a NULL pointer
1705             alSetError(AL_INVALID_VALUE);
1706         }
1707
1708         ProcessContext(Context);
1709     }
1710     else
1711     {
1712         // Invalid Context
1713         alSetError(AL_INVALID_OPERATION);
1714     }
1715
1716     return;
1717 }
1718
1719
1720 ALAPI ALvoid ALAPIENTRY alSourceQueueBuffers( ALuint source, ALsizei n, const ALuint* buffers )
1721 {
1722     ALCcontext *Context;
1723     ALsource *ALSource;
1724     ALsizei i;
1725     ALbufferlistitem *ALBufferList;
1726     ALbufferlistitem *ALBufferListStart;
1727     ALuint DataSize;
1728     ALuint BufferSize;
1729     ALint iFrequency;
1730     ALint iFormat;
1731     ALboolean bBuffersValid = AL_TRUE;
1732
1733     if (n == 0)
1734         return;
1735
1736     Context=alcGetCurrentContext();
1737     if (Context)
1738     {
1739         SuspendContext(Context);
1740
1741         DataSize = 0;
1742         BufferSize = 0;
1743
1744         // Check that all buffers are valid or zero and that the source is valid
1745
1746         // Check that this is a valid source
1747         if (alIsSource(source))
1748         {
1749             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1750
1751             // Check that this is not a STATIC Source
1752             if (ALSource->lSourceType != AL_STATIC)
1753             {
1754                 iFrequency = -1;
1755                 iFormat = -1;
1756
1757                 // Check existing Queue (if any) for a valid Buffers and get its frequency and format
1758                 ALBufferList = ALSource->queue;
1759                 while (ALBufferList)
1760                 {
1761                     if (ALBufferList->buffer)
1762                     {
1763                         iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->frequency;
1764                         iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->format;
1765                         break;
1766                     }
1767                     ALBufferList = ALBufferList->next;
1768                 }
1769
1770                 for (i = 0; i < n; i++)
1771                 {
1772                     if (alIsBuffer(buffers[i]))
1773                     {
1774                         if (buffers[i])
1775                         {
1776                             if ((iFrequency == -1) && (iFormat == -1))
1777                             {
1778                                 iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency;
1779                                 iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format;
1780                             }
1781                             else
1782                             {
1783                                 if ((iFrequency != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency) ||
1784                                     (iFormat != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format))
1785                                 {
1786                                     alSetError(AL_INVALID_OPERATION);
1787                                     bBuffersValid = AL_FALSE;
1788                                     break;
1789                                 }
1790                             }
1791                         }
1792                     }
1793                     else
1794                     {
1795                         alSetError(AL_INVALID_NAME);
1796                         bBuffersValid = AL_FALSE;
1797                         break;
1798                     }
1799                 }
1800
1801                 if (bBuffersValid)
1802                 {
1803                     // Change Source Type
1804                     ALSource->lSourceType = AL_STREAMING;
1805
1806                     // All buffers are valid - so add them to the list
1807                     ALBufferListStart = malloc(sizeof(ALbufferlistitem));
1808                     ALBufferListStart->buffer = buffers[0];
1809                     ALBufferListStart->bufferstate = PENDING;
1810                     ALBufferListStart->flag = 0;
1811                     ALBufferListStart->next = NULL;
1812
1813                     if (buffers[0])
1814                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[0]))->size;
1815                     else
1816                         BufferSize = 0;
1817
1818                     DataSize += BufferSize;
1819
1820                     // Increment reference counter for buffer
1821                     if (buffers[0])
1822                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[0])))->refcount++;
1823
1824                     ALBufferList = ALBufferListStart;
1825
1826                     for (i = 1; i < n; i++)
1827                     {
1828                         ALBufferList->next = malloc(sizeof(ALbufferlistitem));
1829                         ALBufferList->next->buffer = buffers[i];
1830                         ALBufferList->next->bufferstate = PENDING;
1831                         ALBufferList->next->flag = 0;
1832                         ALBufferList->next->next = NULL;
1833
1834                         if (buffers[i])
1835                             BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[i]))->size;
1836                         else
1837                             BufferSize = 0;
1838
1839                         DataSize += BufferSize;
1840
1841                         // Increment reference counter for buffer
1842                         if (buffers[i])
1843                             ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->refcount++;
1844
1845                         ALBufferList = ALBufferList->next;
1846                     }
1847
1848                     if (ALSource->queue == NULL)
1849                     {
1850                         ALSource->queue = ALBufferListStart;
1851                         // Update Current Buffer
1852                         ALSource->ulBufferID = ALBufferListStart->buffer;
1853                     }
1854                     else
1855                     {
1856                         // Find end of queue
1857                         ALBufferList = ALSource->queue;
1858                         while (ALBufferList->next != NULL)
1859                         {
1860                             ALBufferList = ALBufferList->next;
1861                         }
1862
1863                         ALBufferList->next = ALBufferListStart;
1864                     }
1865
1866                     // Update number of buffers in queue
1867                     ALSource->BuffersInQueue += n;
1868                 }
1869             }
1870             else
1871             {
1872                 // Invalid Source Type (can't queue on a Static Source)
1873                 alSetError(AL_INVALID_OPERATION);
1874             }
1875         }
1876         else
1877         {
1878             // Invalid Source Name
1879             alSetError(AL_INVALID_NAME);
1880         }
1881
1882         ProcessContext(Context);
1883     }
1884     else
1885     {
1886         // Invalid Context
1887         alSetError(AL_INVALID_OPERATION);
1888     }
1889
1890     return;
1891 }
1892
1893
1894 // Implementation assumes that n is the number of buffers to be removed from the queue and buffers is
1895 // an array of buffer IDs that are to be filled with the names of the buffers removed
1896 ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers )
1897 {
1898     ALCcontext *Context;
1899     ALsource *ALSource;
1900     ALsizei i;
1901     ALbufferlistitem *ALBufferList;
1902     ALuint DataSize;
1903     ALuint BufferSize;
1904     ALuint BufferID;
1905     ALboolean bBuffersProcessed;
1906
1907     if (n == 0)
1908         return;
1909
1910     DataSize = 0;
1911     BufferSize = 0;
1912     bBuffersProcessed = AL_TRUE;
1913
1914     Context=alcGetCurrentContext();
1915     if (Context)
1916     {
1917         SuspendContext(Context);
1918
1919         if (alIsSource(source))
1920         {
1921             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1922
1923             // Check that all 'n' buffers have been processed
1924             ALBufferList = ALSource->queue;
1925             for (i = 0; i < n; i++)
1926             {
1927                 if ((ALBufferList != NULL) && (ALBufferList->bufferstate == PROCESSED))
1928                 {
1929                     ALBufferList = ALBufferList->next;
1930                 }
1931                 else
1932                 {
1933                     bBuffersProcessed = AL_FALSE;
1934                     break;
1935                 }
1936             }
1937
1938             // If all 'n' buffers have been processed, remove them from the queue
1939             if (bBuffersProcessed)
1940             {
1941                 for (i = 0; i < n; i++)
1942                 {
1943                     ALBufferList = ALSource->queue;
1944
1945                     ALSource->queue = ALBufferList->next;
1946                     // Record name of buffer
1947                     buffers[i] = ALBufferList->buffer;
1948                     // Decrement buffer reference counter
1949                     if (ALBufferList->buffer)
1950                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
1951                     // Record size of buffer
1952                     if (ALBufferList->buffer)
1953                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size;
1954                     else
1955                         BufferSize = 0;
1956
1957                     DataSize += BufferSize;
1958                     // Release memory for buffer list item
1959                     free(ALBufferList);
1960                     ALSource->BuffersInQueue--;
1961                 }
1962
1963                 if (ALSource->state != AL_PLAYING)
1964                 {
1965                     if (ALSource->queue)
1966                         BufferID = ALSource->queue->buffer;
1967                     else
1968                         BufferID = 0;
1969
1970                     ALSource->ulBufferID = BufferID;
1971                 }
1972
1973                 if((ALuint)n > ALSource->BuffersPlayed)
1974                     ALSource->BuffersPlayed = 0;
1975                 else
1976                     ALSource->BuffersPlayed -= n;
1977             }
1978             else
1979             {
1980                 // Some buffers can't be unqueue because they have not been processed
1981                 alSetError(AL_INVALID_VALUE);
1982             }
1983         }
1984         else
1985         {
1986             // Invalid Source Name
1987             alSetError(AL_INVALID_NAME);
1988         }
1989
1990         ProcessContext(Context);
1991     }
1992     else
1993     {
1994         // Invalid Context
1995         alSetError(AL_INVALID_OPERATION);
1996     }
1997
1998     return;
1999 }
2000
2001
2002 static ALvoid InitSourceParams(ALCcontext *Context, ALsource *pSource)
2003 {
2004     pSource->flInnerAngle = 360.0f;
2005     pSource->flOuterAngle = 360.0f;
2006     pSource->flPitch = 1.0f;
2007     pSource->vPosition[0] = 0.0f;
2008     pSource->vPosition[1] = 0.0f;
2009     pSource->vPosition[2] = 0.0f;
2010     pSource->vOrientation[0] = 0.0f;
2011     pSource->vOrientation[1] = 0.0f;
2012     pSource->vOrientation[2] = 0.0f;
2013     pSource->vVelocity[0] = 0.0f;
2014     pSource->vVelocity[1] = 0.0f;
2015     pSource->vVelocity[2] = 0.0f;
2016     pSource->flRefDistance = 1.0f;
2017     pSource->flMaxDistance = FLT_MAX;
2018     pSource->flRollOffFactor = 1.0f;
2019     pSource->bLooping = AL_FALSE;
2020     pSource->flGain = 1.0f;
2021     pSource->flMinGain = 0.0f;
2022     pSource->flMaxGain = 1.0f;
2023     pSource->flOuterGain = 0.0f;
2024     pSource->OuterGainHF = 1.0f;
2025
2026     pSource->DryGainHFAuto = AL_TRUE;
2027     pSource->WetGainAuto = AL_TRUE;
2028     pSource->WetGainHFAuto = AL_TRUE;
2029     pSource->AirAbsorptionFactor = 0.0f;
2030     pSource->RoomRolloffFactor = 0.0f;
2031     pSource->DopplerFactor = 1.0f;
2032
2033     pSource->DistanceModel = Context->DistanceModel;
2034
2035     pSource->state = AL_INITIAL;
2036     pSource->lSourceType = AL_UNDETERMINED;
2037
2038     pSource->ulBufferID= 0;
2039 }
2040
2041
2042 /*
2043     GetSourceOffset
2044
2045     Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)
2046     The offset is relative to the start of the queue (not the start of the current buffer)
2047 */
2048 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset, ALuint updateSize)
2049 {
2050     ALbufferlistitem *pBufferList;
2051     ALbuffer         *pBuffer;
2052     ALfloat        flBufferFreq;
2053     ALint        lChannels;
2054     ALint        readPos, writePos;
2055     ALenum        eOriginalFormat;
2056     ALboolean    bReturn = AL_TRUE;
2057     ALint        lTotalBufferDataSize;
2058
2059     if (((pSource->state == AL_PLAYING) || (pSource->state == AL_PAUSED)) && (pSource->ulBufferID))
2060     {
2061         pBuffer = ALTHUNK_LOOKUPENTRY(pSource->ulBufferID);
2062         // Get Current Buffer Size and frequency (in milliseconds)
2063         flBufferFreq = (ALfloat)pBuffer->frequency;
2064         eOriginalFormat = pBuffer->eOriginalFormat;
2065         lChannels = aluChannelsFromFormat(pBuffer->format);
2066
2067         // Get Current BytesPlayed
2068         readPos = pSource->position * lChannels * 2; // NOTE : This is the byte offset into the *current* buffer
2069         // Add byte length of any processed buffers in the queue
2070         pBufferList = pSource->queue;
2071         while ((pBufferList) && (pBufferList->bufferstate == PROCESSED))
2072         {
2073             readPos += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2074             pBufferList = pBufferList->next;
2075         }
2076
2077         if(pSource->state == AL_PLAYING)
2078             writePos = readPos + (updateSize * lChannels * 2);
2079         else
2080             writePos = readPos;
2081
2082         lTotalBufferDataSize = 0;
2083         pBufferList = pSource->queue;
2084         while (pBufferList)
2085         {
2086             if (pBufferList->buffer)
2087                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2088             pBufferList = pBufferList->next;
2089         }
2090
2091         if (pSource->bLooping)
2092         {
2093             if(readPos < 0)
2094                 readPos = 0;
2095             else
2096                 readPos %= lTotalBufferDataSize;
2097             if(writePos < 0)
2098                 writePos = 0;
2099             else
2100                 writePos %= lTotalBufferDataSize;
2101         }
2102         else
2103         {
2104             // Clamp BytesPlayed to within 0 and lTotalBufferDataSize
2105             if(readPos < 0)
2106                 readPos = 0;
2107             else if(readPos > lTotalBufferDataSize)
2108                 readPos = lTotalBufferDataSize;
2109             if(writePos < 0)
2110                 writePos = 0;
2111             else if(writePos > lTotalBufferDataSize)
2112                 writePos = lTotalBufferDataSize;
2113         }
2114
2115         switch (eName)
2116         {
2117         case AL_SEC_OFFSET:
2118         case AL_SEC_RW_OFFSETS_EXT:
2119             pflOffset[0] = (ALfloat)readPos / (lChannels * 2.0f * flBufferFreq);
2120             pflOffset[1] = (ALfloat)writePos / (lChannels * 2.0f * flBufferFreq);
2121             break;
2122         case AL_SAMPLE_OFFSET:
2123         case AL_SAMPLE_RW_OFFSETS_EXT:
2124             pflOffset[0] = (ALfloat)(readPos / (lChannels * 2));
2125             pflOffset[1] = (ALfloat)(writePos / (lChannels * 2));
2126             break;
2127         case AL_BYTE_OFFSET:
2128         case AL_BYTE_RW_OFFSETS_EXT:
2129             // Take into account the original format of the Buffer
2130             if ((eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2131                 (eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2132             {
2133                 // Round down to nearest ADPCM block
2134                 pflOffset[0] = (ALfloat)((readPos / (65 * 2 * lChannels)) * 36 * lChannels);
2135                 if(pSource->state == AL_PLAYING)
2136                 {
2137                     // Round up to nearest ADPCM block
2138                     pflOffset[1] = (ALfloat)(((writePos + (65 * 2 * lChannels) - 1) / (65 * 2 * lChannels)) * 36 * lChannels);
2139                 }
2140                 else
2141                     pflOffset[1] = pflOffset[0];
2142             }
2143             else if (eOriginalFormat == AL_FORMAT_REAR8)
2144             {
2145                 pflOffset[0] = (ALfloat)(readPos >> 2);
2146                 pflOffset[1] = (ALfloat)(writePos >> 2);
2147             }
2148             else if (eOriginalFormat == AL_FORMAT_REAR16)
2149             {
2150                 pflOffset[0] = (ALfloat)(readPos >> 1);
2151                 pflOffset[1] = (ALfloat)(writePos >> 1);
2152             }
2153             else if (aluBytesFromFormat(eOriginalFormat) == 1)
2154             {
2155                 pflOffset[0] = (ALfloat)(readPos >> 1);
2156                 pflOffset[1] = (ALfloat)(writePos >> 1);
2157             }
2158             else if (aluBytesFromFormat(eOriginalFormat) == 4)
2159             {
2160                 pflOffset[0] = (ALfloat)(readPos << 1);
2161                 pflOffset[1] = (ALfloat)(writePos << 1);
2162             }
2163             else
2164             {
2165                 pflOffset[0] = (ALfloat)readPos;
2166                 pflOffset[1] = (ALfloat)writePos;
2167             }
2168             break;
2169         }
2170     }
2171     else
2172     {
2173         pflOffset[0] = 0.0f;
2174         pflOffset[1] = 0.0f;
2175     }
2176
2177     return bReturn;
2178 }
2179
2180
2181 /*
2182     ApplyOffset
2183
2184     Apply a playback offset to the Source.  This function will update the queue (to correctly
2185     mark buffers as 'pending' or 'processed' depending upon the new offset.
2186 */
2187 static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
2188 {
2189     ALbufferlistitem    *pBufferList;
2190     ALbuffer            *pBuffer;
2191     ALint                lBufferSize, lTotalBufferSize;
2192     ALint                lByteOffset;
2193
2194     // Get true byte offset
2195     lByteOffset = GetByteOffset(pSource);
2196
2197     // If this is a valid offset apply it
2198     if (lByteOffset != -1)
2199     {
2200         // Sort out the queue (pending and processed states)
2201         pBufferList = pSource->queue;
2202         lTotalBufferSize = 0;
2203         pSource->BuffersPlayed = 0;
2204         while (pBufferList)
2205         {
2206             pBuffer = ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2207             lBufferSize = pBuffer ? pBuffer->size : 0;
2208
2209             if ((lTotalBufferSize + lBufferSize) <= lByteOffset)
2210             {
2211                 // Offset is past this buffer so increment BuffersPlayed and if the Source is NOT looping
2212                 // update the state to PROCESSED
2213                 pSource->BuffersPlayed++;
2214
2215                 if (!pSource->bLooping)
2216                     pBufferList->bufferstate = PROCESSED;
2217             }
2218             else if (lTotalBufferSize <= lByteOffset)
2219             {
2220                 // Offset is within this buffer
2221                 pBufferList->bufferstate = PENDING;
2222
2223                 // Set Current Buffer ID
2224                 pSource->ulBufferID = pBufferList->buffer;
2225
2226                 // SW Mixer Positions are in Samples
2227                 pSource->position = (lByteOffset - lTotalBufferSize) /
2228                                     aluBytesFromFormat(pBuffer->format) /
2229                                     aluChannelsFromFormat(pBuffer->format);
2230             }
2231             else
2232             {
2233                 // Offset is before this buffer, so mark as pending
2234                 pBufferList->bufferstate = PENDING;
2235             }
2236
2237             // Increment the TotalBufferSize
2238             lTotalBufferSize += lBufferSize;
2239
2240             // Move on to next buffer in the Queue
2241             pBufferList = pBufferList->next;
2242         }
2243     }
2244     else
2245     {
2246         if (bUpdateContext)
2247             alSetError(AL_INVALID_VALUE);
2248     }
2249
2250     // Clear Offset
2251     pSource->lOffset = 0;
2252 }
2253
2254
2255 /*
2256     GetByteOffset
2257
2258     Returns the 'true' byte offset into the Source's queue (from the Sample, Byte or Millisecond
2259     offset supplied by the application).   This takes into account the fact that the buffer format
2260     may have been modifed by AL (e.g 8bit samples are converted to 16bit)
2261 */
2262 static ALint GetByteOffset(ALsource *pSource)
2263 {
2264     ALbuffer *pBuffer = NULL;
2265     ALbufferlistitem *pBufferList;
2266     ALfloat    flBufferFreq;
2267     ALint    lChannels;
2268     ALint    lByteOffset = -1;
2269     ALint    lTotalBufferDataSize;
2270
2271     // Find the first non-NULL Buffer in the Queue
2272     pBufferList = pSource->queue;
2273     while (pBufferList)
2274     {
2275         if (pBufferList->buffer)
2276         {
2277             pBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2278             break;
2279         }
2280         pBufferList = pBufferList->next;
2281     }
2282
2283     if (pBuffer)
2284     {
2285         flBufferFreq = ((ALfloat)pBuffer->frequency);
2286         lChannels = aluChannelsFromFormat(pBuffer->format);
2287
2288         // Determine the ByteOffset (and ensure it is block aligned)
2289         switch (pSource->lOffsetType)
2290         {
2291         case AL_BYTE_OFFSET:
2292             // Take into consideration the original format
2293             if ((pBuffer->eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2294                 (pBuffer->eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2295             {
2296                 // Round down to nearest ADPCM block
2297                 lByteOffset = (pSource->lOffset / (36 * lChannels)) * 36 * lChannels;
2298                 // Multiply by compression rate
2299                 lByteOffset = (ALint)(3.6111f * (ALfloat)lByteOffset);
2300                 lByteOffset -= (lByteOffset % (lChannels * 2));
2301             }
2302             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR8)
2303             {
2304                 lByteOffset = pSource->lOffset * 4;
2305                 lByteOffset -= (lByteOffset % (lChannels * 2));
2306             }
2307             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR16)
2308             {
2309                 lByteOffset = pSource->lOffset * 2;
2310                 lByteOffset -= (lByteOffset % (lChannels * 2));
2311             }
2312             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 1)
2313             {
2314                 lByteOffset = pSource->lOffset * 2;
2315                 lByteOffset -= (lByteOffset % (lChannels * 2));
2316             }
2317             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 4)
2318             {
2319                 lByteOffset = pSource->lOffset / 2;
2320                 lByteOffset -= (lByteOffset % (lChannels * 2));
2321             }
2322             else
2323             {
2324                 lByteOffset = pSource->lOffset;
2325                 lByteOffset -= (lByteOffset % (lChannels * 2));
2326             }
2327             break;
2328
2329         case AL_SAMPLE_OFFSET:
2330             lByteOffset = pSource->lOffset * lChannels * 2;
2331             break;
2332
2333         case AL_SEC_OFFSET:
2334             // Note - lOffset is internally stored as Milliseconds
2335             lByteOffset = (ALint)(pSource->lOffset * lChannels * 2.0f * flBufferFreq / 1000.0f);
2336             lByteOffset -= (lByteOffset % (lChannels * 2));
2337             break;
2338         }
2339
2340         lTotalBufferDataSize = 0;
2341         pBufferList = pSource->queue;
2342         while (pBufferList)
2343         {
2344             if (pBufferList->buffer)
2345                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2346             pBufferList = pBufferList->next;
2347         }
2348
2349         // Finally, if the ByteOffset is beyond the length of all the buffers in the queue, return -1
2350         if (lByteOffset >= lTotalBufferDataSize)
2351             lByteOffset = -1;
2352     }
2353
2354     return lByteOffset;
2355 }
2356
2357
2358 ALvoid ReleaseALSources(ALCcontext *Context)
2359 {
2360 #ifdef _DEBUG
2361     if(Context->SourceCount > 0)
2362         AL_PRINT("alcDestroyContext(): deleting %d Source(s)\n", Context->SourceCount);
2363 #endif
2364
2365     while(Context->Source)
2366     {
2367         ALsource *temp = Context->Source;
2368         Context->Source = Context->Source->next;
2369
2370         // Release source structure
2371         ALTHUNK_REMOVEENTRY(temp->source);
2372         memset(temp, 0, sizeof(ALsource));
2373         free(temp);
2374     }
2375     Context->SourceCount = 0;
2376 }