OpenAL32/alSource.c

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