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