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