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