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