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