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