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