OpenAL32/alSource.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25 #include <float.h>
  26 #include "alMain.h"
  27 #include "AL/al.h"
  28 #include "AL/alc.h"
  29 #include "alError.h"
  30 #include "alSource.h"
  31 #include "alBuffer.h"
  32 #include "alThunk.h"
  33 #include "alAuxEffectSlot.h"
  34
  35 static ALvoid InitSourceParams(ALsource *pSource);
  36 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset);
  37 static ALvoid ApplyOffset(ALsource *pSource, ALboolean bUpdateContext);
  38 static ALint GetByteOffset(ALsource *pSource);
  39
  40 ALAPI ALvoid ALAPIENTRY alGenSources(ALsizei n,ALuint *sources)
  41 {
  42     ALCcontext *Context;
  43     ALCdevice *Device;
  44     ALsizei i=0;
  45
  46     Context = alcGetCurrentContext();
  47     if (Context)
  48     {
  49         SuspendContext(Context);
  50
  51         if (n > 0)
  52         {
  53             Device = alcGetContextsDevice(Context);
  54
  55             if (Device)
  56             {
  57                 // Check that enough memory has been allocted in the 'sources' array for n Sources
  58                 if (!IsBadWritePtr((void*)sources, n * sizeof(ALuint)))
  59                 {
  60                     // Check that the requested number of sources can be generated
  61                     if ((Context->SourceCount + n) <= Device->MaxNoOfSources)
  62                     {
  63                         ALsource **list = &Context->Source;
  64                         while(*list)
  65                             list = &(*list)->next;
  66
  67                         // Add additional sources to the list (Source->next points to the location for the next Source structure)
  68                         while(i < n)
  69                         {
  70                             *list = calloc(1, sizeof(ALsource));
  71                             if(!(*list))
  72                             {
  73                                 alDeleteSources(i, sources);
  74                                 alSetError(AL_OUT_OF_MEMORY);
  75                                 break;
  76                             }
  77
  78                             sources[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  79                             (*list)->source = sources[i];
  80
  81                             InitSourceParams(*list);
  82                             Context->SourceCount++;
  83                             i++;
  84
  85                             list = &(*list)->next;
  86                         }
  87                     }
  88                     else
  89                     {
  90                         // Not enough resources to create the Sources
  91                         alSetError(AL_INVALID_VALUE);
  92                     }
  93                 }
  94                 else
  95                 {
  96                     // Bad pointer
  97                     alSetError(AL_INVALID_VALUE);
  98                 }
  99             }
 100             else
 101             {
 102                 // No Device created, or attached to Context
 103                 alSetError(AL_INVALID_OPERATION);
 104             }
 105         }
 106
 107         ProcessContext(Context);
 108     }
 109     else
 110     {
 111         // Invalid Context
 112         alSetError(AL_INVALID_OPERATION);
 113     }
 114
 115     return;
 116 }
 117
 118
 119 ALAPI ALvoid ALAPIENTRY alDeleteSources(ALsizei n, const ALuint *sources)
 120 {
 121     ALCcontext *Context;
 122     ALCdevice  *Device;
 123     ALsource *ALSource;
 124     ALsource **list;
 125     ALsizei i, j;
 126     ALbufferlistitem *ALBufferList;
 127     ALboolean bSourcesValid = AL_TRUE;
 128
 129     Context = alcGetCurrentContext();
 130     if (Context)
 131     {
 132         SuspendContext(Context);
 133
 134         if (n >= 0)
 135         {
 136             Device = alcGetContextsDevice(Context);
 137
 138             if (Device)
 139             {
 140                 if ((ALuint)n <= Context->SourceCount)
 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                 }
 203                 else
 204                 {
 205                     // Trying to delete more Sources than have been generated
 206                     alSetError(AL_INVALID_NAME);
 207                 }
 208             }
 209             else
 210             {
 211                 // No Device created, or attached to Context
 212                 alSetError(AL_INVALID_OPERATION);
 213             }
 214         }
 215         else
 216             alSetError(AL_INVALID_VALUE);
 217
 218         ProcessContext(Context);
 219     }
 220     else
 221     {
 222         // Invalid Context
 223         alSetError(AL_INVALID_OPERATION);
 224     }
 225
 226     return;
 227 }
 228
 229
 230 ALAPI ALboolean ALAPIENTRY alIsSource(ALuint source)
 231 {
 232     ALboolean result=AL_FALSE;
 233     ALCcontext *Context;
 234     ALsource *Source;
 235
 236     Context=alcGetCurrentContext();
 237     if (Context)
 238     {
 239         SuspendContext(Context);
 240
 241         // To determine if this is a valid Source name, look through the list of generated Sources
 242         Source = Context->Source;
 243         while(Source)
 244         {
 245             if (Source == (ALsource*)ALTHUNK_LOOKUPENTRY(source))
 246             {
 247                 result = AL_TRUE;
 248                 break;
 249             }
 250
 251             Source = Source->next;
 252         }
 253
 254         ProcessContext(Context);
 255     }
 256     else
 257     {
 258         // Invalid Context
 259         alSetError(AL_INVALID_OPERATION);
 260     }
 261
 262     return result;
 263 }
 264
 265
 266 ALAPI ALvoid ALAPIENTRY alSourcef(ALuint source, ALenum eParam, ALfloat flValue)
 267 {
 268     ALCcontext    *pContext;
 269     ALsource    *pSource;
 270
 271     pContext = alcGetCurrentContext();
 272     if (pContext)
 273     {
 274         SuspendContext(pContext);
 275
 276         if (alIsSource(source))
 277         {
 278             pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 279
 280             switch (eParam)
 281             {
 282             case AL_PITCH:
 283                 if (flValue >= 0.0f)
 284                 {
 285                     pSource->flPitch = flValue;
 286                     if(pSource->flPitch < 0.001f)
 287                         pSource->flPitch = 0.001f;
 288                 }
 289                 else
 290                     alSetError(AL_INVALID_VALUE);
 291                 break;
 292
 293             case AL_CONE_INNER_ANGLE:
 294                 if ((flValue >= 0.0f) && (flValue <= 360.0f))
 295                     pSource->flInnerAngle = flValue;
 296                 else
 297                     alSetError(AL_INVALID_VALUE);
 298                 break;
 299
 300             case AL_CONE_OUTER_ANGLE:
 301                 if ((flValue >= 0.0f) && (flValue <= 360.0f))
 302                     pSource->flOuterAngle = flValue;
 303                 else
 304                     alSetError(AL_INVALID_VALUE);
 305                 break;
 306
 307             case AL_GAIN:
 308                 if (flValue >= 0.0f)
 309                     pSource->flGain = flValue;
 310                 else
 311                     alSetError(AL_INVALID_VALUE);
 312                 break;
 313
 314             case AL_MAX_DISTANCE:
 315                 if (flValue >= 0.0f)
 316                     pSource->flMaxDistance = flValue;
 317                 else
 318                     alSetError(AL_INVALID_VALUE);
 319                 break;
 320
 321             case AL_ROLLOFF_FACTOR:
 322                 if (flValue >= 0.0f)
 323                     pSource->flRollOffFactor = flValue;
 324                 else
 325                     alSetError(AL_INVALID_VALUE);
 326                 break;
 327
 328             case AL_REFERENCE_DISTANCE:
 329                 if (flValue >= 0.0f)
 330                     pSource->flRefDistance = flValue;
 331                 else
 332                     alSetError(AL_INVALID_VALUE);
 333                 break;
 334
 335             case AL_MIN_GAIN:
 336                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 337                     pSource->flMinGain = flValue;
 338                 else
 339                     alSetError(AL_INVALID_VALUE);
 340                 break;
 341
 342             case AL_MAX_GAIN:
 343                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 344                     pSource->flMaxGain = flValue;
 345                 else
 346                     alSetError(AL_INVALID_VALUE);
 347                 break;
 348
 349             case AL_CONE_OUTER_GAIN:
 350                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 351                     pSource->flOuterGain = flValue;
 352                 else
 353                     alSetError(AL_INVALID_VALUE);
 354                 break;
 355
 356             case AL_CONE_OUTER_GAINHF:
 357                 if ((flValue >= 0.0f) && (flValue <= 1.0f))
 358                     pSource->OuterGainHF = flValue;
 359                 else
 360                     alSetError(AL_INVALID_VALUE);
 361                 break;
 362
 363             case AL_AIR_ABSORPTION_FACTOR:
 364                 if (flValue >= 0.0f && flValue <= 10.0f)
 365                     pSource->AirAbsorptionFactor = flValue;
 366                 else
 367                     alSetError(AL_INVALID_VALUE);
 368                 break;
 369
 370             case AL_ROOM_ROLLOFF_FACTOR:
 371                 if (flValue >= 0.0f && flValue <= 1.0f)
 372                     pSource->RoomRolloffFactor = 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                 default:
 938                     alSetError(AL_INVALID_ENUM);
 939                     break;
 940                 }
 941             }
 942             else
 943                 alSetError(AL_INVALID_NAME);
 944         }
 945         else
 946             alSetError(AL_INVALID_VALUE);
 947
 948         ProcessContext(pContext);
 949     }
 950     else
 951         alSetError(AL_INVALID_OPERATION);
 952
 953     return;
 954 }
 955
 956
 957 ALAPI ALvoid ALAPIENTRY alGetSource3f(ALuint source, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)
 958 {
 959     ALCcontext    *pContext;
 960     ALsource    *pSource;
 961
 962     pContext = alcGetCurrentContext();
 963     if (pContext)
 964     {
 965         SuspendContext(pContext);
 966
 967         if ((pflValue1) && (pflValue2) && (pflValue3))
 968         {
 969             if (alIsSource(source))
 970             {
 971                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
 972
 973                 switch(eParam)
 974                 {
 975                 case AL_POSITION:
 976                     *pflValue1 = pSource->vPosition[0];
 977                     *pflValue2 = pSource->vPosition[1];
 978                     *pflValue3 = pSource->vPosition[2];
 979                     break;
 980
 981                 case AL_VELOCITY:
 982                     *pflValue1 = pSource->vVelocity[0];
 983                     *pflValue2 = pSource->vVelocity[1];
 984                     *pflValue3 = pSource->vVelocity[2];
 985                     break;
 986
 987                 case AL_DIRECTION:
 988                     *pflValue1 = pSource->vOrientation[0];
 989                     *pflValue2 = pSource->vOrientation[1];
 990                     *pflValue3 = pSource->vOrientation[2];
 991                     break;
 992
 993                 default:
 994                     alSetError(AL_INVALID_ENUM);
 995                     break;
 996                 }
 997             }
 998             else
 999                 alSetError(AL_INVALID_NAME);
1000         }
1001         else
1002             alSetError(AL_INVALID_VALUE);
1003
1004         ProcessContext(pContext);
1005     }
1006     else
1007         alSetError(AL_INVALID_OPERATION);
1008
1009     return;
1010 }
1011
1012
1013 ALAPI ALvoid ALAPIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pflValues)
1014 {
1015     ALCcontext    *pContext;
1016     ALsource    *pSource;
1017
1018     pContext = alcGetCurrentContext();
1019     if (pContext)
1020     {
1021         SuspendContext(pContext);
1022
1023         if (pflValues)
1024         {
1025             if (alIsSource(source))
1026             {
1027                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1028
1029                 switch(eParam)
1030                 {
1031                 case AL_PITCH:
1032                 case AL_GAIN:
1033                 case AL_MIN_GAIN:
1034                 case AL_MAX_GAIN:
1035                 case AL_MAX_DISTANCE:
1036                 case AL_ROLLOFF_FACTOR:
1037                 case AL_CONE_OUTER_GAIN:
1038                 case AL_SEC_OFFSET:
1039                 case AL_SAMPLE_OFFSET:
1040                 case AL_BYTE_OFFSET:
1041                 case AL_CONE_INNER_ANGLE:
1042                 case AL_CONE_OUTER_ANGLE:
1043                 case AL_REFERENCE_DISTANCE:
1044                 case AL_CONE_OUTER_GAINHF:
1045                 case AL_AIR_ABSORPTION_FACTOR:
1046                 case AL_ROOM_ROLLOFF_FACTOR:
1047                     alGetSourcef(source, eParam, pflValues);
1048                     break;
1049
1050                 case AL_POSITION:
1051                     pflValues[0] = pSource->vPosition[0];
1052                     pflValues[1] = pSource->vPosition[1];
1053                     pflValues[2] = pSource->vPosition[2];
1054                     break;
1055
1056                 case AL_VELOCITY:
1057                     pflValues[0] = pSource->vVelocity[0];
1058                     pflValues[1] = pSource->vVelocity[1];
1059                     pflValues[2] = pSource->vVelocity[2];
1060                     break;
1061
1062                 case AL_DIRECTION:
1063                     pflValues[0] = pSource->vOrientation[0];
1064                     pflValues[1] = pSource->vOrientation[1];
1065                     pflValues[2] = pSource->vOrientation[2];
1066                     break;
1067
1068                 default:
1069                     alSetError(AL_INVALID_ENUM);
1070                     break;
1071                 }
1072             }
1073             else
1074                 alSetError(AL_INVALID_NAME);
1075         }
1076         else
1077             alSetError(AL_INVALID_VALUE);
1078
1079         ProcessContext(pContext);
1080     }
1081     else
1082         alSetError(AL_INVALID_OPERATION);
1083
1084     return;
1085 }
1086
1087
1088 ALAPI ALvoid ALAPIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValue)
1089 {
1090     ALCcontext *pContext;
1091     ALsource   *pSource;
1092     ALfloat     flOffset;
1093
1094     pContext = alcGetCurrentContext();
1095     if (pContext)
1096     {
1097         SuspendContext(pContext);
1098
1099         if (plValue)
1100         {
1101             if (alIsSource(source))
1102             {
1103                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1104
1105                 switch(eParam)
1106                 {
1107                 case AL_MAX_DISTANCE:
1108                     *plValue = (ALint)pSource->flMaxDistance;
1109                     break;
1110
1111                 case AL_ROLLOFF_FACTOR:
1112                     *plValue = (ALint)pSource->flRollOffFactor;
1113                     break;
1114
1115                 case AL_REFERENCE_DISTANCE:
1116                     *plValue = (ALint)pSource->flRefDistance;
1117                     break;
1118
1119                 case AL_SOURCE_RELATIVE:
1120                     *plValue = pSource->bHeadRelative;
1121                     break;
1122
1123                 case AL_CONE_INNER_ANGLE:
1124                     *plValue = (ALint)pSource->flInnerAngle;
1125                     break;
1126
1127                 case AL_CONE_OUTER_ANGLE:
1128                     *plValue = (ALint)pSource->flOuterAngle;
1129                     break;
1130
1131                 case AL_LOOPING:
1132                     *plValue = pSource->bLooping;
1133                     break;
1134
1135                 case AL_BUFFER:
1136                     *plValue = pSource->ulBufferID;
1137                     break;
1138
1139                 case AL_SOURCE_STATE:
1140                     *plValue = pSource->state;
1141                     break;
1142
1143                 case AL_BUFFERS_QUEUED:
1144                     *plValue = pSource->BuffersInQueue;
1145                     break;
1146
1147                 case AL_BUFFERS_PROCESSED:
1148                     if(pSource->bLooping)
1149                     {
1150                         /* Buffers on a looping source are in a perpetual state
1151                          * of PENDING, so don't report any as PROCESSED */
1152                         *plValue = 0;
1153                     }
1154                     else
1155                         *plValue = pSource->BuffersProcessed;
1156                     break;
1157
1158                 case AL_SOURCE_TYPE:
1159                     *plValue = pSource->lSourceType;
1160                     break;
1161
1162                 case AL_SEC_OFFSET:
1163                 case AL_SAMPLE_OFFSET:
1164                 case AL_BYTE_OFFSET:
1165                     if (GetSourceOffset(pSource, eParam, &flOffset))
1166                         *plValue = (ALint)flOffset;
1167                     else
1168                         alSetError(AL_INVALID_OPERATION);
1169                     break;
1170
1171                 case AL_DIRECT_FILTER:
1172                     *plValue = pSource->DirectFilter.filter;
1173                     break;
1174
1175                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1176                     *plValue = pSource->DryGainHFAuto;
1177                     break;
1178
1179                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1180                     *plValue = pSource->WetGainAuto;
1181                     break;
1182
1183                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1184                     *plValue = pSource->WetGainHFAuto;
1185                     break;
1186
1187                 default:
1188                     alSetError(AL_INVALID_ENUM);
1189                     break;
1190                 }
1191             }
1192             else
1193                 alSetError(AL_INVALID_NAME);
1194         }
1195         else
1196             alSetError(AL_INVALID_VALUE);
1197
1198         ProcessContext(pContext);
1199     }
1200     else
1201         alSetError(AL_INVALID_OPERATION);
1202
1203     return;
1204 }
1205
1206
1207 ALAPI void ALAPIENTRY alGetSource3i(ALuint source, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)
1208 {
1209     ALCcontext  *pContext;
1210     ALsource    *pSource;
1211
1212     pContext = alcGetCurrentContext();
1213     if (pContext)
1214     {
1215         SuspendContext(pContext);
1216
1217         if ((plValue1) && (plValue2) && (plValue3))
1218         {
1219             if (alIsSource(source))
1220             {
1221                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1222
1223                 switch(eParam)
1224                 {
1225                 case AL_POSITION:
1226                     *plValue1 = (ALint)pSource->vPosition[0];
1227                     *plValue2 = (ALint)pSource->vPosition[1];
1228                     *plValue3 = (ALint)pSource->vPosition[2];
1229                     break;
1230
1231                 case AL_VELOCITY:
1232                     *plValue1 = (ALint)pSource->vVelocity[0];
1233                     *plValue2 = (ALint)pSource->vVelocity[1];
1234                     *plValue3 = (ALint)pSource->vVelocity[2];
1235                     break;
1236
1237                 case AL_DIRECTION:
1238                     *plValue1 = (ALint)pSource->vOrientation[0];
1239                     *plValue2 = (ALint)pSource->vOrientation[1];
1240                     *plValue3 = (ALint)pSource->vOrientation[2];
1241                     break;
1242
1243                 default:
1244                     alSetError(AL_INVALID_ENUM);
1245                     break;
1246                 }
1247             }
1248             else
1249                 alSetError(AL_INVALID_NAME);
1250         }
1251         else
1252             alSetError(AL_INVALID_VALUE);
1253
1254         ProcessContext(pContext);
1255     }
1256     else
1257         alSetError(AL_INVALID_OPERATION);
1258
1259     return;
1260 }
1261
1262
1263 ALAPI void ALAPIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValues)
1264 {
1265     ALCcontext  *pContext;
1266     ALsource    *pSource;
1267
1268     pContext = alcGetCurrentContext();
1269     if (pContext)
1270     {
1271         SuspendContext(pContext);
1272
1273         if (plValues)
1274         {
1275             if (alIsSource(source))
1276             {
1277                 pSource = ((ALsource *)ALTHUNK_LOOKUPENTRY(source));
1278
1279                 switch (eParam)
1280                 {
1281                 case AL_SOURCE_RELATIVE:
1282                 case AL_CONE_INNER_ANGLE:
1283                 case AL_CONE_OUTER_ANGLE:
1284                 case AL_LOOPING:
1285                 case AL_BUFFER:
1286                 case AL_SOURCE_STATE:
1287                 case AL_BUFFERS_QUEUED:
1288                 case AL_BUFFERS_PROCESSED:
1289                 case AL_SEC_OFFSET:
1290                 case AL_SAMPLE_OFFSET:
1291                 case AL_BYTE_OFFSET:
1292                 case AL_MAX_DISTANCE:
1293                 case AL_ROLLOFF_FACTOR:
1294                 case AL_REFERENCE_DISTANCE:
1295                 case AL_SOURCE_TYPE:
1296                 case AL_DIRECT_FILTER:
1297                 case AL_DIRECT_FILTER_GAINHF_AUTO:
1298                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:
1299                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:
1300                     alGetSourcei(source, eParam, plValues);
1301                     break;
1302
1303                 case AL_POSITION:
1304                     plValues[0] = (ALint)pSource->vPosition[0];
1305                     plValues[1] = (ALint)pSource->vPosition[1];
1306                     plValues[2] = (ALint)pSource->vPosition[2];
1307                     break;
1308
1309                 case AL_VELOCITY:
1310                     plValues[0] = (ALint)pSource->vVelocity[0];
1311                     plValues[1] = (ALint)pSource->vVelocity[1];
1312                     plValues[2] = (ALint)pSource->vVelocity[2];
1313                     break;
1314
1315                 case AL_DIRECTION:
1316                     plValues[0] = (ALint)pSource->vOrientation[0];
1317                     plValues[1] = (ALint)pSource->vOrientation[1];
1318                     plValues[2] = (ALint)pSource->vOrientation[2];
1319                     break;
1320
1321                 default:
1322                     alSetError(AL_INVALID_ENUM);
1323                     break;
1324                 }
1325             }
1326             else
1327                 alSetError(AL_INVALID_NAME);
1328         }
1329         else
1330             alSetError(AL_INVALID_VALUE);
1331
1332         ProcessContext(pContext);
1333     }
1334     else
1335         alSetError(AL_INVALID_OPERATION);
1336
1337     return;
1338 }
1339
1340
1341 ALAPI ALvoid ALAPIENTRY alSourcePlay(ALuint source)
1342 {
1343     alSourcePlayv(1, &source);
1344     return;
1345 }
1346
1347 ALAPI ALvoid ALAPIENTRY alSourcePlayv(ALsizei n, const ALuint *pSourceList)
1348 {
1349     ALCcontext          *pContext;
1350     ALsource            *pSource;
1351     ALbufferlistitem    *ALBufferList;
1352     ALboolean            bSourcesValid = AL_TRUE;
1353     ALboolean            bPlay;
1354     ALsizei              i;
1355
1356     pContext = alcGetCurrentContext();
1357     if (pContext)
1358     {
1359         SuspendContext(pContext);
1360
1361         if (pSourceList)
1362         {
1363             // Check that all the Sources are valid
1364             for (i = 0; i < n; i++)
1365             {
1366                 if (!alIsSource(pSourceList[i]))
1367                 {
1368                     alSetError(AL_INVALID_NAME);
1369                     bSourcesValid = AL_FALSE;
1370                     break;
1371                 }
1372             }
1373
1374             if (bSourcesValid)
1375             {
1376                 for (i = 0; i < n; i++)
1377                 {
1378                     // Assume Source won't need to play
1379                     bPlay = AL_FALSE;
1380
1381                     pSource = ((ALsource*)ALTHUNK_LOOKUPENTRY(pSourceList[i]));
1382
1383                     // Check that there is a queue containing at least one non-null, non zero length AL Buffer
1384                     ALBufferList = pSource->queue;
1385                     while (ALBufferList)
1386                     {
1387                         if ((ALBufferList->buffer != 0) && (((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size))
1388                         {
1389                             bPlay = AL_TRUE;
1390                             break;
1391                         }
1392                         ALBufferList = ALBufferList->next;
1393                     }
1394
1395                     if (bPlay)
1396                     {
1397                         if (pSource->state != AL_PAUSED)
1398                         {
1399                             pSource->state = AL_PLAYING;
1400                             pSource->inuse = AL_TRUE;
1401                             pSource->play = AL_TRUE;
1402                             pSource->position = 0;
1403                             pSource->position_fraction = 0;
1404                             pSource->BuffersProcessed = 0;
1405                             pSource->BuffersPlayed = 0;
1406                             pSource->BufferPosition = 0;
1407                             pSource->lBytesPlayed = 0;
1408
1409                             pSource->ulBufferID = pSource->queue->buffer;
1410
1411                             // Make sure all the Buffers in the queue are marked as PENDING
1412                             ALBufferList = pSource->queue;
1413                             while (ALBufferList)
1414                             {
1415                                 ALBufferList->bufferstate = PENDING;
1416                                 ALBufferList = ALBufferList->next;
1417                             }
1418                         }
1419                         else
1420                         {
1421                             pSource->state = AL_PLAYING;
1422                             pSource->inuse = AL_TRUE;
1423                             pSource->play = AL_TRUE;
1424                         }
1425
1426                         // Check if an Offset has been set
1427                         if (pSource->lOffset)
1428                             ApplyOffset(pSource, AL_FALSE);
1429                     }
1430                     else
1431                     {
1432                         // If there is a queue (must all be NULL or Zero length Buffers) mark them all as processed
1433                         ALBufferList = pSource->queue;
1434                         while (ALBufferList)
1435                         {
1436                             ALBufferList->bufferstate = PROCESSED;
1437                             ALBufferList = ALBufferList->next;
1438                         }
1439
1440                         pSource->BuffersPlayed = pSource->BuffersProcessed = pSource->BuffersInQueue;
1441                     }
1442                 }
1443             }
1444         }
1445         else
1446         {
1447             // sources is a NULL pointer
1448             alSetError(AL_INVALID_VALUE);
1449         }
1450
1451         ProcessContext(pContext);
1452     }
1453     else
1454     {
1455         // Invalid Context
1456         alSetError(AL_INVALID_OPERATION);
1457     }
1458
1459     return;
1460 }
1461
1462 ALAPI ALvoid ALAPIENTRY alSourcePause(ALuint source)
1463 {
1464     alSourcePausev(1, &source);
1465     return;
1466 }
1467
1468 ALAPI ALvoid ALAPIENTRY alSourcePausev(ALsizei n, const ALuint *sources)
1469 {
1470     ALCcontext *Context;
1471     ALsource *Source;
1472     ALsizei i;
1473     ALboolean bSourcesValid = AL_TRUE;
1474
1475     Context=alcGetCurrentContext();
1476     if (Context)
1477     {
1478         SuspendContext(Context);
1479
1480         if (sources)
1481         {
1482             // Check all the Sources are valid
1483             for (i=0;i<n;i++)
1484             {
1485                 if (!alIsSource(sources[i]))
1486                 {
1487                     alSetError(AL_INVALID_NAME);
1488                     bSourcesValid = AL_FALSE;
1489                     break;
1490                 }
1491             }
1492
1493             if (bSourcesValid)
1494             {
1495                 for (i=0;i<n;i++)
1496                 {
1497                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1498                     if (Source->state==AL_PLAYING)
1499                     {
1500                         Source->state=AL_PAUSED;
1501                         Source->inuse=AL_FALSE;
1502                     }
1503                 }
1504             }
1505         }
1506         else
1507         {
1508             // sources is a NULL pointer
1509             alSetError(AL_INVALID_VALUE);
1510         }
1511
1512         ProcessContext(Context);
1513     }
1514     else
1515     {
1516         // Invalid Context
1517         alSetError(AL_INVALID_OPERATION);
1518     }
1519
1520     return;
1521 }
1522
1523 ALAPI ALvoid ALAPIENTRY alSourceStop(ALuint source)
1524 {
1525     alSourceStopv(1, &source);
1526     return;
1527 }
1528
1529 ALAPI ALvoid ALAPIENTRY alSourceStopv(ALsizei n, const ALuint *sources)
1530 {
1531     ALCcontext *Context;
1532     ALsource *Source;
1533     ALsizei i;
1534     ALbufferlistitem *ALBufferListItem;
1535     ALboolean bSourcesValid = AL_TRUE;
1536
1537     Context=alcGetCurrentContext();
1538     if (Context)
1539     {
1540         SuspendContext(Context);
1541
1542         if (sources)
1543         {
1544             // Check all the Sources are valid
1545             for (i=0;i<n;i++)
1546             {
1547                 if (!alIsSource(sources[i]))
1548                 {
1549                     alSetError(AL_INVALID_NAME);
1550                     bSourcesValid = AL_FALSE;
1551                     break;
1552                 }
1553             }
1554
1555             if (bSourcesValid)
1556             {
1557                 for (i=0;i<n;i++)
1558                 {
1559                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1560                     if (Source->state!=AL_INITIAL)
1561                     {
1562                         Source->state=AL_STOPPED;
1563                         Source->inuse=AL_FALSE;
1564                         Source->BuffersPlayed = Source->BuffersProcessed = Source->BuffersInQueue;
1565                         ALBufferListItem= Source->queue;
1566                         while (ALBufferListItem != NULL)
1567                         {
1568                             ALBufferListItem->bufferstate = PROCESSED;
1569                             ALBufferListItem = ALBufferListItem->next;
1570                         }
1571                     }
1572                     Source->lOffset = 0;
1573                 }
1574             }
1575         }
1576         else
1577         {
1578             // sources is a NULL pointer
1579             alSetError(AL_INVALID_VALUE);
1580         }
1581
1582         ProcessContext(Context);
1583     }
1584     else
1585     {
1586         // Invalid Context
1587         alSetError(AL_INVALID_OPERATION);
1588     }
1589
1590     return;
1591 }
1592
1593 ALAPI ALvoid ALAPIENTRY alSourceRewind(ALuint source)
1594 {
1595     alSourceRewindv(1, &source);
1596     return;
1597 }
1598
1599 ALAPI ALvoid ALAPIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)
1600 {
1601     ALCcontext *Context;
1602     ALsource *Source;
1603     ALsizei i;
1604     ALbufferlistitem *ALBufferListItem;
1605     ALboolean bSourcesValid = AL_TRUE;
1606
1607     Context=alcGetCurrentContext();
1608     if (Context)
1609     {
1610         SuspendContext(Context);
1611
1612         if (sources)
1613         {
1614             // Check all the Sources are valid
1615             for (i=0;i<n;i++)
1616             {
1617                 if (!alIsSource(sources[i]))
1618                 {
1619                     alSetError(AL_INVALID_NAME);
1620                     bSourcesValid = AL_FALSE;
1621                     break;
1622                 }
1623             }
1624
1625             if (bSourcesValid)
1626             {
1627                 for (i=0;i<n;i++)
1628                 {
1629                     Source=((ALsource *)ALTHUNK_LOOKUPENTRY(sources[i]));
1630                     if (Source->state!=AL_INITIAL)
1631                     {
1632                         Source->state=AL_INITIAL;
1633                         Source->inuse=AL_FALSE;
1634                         Source->position=0;
1635                         Source->position_fraction=0;
1636                         Source->BuffersProcessed = 0;
1637                         ALBufferListItem= Source->queue;
1638                         while (ALBufferListItem != NULL)
1639                         {
1640                             ALBufferListItem->bufferstate = PENDING;
1641                             ALBufferListItem = ALBufferListItem->next;
1642                         }
1643                         if (Source->queue)
1644                             Source->ulBufferID = Source->queue->buffer;
1645                     }
1646                     Source->lOffset = 0;
1647                 }
1648             }
1649         }
1650         else
1651         {
1652             // sources is a NULL pointer
1653             alSetError(AL_INVALID_VALUE);
1654         }
1655
1656         ProcessContext(Context);
1657     }
1658     else
1659     {
1660         // Invalid Context
1661         alSetError(AL_INVALID_OPERATION);
1662     }
1663
1664     return;
1665 }
1666
1667
1668 ALAPI ALvoid ALAPIENTRY alSourceQueueBuffers( ALuint source, ALsizei n, const ALuint* buffers )
1669 {
1670     ALCcontext *Context;
1671     ALsource *ALSource;
1672     ALsizei i;
1673     ALbufferlistitem *ALBufferList;
1674     ALbufferlistitem *ALBufferListStart;
1675     ALuint DataSize;
1676     ALuint BufferSize;
1677     ALint iFrequency;
1678     ALint iFormat;
1679     ALboolean bBuffersValid = AL_TRUE;
1680
1681     if (n == 0)
1682         return;
1683
1684     Context=alcGetCurrentContext();
1685     if (Context)
1686     {
1687         SuspendContext(Context);
1688
1689         DataSize = 0;
1690         BufferSize = 0;
1691
1692         // Check that all buffers are valid or zero and that the source is valid
1693
1694         // Check that this is a valid source
1695         if (alIsSource(source))
1696         {
1697             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1698
1699             // Check that this is not a STATIC Source
1700             if (ALSource->lSourceType != AL_STATIC)
1701             {
1702                 iFrequency = -1;
1703                 iFormat = -1;
1704
1705                 // Check existing Queue (if any) for a valid Buffers and get its frequency and format
1706                 ALBufferList = ALSource->queue;
1707                 while (ALBufferList)
1708                 {
1709                     if (ALBufferList->buffer)
1710                     {
1711                         iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->frequency;
1712                         iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->format;
1713                         break;
1714                     }
1715                     ALBufferList = ALBufferList->next;
1716                 }
1717
1718                 for (i = 0; i < n; i++)
1719                 {
1720                     if (alIsBuffer(buffers[i]))
1721                     {
1722                         if (buffers[i])
1723                         {
1724                             if ((iFrequency == -1) && (iFormat == -1))
1725                             {
1726                                 iFrequency = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency;
1727                                 iFormat = ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format;
1728                             }
1729                             else
1730                             {
1731                                 if ((iFrequency != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->frequency) ||
1732                                     (iFormat != ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->format))
1733                                 {
1734                                     alSetError(AL_INVALID_OPERATION);
1735                                     bBuffersValid = AL_FALSE;
1736                                     break;
1737                                 }
1738                             }
1739                         }
1740                     }
1741                     else
1742                     {
1743                         alSetError(AL_INVALID_NAME);
1744                         bBuffersValid = AL_FALSE;
1745                         break;
1746                     }
1747                 }
1748
1749                 if (bBuffersValid)
1750                 {
1751                     // Change Source Type
1752                     ALSource->lSourceType = AL_STREAMING;
1753
1754                     // All buffers are valid - so add them to the list
1755                     ALBufferListStart = malloc(sizeof(ALbufferlistitem));
1756                     ALBufferListStart->buffer = buffers[0];
1757                     ALBufferListStart->bufferstate = PENDING;
1758                     ALBufferListStart->flag = 0;
1759                     ALBufferListStart->next = NULL;
1760
1761                     if (buffers[0])
1762                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[0]))->size;
1763                     else
1764                         BufferSize = 0;
1765
1766                     DataSize += BufferSize;
1767
1768                     // Increment reference counter for buffer
1769                     if (buffers[0])
1770                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[0])))->refcount++;
1771
1772                     ALBufferList = ALBufferListStart;
1773
1774                     for (i = 1; i < n; i++)
1775                     {
1776                         ALBufferList->next = malloc(sizeof(ALbufferlistitem));
1777                         ALBufferList->next->buffer = buffers[i];
1778                         ALBufferList->next->bufferstate = PENDING;
1779                         ALBufferList->next->flag = 0;
1780                         ALBufferList->next->next = NULL;
1781
1782                         if (buffers[i])
1783                             BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(buffers[i]))->size;
1784                         else
1785                             BufferSize = 0;
1786
1787                         DataSize += BufferSize;
1788
1789                         // Increment reference counter for buffer
1790                         if (buffers[i])
1791                             ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(buffers[i])))->refcount++;
1792
1793                         ALBufferList = ALBufferList->next;
1794                     }
1795
1796                     if (ALSource->queue == NULL)
1797                     {
1798                         ALSource->queue = ALBufferListStart;
1799                         // Update Current Buffer
1800                         ALSource->ulBufferID = ALBufferListStart->buffer;
1801                     }
1802                     else
1803                     {
1804                         // Find end of queue
1805                         ALBufferList = ALSource->queue;
1806                         while (ALBufferList->next != NULL)
1807                         {
1808                             ALBufferList = ALBufferList->next;
1809                         }
1810
1811                         ALBufferList->next = ALBufferListStart;
1812                     }
1813
1814                     // Update number of buffers in queue
1815                     ALSource->BuffersInQueue += n;
1816                 }
1817             }
1818             else
1819             {
1820                 // Invalid Source Type (can't queue on a Static Source)
1821                 alSetError(AL_INVALID_OPERATION);
1822             }
1823         }
1824         else
1825         {
1826             // Invalid Source Name
1827             alSetError(AL_INVALID_NAME);
1828         }
1829
1830         ProcessContext(Context);
1831     }
1832     else
1833     {
1834         // Invalid Context
1835         alSetError(AL_INVALID_OPERATION);
1836     }
1837
1838     return;
1839 }
1840
1841
1842 // Implementation assumes that n is the number of buffers to be removed from the queue and buffers is
1843 // an array of buffer IDs that are to be filled with the names of the buffers removed
1844 ALAPI ALvoid ALAPIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers )
1845 {
1846     ALCcontext *Context;
1847     ALsource *ALSource;
1848     ALsizei i;
1849     ALbufferlistitem *ALBufferList;
1850     ALuint DataSize;
1851     ALuint BufferSize;
1852     ALuint BufferID;
1853     ALboolean bBuffersProcessed;
1854
1855     if (n == 0)
1856         return;
1857
1858     DataSize = 0;
1859     BufferSize = 0;
1860     bBuffersProcessed = AL_TRUE;
1861
1862     Context=alcGetCurrentContext();
1863     if (Context)
1864     {
1865         SuspendContext(Context);
1866
1867         if (alIsSource(source))
1868         {
1869             ALSource = (ALsource*)ALTHUNK_LOOKUPENTRY(source);
1870
1871             // Check that all 'n' buffers have been processed
1872             ALBufferList = ALSource->queue;
1873             for (i = 0; i < n; i++)
1874             {
1875                 if ((ALBufferList != NULL) && (ALBufferList->bufferstate == PROCESSED))
1876                 {
1877                     ALBufferList = ALBufferList->next;
1878                 }
1879                 else
1880                 {
1881                     bBuffersProcessed = AL_FALSE;
1882                     break;
1883                 }
1884             }
1885
1886             // If all 'n' buffers have been processed, remove them from the queue
1887             if (bBuffersProcessed)
1888             {
1889                 for (i = 0; i < n; i++)
1890                 {
1891                     ALBufferList = ALSource->queue;
1892
1893                     ALSource->queue = ALBufferList->next;
1894                     // Record name of buffer
1895                     buffers[i] = ALBufferList->buffer;
1896                     // Decrement buffer reference counter
1897                     if (ALBufferList->buffer)
1898                         ((ALbuffer*)(ALTHUNK_LOOKUPENTRY(ALBufferList->buffer)))->refcount--;
1899                     // Record size of buffer
1900                     if (ALBufferList->buffer)
1901                         BufferSize = ((ALbuffer*)ALTHUNK_LOOKUPENTRY(ALBufferList->buffer))->size;
1902                     else
1903                         BufferSize = 0;
1904
1905                     DataSize += BufferSize;
1906                     // Release memory for buffer list item
1907                     free(ALBufferList);
1908                     ALSource->BuffersInQueue--;
1909                     ALSource->BuffersProcessed--;
1910                 }
1911
1912                 if (ALSource->state != AL_PLAYING)
1913                 {
1914                     if (ALSource->queue)
1915                         BufferID = ALSource->queue->buffer;
1916                     else
1917                         BufferID = 0;
1918
1919                     ALSource->ulBufferID = BufferID;
1920                 }
1921
1922                 if((ALuint)n > ALSource->BuffersPlayed)
1923                 {
1924                     ALSource->BuffersPlayed = 0;
1925                     ALSource->BufferPosition = 0;
1926                 }
1927                 else
1928                     ALSource->BuffersPlayed -= n;
1929             }
1930             else
1931             {
1932                 // Some buffers can't be unqueue because they have not been processed
1933                 alSetError(AL_INVALID_VALUE);
1934             }
1935         }
1936         else
1937         {
1938             // Invalid Source Name
1939             alSetError(AL_INVALID_NAME);
1940         }
1941
1942         ProcessContext(Context);
1943     }
1944     else
1945     {
1946         // Invalid Context
1947         alSetError(AL_INVALID_OPERATION);
1948     }
1949
1950     return;
1951 }
1952
1953
1954 static ALvoid InitSourceParams(ALsource *pSource)
1955 {
1956     pSource->flInnerAngle = 360.0f;
1957     pSource->flOuterAngle = 360.0f;
1958     pSource->flPitch = 1.0f;
1959     pSource->vPosition[0] = 0.0f;
1960     pSource->vPosition[1] = 0.0f;
1961     pSource->vPosition[2] = 0.0f;
1962     pSource->vOrientation[0] = 0.0f;
1963     pSource->vOrientation[1] = 0.0f;
1964     pSource->vOrientation[2] = 0.0f;
1965     pSource->vVelocity[0] = 0.0f;
1966     pSource->vVelocity[1] = 0.0f;
1967     pSource->vVelocity[2] = 0.0f;
1968     pSource->flRefDistance = 1.0f;
1969     pSource->flMaxDistance = FLT_MAX;
1970     pSource->flRollOffFactor = 1.0f;
1971     pSource->bLooping = AL_FALSE;
1972     pSource->flGain = 1.0f;
1973     pSource->flMinGain = 0.0f;
1974     pSource->flMaxGain = 1.0f;
1975     pSource->flOuterGain = 0.0f;
1976     pSource->OuterGainHF = 1.0f;
1977
1978     pSource->DryGainHFAuto = AL_TRUE;
1979     pSource->WetGainAuto = AL_TRUE;
1980     pSource->WetGainHFAuto = AL_TRUE;
1981     pSource->AirAbsorptionFactor = 0.0f;
1982     pSource->RoomRolloffFactor = 0.0f;
1983
1984     pSource->state = AL_INITIAL;
1985     pSource->lSourceType = AL_UNDETERMINED;
1986
1987     pSource->ulBufferID= 0;
1988 }
1989
1990
1991 /*
1992     GetSourceOffset
1993
1994     Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)
1995     The offset is relative to the start of the queue (not the start of the current buffer)
1996 */
1997 static ALboolean GetSourceOffset(ALsource *pSource, ALenum eName, ALfloat *pflOffset)
1998 {
1999     ALbufferlistitem *pBufferList;
2000     ALbuffer         *pBuffer;
2001     ALfloat        flBufferFreq;
2002     ALint        lBytesPlayed, lChannels;
2003     ALenum        eOriginalFormat;
2004     ALboolean    bReturn = AL_TRUE;
2005     ALint        lTotalBufferDataSize;
2006
2007     if (((pSource->state == AL_PLAYING) || (pSource->state == AL_PAUSED)) && (pSource->ulBufferID))
2008     {
2009         pBuffer = ALTHUNK_LOOKUPENTRY(pSource->ulBufferID);
2010         // Get Current Buffer Size and frequency (in milliseconds)
2011         flBufferFreq = (ALfloat)pBuffer->frequency;
2012         eOriginalFormat = pBuffer->eOriginalFormat;
2013         lChannels = aluChannelsFromFormat(pBuffer->format);
2014
2015         // Get Current BytesPlayed
2016         lBytesPlayed = pSource->position * lChannels * 2; // NOTE : This is the byte offset into the *current* buffer
2017         // Add byte length of any processed buffers in the queue
2018         pBufferList = pSource->queue;
2019         while ((pBufferList) && (pBufferList->bufferstate == PROCESSED))
2020         {
2021             lBytesPlayed += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2022             pBufferList = pBufferList->next;
2023         }
2024
2025         lTotalBufferDataSize = 0;
2026         pBufferList = pSource->queue;
2027         while (pBufferList)
2028         {
2029             if (pBufferList->buffer)
2030                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2031             pBufferList = pBufferList->next;
2032         }
2033
2034         if (pSource->bLooping)
2035         {
2036             if (lBytesPlayed < 0)
2037                 lBytesPlayed = 0;
2038             else
2039                 lBytesPlayed = lBytesPlayed % lTotalBufferDataSize;
2040         }
2041         else
2042         {
2043             // Clamp BytesPlayed to within 0 and lTotalBufferDataSize
2044             if(lBytesPlayed < 0)
2045                 lBytesPlayed = 0;
2046             if(lBytesPlayed > lTotalBufferDataSize)
2047                 lBytesPlayed = lTotalBufferDataSize;
2048         }
2049
2050         switch (eName)
2051         {
2052         case AL_SEC_OFFSET:
2053             *pflOffset = ((ALfloat)lBytesPlayed / (lChannels * 2.0f * flBufferFreq));
2054             break;
2055         case AL_SAMPLE_OFFSET:
2056             *pflOffset = (ALfloat)(lBytesPlayed / (lChannels * 2));
2057             break;
2058         case AL_BYTE_OFFSET:
2059             // Take into account the original format of the Buffer
2060             if ((eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2061                 (eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2062             {
2063                 // Compression rate of the ADPCM supported is 3.6111 to 1
2064                 lBytesPlayed = (ALint)((ALfloat)lBytesPlayed / 3.6111f);
2065                 // Round down to nearest ADPCM block
2066                 *pflOffset = (ALfloat)((lBytesPlayed / (36 * lChannels)) * 36 * lChannels);
2067             }
2068             else if (eOriginalFormat == AL_FORMAT_REAR8)
2069             {
2070                 *pflOffset = (ALfloat)(lBytesPlayed >> 2);
2071             }
2072             else if (eOriginalFormat == AL_FORMAT_REAR16)
2073             {
2074                 *pflOffset = (ALfloat)(lBytesPlayed >> 1);
2075             }
2076             else if (aluBytesFromFormat(eOriginalFormat) == 1)
2077             {
2078                 *pflOffset = (ALfloat)(lBytesPlayed >> 1);
2079             }
2080             else if (aluBytesFromFormat(eOriginalFormat) == 4)
2081             {
2082                 *pflOffset = (ALfloat)(lBytesPlayed << 1);
2083             }
2084             else
2085             {
2086                 *pflOffset = (ALfloat)lBytesPlayed;
2087             }
2088             break;
2089         }
2090     }
2091     else
2092     {
2093         *pflOffset = 0.0f;
2094     }
2095
2096     return bReturn;
2097 }
2098
2099
2100 /*
2101     ApplyOffset
2102
2103     Apply a playback offset to the Source.  This function will update the queue (to correctly
2104     mark buffers as 'pending' or 'processed' depending upon the new offset.
2105 */
2106 static void ApplyOffset(ALsource *pSource, ALboolean bUpdateContext)
2107 {
2108     ALbufferlistitem    *pBufferList;
2109     ALbuffer            *pBuffer;
2110     ALint                lBufferSize, lTotalBufferSize;
2111     ALint                lByteOffset;
2112
2113     // Get true byte offset
2114     lByteOffset = GetByteOffset(pSource);
2115
2116     // If this is a valid offset apply it
2117     if (lByteOffset != -1)
2118     {
2119         // Sort out the queue (pending and processed states)
2120         pBufferList = pSource->queue;
2121         lTotalBufferSize = 0;
2122         pSource->BuffersPlayed = 0;
2123         pSource->BuffersProcessed = 0;
2124         while (pBufferList)
2125         {
2126             pBuffer = ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2127             lBufferSize = pBuffer ? pBuffer->size : 0;
2128
2129             if ((lTotalBufferSize + lBufferSize) <= lByteOffset)
2130             {
2131                 // Offset is past this buffer so increment BuffersPlayed and if the Source is NOT looping
2132                 // update the state to PROCESSED
2133                 pSource->BuffersPlayed++;
2134
2135                 if (!pSource->bLooping)
2136                 {
2137                     pBufferList->bufferstate = PROCESSED;
2138                     pSource->BuffersProcessed++;
2139                 }
2140             }
2141             else if (lTotalBufferSize <= lByteOffset)
2142             {
2143                 // Offset is within this buffer
2144                 pBufferList->bufferstate = PENDING;
2145
2146                 // Set Current Buffer ID
2147                 pSource->ulBufferID = pBufferList->buffer;
2148
2149                 // Set current position in this buffer
2150                 pSource->BufferPosition = lByteOffset - lTotalBufferSize;
2151
2152                 // Set Total Bytes Played to Offset
2153                 pSource->lBytesPlayed = lByteOffset;
2154
2155                 // SW Mixer Positions are in Samples
2156                 pSource->position = pSource->BufferPosition /
2157                                     aluBytesFromFormat(pBuffer->format) /
2158                                     aluChannelsFromFormat(pBuffer->format);
2159             }
2160             else
2161             {
2162                 // Offset is before this buffer, so mark as pending
2163                 pBufferList->bufferstate = PENDING;
2164             }
2165
2166             // Increment the TotalBufferSize
2167             lTotalBufferSize += lBufferSize;
2168
2169             // Move on to next buffer in the Queue
2170             pBufferList = pBufferList->next;
2171         }
2172     }
2173     else
2174     {
2175         if (bUpdateContext)
2176             alSetError(AL_INVALID_VALUE);
2177     }
2178
2179     // Clear Offset
2180     pSource->lOffset = 0;
2181 }
2182
2183
2184 /*
2185     GetByteOffset
2186
2187     Returns the 'true' byte offset into the Source's queue (from the Sample, Byte or Millisecond
2188     offset supplied by the application).   This takes into account the fact that the buffer format
2189     may have been modifed by AL (e.g 8bit samples are converted to 16bit)
2190 */
2191 static ALint GetByteOffset(ALsource *pSource)
2192 {
2193     ALbuffer *pBuffer = NULL;
2194     ALbufferlistitem *pBufferList;
2195     ALfloat    flBufferFreq;
2196     ALint    lChannels;
2197     ALint    lByteOffset = -1;
2198     ALint    lTotalBufferDataSize;
2199
2200     // Find the first non-NULL Buffer in the Queue
2201     pBufferList = pSource->queue;
2202     while (pBufferList)
2203     {
2204         if (pBufferList->buffer)
2205         {
2206             pBuffer = (ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer);
2207             break;
2208         }
2209         pBufferList = pBufferList->next;
2210     }
2211
2212     if (pBuffer)
2213     {
2214         flBufferFreq = ((ALfloat)pBuffer->frequency);
2215         lChannels = aluChannelsFromFormat(pBuffer->format);
2216
2217         // Determine the ByteOffset (and ensure it is block aligned)
2218         switch (pSource->lOffsetType)
2219         {
2220         case AL_BYTE_OFFSET:
2221             // Take into consideration the original format
2222             if ((pBuffer->eOriginalFormat == AL_FORMAT_MONO_IMA4) ||
2223                 (pBuffer->eOriginalFormat == AL_FORMAT_STEREO_IMA4))
2224             {
2225                 // Round down to nearest ADPCM block
2226                 lByteOffset = (pSource->lOffset / (36 * lChannels)) * 36 * lChannels;
2227                 // Multiply by compression rate
2228                 lByteOffset = (ALint)(3.6111f * (ALfloat)lByteOffset);
2229                 lByteOffset -= (lByteOffset % (lChannels * 2));
2230             }
2231             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR8)
2232             {
2233                 lByteOffset = pSource->lOffset * 4;
2234                 lByteOffset -= (lByteOffset % (lChannels * 2));
2235             }
2236             else if (pBuffer->eOriginalFormat == AL_FORMAT_REAR16)
2237             {
2238                 lByteOffset = pSource->lOffset * 2;
2239                 lByteOffset -= (lByteOffset % (lChannels * 2));
2240             }
2241             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 1)
2242             {
2243                 lByteOffset = pSource->lOffset * 2;
2244                 lByteOffset -= (lByteOffset % (lChannels * 2));
2245             }
2246             else if (aluBytesFromFormat(pBuffer->eOriginalFormat) == 4)
2247             {
2248                 lByteOffset = pSource->lOffset / 2;
2249                 lByteOffset -= (lByteOffset % (lChannels * 2));
2250             }
2251             else
2252             {
2253                 lByteOffset = pSource->lOffset;
2254                 lByteOffset -= (lByteOffset % (lChannels * 2));
2255             }
2256             break;
2257
2258         case AL_SAMPLE_OFFSET:
2259             lByteOffset = pSource->lOffset * lChannels * 2;
2260             break;
2261
2262         case AL_SEC_OFFSET:
2263             // Note - lOffset is internally stored as Milliseconds
2264             lByteOffset = (ALint)(pSource->lOffset * lChannels * 2.0f * flBufferFreq / 1000.0f);
2265             lByteOffset -= (lByteOffset % (lChannels * 2));
2266             break;
2267         }
2268
2269         lTotalBufferDataSize = 0;
2270         pBufferList = pSource->queue;
2271         while (pBufferList)
2272         {
2273             if (pBufferList->buffer)
2274                 lTotalBufferDataSize += ((ALbuffer*)ALTHUNK_LOOKUPENTRY(pBufferList->buffer))->size;
2275             pBufferList = pBufferList->next;
2276         }
2277
2278         // Finally, if the ByteOffset is beyond the length of all the buffers in the queue, return -1
2279         if (lByteOffset >= lTotalBufferDataSize)
2280             lByteOffset = -1;
2281     }
2282
2283     return lByteOffset;
2284 }
2285
2286
2287 ALvoid ReleaseALSources(ALCcontext *Context)
2288 {
2289 #ifdef _DEBUG
2290     if(Context->SourceCount > 0)
2291         AL_PRINT("alcDestroyContext(): %d Source(s) NOT deleted\n", Context->SourceCount);
2292 #endif
2293
2294     while(Context->Source)
2295     {
2296         ALsource *temp = Context->Source;
2297         Context->Source = Context->Source->next;
2298
2299         // Release source structure
2300         ALTHUNK_REMOVEENTRY(temp->source);
2301         memset(temp, 0, sizeof(ALsource));
2302         free(temp);
2303     }
2304     Context->SourceCount = 0;
2305 }