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(ALsource *pSource);
  36 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset);
  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(*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 <= 1.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             default:
 708                 alSetError(AL_INVALID_ENUM);
 709                 break;
 710             }
 711         }
 712         else
 713             alSetError(AL_INVALID_NAME);
 714
 715         ProcessContext(pContext);
 716     }
 717     else
 718         alSetError(AL_INVALID_OPERATION);
 719
 720     return;
 721 }
 722
 723
 724 ALAPI void ALAPIENTRY alSource3i(ALuint source, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)
 725 {
 726     ALCcontext    *pContext;
 727
 728     pContext = alcGetCurrentContext();
 729     if (pContext)
 730     {
 731         SuspendContext(pContext);
 732
 733         if (alIsSource(source))
 734         {
 735             ALsource *pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 736
 737             switch (eParam)
 738             {
 739             case AL_POSITION:
 740             case AL_VELOCITY:
 741             case AL_DIRECTION:
 742                 alSource3f(source, eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);
 743                 break;
 744
 745             case AL_AUXILIARY_SEND_FILTER:
 746                 if(lValue2 >= 0 && lValue2 < MAX_SENDS &&
 747                    (alIsAuxiliaryEffectSlot(lValue1) || lValue1 == 0) &&
 748                    alIsFilter(lValue3))
 749                 {
 750                     ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(lValue1);
 751                     ALfilter     *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(lValue3);
 752
 753                     /* Release refcount on the previous slot, and add one for
 754                      * the new slot */
 755                     if(pSource->Send[lValue2].Slot)
 756                         pSource->Send[lValue2].Slot->refcount--;
 757                     pSource->Send[lValue2].Slot = ALEffectSlot;
 758                     if(pSource->Send[lValue2].Slot)
 759                         pSource->Send[lValue2].Slot->refcount++;
 760
 761                     if(!ALFilter)
 762                     {
 763                         /* Disable filter */
 764                         pSource->Send[lValue2].WetFilter.type = 0;
 765                         pSource->Send[lValue2].WetFilter.filter = 0;
 766                     }
 767                     else
 768                         memcpy(&pSource->Send[lValue2].WetFilter, ALFilter, sizeof(*ALFilter));
 769                 }
 770                 else
 771                     alSetError(AL_INVALID_VALUE);
 772                 break;
 773
 774             default:
 775                 alSetError(AL_INVALID_ENUM);
 776                 break;
 777             }
 778         }
 779         else
 780             alSetError(AL_INVALID_NAME);
 781
 782         ProcessContext(pContext);
 783     }
 784     else
 785         alSetError(AL_INVALID_OPERATION);
 786
 787     return;
 788 }
 789
 790
 791 ALAPI void ALAPIENTRY alSourceiv(ALuint source, ALenum eParam, const ALint* plValues)
 792 {
 793     ALCcontext    *pContext;
 794
 795     pContext = alcGetCurrentContext();
 796     if (pContext)
 797     {
 798         SuspendContext(pContext);
 799
 800         if (plValues)
 801         {
 802             if (alIsSource(source))
 803             {
 804                 switch (eParam)
 805                 {
 806                 case AL_SOURCE_RELATIVE:
 807                 case AL_CONE_INNER_ANGLE:
 808                 case AL_CONE_OUTER_ANGLE:
 809                 case AL_LOOPING:
 810                 case AL_BUFFER:
 811                 case AL_SOURCE_STATE:
 812                 case AL_SEC_OFFSET:
 813                 case AL_SAMPLE_OFFSET:
 814                 case AL_BYTE_OFFSET:
 815                 case AL_MAX_DISTANCE:
 816                 case AL_ROLLOFF_FACTOR:
 817                 case AL_REFERENCE_DISTANCE:
 818                 case AL_DIRECT_FILTER:
 819                 case AL_DIRECT_FILTER_GAINHF_AUTO:
 820                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
 821                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
 822                     alSourcei(source, eParam, plValues[0]);
 823                     break;
 824
 825                 case AL_POSITION:
 826                 case AL_VELOCITY:
 827                 case AL_DIRECTION:
 828                 case AL_AUXILIARY_SEND_FILTER:
 829                     alSource3i(source, eParam, plValues[0], plValues[1], plValues[2]);
 830                     break;
 831
 832                 default:
 833                     alSetError(AL_INVALID_ENUM);
 834                     break;
 835                 }
 836             }
 837             else
 838                 alSetError(AL_INVALID_NAME);
 839         }
 840         else
 841             alSetError(AL_INVALID_VALUE);
 842
 843         ProcessContext(pContext);
 844     }
 845     else
 846         alSetError(AL_INVALID_OPERATION);
 847
 848     return;
 849 }
 850
 851
 852 ALAPI ALvoid ALAPIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflValue)
 853 {
 854     ALCcontext    *pContext;
 855     ALsource    *pSource;
 856     ALfloat        flOffset;
 857
 858     pContext = alcGetCurrentContext();
 859     if (pContext)
 860     {
 861         SuspendContext(pContext);
 862
 863         if (pflValue)
 864         {
 865             if (alIsSource(source))
 866             {
 867                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 868
 869                 switch(eParam)
 870                 {
 871                 case AL_PITCH:
 872                     *pflValue = pSource->flPitch;
 873                     break;
 874
 875                 case AL_GAIN:
 876                     *pflValue = pSource->flGain;
 877                     break;
 878
 879                 case AL_MIN_GAIN:
 880                     *pflValue = pSource->flMinGain;
 881                     break;
 882
 883                 case AL_MAX_GAIN:
 884                     *pflValue = pSource->flMaxGain;
 885                     break;
 886
 887                 case AL_MAX_DISTANCE:
 888                     *pflValue = pSource->flMaxDistance;
 889                     break;
 890
 891                 case AL_ROLLOFF_FACTOR:
 892                     *pflValue = pSource->flRollOffFactor;
 893                     break;
 894
 895                 case AL_CONE_OUTER_GAIN:
 896                     *pflValue = pSource->flOuterGain;
 897                     break;
 898
 899                 case AL_CONE_OUTER_GAINHF:
 900                     *pflValue = pSource->OuterGainHF;
 901                     break;
 902
 903                 case AL_SEC_OFFSET:
 904                 case AL_SAMPLE_OFFSET:
 905                 case AL_BYTE_OFFSET:
 906                     if (GetSourceOffset(pSource, eParam, &flOffset))
 907                         *pflValue = flOffset;
 908                     else
 909                         alSetError(AL_INVALID_OPERATION);
 910                     break;
 911
 912                 case AL_CONE_INNER_ANGLE:
 913                     *pflValue = pSource->flInnerAngle;
 914                     break;
 915
 916                 case AL_CONE_OUTER_ANGLE:
 917                     *pflValue = pSource->flOuterAngle;
 918                     break;
 919
 920                 case AL_REFERENCE_DISTANCE:
 921                     *pflValue = pSource->flRefDistance;
 922                     break;
 923
 924                 case AL_AIR_ABSORPTION_FACTOR:
 925                     *pflValue = pSource->AirAbsorptionFactor;
 926                     break;
 927
 928                 case AL_ROOM_ROLLOFF_FACTOR:
 929                     *pflValue = pSource->RoomRolloffFactor;
 930                     break;
 931
 932                 case AL_DOPPLER_FACTOR:
 933                     *pflValue = pSource->DopplerFactor;
 934                     break;
 935
 936                 default:
 937                     alSetError(AL_INVALID_ENUM);
 938                     break;
 939                 }
 940             }
 941             else
 942                 alSetError(AL_INVALID_NAME);
 943         }
 944         else
 945             alSetError(AL_INVALID_VALUE);
 946
 947         ProcessContext(pContext);
 948     }
 949     else
 950         alSetError(AL_INVALID_OPERATION);
 951
 952     return;
 953 }
 954
 955
 956 ALAPI ALvoid ALAPIENTRY alGetSource3f(ALuint source, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 957 {
 958     ALCcontext    *pContext;
 959     ALsource    *pSource;
 960
 961     pContext = alcGetCurrentContext();
 962     if (pContext)
 963     {
 964         SuspendContext(pContext);
 965
 966         if ((pflValue1) && (pflValue2) && (pflValue3))
 967         {
 968             if (alIsSource(source))
 969             {
 970                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 971
 972                 switch(eParam)
 973                 {
 974                 case AL_POSITION:
 975                     *pflValue1 = pSource->vPosition[0];
 976                     *pflValue2 = pSource->vPosition[1];
 977                     *pflValue3 = pSource->vPosition[2];
 978                     break;
 979
 980                 case AL_VELOCITY:
 981                     *pflValue1 = pSource->vVelocity[0];
 982                     *pflValue2 = pSource->vVelocity[1];
 983                     *pflValue3 = pSource->vVelocity[2];
 984                     break;
 985
 986                 case AL_DIRECTION:
 987                     *pflValue1 = pSource->vOrientation[0];
 988                     *pflValue2 = pSource->vOrientation[1];
 989                     *pflValue3 = pSource->vOrientation[2];
 990                     break;
 991
 992                 default:
 993                     alSetError(AL_INVALID_ENUM);
 994                     break;
 995                 }
 996             }
 997             else
 998                 alSetError(AL_INVALID_NAME);
 999         }
1000         else
1001             alSetError(AL_INVALID_VALUE);
1002
1003         ProcessContext(pContext);
1004     }
1005     else
1006         alSetError(AL_INVALID_OPERATION);
1007
1008     return;
1009 }
1010
1011
1012 ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pflValues)
1013 {
1014     ALCcontext    *pContext;
1015     ALsource    *pSource;
1016
1017     pContext = alcGetCurrentContext();
1018     if (pContext)
1019     {
1020         SuspendContext(pContext);
1021
1022         if (pflValues)
1023         {
1024             if (alIsSource(source))
1025             {
1026                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1027
1028                 switch(eParam)
1029                 {
1030                 case AL_PITCH:
1031                 case AL_GAIN:
1032                 case AL_MIN_GAIN:
1033                 case AL_MAX_GAIN:
1034                 case AL_MAX_DISTANCE:
1035                 case AL_ROLLOFF_FACTOR:
1036                 case AL_DOPPLER_FACTOR:
1037                 case AL_CONE_OUTER_GAIN:
1038                 case AL_SEC_OFFSET:
1039                 case AL_SAMPLE_OFFSET:
1040                 case AL_BYTE_OFFSET:
1041                 case AL_CONE_INNER_ANGLE:
1042                 case AL_CONE_OUTER_ANGLE:
1043                 case AL_REFERENCE_DISTANCE:
1044                 case AL_CONE_OUTER_GAINHF:
1045                 case AL_AIR_ABSORPTION_FACTOR:
1046                 case AL_ROOM_ROLLOFF_FACTOR:
1047                     alGetSourcef(source, eParam, pflValues);
1048                     break;
1049
1050                 case AL_POSITION:
1051                     pflValues[0] = pSource->vPosition[0];
1052                     pflValues[1] = pSource->vPosition[1];
1053                     pflValues[2] = pSource->vPosition[2];
1054                     break;
1055
1056                 case AL_VELOCITY:
1057                     pflValues[0] = pSource->vVelocity[0];
1058                     pflValues[1] = pSource->vVelocity[1];
1059                     pflValues[2] = pSource->vVelocity[2];
1060                     break;
1061
1062                 case AL_DIRECTION:
1063                     pflValues[0] = pSource->vOrientation[0];
1064                     pflValues[1] = pSource->vOrientation[1];
1065                     pflValues[2] = pSource->vOrientation[2];
1066                     break;
1067
1068                 default:
1069                     alSetError(AL_INVALID_ENUM);
1070                     break;
1071                 }
1072             }
1073             else
1074                 alSetError(AL_INVALID_NAME);
1075         }
1076         else
1077             alSetError(AL_INVALID_VALUE);
1078
1079         ProcessContext(pContext);
1080     }
1081     else
1082         alSetError(AL_INVALID_OPERATION);
1083
1084     return;
1085 }
1086
1087
1088 ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValue)
1089 {
1090     ALCcontext *pContext;
1091     ALsource   *pSource;
1092     ALfloat     flOffset;
1093
1094     pContext = alcGetCurrentContext();
1095     if (pContext)
1096     {
1097         SuspendContext(pContext);
1098
1099         if (plValue)
1100         {
1101             if (alIsSource(source))
1102             {
1103                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1104
1105                 switch(eParam)
1106                 {
1107                 case AL_MAX_DISTANCE:
1108                     *plValue = (ALint)pSource->flMaxDistance;
1109                     break;
1110
1111                 case AL_ROLLOFF_FACTOR:
1112                     *plValue = (ALint)pSource->flRollOffFactor;
1113                     break;
1114
1115                 case AL_REFERENCE_DISTANCE:
1116                     *plValue = (ALint)pSource->flRefDistance;
1117                     break;
1118
1119                 case AL_SOURCE_RELATIVE:
1120                     *plValue = pSource->bHeadRelative;
1121                     break;
1122
1123                 case AL_CONE_INNER_ANGLE:
1124                     *plValue = (ALint)pSource->flInnerAngle;
1125                     break;
1126
1127                 case AL_CONE_OUTER_ANGLE:
1128                     *plValue = (ALint)pSource->flOuterAngle;
1129                     break;
1130
1131                 case AL_LOOPING:
1132                     *plValue = pSource->bLooping;
1133                     break;
1134
1135                 case AL_BUFFER:
1136                     *plValue = pSource->ulBufferID;
1137                     break;
1138
1139                 case AL_SOURCE_STATE:
1140                     *plValue = pSource->state;
1141                     break;
1142
1143                 case AL_BUFFERS_QUEUED:
1144                     *plValue = pSource->BuffersInQueue;
1145                     break;
1146
1147                 case AL_BUFFERS_PROCESSED:
1148                     if(pSource->bLooping)
1149                     {
1150                         /* Buffers on a looping source are in a perpetual state
1151                          * of PENDING, so don't report any as PROCESSED */
1152                         *plValue = 0;
1153                     }
1154                     else
1155                         *plValue = pSource->BuffersPlayed;
1156                     break;
1157
1158                 case AL_SOURCE_TYPE:
1159                     *plValue = pSource->lSourceType;
1160                     break;
1161
1162                 case AL_SEC_OFFSET:
1163                 case AL_SAMPLE_OFFSET:
1164                 case AL_BYTE_OFFSET:
1165                     if (GetSourceOffset(pSource, eParam, &flOffset))
1166                         *plValue = (ALint)flOffset;
1167                     else
1168                         alSetError(AL_INVALID_OPERATION);
1169                     break;
1170
1171                 case AL_DIRECT_FILTER:
1172                     *plValue = pSource->DirectFilter.filter;
1173                     break;
1174
1175                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1176                     *plValue = pSource->DryGainHFAuto;
1177                     break;
1178
1179                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1180                     *plValue = pSource->WetGainAuto;
1181                     break;
1182
1183                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1184                     *plValue = pSource->WetGainHFAuto;
1185                     break;
1186
1187                 case AL_DOPPLER_FACTOR:
1188                     *plValue = (ALint)pSource->DopplerFactor;
1189                     break;
1190
1191                 default:
1192                     alSetError(AL_INVALID_ENUM);
1193                     break;
1194                 }
1195             }
1196             else
1197                 alSetError(AL_INVALID_NAME);
1198         }
1199         else
1200             alSetError(AL_INVALID_VALUE);
1201
1202         ProcessContext(pContext);
1203     }
1204     else
1205         alSetError(AL_INVALID_OPERATION);
1206
1207     return;
1208 }
1209
1210
1211 ALAPI void ALAPIENTRY alGetSource3i(ALuint source, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
1212 {
1213     ALCcontext  *pContext;
1214     ALsource    *pSource;
1215
1216     pContext = alcGetCurrentContext();
1217     if (pContext)
1218     {
1219         SuspendContext(pContext);
1220
1221         if ((plValue1) && (plValue2) && (plValue3))
1222         {
1223             if (alIsSource(source))
1224             {
1225                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1226
1227                 switch(eParam)
1228                 {
1229                 case AL_POSITION:
1230                     *plValue1 = (ALint)pSource->vPosition[0];
1231                     *plValue2 = (ALint)pSource->vPosition[1];
1232                     *plValue3 = (ALint)pSource->vPosition[2];
1233                     break;
1234
1235                 case AL_VELOCITY:
1236                     *plValue1 = (ALint)pSource->vVelocity[0];
1237                     *plValue2 = (ALint)pSource->vVelocity[1];
1238                     *plValue3 = (ALint)pSource->vVelocity[2];
1239                     break;
1240
1241                 case AL_DIRECTION:
1242                     *plValue1 = (ALint)pSource->vOrientation[0];
1243                     *plValue2 = (ALint)pSource->vOrientation[1];
1244                     *plValue3 = (ALint)pSource->vOrientation[2];
1245                     break;
1246
1247                 default:
1248                     alSetError(AL_INVALID_ENUM);
1249                     break;
1250                 }
1251             }
1252             else
1253                 alSetError(AL_INVALID_NAME);
1254         }
1255         else
1256             alSetError(AL_INVALID_VALUE);
1257
1258         ProcessContext(pContext);
1259     }
1260     else
1261         alSetError(AL_INVALID_OPERATION);
1262
1263     return;
1264 }
1265
1266
1267 ALAPI void ALAPIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValues)
1268 {
1269     ALCcontext  *pContext;
1270     ALsource    *pSource;
1271
1272     pContext = alcGetCurrentContext();
1273     if (pContext)
1274     {
1275         SuspendContext(pContext);
1276
1277         if (plValues)
1278         {
1279             if (alIsSource(source))
1280             {
1281                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1282
1283                 switch (eParam)
1284                 {
1285                 case AL_SOURCE_RELATIVE:
1286                 case AL_CONE_INNER_ANGLE:
1287                 case AL_CONE_OUTER_ANGLE:
1288                 case AL_LOOPING:
1289                 case AL_BUFFER:
1290                 case AL_SOURCE_STATE:
1291                 case AL_BUFFERS_QUEUED:
1292                 case AL_BUFFERS_PROCESSED:
1293                 case AL_SEC_OFFSET:
1294                 case AL_SAMPLE_OFFSET:
1295                 case AL_BYTE_OFFSET:
1296                 case AL_MAX_DISTANCE:
1297                 case AL_ROLLOFF_FACTOR:
1298                 case AL_DOPPLER_FACTOR:
1299                 case AL_REFERENCE_DISTANCE:
1300                 case AL_SOURCE_TYPE:
1301                 case AL_DIRECT_FILTER:
1302                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1303                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1304                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1305                     alGetSourcei(source, eParam, plValues);
1306                     break;
1307
1308                 case AL_POSITION:
1309                     plValues[0] = (ALint)pSource->vPosition[0];
1310                     plValues[1] = (ALint)pSource->vPosition[1];
1311                     plValues[2] = (ALint)pSource->vPosition[2];
1312                     break;
1313
1314                 case AL_VELOCITY:
1315                     plValues[0] = (ALint)pSource->vVelocity[0];
1316                     plValues[1] = (ALint)pSource->vVelocity[1];
1317                     plValues[2] = (ALint)pSource->vVelocity[2];
1318                     break;
1319
1320                 case AL_DIRECTION:
1321                     plValues[0] = (ALint)pSource->vOrientation[0];
1322                     plValues[1] = (ALint)pSource->vOrientation[1];
1323                     plValues[2] = (ALint)pSource->vOrientation[2];
1324                     break;
1325
1326                 default:
1327                     alSetError(AL_INVALID_ENUM);
1328                     break;
1329                 }
1330             }
1331             else
1332                 alSetError(AL_INVALID_NAME);
1333         }
1334         else
1335             alSetError(AL_INVALID_VALUE);
1336
1337         ProcessContext(pContext);
1338     }
1339     else
1340         alSetError(AL_INVALID_OPERATION);
1341
1342     return;
1343 }
1344
1345
1346 ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint source)
1347 {
1348     alSourcePlayv(1, &source);
1349     return;
1350 }
1351
1352 ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
1353 {
1354     ALCcontext          *pContext;
1355     ALsource            *pSource;
1356     ALbufferlistitem    *ALBufferList;
1357     ALboolean            bSourcesValid = AL_TRUE;
1358     ALboolean            bPlay;
1359     ALsizei              i, j;
1360
1361     pContext = alcGetCurrentContext();
1362     if (pContext)
1363     {
1364         SuspendContext(pContext);
1365
1366         if (pSourceList)
1367         {
1368             // Check that all the Sources are valid
1369             for (i = 0; i < n; i++)
1370             {
1371                 if (!alIsSource(pSourceList[i]))
1372                 {
1373                     alSetError(AL_INVALID_NAME);
1374                     bSourcesValid = AL_FALSE;
1375                     break;
1376                 }
1377             }
1378
1379             if (bSourcesValid)
1380             {
1381                 for (i = 0; i < n; i++)
1382                 {
1383                     // Assume Source won't need to play
1384                     bPlay = AL_FALSE;
1385
1386                     pSource = ((ALsource*)ALTHUNK_LOOKUPENTRY(pSourceList[i]));
1387
1388                     // Check that there is a queue containing at least one non-null, non zero length AL Buffer
1389                     ALBufferList = pSource->queue;
1390                     while (ALBufferList)
1391                     {
1392                         if ((ALBufferList->buffer != 0) && (((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size))
1393                         {
1394                             bPlay = AL_TRUE;
1395                             break;
1396                         }
1397                         ALBufferList = ALBufferList->next;
1398                     }
1399
1400                     if (bPlay)
1401                     {
1402                         for(j = 0;j < OUTPUTCHANNELS;j++)
1403                             pSource->DryGains[j] = 0.0f;
1404                         pSource->WetGain = 0.0f;
1405
1406                         if (pSource->state != AL_PAUSED)
1407                         {
1408                             pSource->state = AL_PLAYING;
1409                             pSource->inuse = AL_TRUE;
1410                             pSource->play = AL_TRUE;
1411                             pSource->position = 0;
1412                             pSource->position_fraction = 0;
1413                             pSource->BuffersPlayed = 0;
1414
1415                             pSource->ulBufferID = pSource->queue->buffer;
1416
1417                             // Make sure all the Buffers in the queue are marked as PENDING
1418                             ALBufferList = pSource->queue;
1419                             while (ALBufferList)
1420                             {
1421                                 ALBufferList->bufferstate = PENDING;
1422                                 ALBufferList = ALBufferList->next;
1423                             }
1424                         }
1425                         else
1426                         {
1427                             pSource->state = AL_PLAYING;
1428                             pSource->inuse = AL_TRUE;
1429                             pSource->play = AL_TRUE;
1430                         }
1431
1432                         // Check if an Offset has been set
1433                         if (pSource->lOffset)
1434                             ApplyOffset(pSource, AL_FALSE);
1435                     }
1436                     else
1437                     {
1438                         // If there is a queue (must all be NULL or Zero length Buffers) mark them all as processed
1439                         ALBufferList = pSource->queue;
1440                         while (ALBufferList)
1441                         {
1442                             ALBufferList->bufferstate = PROCESSED;
1443                             ALBufferList = ALBufferList->next;
1444                         }
1445
1446                         pSource->BuffersPlayed = pSource->BuffersInQueue;
1447                     }
1448                 }
1449             }
1450         }
1451         else
1452         {
1453             // sources is a NULL pointer
1454             alSetError(AL_INVALID_VALUE);
1455         }
1456
1457         ProcessContext(pContext);
1458     }
1459     else
1460     {
1461         // Invalid Context
1462         alSetError(AL_INVALID_OPERATION);
1463     }
1464
1465     return;
1466 }
1467
1468 ALAPI ALvoid ALAPIENTRY alSourcePause(ALuint source)
1469 {
1470     alSourcePausev(1, &source);
1471     return;
1472 }
1473
1474 ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
1475 {
1476     ALCcontext *Context;
1477     ALsource *Source;
1478     ALsizei i;
1479     ALboolean bSourcesValid = AL_TRUE;
1480
1481     Context=alcGetCurrentContext();
1482     if (Context)
1483     {
1484         SuspendContext(Context);
1485
1486         if (sources)
1487         {
1488             // Check all the Sources are valid
1489             for (i=0;i<n;i++)
1490             {
1491                 if (!alIsSource(sources[i]))
1492                 {
1493                     alSetError(AL_INVALID_NAME);
1494                     bSourcesValid = AL_FALSE;
1495                     break;
1496                 }
1497             }
1498
1499             if (bSourcesValid)
1500             {
1501                 for (i=0;i<n;i++)
1502                 {
1503                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1504                     if (Source->state==AL_PLAYING)
1505                     {
1506                         Source->state=AL_PAUSED;
1507                         Source->inuse=AL_FALSE;
1508                     }
1509                 }
1510             }
1511         }
1512         else
1513         {
1514             // sources is a NULL pointer
1515             alSetError(AL_INVALID_VALUE);
1516         }
1517
1518         ProcessContext(Context);
1519     }
1520     else
1521     {
1522         // Invalid Context
1523         alSetError(AL_INVALID_OPERATION);
1524     }
1525
1526     return;
1527 }
1528
1529 ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint source)
1530 {
1531     alSourceStopv(1, &source);
1532     return;
1533 }
1534
1535 ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
1536 {
1537     ALCcontext *Context;
1538     ALsource *Source;
1539     ALsizei i;
1540     ALbufferlistitem *ALBufferListItem;
1541     ALboolean bSourcesValid = AL_TRUE;
1542
1543     Context=alcGetCurrentContext();
1544     if (Context)
1545     {
1546         SuspendContext(Context);
1547
1548         if (sources)
1549         {
1550             // Check all the Sources are valid
1551             for (i=0;i<n;i++)
1552             {
1553                 if (!alIsSource(sources[i]))
1554                 {
1555                     alSetError(AL_INVALID_NAME);
1556                     bSourcesValid = AL_FALSE;
1557                     break;
1558                 }
1559             }
1560
1561             if (bSourcesValid)
1562             {
1563                 for (i=0;i<n;i++)
1564                 {
1565                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1566                     if (Source->state!=AL_INITIAL)
1567                     {
1568                         Source->state=AL_STOPPED;
1569                         Source->inuse=AL_FALSE;
1570                         Source->BuffersPlayed = Source->BuffersInQueue;
1571                         ALBufferListItem= Source->queue;
1572                         while (ALBufferListItem != NULL)
1573                         {
1574                             ALBufferListItem->bufferstate = PROCESSED;
1575                             ALBufferListItem = ALBufferListItem->next;
1576                         }
1577                     }
1578                     Source->lOffset = 0;
1579                 }
1580             }
1581         }
1582         else
1583         {
1584             // sources is a NULL pointer
1585             alSetError(AL_INVALID_VALUE);
1586         }
1587
1588         ProcessContext(Context);
1589     }
1590     else
1591     {
1592         // Invalid Context
1593         alSetError(AL_INVALID_OPERATION);
1594     }
1595
1596     return;
1597 }
1598
1599 ALAPI ALvoid ALAPIENTRY alSourceRewind(ALuint source)
1600 {
1601     alSourceRewindv(1, &source);
1602     return;
1603 }
1604
1605 ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
1606 {
1607     ALCcontext *Context;
1608     ALsource *Source;
1609     ALsizei i;
1610     ALbufferlistitem *ALBufferListItem;
1611     ALboolean bSourcesValid = AL_TRUE;
1612
1613     Context=alcGetCurrentContext();
1614     if (Context)
1615     {
1616         SuspendContext(Context);
1617
1618         if (sources)
1619         {
1620             // Check all the Sources are valid
1621             for (i=0;i<n;i++)
1622             {
1623                 if (!alIsSource(sources[i]))
1624                 {
1625                     alSetError(AL_INVALID_NAME);
1626                     bSourcesValid = AL_FALSE;
1627                     break;
1628                 }
1629             }
1630
1631             if (bSourcesValid)
1632             {
1633                 for (i=0;i<n;i++)
1634                 {
1635                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1636                     if (Source->state!=AL_INITIAL)
1637                     {
1638                         Source->state=AL_INITIAL;
1639                         Source->inuse=AL_FALSE;
1640                         Source->position=0;
1641                         Source->position_fraction=0;
1642                         Source->BuffersPlayed = 0;
1643                         ALBufferListItem= Source->queue;
1644                         while (ALBufferListItem != NULL)
1645                         {
1646                             ALBufferListItem->bufferstate = PENDING;
1647                             ALBufferListItem = ALBufferListItem->next;
1648                         }
1649                         if (Source->queue)
1650                             Source->ulBufferID = Source->queue->buffer;
1651                     }
1652                     Source->lOffset = 0;
1653                 }
1654             }
1655         }
1656         else
1657         {
1658             // sources is a NULL pointer
1659             alSetError(AL_INVALID_VALUE);
1660         }
1661
1662         ProcessContext(Context);
1663     }
1664     else
1665     {
1666         // Invalid Context
1667         alSetError(AL_INVALID_OPERATION);
1668     }
1669
1670     return;
1671 }
1672
1673
1674 ALAPI ALvoid ALAPIENTRY alSourceQueueBuffers( ALuint source, ALsizei n, const ALuint* buffers )
1675 {
1676     ALCcontext *Context;
1677     ALsource *ALSource;
1678     ALsizei i;
1679     ALbufferlistitem *ALBufferList;
1680     ALbufferlistitem *ALBufferListStart;
1681     ALuint DataSize;
1682     ALuint BufferSize;
1683     ALint iFrequency;
1684     ALint iFormat;
1685     ALboolean bBuffersValid = AL_TRUE;
1686
1687     if (n == 0)
1688         return;
1689
1690     Context=alcGetCurrentContext();
1691     if (Context)
1692     {
1693         SuspendContext(Context);
1694
1695         DataSize = 0;
1696         BufferSize = 0;
1697
1698         // Check that all buffers are valid or zero and that the source is valid
1699
1700         // Check that this is a valid source
1701         if (alIsSource(source))
1702         {
1703             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1704
1705             // Check that this is not a STATIC Source
1706             if (ALSource->lSourceType != AL_STATIC)
1707             {
1708                 iFrequency = -1;
1709                 iFormat = -1;
1710
1711                 // Check existing Queue (if any) for a valid Buffers and get its frequency and format
1712                 ALBufferList = ALSource->queue;
1713                 while (ALBufferList)
1714                 {
1715                     if (ALBufferList->buffer)
1716                     {
1717                         iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->frequency;
1718                         iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->format;
1719                         break;
1720                     }
1721                     ALBufferList = ALBufferList->next;
1722                 }
1723
1724                 for (i = 0; i < n; i++)
1725                 {
1726                     if (alIsBuffer(buffers[i]))
1727                     {
1728                         if (buffers[i])
1729                         {
1730                             if ((iFrequency == -1) && (iFormat == -1))
1731                             {
1732                                 iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency;
1733                                 iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format;
1734                             }
1735                             else
1736                             {
1737                                 if ((iFrequency != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency) ||
1738                                     (iFormat != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format))
1739                                 {
1740                                     alSetError(AL_INVALID_OPERATION);
1741                                     bBuffersValid = AL_FALSE;
1742                                     break;
1743                                 }
1744                             }
1745                         }
1746                     }
1747                     else
1748                     {
1749                         alSetError(AL_INVALID_NAME);
1750                         bBuffersValid = AL_FALSE;
1751                         break;
1752                     }
1753                 }
1754
1755                 if (bBuffersValid)
1756                 {
1757                     // Change Source Type
1758                     ALSource->lSourceType = AL_STREAMING;
1759
1760                     // All buffers are valid - so add them to the list
1761                     ALBufferListStart = malloc(sizeof(ALbufferlistitem));
1762                     ALBufferListStart->buffer = buffers[0];
1763                     ALBufferListStart->bufferstate = PENDING;
1764                     ALBufferListStart->flag = 0;
1765                     ALBufferListStart->next = NULL;
1766
1767                     if (buffers[0])
1768                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[0]))->size;
1769                     else
1770                         BufferSize = 0;
1771
1772                     DataSize += BufferSize;
1773
1774                     // Increment reference counter for buffer
1775                     if (buffers[0])
1776                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[0])))->refcount++;
1777
1778                     ALBufferList = ALBufferListStart;
1779
1780                     for (i = 1; i < n; i++)
1781                     {
1782                         ALBufferList->next = malloc(sizeof(ALbufferlistitem));
1783                         ALBufferList->next->buffer = buffers[i];
1784                         ALBufferList->next->bufferstate = PENDING;
1785                         ALBufferList->next->flag = 0;
1786                         ALBufferList->next->next = NULL;
1787
1788                         if (buffers[i])
1789                             BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[i]))->size;
1790                         else
1791                             BufferSize = 0;
1792
1793                         DataSize += BufferSize;
1794
1795                         // Increment reference counter for buffer
1796                         if (buffers[i])
1797                             ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->refcount++;
1798
1799                         ALBufferList = ALBufferList->next;
1800                     }
1801
1802                     if (ALSource->queue == NULL)
1803                     {
1804                         ALSource->queue = ALBufferListStart;
1805                         // Update Current Buffer
1806                         ALSource->ulBufferID = ALBufferListStart->buffer;
1807                     }
1808                     else
1809                     {
1810                         // Find end of queue
1811                         ALBufferList = ALSource->queue;
1812                         while (ALBufferList->next != NULL)
1813                         {
1814                             ALBufferList = ALBufferList->next;
1815                         }
1816
1817                         ALBufferList->next = ALBufferListStart;
1818                     }
1819
1820                     // Update number of buffers in queue
1821                     ALSource->BuffersInQueue += n;
1822                 }
1823             }
1824             else
1825             {
1826                 // Invalid Source Type (can't queue on a Static Source)
1827                 alSetError(AL_INVALID_OPERATION);
1828             }
1829         }
1830         else
1831         {
1832             // Invalid Source Name
1833             alSetError(AL_INVALID_NAME);
1834         }
1835
1836         ProcessContext(Context);
1837     }
1838     else
1839     {
1840         // Invalid Context
1841         alSetError(AL_INVALID_OPERATION);
1842     }
1843
1844     return;
1845 }
1846
1847
1848 // Implementation assumes that n is the number of buffers to be removed from the queue and buffers is
1849 // an array of buffer IDs that are to be filled with the names of the buffers removed
1850 ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers )
1851 {
1852     ALCcontext *Context;
1853     ALsource *ALSource;
1854     ALsizei i;
1855     ALbufferlistitem *ALBufferList;
1856     ALuint DataSize;
1857     ALuint BufferSize;
1858     ALuint BufferID;
1859     ALboolean bBuffersProcessed;
1860
1861     if (n == 0)
1862         return;
1863
1864     DataSize = 0;
1865     BufferSize = 0;
1866     bBuffersProcessed = AL_TRUE;
1867
1868     Context=alcGetCurrentContext();
1869     if (Context)
1870     {
1871         SuspendContext(Context);
1872
1873         if (alIsSource(source))
1874         {
1875             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1876
1877             // Check that all 'n' buffers have been processed
1878             ALBufferList = ALSource->queue;
1879             for (i = 0; i < n; i++)
1880             {
1881                 if ((ALBufferList != NULL) && (ALBufferList->bufferstate == PROCESSED))
1882                 {
1883                     ALBufferList = ALBufferList->next;
1884                 }
1885                 else
1886                 {
1887                     bBuffersProcessed = AL_FALSE;
1888                     break;
1889                 }
1890             }
1891
1892             // If all 'n' buffers have been processed, remove them from the queue
1893             if (bBuffersProcessed)
1894             {
1895                 for (i = 0; i < n; i++)
1896                 {
1897                     ALBufferList = ALSource->queue;
1898
1899                     ALSource->queue = ALBufferList->next;
1900                     // Record name of buffer
1901                     buffers[i] = ALBufferList->buffer;
1902                     // Decrement buffer reference counter
1903                     if (ALBufferList->buffer)
1904                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
1905                     // Record size of buffer
1906                     if (ALBufferList->buffer)
1907                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size;
1908                     else
1909                         BufferSize = 0;
1910
1911                     DataSize += BufferSize;
1912                     // Release memory for buffer list item
1913                     free(ALBufferList);
1914                     ALSource->BuffersInQueue--;
1915                 }
1916
1917                 if (ALSource->state != AL_PLAYING)
1918                 {
1919                     if (ALSource->queue)
1920                         BufferID = ALSource->queue->buffer;
1921                     else
1922                         BufferID = 0;
1923
1924                     ALSource->ulBufferID = BufferID;
1925                 }
1926
1927                 if((ALuint)n > ALSource->BuffersPlayed)
1928                     ALSource->BuffersPlayed = 0;
1929                 else
1930                     ALSource->BuffersPlayed -= n;
1931             }
1932             else
1933             {
1934                 // Some buffers can't be unqueue because they have not been processed
1935                 alSetError(AL_INVALID_VALUE);
1936             }
1937         }
1938         else
1939         {
1940             // Invalid Source Name
1941             alSetError(AL_INVALID_NAME);
1942         }
1943
1944         ProcessContext(Context);
1945     }
1946     else
1947     {
1948         // Invalid Context
1949         alSetError(AL_INVALID_OPERATION);
1950     }
1951
1952     return;
1953 }
1954
1955
1956 static ALvoid InitSourceParams(ALsource *pSource)
1957 {
1958     pSource->flInnerAngle = 360.0f;
1959     pSource->flOuterAngle = 360.0f;
1960     pSource->flPitch = 1.0f;
1961     pSource->vPosition[0] = 0.0f;
1962     pSource->vPosition[1] = 0.0f;
1963     pSource->vPosition[2] = 0.0f;
1964     pSource->vOrientation[0] = 0.0f;
1965     pSource->vOrientation[1] = 0.0f;
1966     pSource->vOrientation[2] = 0.0f;
1967     pSource->vVelocity[0] = 0.0f;
1968     pSource->vVelocity[1] = 0.0f;
1969     pSource->vVelocity[2] = 0.0f;
1970     pSource->flRefDistance = 1.0f;
1971     pSource->flMaxDistance = FLT_MAX;
1972     pSource->flRollOffFactor = 1.0f;
1973     pSource->bLooping = AL_FALSE;
1974     pSource->flGain = 1.0f;
1975     pSource->flMinGain = 0.0f;
1976     pSource->flMaxGain = 1.0f;
1977     pSource->flOuterGain = 0.0f;
1978     pSource->OuterGainHF = 1.0f;
1979
1980     pSource->DryGainHFAuto = AL_TRUE;
1981     pSource->WetGainAuto = AL_TRUE;
1982     pSource->WetGainHFAuto = AL_TRUE;
1983     pSource->AirAbsorptionFactor = 0.0f;
1984     pSource->RoomRolloffFactor = 0.0f;
1985     pSource->DopplerFactor = 1.0f;
1986
1987     pSource->state = AL_INITIAL;
1988     pSource->lSourceType = AL_UNDETERMINED;
1989
1990     pSource->ulBufferID= 0;
1991 }
1992
1993
1994 /*
1995     GetSourceOffset
1996
1997     Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)
1998     The offset is relative to the start of the queue (not the start of the current buffer)
1999 */
2000 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset)
2001 {
2002     ALbufferlistitem *pBufferList;
2003     ALbuffer         *pBuffer;
2004     ALfloat        flBufferFreq;
2005     ALint        lBytesPlayed, lChannels;
2006     ALenum        eOriginalFormat;
2007     ALboolean    bReturn = AL_TRUE;
2008     ALint        lTotalBufferDataSize;
2009
2010     if (((pSource->state == AL_PLAYING) || (pSource->state == AL_PAUSED)) && (pSource->ulBufferID))
2011     {
2012         pBuffer = ALTHUNK_LOOKUPENTRY(pSource->ulBufferID);
2013         // Get Current Buffer Size and frequency (in milliseconds)
2014         flBufferFreq = (ALfloat)pBuffer->frequency;
2015         eOriginalFormat = pBuffer->eOriginalFormat;
2016         lChannels = aluChannelsFromFormat(pBuffer->format);
2017
2018         // Get Current BytesPlayed
2019         lBytesPlayed = pSource->position * lChannels * 2; // NOTE : This is the byte offset into the *current* buffer
2020         // Add byte length of any processed buffers in the queue
2021         pBufferList = pSource->queue;
2022         while ((pBufferList) && (pBufferList->bufferstate == PROCESSED))
2023         {
2024             lBytesPlayed += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2025             pBufferList = pBufferList->next;
2026         }
2027
2028         lTotalBufferDataSize = 0;
2029         pBufferList = pSource->queue;
2030         while (pBufferList)
2031         {
2032             if (pBufferList->buffer)
2033                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2034             pBufferList = pBufferList->next;
2035         }
2036
2037         if (pSource->bLooping)
2038         {
2039             if (lBytesPlayed < 0)
2040                 lBytesPlayed = 0;
2041             else
2042                 lBytesPlayed = lBytesPlayed % lTotalBufferDataSize;
2043         }
2044         else
2045         {
2046             // Clamp BytesPlayed to within 0 and lTotalBufferDataSize
2047             if(lBytesPlayed < 0)
2048                 lBytesPlayed = 0;
2049             if(lBytesPlayed > lTotalBufferDataSize)
2050                 lBytesPlayed = lTotalBufferDataSize;
2051         }
2052
2053         switch (eName)
2054         {
2055         case AL_SEC_OFFSET:
2056             *pflOffset = ((ALfloat)lBytesPlayed / (lChannels * 2.0f * flBufferFreq));
2057             break;
2058         case AL_SAMPLE_OFFSET:
2059             *pflOffset = (ALfloat)(lBytesPlayed / (lChannels * 2));
2060             break;
2061         case AL_BYTE_OFFSET:
2062             // Take into account the original format of the Buffer
2063             if ((eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2064                 (eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2065             {
2066                 // Compression rate of the ADPCM supported is 3.6111 to 1
2067                 lBytesPlayed = (ALint)((ALfloat)lBytesPlayed / 3.6111f);
2068                 // Round down to nearest ADPCM block
2069                 *pflOffset = (ALfloat)((lBytesPlayed / (36 * lChannels)) * 36 * lChannels);
2070             }
2071             else if (eOriginalFormat == AL_FORMAT_REAR8)
2072             {
2073                 *pflOffset = (ALfloat)(lBytesPlayed >> 2);
2074             }
2075             else if (eOriginalFormat == AL_FORMAT_REAR16)
2076             {
2077                 *pflOffset = (ALfloat)(lBytesPlayed >> 1);
2078             }
2079             else if (aluBytesFromFormat(eOriginalFormat) == 1)
2080             {
2081                 *pflOffset = (ALfloat)(lBytesPlayed >> 1);
2082             }
2083             else if (aluBytesFromFormat(eOriginalFormat) == 4)
2084             {
2085                 *pflOffset = (ALfloat)(lBytesPlayed << 1);
2086             }
2087             else
2088             {
2089                 *pflOffset = (ALfloat)lBytesPlayed;
2090             }
2091             break;
2092         }
2093     }
2094     else
2095     {
2096         *pflOffset = 0.0f;
2097     }
2098
2099     return bReturn;
2100 }
2101
2102
2103 /*
2104     ApplyOffset
2105
2106     Apply a playback offset to the Source.  This function will update the queue (to correctly
2107     mark buffers as 'pending' or 'processed' depending upon the new offset.
2108 */
2109 static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
2110 {
2111     ALbufferlistitem    *pBufferList;
2112     ALbuffer            *pBuffer;
2113     ALint                lBufferSize, lTotalBufferSize;
2114     ALint                lByteOffset;
2115
2116     // Get true byte offset
2117     lByteOffset = GetByteOffset(pSource);
2118
2119     // If this is a valid offset apply it
2120     if (lByteOffset != -1)
2121     {
2122         // Sort out the queue (pending and processed states)
2123         pBufferList = pSource->queue;
2124         lTotalBufferSize = 0;
2125         pSource->BuffersPlayed = 0;
2126         while (pBufferList)
2127         {
2128             pBuffer = ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2129             lBufferSize = pBuffer ? pBuffer->size : 0;
2130
2131             if ((lTotalBufferSize + lBufferSize) <= lByteOffset)
2132             {
2133                 // Offset is past this buffer so increment BuffersPlayed and if the Source is NOT looping
2134                 // update the state to PROCESSED
2135                 pSource->BuffersPlayed++;
2136
2137                 if (!pSource->bLooping)
2138                     pBufferList->bufferstate = PROCESSED;
2139             }
2140             else if (lTotalBufferSize <= lByteOffset)
2141             {
2142                 // Offset is within this buffer
2143                 pBufferList->bufferstate = PENDING;
2144
2145                 // Set Current Buffer ID
2146                 pSource->ulBufferID = pBufferList->buffer;
2147
2148                 // SW Mixer Positions are in Samples
2149                 pSource->position = (lByteOffset - lTotalBufferSize) /
2150                                     aluBytesFromFormat(pBuffer->format) /
2151                                     aluChannelsFromFormat(pBuffer->format);
2152             }
2153             else
2154             {
2155                 // Offset is before this buffer, so mark as pending
2156                 pBufferList->bufferstate = PENDING;
2157             }
2158
2159             // Increment the TotalBufferSize
2160             lTotalBufferSize += lBufferSize;
2161
2162             // Move on to next buffer in the Queue
2163             pBufferList = pBufferList->next;
2164         }
2165     }
2166     else
2167     {
2168         if (bUpdateContext)
2169             alSetError(AL_INVALID_VALUE);
2170     }
2171
2172     // Clear Offset
2173     pSource->lOffset = 0;
2174 }
2175
2176
2177 /*
2178     GetByteOffset
2179
2180     Returns the 'true' byte offset into the Source's queue (from the Sample, Byte or Millisecond
2181     offset supplied by the application).   This takes into account the fact that the buffer format
2182     may have been modifed by AL (e.g 8bit samples are converted to 16bit)
2183 */
2184 static ALint GetByteOffset(ALsource *pSource)
2185 {
2186     ALbuffer *pBuffer = NULL;
2187     ALbufferlistitem *pBufferList;
2188     ALfloat    flBufferFreq;
2189     ALint    lChannels;
2190     ALint    lByteOffset = -1;
2191     ALint    lTotalBufferDataSize;
2192
2193     // Find the first non-NULL Buffer in the Queue
2194     pBufferList = pSource->queue;
2195     while (pBufferList)
2196     {
2197         if (pBufferList->buffer)
2198         {
2199             pBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2200             break;
2201         }
2202         pBufferList = pBufferList->next;
2203     }
2204
2205     if (pBuffer)
2206     {
2207         flBufferFreq = ((ALfloat)pBuffer->frequency);
2208         lChannels = aluChannelsFromFormat(pBuffer->format);
2209
2210         // Determine the ByteOffset (and ensure it is block aligned)
2211         switch (pSource->lOffsetType)
2212         {
2213         case AL_BYTE_OFFSET:
2214             // Take into consideration the original format
2215             if ((pBuffer->eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2216                 (pBuffer->eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2217             {
2218                 // Round down to nearest ADPCM block
2219                 lByteOffset = (pSource->lOffset / (36 * lChannels)) * 36 * lChannels;
2220                 // Multiply by compression rate
2221                 lByteOffset = (ALint)(3.6111f * (ALfloat)lByteOffset);
2222                 lByteOffset -= (lByteOffset % (lChannels * 2));
2223             }
2224             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR8)
2225             {
2226                 lByteOffset = pSource->lOffset * 4;
2227                 lByteOffset -= (lByteOffset % (lChannels * 2));
2228             }
2229             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR16)
2230             {
2231                 lByteOffset = pSource->lOffset * 2;
2232                 lByteOffset -= (lByteOffset % (lChannels * 2));
2233             }
2234             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 1)
2235             {
2236                 lByteOffset = pSource->lOffset * 2;
2237                 lByteOffset -= (lByteOffset % (lChannels * 2));
2238             }
2239             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 4)
2240             {
2241                 lByteOffset = pSource->lOffset / 2;
2242                 lByteOffset -= (lByteOffset % (lChannels * 2));
2243             }
2244             else
2245             {
2246                 lByteOffset = pSource->lOffset;
2247                 lByteOffset -= (lByteOffset % (lChannels * 2));
2248             }
2249             break;
2250
2251         case AL_SAMPLE_OFFSET:
2252             lByteOffset = pSource->lOffset * lChannels * 2;
2253             break;
2254
2255         case AL_SEC_OFFSET:
2256             // Note - lOffset is internally stored as Milliseconds
2257             lByteOffset = (ALint)(pSource->lOffset * lChannels * 2.0f * flBufferFreq / 1000.0f);
2258             lByteOffset -= (lByteOffset % (lChannels * 2));
2259             break;
2260         }
2261
2262         lTotalBufferDataSize = 0;
2263         pBufferList = pSource->queue;
2264         while (pBufferList)
2265         {
2266             if (pBufferList->buffer)
2267                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2268             pBufferList = pBufferList->next;
2269         }
2270
2271         // Finally, if the ByteOffset is beyond the length of all the buffers in the queue, return -1
2272         if (lByteOffset >= lTotalBufferDataSize)
2273             lByteOffset = -1;
2274     }
2275
2276     return lByteOffset;
2277 }
2278
2279
2280 ALvoid ReleaseALSources(ALCcontext *Context)
2281 {
2282 #ifdef _DEBUG
2283     if(Context->SourceCount > 0)
2284         AL_PRINT("alcDestroyContext(): deleting %d Source(s)\n", Context->SourceCount);
2285 #endif
2286
2287     while(Context->Source)
2288     {
2289         ALsource *temp = Context->Source;
2290         Context->Source = Context->Source->next;
2291
2292         // Release source structure
2293         ALTHUNK_REMOVEENTRY(temp->source);
2294         memset(temp, 0, sizeof(ALsource));
2295         free(temp);
2296     }
2297     Context->SourceCount = 0;
2298 }