OpenAL32/alSource.c

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