Mercurial > audio-send

     1 /**

     2  * OpenAL cross platform audio library

     3  * Copyright (C) 1999-2007 by authors.

     4  * This library is free software; you can redistribute it and/or

     5  *  modify it under the terms of the GNU Library General Public

     6  *  License as published by the Free Software Foundation; either

     7  *  version 2 of the License, or (at your option) any later version.

     8  *

     9  * This library is distributed in the hope that it will be useful,

    10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    12  *  Library General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Library General Public

    15  *  License along with this library; if not, write to the

    16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    17  *  Boston, MA  02111-1307, USA.

    18  * Or go to http://www.gnu.org/copyleft/lgpl.html

    19  */

    20 

    21 #include "config.h"

    22 

    23 #include <stdlib.h>

    24 #include <math.h>

    25 #include <float.h>

    26 #include "alMain.h"

    27 #include "AL/al.h"

    28 #include "AL/alc.h"

    29 #include "alError.h"

    30 #include "alSource.h"

    31 #include "alBuffer.h"

    32 #include "alThunk.h"

    33 #include "alAuxEffectSlot.h"

    34 

    35 

    36 enum Resampler DefaultResampler;

    37 const ALsizei ResamplerPadding[RESAMPLER_MAX] = {

    38     0, /* Point */

    39     1, /* Linear */

    40     2, /* Cubic */

    41 };

    42 const ALsizei ResamplerPrePadding[RESAMPLER_MAX] = {

    43     0, /* Point */

    44     0, /* Linear */

    45     1, /* Cubic */

    46 };

    47 

    48 

    49 static ALvoid InitSourceParams(ALsource *Source);

    50 static ALvoid GetSourceOffset(ALsource *Source, ALenum eName, ALdouble *Offsets, ALdouble updateLen);

    51 static ALint GetByteOffset(ALsource *Source);

    52 

    53 #define LookupSource(m, k) ((ALsource*)LookupUIntMapKey(&(m), (k)))

    54 #define LookupBuffer(m, k) ((ALbuffer*)LookupUIntMapKey(&(m), (k)))

    55 #define LookupFilter(m, k) ((ALfilter*)LookupUIntMapKey(&(m), (k)))

    56 #define LookupEffectSlot(m, k) ((ALeffectslot*)LookupUIntMapKey(&(m), (k)))

    57 

    58 AL_API ALvoid AL_APIENTRY alGenSources(ALsizei n,ALuint *sources)

    59 {

    60     ALCcontext *Context;

    61     ALCdevice *Device;

    62 

    63     Context = GetLockedContext();

    64     if(!Context) return;

    65 

    66     Device = Context->Device;

    67     if(n < 0 || IsBadWritePtr((void*)sources, n * sizeof(ALuint)))

    68         alSetError(Context, AL_INVALID_VALUE);

    69     else if((ALuint)n > Device->MaxNoOfSources - Context->SourceMap.size)

    70         alSetError(Context, AL_INVALID_VALUE);

    71     else

    72     {

    73         ALenum err;

    74         ALsizei i;

    75 

    76         // Add additional sources to the list

    77         i = 0;

    78         while(i < n)

    79         {

    80             ALsource *source = calloc(1, sizeof(ALsource));

    81             if(!source)

    82             {

    83                 alSetError(Context, AL_OUT_OF_MEMORY);

    84                 alDeleteSources(i, sources);

    85                 break;

    86             }

    87 

    88             err = NewThunkEntry(&source->source);

    89             if(err == AL_NO_ERROR)

    90                 err = InsertUIntMapEntry(&Context->SourceMap, source->source, source);

    91             if(err != AL_NO_ERROR)

    92             {

    93                 FreeThunkEntry(source->source);

    94                 memset(source, 0, sizeof(ALsource));

    95                 free(source);

    96 

    97                 alSetError(Context, err);

    98                 alDeleteSources(i, sources);

    99                 break;

   100             }

   101 

   102             sources[i++] = source->source;

   103             InitSourceParams(source);

   104         }

   105     }

   106 

   107     UnlockContext(Context);

   108 }

   109 

   110 

   111 AL_API ALvoid AL_APIENTRY alDeleteSources(ALsizei n, const ALuint *sources)

   112 {

   113     ALCcontext *Context;

   114     ALsource *Source;

   115     ALsizei i, j;

   116     ALbufferlistitem *BufferList;

   117     ALboolean SourcesValid = AL_FALSE;

   118 

   119     Context = GetLockedContext();

   120     if(!Context) return;

   121 

   122     if(n < 0)

   123         alSetError(Context, AL_INVALID_VALUE);

   124     else

   125     {

   126         SourcesValid = AL_TRUE;

   127         // Check that all Sources are valid (and can therefore be deleted)

   128         for(i = 0;i < n;i++)

   129         {

   130             if(LookupSource(Context->SourceMap, sources[i]) == NULL)

   131             {

   132                 alSetError(Context, AL_INVALID_NAME);

   133                 SourcesValid = AL_FALSE;

   134                 break;

   135             }

   136         }

   137     }

   138 

   139     if(SourcesValid)

   140     {

   141         // All Sources are valid, and can be deleted

   142         for(i = 0;i < n;i++)

   143         {

   144             // Recheck that the Source is valid, because there could be duplicated Source names

   145             if((Source=LookupSource(Context->SourceMap, sources[i])) == NULL)

   146                 continue;

   147 

   148             for(j = 0;j < Context->ActiveSourceCount;j++)

   149             {

   150                 if(Context->ActiveSources[j] == Source)

   151                 {

   152                     ALsizei end = --(Context->ActiveSourceCount);

   153                     Context->ActiveSources[j] = Context->ActiveSources[end];

   154                     break;

   155                 }

   156             }

   157 

   158             // For each buffer in the source's queue...

   159             while(Source->queue != NULL)

   160             {

   161                 BufferList = Source->queue;

   162                 Source->queue = BufferList->next;

   163 

   164                 if(BufferList->buffer != NULL)

   165                     BufferList->buffer->refcount--;

   166                 free(BufferList);

   167             }

   168 

   169             for(j = 0;j < MAX_SENDS;++j)

   170             {

   171                 if(Source->Send[j].Slot)

   172                     Source->Send[j].Slot->refcount--;

   173                 Source->Send[j].Slot = NULL;

   174             }

   175 

   176             // Remove Source from list of Sources

   177             RemoveUIntMapKey(&Context->SourceMap, Source->source);

   178             FreeThunkEntry(Source->source);

   179 

   180             memset(Source,0,sizeof(ALsource));

   181             free(Source);

   182         }

   183     }

   184 

   185     UnlockContext(Context);

   186 }

   187 

   188 

   189 AL_API ALboolean AL_APIENTRY alIsSource(ALuint source)

   190 {

   191     ALCcontext *Context;

   192     ALboolean  result;

   193 

   194     Context = GetLockedContext();

   195     if(!Context) return AL_FALSE;

   196 

   197     result = (LookupSource(Context->SourceMap, source) ? AL_TRUE : AL_FALSE);

   198 

   199     UnlockContext(Context);

   200 

   201     return result;

   202 }

   203 

   204 

   205 AL_API ALvoid AL_APIENTRY alSourcef(ALuint source, ALenum eParam, ALfloat flValue)

   206 {

   207     ALCcontext    *pContext;

   208     ALsource    *Source;

   209 

   210     pContext = GetLockedContext();

   211     if(!pContext) return;

   212 

   213     if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   214     {

   215         switch(eParam)

   216         {

   217             case AL_PITCH:

   218                 if(flValue >= 0.0f)

   219                 {

   220                     Source->flPitch = flValue;

   221                     Source->NeedsUpdate = AL_TRUE;

   222                 }

   223                 else

   224                     alSetError(pContext, AL_INVALID_VALUE);

   225                 break;

   226 

   227             case AL_CONE_INNER_ANGLE:

   228                 if(flValue >= 0.0f && flValue <= 360.0f)

   229                 {

   230                     Source->flInnerAngle = flValue;

   231                     Source->NeedsUpdate = AL_TRUE;

   232                 }

   233                 else

   234                     alSetError(pContext, AL_INVALID_VALUE);

   235                 break;

   236 

   237             case AL_CONE_OUTER_ANGLE:

   238                 if(flValue >= 0.0f && flValue <= 360.0f)

   239                 {

   240                     Source->flOuterAngle = flValue;

   241                     Source->NeedsUpdate = AL_TRUE;

   242                 }

   243                 else

   244                     alSetError(pContext, AL_INVALID_VALUE);

   245                 break;

   246 

   247             case AL_GAIN:

   248                 if(flValue >= 0.0f)

   249                 {

   250                     Source->flGain = flValue;

   251                     Source->NeedsUpdate = AL_TRUE;

   252                 }

   253                 else

   254                     alSetError(pContext, AL_INVALID_VALUE);

   255                 break;

   256 

   257             case AL_MAX_DISTANCE:

   258                 if(flValue >= 0.0f)

   259                 {

   260                     Source->flMaxDistance = flValue;

   261                     Source->NeedsUpdate = AL_TRUE;

   262                 }

   263                 else

   264                     alSetError(pContext, AL_INVALID_VALUE);

   265                 break;

   266 

   267             case AL_ROLLOFF_FACTOR:

   268                 if(flValue >= 0.0f)

   269                 {

   270                     Source->flRollOffFactor = flValue;

   271                     Source->NeedsUpdate = AL_TRUE;

   272                 }

   273                 else

   274                     alSetError(pContext, AL_INVALID_VALUE);

   275                 break;

   276 

   277             case AL_REFERENCE_DISTANCE:

   278                 if(flValue >= 0.0f)

   279                 {

   280                     Source->flRefDistance = flValue;

   281                     Source->NeedsUpdate = AL_TRUE;

   282                 }

   283                 else

   284                     alSetError(pContext, AL_INVALID_VALUE);

   285                 break;

   286 

   287             case AL_MIN_GAIN:

   288                 if(flValue >= 0.0f && flValue <= 1.0f)

   289                 {

   290                     Source->flMinGain = flValue;

   291                     Source->NeedsUpdate = AL_TRUE;

   292                 }

   293                 else

   294                     alSetError(pContext, AL_INVALID_VALUE);

   295                 break;

   296 

   297             case AL_MAX_GAIN:

   298                 if(flValue >= 0.0f && flValue <= 1.0f)

   299                 {

   300                     Source->flMaxGain = flValue;

   301                     Source->NeedsUpdate = AL_TRUE;

   302                 }

   303                 else

   304                     alSetError(pContext, AL_INVALID_VALUE);

   305                 break;

   306 

   307             case AL_CONE_OUTER_GAIN:

   308                 if(flValue >= 0.0f && flValue <= 1.0f)

   309                 {

   310                     Source->flOuterGain = flValue;

   311                     Source->NeedsUpdate = AL_TRUE;

   312                 }

   313                 else

   314                     alSetError(pContext, AL_INVALID_VALUE);

   315                 break;

   316 

   317             case AL_CONE_OUTER_GAINHF:

   318                 if(flValue >= 0.0f && flValue <= 1.0f)

   319                 {

   320                     Source->OuterGainHF = flValue;

   321                     Source->NeedsUpdate = AL_TRUE;

   322                 }

   323                 else

   324                     alSetError(pContext, AL_INVALID_VALUE);

   325                 break;

   326 

   327             case AL_AIR_ABSORPTION_FACTOR:

   328                 if(flValue >= 0.0f && flValue <= 10.0f)

   329                 {

   330                     Source->AirAbsorptionFactor = flValue;

   331                     Source->NeedsUpdate = AL_TRUE;

   332                 }

   333                 else

   334                     alSetError(pContext, AL_INVALID_VALUE);

   335                 break;

   336 

   337             case AL_ROOM_ROLLOFF_FACTOR:

   338                 if(flValue >= 0.0f && flValue <= 10.0f)

   339                 {

   340                     Source->RoomRolloffFactor = flValue;

   341                     Source->NeedsUpdate = AL_TRUE;

   342                 }

   343                 else

   344                     alSetError(pContext, AL_INVALID_VALUE);

   345                 break;

   346 

   347             case AL_DOPPLER_FACTOR:

   348                 if(flValue >= 0.0f && flValue <= 1.0f)

   349                 {

   350                     Source->DopplerFactor = flValue;

   351                     Source->NeedsUpdate = AL_TRUE;

   352                 }

   353                 else

   354                     alSetError(pContext, AL_INVALID_VALUE);

   355                 break;

   356 

   357             case AL_SEC_OFFSET:

   358             case AL_SAMPLE_OFFSET:

   359             case AL_BYTE_OFFSET:

   360                 if(flValue >= 0.0f)

   361                 {

   362                     Source->lOffsetType = eParam;

   363 

   364                     // Store Offset (convert Seconds into Milliseconds)

   365                     if(eParam == AL_SEC_OFFSET)

   366                         Source->lOffset = (ALint)(flValue * 1000.0f);

   367                     else

   368                         Source->lOffset = (ALint)flValue;

   369 

   370                     if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&

   371                        !pContext->DeferUpdates)

   372                     {

   373                         if(ApplyOffset(Source) == AL_FALSE)

   374                             alSetError(pContext, AL_INVALID_VALUE);

   375                     }

   376                 }

   377                 else

   378                     alSetError(pContext, AL_INVALID_VALUE);

   379                 break;

   380 

   381             default:

   382                 alSetError(pContext, AL_INVALID_ENUM);

   383                 break;

   384         }

   385     }

   386     else

   387     {

   388         // Invalid Source Name

   389         alSetError(pContext, AL_INVALID_NAME);

   390     }

   391 

   392     UnlockContext(pContext);

   393 }

   394 

   395 

   396 AL_API ALvoid AL_APIENTRY alSource3f(ALuint source, ALenum eParam, ALfloat flValue1,ALfloat flValue2,ALfloat flValue3)

   397 {

   398     ALCcontext    *pContext;

   399     ALsource    *Source;

   400 

   401     pContext = GetLockedContext();

   402     if(!pContext) return;

   403 

   404     if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   405     {

   406         switch(eParam)

   407         {

   408             case AL_POSITION:

   409                 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))

   410                 {

   411                     Source->vPosition[0] = flValue1;

   412                     Source->vPosition[1] = flValue2;

   413                     Source->vPosition[2] = flValue3;

   414                     Source->NeedsUpdate = AL_TRUE;

   415                 }

   416                 else

   417                     alSetError(pContext, AL_INVALID_VALUE);

   418                 break;

   419 

   420             case AL_VELOCITY:

   421                 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))

   422                 {

   423                     Source->vVelocity[0] = flValue1;

   424                     Source->vVelocity[1] = flValue2;

   425                     Source->vVelocity[2] = flValue3;

   426                     Source->NeedsUpdate = AL_TRUE;

   427                 }

   428                 else

   429                     alSetError(pContext, AL_INVALID_VALUE);

   430                 break;

   431 

   432             case AL_DIRECTION:

   433                 if(isfinite(flValue1) && isfinite(flValue2) && isfinite(flValue3))

   434                 {

   435                     Source->vOrientation[0] = flValue1;

   436                     Source->vOrientation[1] = flValue2;

   437                     Source->vOrientation[2] = flValue3;

   438                     Source->NeedsUpdate = AL_TRUE;

   439                 }

   440                 else

   441                     alSetError(pContext, AL_INVALID_VALUE);

   442                 break;

   443 

   444             default:

   445                 alSetError(pContext, AL_INVALID_ENUM);

   446                 break;

   447         }

   448     }

   449     else

   450         alSetError(pContext, AL_INVALID_NAME);

   451 

   452     UnlockContext(pContext);

   453 }

   454 

   455 

   456 AL_API ALvoid AL_APIENTRY alSourcefv(ALuint source, ALenum eParam, const ALfloat *pflValues)

   457 {

   458     ALCcontext    *pContext;

   459 

   460     if(pflValues)

   461     {

   462         switch(eParam)

   463         {

   464             case AL_PITCH:

   465             case AL_CONE_INNER_ANGLE:

   466             case AL_CONE_OUTER_ANGLE:

   467             case AL_GAIN:

   468             case AL_MAX_DISTANCE:

   469             case AL_ROLLOFF_FACTOR:

   470             case AL_REFERENCE_DISTANCE:

   471             case AL_MIN_GAIN:

   472             case AL_MAX_GAIN:

   473             case AL_CONE_OUTER_GAIN:

   474             case AL_CONE_OUTER_GAINHF:

   475             case AL_SEC_OFFSET:

   476             case AL_SAMPLE_OFFSET:

   477             case AL_BYTE_OFFSET:

   478             case AL_AIR_ABSORPTION_FACTOR:

   479             case AL_ROOM_ROLLOFF_FACTOR:

   480                 alSourcef(source, eParam, pflValues[0]);

   481                 return;

   482 

   483             case AL_POSITION:

   484             case AL_VELOCITY:

   485             case AL_DIRECTION:

   486                 alSource3f(source, eParam, pflValues[0], pflValues[1], pflValues[2]);

   487                 return;

   488         }

   489     }

   490 

   491     pContext = GetLockedContext();

   492     if(!pContext) return;

   493 

   494     if(pflValues)

   495     {

   496         if(LookupSource(pContext->SourceMap, source) != NULL)

   497         {

   498             switch(eParam)

   499             {

   500                 default:

   501                     alSetError(pContext, AL_INVALID_ENUM);

   502                     break;

   503             }

   504         }

   505         else

   506             alSetError(pContext, AL_INVALID_NAME);

   507     }

   508     else

   509         alSetError(pContext, AL_INVALID_VALUE);

   510 

   511     UnlockContext(pContext);

   512 }

   513 

   514 

   515 AL_API ALvoid AL_APIENTRY alSourcei(ALuint source,ALenum eParam,ALint lValue)

   516 {

   517     ALCcontext          *pContext;

   518     ALsource            *Source;

   519     ALbufferlistitem    *BufferListItem;

   520 

   521     switch(eParam)

   522     {

   523         case AL_MAX_DISTANCE:

   524         case AL_ROLLOFF_FACTOR:

   525         case AL_CONE_INNER_ANGLE:

   526         case AL_CONE_OUTER_ANGLE:

   527         case AL_REFERENCE_DISTANCE:

   528             alSourcef(source, eParam, (ALfloat)lValue);

   529             return;

   530     }

   531 

   532     pContext = GetLockedContext();

   533     if(!pContext) return;

   534 

   535     if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   536     {

   537         ALCdevice *device = pContext->Device;

   538 

   539         switch(eParam)

   540         {

   541             case AL_SOURCE_RELATIVE:

   542                 if(lValue == AL_FALSE || lValue == AL_TRUE)

   543                 {

   544                     Source->bHeadRelative = (ALboolean)lValue;

   545                     Source->NeedsUpdate = AL_TRUE;

   546                 }

   547                 else

   548                     alSetError(pContext, AL_INVALID_VALUE);

   549                 break;

   550 

   551             case AL_LOOPING:

   552                 if(lValue == AL_FALSE || lValue == AL_TRUE)

   553                     Source->bLooping = (ALboolean)lValue;

   554                 else

   555                     alSetError(pContext, AL_INVALID_VALUE);

   556                 break;

   557 

   558             case AL_BUFFER:

   559                 if(Source->state == AL_STOPPED || Source->state == AL_INITIAL)

   560                 {

   561                     ALbuffer *buffer = NULL;

   562 

   563                     if(lValue == 0 ||

   564                        (buffer=LookupBuffer(device->BufferMap, lValue)) != NULL)

   565                     {

   566                         // Remove all elements in the queue

   567                         while(Source->queue != NULL)

   568                         {

   569                             BufferListItem = Source->queue;

   570                             Source->queue = BufferListItem->next;

   571 

   572                             if(BufferListItem->buffer)

   573                                 BufferListItem->buffer->refcount--;

   574                             free(BufferListItem);

   575                         }

   576                         Source->BuffersInQueue = 0;

   577 

   578                         // Add the buffer to the queue (as long as it is NOT the NULL buffer)

   579                         if(buffer != NULL)

   580                         {

   581                             // Source is now in STATIC mode

   582                             Source->lSourceType = AL_STATIC;

   583 

   584                             // Add the selected buffer to the queue

   585                             BufferListItem = malloc(sizeof(ALbufferlistitem));

   586                             BufferListItem->buffer = buffer;

   587                             BufferListItem->next = NULL;

   588                             BufferListItem->prev = NULL;

   589 

   590                             Source->queue = BufferListItem;

   591                             Source->BuffersInQueue = 1;

   592 

   593                             Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);

   594                             Source->SampleSize  = BytesFromFmt(buffer->FmtType);

   595                             if(buffer->FmtChannels == FmtMono)

   596                                 Source->Update = CalcSourceParams;

   597                             else

   598                                 Source->Update = CalcNonAttnSourceParams;

   599 

   600                             // Increment reference counter for buffer

   601                             buffer->refcount++;

   602                         }

   603                         else

   604                         {

   605                             // Source is now in UNDETERMINED mode

   606                             Source->lSourceType = AL_UNDETERMINED;

   607                         }

   608                         Source->BuffersPlayed = 0;

   609 

   610                         // Update AL_BUFFER parameter

   611                         Source->Buffer = buffer;

   612                         Source->NeedsUpdate = AL_TRUE;

   613                     }

   614                     else

   615                         alSetError(pContext, AL_INVALID_VALUE);

   616                 }

   617                 else

   618                     alSetError(pContext, AL_INVALID_OPERATION);

   619                 break;

   620 

   621             case AL_SOURCE_STATE:

   622                 // Query only

   623                 alSetError(pContext, AL_INVALID_OPERATION);

   624                 break;

   625 

   626             case AL_SEC_OFFSET:

   627             case AL_SAMPLE_OFFSET:

   628             case AL_BYTE_OFFSET:

   629                 if(lValue >= 0)

   630                 {

   631                     Source->lOffsetType = eParam;

   632 

   633                     // Store Offset (convert Seconds into Milliseconds)

   634                     if(eParam == AL_SEC_OFFSET)

   635                         Source->lOffset = lValue * 1000;

   636                     else

   637                         Source->lOffset = lValue;

   638 

   639                     if((Source->state == AL_PLAYING || Source->state == AL_PAUSED) &&

   640                        !pContext->DeferUpdates)

   641                     {

   642                         if(ApplyOffset(Source) == AL_FALSE)

   643                             alSetError(pContext, AL_INVALID_VALUE);

   644                     }

   645                 }

   646                 else

   647                     alSetError(pContext, AL_INVALID_VALUE);

   648                 break;

   649 

   650             case AL_DIRECT_FILTER: {

   651                 ALfilter *filter = NULL;

   652 

   653                 if(lValue == 0 ||

   654                    (filter=LookupFilter(pContext->Device->FilterMap, lValue)) != NULL)

   655                 {

   656                     if(!filter)

   657                     {

   658                         Source->DirectFilter.type = AL_FILTER_NULL;

   659                         Source->DirectFilter.filter = 0;

   660                     }

   661                     else

   662                         memcpy(&Source->DirectFilter, filter, sizeof(*filter));

   663                     Source->NeedsUpdate = AL_TRUE;

   664                 }

   665                 else

   666                     alSetError(pContext, AL_INVALID_VALUE);

   667             }   break;

   668 

   669             case AL_DIRECT_FILTER_GAINHF_AUTO:

   670                 if(lValue == AL_TRUE || lValue == AL_FALSE)

   671                 {

   672                     Source->DryGainHFAuto = lValue;

   673                     Source->NeedsUpdate = AL_TRUE;

   674                 }

   675                 else

   676                     alSetError(pContext, AL_INVALID_VALUE);

   677                 break;

   678 

   679             case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:

   680                 if(lValue == AL_TRUE || lValue == AL_FALSE)

   681                 {

   682                     Source->WetGainAuto = lValue;

   683                     Source->NeedsUpdate = AL_TRUE;

   684                 }

   685                 else

   686                     alSetError(pContext, AL_INVALID_VALUE);

   687                 break;

   688 

   689             case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:

   690                 if(lValue == AL_TRUE || lValue == AL_FALSE)

   691                 {

   692                     Source->WetGainHFAuto = lValue;

   693                     Source->NeedsUpdate = AL_TRUE;

   694                 }

   695                 else

   696                     alSetError(pContext, AL_INVALID_VALUE);

   697                 break;

   698 

   699             case AL_VIRTUAL_CHANNELS_SOFT:

   700                 if(lValue == AL_TRUE || lValue == AL_FALSE)

   701                 {

   702                     Source->VirtualChannels = lValue;

   703                     Source->NeedsUpdate = AL_TRUE;

   704                 }

   705                 else

   706                     alSetError(pContext, AL_INVALID_VALUE);

   707                 break;

   708 

   709             case AL_DISTANCE_MODEL:

   710                 if(lValue == AL_NONE ||

   711                    lValue == AL_INVERSE_DISTANCE ||

   712                    lValue == AL_INVERSE_DISTANCE_CLAMPED ||

   713                    lValue == AL_LINEAR_DISTANCE ||

   714                    lValue == AL_LINEAR_DISTANCE_CLAMPED ||

   715                    lValue == AL_EXPONENT_DISTANCE ||

   716                    lValue == AL_EXPONENT_DISTANCE_CLAMPED)

   717                 {

   718                     Source->DistanceModel = lValue;

   719                     if(pContext->SourceDistanceModel)

   720                         Source->NeedsUpdate = AL_TRUE;

   721                 }

   722                 else

   723                     alSetError(pContext, AL_INVALID_VALUE);

   724                 break;

   725 

   726             default:

   727                 alSetError(pContext, AL_INVALID_ENUM);

   728                 break;

   729         }

   730     }

   731     else

   732         alSetError(pContext, AL_INVALID_NAME);

   733 

   734     UnlockContext(pContext);

   735 }

   736 

   737 

   738 AL_API void AL_APIENTRY alSource3i(ALuint source, ALenum eParam, ALint lValue1, ALint lValue2, ALint lValue3)

   739 {

   740     ALCcontext *pContext;

   741     ALsource   *Source;

   742 

   743     switch(eParam)

   744     {

   745         case AL_POSITION:

   746         case AL_VELOCITY:

   747         case AL_DIRECTION:

   748             alSource3f(source, eParam, (ALfloat)lValue1, (ALfloat)lValue2, (ALfloat)lValue3);

   749             return;

   750     }

   751 

   752     pContext = GetLockedContext();

   753     if(!pContext) return;

   754 

   755     if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   756     {

   757         ALCdevice *device = pContext->Device;

   758 

   759         switch(eParam)

   760         {

   761             case AL_AUXILIARY_SEND_FILTER: {

   762                 ALeffectslot *ALEffectSlot = NULL;

   763                 ALfilter     *ALFilter = NULL;

   764 

   765                 if((ALuint)lValue2 < device->NumAuxSends &&

   766                    (lValue1 == 0 ||

   767                     (ALEffectSlot=LookupEffectSlot(pContext->EffectSlotMap, lValue1)) != NULL) &&

   768                    (lValue3 == 0 ||

   769                     (ALFilter=LookupFilter(device->FilterMap, lValue3)) != NULL))

   770                 {

   771                     /* Release refcount on the previous slot, and add one for

   772                      * the new slot */

   773                     if(Source->Send[lValue2].Slot)

   774                         Source->Send[lValue2].Slot->refcount--;

   775                     Source->Send[lValue2].Slot = ALEffectSlot;

   776                     if(Source->Send[lValue2].Slot)

   777                         Source->Send[lValue2].Slot->refcount++;

   778 

   779                     if(!ALFilter)

   780                     {

   781                         /* Disable filter */

   782                         Source->Send[lValue2].WetFilter.type = 0;

   783                         Source->Send[lValue2].WetFilter.filter = 0;

   784                     }

   785                     else

   786                         memcpy(&Source->Send[lValue2].WetFilter, ALFilter, sizeof(*ALFilter));

   787                     Source->NeedsUpdate = AL_TRUE;

   788                 }

   789                 else

   790                     alSetError(pContext, AL_INVALID_VALUE);

   791             }    break;

   792 

   793             default:

   794                 alSetError(pContext, AL_INVALID_ENUM);

   795                 break;

   796         }

   797     }

   798     else

   799         alSetError(pContext, AL_INVALID_NAME);

   800 

   801     UnlockContext(pContext);

   802 }

   803 

   804 

   805 AL_API void AL_APIENTRY alSourceiv(ALuint source, ALenum eParam, const ALint* plValues)

   806 {

   807     ALCcontext    *pContext;

   808 

   809     if(plValues)

   810     {

   811         switch(eParam)

   812         {

   813             case AL_SOURCE_RELATIVE:

   814             case AL_CONE_INNER_ANGLE:

   815             case AL_CONE_OUTER_ANGLE:

   816             case AL_LOOPING:

   817             case AL_BUFFER:

   818             case AL_SOURCE_STATE:

   819             case AL_SEC_OFFSET:

   820             case AL_SAMPLE_OFFSET:

   821             case AL_BYTE_OFFSET:

   822             case AL_MAX_DISTANCE:

   823             case AL_ROLLOFF_FACTOR:

   824             case AL_REFERENCE_DISTANCE:

   825             case AL_DIRECT_FILTER:

   826             case AL_DIRECT_FILTER_GAINHF_AUTO:

   827             case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:

   828             case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:

   829             case AL_DISTANCE_MODEL:

   830             case AL_VIRTUAL_CHANNELS_SOFT:

   831                 alSourcei(source, eParam, plValues[0]);

   832                 return;

   833 

   834             case AL_POSITION:

   835             case AL_VELOCITY:

   836             case AL_DIRECTION:

   837             case AL_AUXILIARY_SEND_FILTER:

   838                 alSource3i(source, eParam, plValues[0], plValues[1], plValues[2]);

   839                 return;

   840         }

   841     }

   842 

   843     pContext = GetLockedContext();

   844     if(!pContext) return;

   845 

   846     if(plValues)

   847     {

   848         if(LookupSource(pContext->SourceMap, source) != NULL)

   849         {

   850             switch(eParam)

   851             {

   852                 default:

   853                     alSetError(pContext, AL_INVALID_ENUM);

   854                     break;

   855             }

   856         }

   857         else

   858             alSetError(pContext, AL_INVALID_NAME);

   859     }

   860     else

   861         alSetError(pContext, AL_INVALID_VALUE);

   862 

   863     UnlockContext(pContext);

   864 }

   865 

   866 

   867 AL_API ALvoid AL_APIENTRY alGetSourcef(ALuint source, ALenum eParam, ALfloat *pflValue)

   868 {

   869     ALCcontext  *pContext;

   870     ALsource    *Source;

   871     ALdouble    Offsets[2];

   872     ALdouble    updateLen;

   873 

   874     pContext = GetLockedContext();

   875     if(!pContext) return;

   876 

   877     if(pflValue)

   878     {

   879         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   880         {

   881             switch(eParam)

   882             {

   883                 case AL_PITCH:

   884                     *pflValue = Source->flPitch;

   885                     break;

   886 

   887                 case AL_GAIN:

   888                     *pflValue = Source->flGain;

   889                     break;

   890 

   891                 case AL_MIN_GAIN:

   892                     *pflValue = Source->flMinGain;

   893                     break;

   894 

   895                 case AL_MAX_GAIN:

   896                     *pflValue = Source->flMaxGain;

   897                     break;

   898 

   899                 case AL_MAX_DISTANCE:

   900                     *pflValue = Source->flMaxDistance;

   901                     break;

   902 

   903                 case AL_ROLLOFF_FACTOR:

   904                     *pflValue = Source->flRollOffFactor;

   905                     break;

   906 

   907                 case AL_CONE_OUTER_GAIN:

   908                     *pflValue = Source->flOuterGain;

   909                     break;

   910 

   911                 case AL_CONE_OUTER_GAINHF:

   912                     *pflValue = Source->OuterGainHF;

   913                     break;

   914 

   915                 case AL_SEC_OFFSET:

   916                 case AL_SAMPLE_OFFSET:

   917                 case AL_BYTE_OFFSET:

   918                     updateLen = (ALdouble)pContext->Device->UpdateSize /

   919                                 pContext->Device->Frequency;

   920                     GetSourceOffset(Source, eParam, Offsets, updateLen);

   921                     *pflValue = Offsets[0];

   922                     break;

   923 

   924                 case AL_CONE_INNER_ANGLE:

   925                     *pflValue = Source->flInnerAngle;

   926                     break;

   927 

   928                 case AL_CONE_OUTER_ANGLE:

   929                     *pflValue = Source->flOuterAngle;

   930                     break;

   931 

   932                 case AL_REFERENCE_DISTANCE:

   933                     *pflValue = Source->flRefDistance;

   934                     break;

   935 

   936                 case AL_AIR_ABSORPTION_FACTOR:

   937                     *pflValue = Source->AirAbsorptionFactor;

   938                     break;

   939 

   940                 case AL_ROOM_ROLLOFF_FACTOR:

   941                     *pflValue = Source->RoomRolloffFactor;

   942                     break;

   943 

   944                 case AL_DOPPLER_FACTOR:

   945                     *pflValue = Source->DopplerFactor;

   946                     break;

   947 

   948                 default:

   949                     alSetError(pContext, AL_INVALID_ENUM);

   950                     break;

   951             }

   952         }

   953         else

   954             alSetError(pContext, AL_INVALID_NAME);

   955     }

   956     else

   957         alSetError(pContext, AL_INVALID_VALUE);

   958 

   959     UnlockContext(pContext);

   960 }

   961 

   962 

   963 AL_API ALvoid AL_APIENTRY alGetSource3f(ALuint source, ALenum eParam, ALfloat* pflValue1, ALfloat* pflValue2, ALfloat* pflValue3)

   964 {

   965     ALCcontext    *pContext;

   966     ALsource    *Source;

   967 

   968     pContext = GetLockedContext();

   969     if(!pContext) return;

   970 

   971     if(pflValue1 && pflValue2 && pflValue3)

   972     {

   973         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

   974         {

   975             switch(eParam)

   976             {

   977                 case AL_POSITION:

   978                     *pflValue1 = Source->vPosition[0];

   979                     *pflValue2 = Source->vPosition[1];

   980                     *pflValue3 = Source->vPosition[2];

   981                     break;

   982 

   983                 case AL_VELOCITY:

   984                     *pflValue1 = Source->vVelocity[0];

   985                     *pflValue2 = Source->vVelocity[1];

   986                     *pflValue3 = Source->vVelocity[2];

   987                     break;

   988 

   989                 case AL_DIRECTION:

   990                     *pflValue1 = Source->vOrientation[0];

   991                     *pflValue2 = Source->vOrientation[1];

   992                     *pflValue3 = Source->vOrientation[2];

   993                     break;

   994 

   995                 default:

   996                     alSetError(pContext, AL_INVALID_ENUM);

   997                     break;

   998             }

   999         }

  1000         else

  1001             alSetError(pContext, AL_INVALID_NAME);

  1002     }

  1003     else

  1004         alSetError(pContext, AL_INVALID_VALUE);

  1005 

  1006     UnlockContext(pContext);

  1007 }

  1008 

  1009 

  1010 AL_API ALvoid AL_APIENTRY alGetSourcefv(ALuint source, ALenum eParam, ALfloat *pflValues)

  1011 {

  1012     ALCcontext  *pContext;

  1013     ALsource    *Source;

  1014     ALdouble    Offsets[2];

  1015     ALdouble    updateLen;

  1016 

  1017     switch(eParam)

  1018     {

  1019         case AL_PITCH:

  1020         case AL_GAIN:

  1021         case AL_MIN_GAIN:

  1022         case AL_MAX_GAIN:

  1023         case AL_MAX_DISTANCE:

  1024         case AL_ROLLOFF_FACTOR:

  1025         case AL_DOPPLER_FACTOR:

  1026         case AL_CONE_OUTER_GAIN:

  1027         case AL_SEC_OFFSET:

  1028         case AL_SAMPLE_OFFSET:

  1029         case AL_BYTE_OFFSET:

  1030         case AL_CONE_INNER_ANGLE:

  1031         case AL_CONE_OUTER_ANGLE:

  1032         case AL_REFERENCE_DISTANCE:

  1033         case AL_CONE_OUTER_GAINHF:

  1034         case AL_AIR_ABSORPTION_FACTOR:

  1035         case AL_ROOM_ROLLOFF_FACTOR:

  1036             alGetSourcef(source, eParam, pflValues);

  1037             return;

  1038 

  1039         case AL_POSITION:

  1040         case AL_VELOCITY:

  1041         case AL_DIRECTION:

  1042             alGetSource3f(source, eParam, pflValues+0, pflValues+1, pflValues+2);

  1043             return;

  1044     }

  1045 

  1046     pContext = GetLockedContext();

  1047     if(!pContext) return;

  1048 

  1049     if(pflValues)

  1050     {

  1051         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

  1052         {

  1053             switch(eParam)

  1054             {

  1055                 case AL_SAMPLE_RW_OFFSETS_SOFT:

  1056                 case AL_BYTE_RW_OFFSETS_SOFT:

  1057                     updateLen = (ALdouble)pContext->Device->UpdateSize /

  1058                                 pContext->Device->Frequency;

  1059                     GetSourceOffset(Source, eParam, Offsets, updateLen);

  1060                     pflValues[0] = Offsets[0];

  1061                     pflValues[1] = Offsets[1];

  1062                     break;

  1063 

  1064                 default:

  1065                     alSetError(pContext, AL_INVALID_ENUM);

  1066                     break;

  1067             }

  1068         }

  1069         else

  1070             alSetError(pContext, AL_INVALID_NAME);

  1071     }

  1072     else

  1073         alSetError(pContext, AL_INVALID_VALUE);

  1074 

  1075     UnlockContext(pContext);

  1076 }

  1077 

  1078 

  1079 AL_API ALvoid AL_APIENTRY alGetSourcei(ALuint source, ALenum eParam, ALint *plValue)

  1080 {

  1081     ALCcontext *pContext;

  1082     ALsource   *Source;

  1083     ALdouble   Offsets[2];

  1084     ALdouble   updateLen;

  1085 

  1086     pContext = GetLockedContext();

  1087     if(!pContext) return;

  1088 

  1089     if(plValue)

  1090     {

  1091         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

  1092         {

  1093             switch(eParam)

  1094             {

  1095                 case AL_MAX_DISTANCE:

  1096                     *plValue = (ALint)Source->flMaxDistance;

  1097                     break;

  1098 

  1099                 case AL_ROLLOFF_FACTOR:

  1100                     *plValue = (ALint)Source->flRollOffFactor;

  1101                     break;

  1102 

  1103                 case AL_REFERENCE_DISTANCE:

  1104                     *plValue = (ALint)Source->flRefDistance;

  1105                     break;

  1106 

  1107                 case AL_SOURCE_RELATIVE:

  1108                     *plValue = Source->bHeadRelative;

  1109                     break;

  1110 

  1111                 case AL_CONE_INNER_ANGLE:

  1112                     *plValue = (ALint)Source->flInnerAngle;

  1113                     break;

  1114 

  1115                 case AL_CONE_OUTER_ANGLE:

  1116                     *plValue = (ALint)Source->flOuterAngle;

  1117                     break;

  1118 

  1119                 case AL_LOOPING:

  1120                     *plValue = Source->bLooping;

  1121                     break;

  1122 

  1123                 case AL_BUFFER:

  1124                     *plValue = (Source->Buffer ? Source->Buffer->buffer : 0);

  1125                     break;

  1126 

  1127                 case AL_SOURCE_STATE:

  1128                     *plValue = Source->state;

  1129                     break;

  1130 

  1131                 case AL_BUFFERS_QUEUED:

  1132                     *plValue = Source->BuffersInQueue;

  1133                     break;

  1134 

  1135                 case AL_BUFFERS_PROCESSED:

  1136                     if(Source->bLooping || Source->lSourceType != AL_STREAMING)

  1137                     {

  1138                         /* Buffers on a looping source are in a perpetual state

  1139                          * of PENDING, so don't report any as PROCESSED */

  1140                         *plValue = 0;

  1141                     }

  1142                     else

  1143                         *plValue = Source->BuffersPlayed;

  1144                     break;

  1145 

  1146                 case AL_SOURCE_TYPE:

  1147                     *plValue = Source->lSourceType;

  1148                     break;

  1149 

  1150                 case AL_SEC_OFFSET:

  1151                 case AL_SAMPLE_OFFSET:

  1152                 case AL_BYTE_OFFSET:

  1153                     updateLen = (ALdouble)pContext->Device->UpdateSize /

  1154                                 pContext->Device->Frequency;

  1155                     GetSourceOffset(Source, eParam, Offsets, updateLen);

  1156                     *plValue = (ALint)Offsets[0];

  1157                     break;

  1158 

  1159                 case AL_DIRECT_FILTER:

  1160                     *plValue = Source->DirectFilter.filter;

  1161                     break;

  1162 

  1163                 case AL_DIRECT_FILTER_GAINHF_AUTO:

  1164                     *plValue = Source->DryGainHFAuto;

  1165                     break;

  1166 

  1167                 case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:

  1168                     *plValue = Source->WetGainAuto;

  1169                     break;

  1170 

  1171                 case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:

  1172                     *plValue = Source->WetGainHFAuto;

  1173                     break;

  1174 

  1175                 case AL_DOPPLER_FACTOR:

  1176                     *plValue = (ALint)Source->DopplerFactor;

  1177                     break;

  1178 

  1179                 case AL_VIRTUAL_CHANNELS_SOFT:

  1180                     *plValue = Source->VirtualChannels;

  1181                     break;

  1182 

  1183                 case AL_DISTANCE_MODEL:

  1184                     *plValue = Source->DistanceModel;

  1185                     break;

  1186 

  1187                 default:

  1188                     alSetError(pContext, AL_INVALID_ENUM);

  1189                     break;

  1190             }

  1191         }

  1192         else

  1193             alSetError(pContext, AL_INVALID_NAME);

  1194     }

  1195     else

  1196         alSetError(pContext, AL_INVALID_VALUE);

  1197 

  1198     UnlockContext(pContext);

  1199 }

  1200 

  1201 

  1202 AL_API void AL_APIENTRY alGetSource3i(ALuint source, ALenum eParam, ALint* plValue1, ALint* plValue2, ALint* plValue3)

  1203 {

  1204     ALCcontext  *pContext;

  1205     ALsource    *Source;

  1206 

  1207     pContext = GetLockedContext();

  1208     if(!pContext) return;

  1209 

  1210     if(plValue1 && plValue2 && plValue3)

  1211     {

  1212         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

  1213         {

  1214             switch(eParam)

  1215             {

  1216                 case AL_POSITION:

  1217                     *plValue1 = (ALint)Source->vPosition[0];

  1218                     *plValue2 = (ALint)Source->vPosition[1];

  1219                     *plValue3 = (ALint)Source->vPosition[2];

  1220                     break;

  1221 

  1222                 case AL_VELOCITY:

  1223                     *plValue1 = (ALint)Source->vVelocity[0];

  1224                     *plValue2 = (ALint)Source->vVelocity[1];

  1225                     *plValue3 = (ALint)Source->vVelocity[2];

  1226                     break;

  1227 

  1228                 case AL_DIRECTION:

  1229                     *plValue1 = (ALint)Source->vOrientation[0];

  1230                     *plValue2 = (ALint)Source->vOrientation[1];

  1231                     *plValue3 = (ALint)Source->vOrientation[2];

  1232                     break;

  1233 

  1234                 default:

  1235                     alSetError(pContext, AL_INVALID_ENUM);

  1236                     break;

  1237             }

  1238         }

  1239         else

  1240             alSetError(pContext, AL_INVALID_NAME);

  1241     }

  1242     else

  1243         alSetError(pContext, AL_INVALID_VALUE);

  1244 

  1245     UnlockContext(pContext);

  1246 }

  1247 

  1248 

  1249 AL_API void AL_APIENTRY alGetSourceiv(ALuint source, ALenum eParam, ALint* plValues)

  1250 {

  1251     ALCcontext  *pContext;

  1252     ALsource    *Source;

  1253     ALdouble    Offsets[2];

  1254     ALdouble    updateLen;

  1255 

  1256     switch(eParam)

  1257     {

  1258         case AL_SOURCE_RELATIVE:

  1259         case AL_CONE_INNER_ANGLE:

  1260         case AL_CONE_OUTER_ANGLE:

  1261         case AL_LOOPING:

  1262         case AL_BUFFER:

  1263         case AL_SOURCE_STATE:

  1264         case AL_BUFFERS_QUEUED:

  1265         case AL_BUFFERS_PROCESSED:

  1266         case AL_SEC_OFFSET:

  1267         case AL_SAMPLE_OFFSET:

  1268         case AL_BYTE_OFFSET:

  1269         case AL_MAX_DISTANCE:

  1270         case AL_ROLLOFF_FACTOR:

  1271         case AL_DOPPLER_FACTOR:

  1272         case AL_REFERENCE_DISTANCE:

  1273         case AL_SOURCE_TYPE:

  1274         case AL_DIRECT_FILTER:

  1275         case AL_DIRECT_FILTER_GAINHF_AUTO:

  1276         case AL_AUXILIARY_SEND_FILTER_GAIN_AUTO:

  1277         case AL_AUXILIARY_SEND_FILTER_GAINHF_AUTO:

  1278         case AL_DISTANCE_MODEL:

  1279         case AL_VIRTUAL_CHANNELS_SOFT:

  1280             alGetSourcei(source, eParam, plValues);

  1281             return;

  1282 

  1283         case AL_POSITION:

  1284         case AL_VELOCITY:

  1285         case AL_DIRECTION:

  1286             alGetSource3i(source, eParam, plValues+0, plValues+1, plValues+2);

  1287             return;

  1288     }

  1289 

  1290     pContext = GetLockedContext();

  1291     if(!pContext) return;

  1292 

  1293     if(plValues)

  1294     {

  1295         if((Source=LookupSource(pContext->SourceMap, source)) != NULL)

  1296         {

  1297             switch(eParam)

  1298             {

  1299                 case AL_SAMPLE_RW_OFFSETS_SOFT:

  1300                 case AL_BYTE_RW_OFFSETS_SOFT:

  1301                     updateLen = (ALdouble)pContext->Device->UpdateSize /

  1302                                 pContext->Device->Frequency;

  1303                     GetSourceOffset(Source, eParam, Offsets, updateLen);

  1304                     plValues[0] = (ALint)Offsets[0];

  1305                     plValues[1] = (ALint)Offsets[1];

  1306                     break;

  1307 

  1308                 default:

  1309                     alSetError(pContext, AL_INVALID_ENUM);

  1310                     break;

  1311             }

  1312         }

  1313         else

  1314             alSetError(pContext, AL_INVALID_NAME);

  1315     }

  1316     else

  1317         alSetError(pContext, AL_INVALID_VALUE);

  1318 

  1319     UnlockContext(pContext);

  1320 }

  1321 

  1322 

  1323 AL_API ALvoid AL_APIENTRY alSourcePlay(ALuint source)

  1324 {

  1325     alSourcePlayv(1, &source);

  1326 }

  1327 

  1328 AL_API ALvoid AL_APIENTRY alSourcePlayv(ALsizei n, const ALuint *sources)

  1329 {

  1330     ALCcontext       *Context;

  1331     ALsource         *Source;

  1332     ALsizei          i;

  1333 

  1334     Context = GetLockedContext();

  1335     if(!Context) return;

  1336 

  1337     if(n < 0)

  1338     {

  1339         alSetError(Context, AL_INVALID_VALUE);

  1340         goto done;

  1341     }

  1342     if(n > 0 && !sources)

  1343     {

  1344         alSetError(Context, AL_INVALID_VALUE);

  1345         goto done;

  1346     }

  1347 

  1348     // Check that all the Sources are valid

  1349     for(i = 0;i < n;i++)

  1350     {

  1351         if(!LookupSource(Context->SourceMap, sources[i]))

  1352         {

  1353             alSetError(Context, AL_INVALID_NAME);

  1354             goto done;

  1355         }

  1356     }

  1357 

  1358     while(Context->MaxActiveSources-Context->ActiveSourceCount < n)

  1359     {

  1360         void *temp = NULL;

  1361         ALsizei newcount;

  1362 

  1363         newcount = Context->MaxActiveSources << 1;

  1364         if(newcount > 0)

  1365             temp = realloc(Context->ActiveSources,

  1366                            sizeof(*Context->ActiveSources) * newcount);

  1367         if(!temp)

  1368         {

  1369             alSetError(Context, AL_OUT_OF_MEMORY);

  1370             goto done;

  1371         }

  1372 

  1373         Context->ActiveSources = temp;

  1374         Context->MaxActiveSources = newcount;

  1375     }

  1376 

  1377     for(i = 0;i < n;i++)

  1378     {

  1379         Source = LookupSource(Context->SourceMap, sources[i]);

  1380         if(Context->DeferUpdates) Source->new_state = AL_PLAYING;

  1381         else SetSourceState(Source, Context, AL_PLAYING);

  1382     }

  1383 

  1384 done:

  1385     UnlockContext(Context);

  1386 }

  1387 

  1388 AL_API ALvoid AL_APIENTRY alSourcePause(ALuint source)

  1389 {

  1390     alSourcePausev(1, &source);

  1391 }

  1392 

  1393 AL_API ALvoid AL_APIENTRY alSourcePausev(ALsizei n, const ALuint *sources)

  1394 {

  1395     ALCcontext *Context;

  1396     ALsource *Source;

  1397     ALsizei i;

  1398 

  1399     Context = GetLockedContext();

  1400     if(!Context) return;

  1401 

  1402     if(n < 0)

  1403     {

  1404         alSetError(Context, AL_INVALID_VALUE);

  1405         goto done;

  1406     }

  1407     if(n > 0 && !sources)

  1408     {

  1409         alSetError(Context, AL_INVALID_VALUE);

  1410         goto done;

  1411     }

  1412 

  1413     // Check all the Sources are valid

  1414     for(i = 0;i < n;i++)

  1415     {

  1416         if(!LookupSource(Context->SourceMap, sources[i]))

  1417         {

  1418             alSetError(Context, AL_INVALID_NAME);

  1419             goto done;

  1420         }

  1421     }

  1422 

  1423     for(i = 0;i < n;i++)

  1424     {

  1425         Source = LookupSource(Context->SourceMap, sources[i]);

  1426         if(Context->DeferUpdates) Source->new_state = AL_PAUSED;

  1427         else SetSourceState(Source, Context, AL_PAUSED);

  1428     }

  1429 

  1430 done:

  1431     UnlockContext(Context);

  1432 }

  1433 

  1434 AL_API ALvoid AL_APIENTRY alSourceStop(ALuint source)

  1435 {

  1436     alSourceStopv(1, &source);

  1437 }

  1438 

  1439 AL_API ALvoid AL_APIENTRY alSourceStopv(ALsizei n, const ALuint *sources)

  1440 {

  1441     ALCcontext *Context;

  1442     ALsource *Source;

  1443     ALsizei i;

  1444 

  1445     Context = GetLockedContext();

  1446     if(!Context) return;

  1447 

  1448     if(n < 0)

  1449     {

  1450         alSetError(Context, AL_INVALID_VALUE);

  1451         goto done;

  1452     }

  1453     if(n > 0 && !sources)

  1454     {

  1455         alSetError(Context, AL_INVALID_VALUE);

  1456         goto done;

  1457     }

  1458 

  1459     // Check all the Sources are valid

  1460     for(i = 0;i < n;i++)

  1461     {

  1462         if(!LookupSource(Context->SourceMap, sources[i]))

  1463         {

  1464             alSetError(Context, AL_INVALID_NAME);

  1465             goto done;

  1466         }

  1467     }

  1468 

  1469     for(i = 0;i < n;i++)

  1470     {

  1471         Source = LookupSource(Context->SourceMap, sources[i]);

  1472         if(Context->DeferUpdates) Source->new_state = AL_STOPPED;

  1473         else SetSourceState(Source, Context, AL_STOPPED);

  1474     }

  1475 

  1476 done:

  1477     UnlockContext(Context);

  1478 }

  1479 

  1480 AL_API ALvoid AL_APIENTRY alSourceRewind(ALuint source)

  1481 {

  1482     alSourceRewindv(1, &source);

  1483 }

  1484 

  1485 AL_API ALvoid AL_APIENTRY alSourceRewindv(ALsizei n, const ALuint *sources)

  1486 {

  1487     ALCcontext *Context;

  1488     ALsource *Source;

  1489     ALsizei i;

  1490 

  1491     Context = GetLockedContext();

  1492     if(!Context) return;

  1493 

  1494     if(n < 0)

  1495     {

  1496         alSetError(Context, AL_INVALID_VALUE);

  1497         goto done;

  1498     }

  1499     if(n > 0 && !sources)

  1500     {

  1501         alSetError(Context, AL_INVALID_VALUE);

  1502         goto done;

  1503     }

  1504 

  1505     // Check all the Sources are valid

  1506     for(i = 0;i < n;i++)

  1507     {

  1508         if(!LookupSource(Context->SourceMap, sources[i]))

  1509         {

  1510             alSetError(Context, AL_INVALID_NAME);

  1511             goto done;

  1512         }

  1513     }

  1514 

  1515     for(i = 0;i < n;i++)

  1516     {

  1517         Source = LookupSource(Context->SourceMap, sources[i]);

  1518         if(Context->DeferUpdates) Source->new_state = AL_INITIAL;

  1519         else SetSourceState(Source, Context, AL_INITIAL);

  1520     }

  1521 

  1522 done:

  1523     UnlockContext(Context);

  1524 }

  1525 

  1526 

  1527 AL_API ALvoid AL_APIENTRY alSourceQueueBuffers(ALuint source, ALsizei n, const ALuint *buffers)

  1528 {

  1529     ALCcontext *Context;

  1530     ALCdevice *device;

  1531     ALsource *Source;

  1532     ALbuffer *buffer;

  1533     ALsizei i;

  1534     ALbufferlistitem *BufferListStart;

  1535     ALbufferlistitem *BufferList;

  1536     ALbuffer *BufferFmt;

  1537 

  1538     if(n == 0)

  1539         return;

  1540 

  1541     Context = GetLockedContext();

  1542     if(!Context) return;

  1543 

  1544     if(n < 0)

  1545     {

  1546         alSetError(Context, AL_INVALID_VALUE);

  1547         goto done;

  1548     }

  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((Source=LookupSource(Context->SourceMap, source)) == NULL)

  1554     {

  1555         alSetError(Context, AL_INVALID_NAME);

  1556         goto done;

  1557     }

  1558 

  1559     // Check that this is not a STATIC Source

  1560     if(Source->lSourceType == AL_STATIC)

  1561     {

  1562         // Invalid Source Type (can't queue on a Static Source)

  1563         alSetError(Context, AL_INVALID_OPERATION);

  1564         goto done;

  1565     }

  1566 

  1567     device = Context->Device;

  1568 

  1569     BufferFmt = NULL;

  1570 

  1571     // Check existing Queue (if any) for a valid Buffers and get its frequency and format

  1572     BufferList = Source->queue;

  1573     while(BufferList)

  1574     {

  1575         if(BufferList->buffer)

  1576         {

  1577             BufferFmt = BufferList->buffer;

  1578             break;

  1579         }

  1580         BufferList = BufferList->next;

  1581     }

  1582 

  1583     for(i = 0;i < n;i++)

  1584     {

  1585         if(!buffers[i])

  1586             continue;

  1587 

  1588         if((buffer=LookupBuffer(device->BufferMap, buffers[i])) == NULL)

  1589         {

  1590             alSetError(Context, AL_INVALID_NAME);

  1591             goto done;

  1592         }

  1593 

  1594         if(BufferFmt == NULL)

  1595         {

  1596             BufferFmt = buffer;

  1597 

  1598             Source->NumChannels = ChannelsFromFmt(buffer->FmtChannels);

  1599             Source->SampleSize  = BytesFromFmt(buffer->FmtType);

  1600             if(buffer->FmtChannels == FmtMono)

  1601                 Source->Update = CalcSourceParams;

  1602             else

  1603                 Source->Update = CalcNonAttnSourceParams;

  1604 

  1605             Source->NeedsUpdate = AL_TRUE;

  1606         }

  1607         else if(BufferFmt->Frequency != buffer->Frequency ||

  1608                 BufferFmt->OriginalChannels != buffer->OriginalChannels ||

  1609                 BufferFmt->OriginalType != buffer->OriginalType)

  1610         {

  1611             alSetError(Context, AL_INVALID_OPERATION);

  1612             goto done;

  1613         }

  1614     }

  1615 

  1616     // Change Source Type

  1617     Source->lSourceType = AL_STREAMING;

  1618 

  1619     buffer = LookupBuffer(device->BufferMap, buffers[0]);

  1620 

  1621     // All buffers are valid - so add them to the list

  1622     BufferListStart = malloc(sizeof(ALbufferlistitem));

  1623     BufferListStart->buffer = buffer;

  1624     BufferListStart->next = NULL;

  1625     BufferListStart->prev = NULL;

  1626 

  1627     // Increment reference counter for buffer

  1628     if(buffer) buffer->refcount++;

  1629 

  1630     BufferList = BufferListStart;

  1631 

  1632     for(i = 1;i < n;i++)

  1633     {

  1634         buffer = LookupBuffer(device->BufferMap, buffers[i]);

  1635 

  1636         BufferList->next = malloc(sizeof(ALbufferlistitem));

  1637         BufferList->next->buffer = buffer;

  1638         BufferList->next->next = NULL;

  1639         BufferList->next->prev = BufferList;

  1640 

  1641         // Increment reference counter for buffer

  1642         if(buffer) buffer->refcount++;

  1643 

  1644         BufferList = BufferList->next;

  1645     }

  1646 

  1647     if(Source->queue == NULL)

  1648     {

  1649         Source->queue = BufferListStart;

  1650         // Update Current Buffer

  1651         Source->Buffer = BufferListStart->buffer;

  1652     }

  1653     else

  1654     {

  1655         // Find end of queue

  1656         BufferList = Source->queue;

  1657         while(BufferList->next != NULL)

  1658             BufferList = BufferList->next;

  1659 

  1660         BufferList->next = BufferListStart;

  1661         BufferList->next->prev = BufferList;

  1662     }

  1663 

  1664     // Update number of buffers in queue

  1665     Source->BuffersInQueue += n;

  1666 

  1667 done:

  1668     UnlockContext(Context);

  1669 }

  1670 

  1671 

  1672 // Implementation assumes that n is the number of buffers to be removed from the queue and buffers is

  1673 // an array of buffer IDs that are to be filled with the names of the buffers removed

  1674 AL_API ALvoid AL_APIENTRY alSourceUnqueueBuffers( ALuint source, ALsizei n, ALuint* buffers )

  1675 {

  1676     ALCcontext *Context;

  1677     ALsource *Source;

  1678     ALsizei i;

  1679     ALbufferlistitem *BufferList;

  1680 

  1681     if(n == 0)

  1682         return;

  1683 

  1684     Context = GetLockedContext();

  1685     if(!Context) return;

  1686 

  1687     if(n < 0)

  1688     {

  1689         alSetError(Context, AL_INVALID_VALUE);

  1690         goto done;

  1691     }

  1692 

  1693     if((Source=LookupSource(Context->SourceMap, source)) == NULL)

  1694     {

  1695         alSetError(Context, AL_INVALID_NAME);

  1696         goto done;

  1697     }

  1698 

  1699     if(Source->bLooping || Source->lSourceType != AL_STREAMING ||

  1700        (ALuint)n > Source->BuffersPlayed)

  1701     {

  1702         // Some buffers can't be unqueue because they have not been processed

  1703         alSetError(Context, AL_INVALID_VALUE);

  1704         goto done;

  1705     }

  1706 

  1707     for(i = 0;i < n;i++)

  1708     {

  1709         BufferList = Source->queue;

  1710         Source->queue = BufferList->next;

  1711 

  1712         if(BufferList->buffer)

  1713         {

  1714             // Record name of buffer

  1715             buffers[i] = BufferList->buffer->buffer;

  1716             // Decrement buffer reference counter

  1717             BufferList->buffer->refcount--;

  1718         }

  1719         else

  1720             buffers[i] = 0;

  1721 

  1722         // Release memory for buffer list item

  1723         free(BufferList);

  1724         Source->BuffersInQueue--;

  1725     }

  1726     if(Source->queue)

  1727         Source->queue->prev = NULL;

  1728 

  1729     if(Source->state != AL_PLAYING)

  1730     {

  1731         if(Source->queue)

  1732             Source->Buffer = Source->queue->buffer;

  1733         else

  1734             Source->Buffer = NULL;

  1735     }

  1736     Source->BuffersPlayed -= n;

  1737 

  1738 done:

  1739     UnlockContext(Context);

  1740 }

  1741 

  1742 

  1743 static ALvoid InitSourceParams(ALsource *Source)

  1744 {

  1745     Source->flInnerAngle = 360.0f;

  1746     Source->flOuterAngle = 360.0f;

  1747     Source->flPitch = 1.0f;

  1748     Source->vPosition[0] = 0.0f;

  1749     Source->vPosition[1] = 0.0f;

  1750     Source->vPosition[2] = 0.0f;

  1751     Source->vOrientation[0] = 0.0f;

  1752     Source->vOrientation[1] = 0.0f;

  1753     Source->vOrientation[2] = 0.0f;

  1754     Source->vVelocity[0] = 0.0f;

  1755     Source->vVelocity[1] = 0.0f;

  1756     Source->vVelocity[2] = 0.0f;

  1757     Source->flRefDistance = 1.0f;

  1758     Source->flMaxDistance = FLT_MAX;

  1759     Source->flRollOffFactor = 1.0f;

  1760     Source->bLooping = AL_FALSE;

  1761     Source->flGain = 1.0f;

  1762     Source->flMinGain = 0.0f;

  1763     Source->flMaxGain = 1.0f;

  1764     Source->flOuterGain = 0.0f;

  1765     Source->OuterGainHF = 1.0f;

  1766 

  1767     Source->DryGainHFAuto = AL_TRUE;

  1768     Source->WetGainAuto = AL_TRUE;

  1769     Source->WetGainHFAuto = AL_TRUE;

  1770     Source->AirAbsorptionFactor = 0.0f;

  1771     Source->RoomRolloffFactor = 0.0f;

  1772     Source->DopplerFactor = 1.0f;

  1773     Source->VirtualChannels = AL_TRUE;

  1774 

  1775     Source->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;

  1776 

  1777     Source->Resampler = DefaultResampler;

  1778 

  1779     Source->state = AL_INITIAL;

  1780     Source->new_state = AL_NONE;

  1781     Source->lSourceType = AL_UNDETERMINED;

  1782     Source->lOffset = -1;

  1783 

  1784     Source->NeedsUpdate = AL_TRUE;

  1785 

  1786     Source->Buffer = NULL;

  1787 

  1788     Source->HrtfMoving = AL_FALSE;

  1789     Source->HrtfCounter = 0;

  1790 }

  1791 

  1792 

  1793 /*

  1794  * SetSourceState

  1795  *

  1796  * Sets the source's new play state given its current state

  1797  */

  1798 ALvoid SetSourceState(ALsource *Source, ALCcontext *Context, ALenum state)

  1799 {

  1800     if(state == AL_PLAYING)

  1801     {

  1802         ALbufferlistitem *BufferList;

  1803         ALsizei j, k;

  1804 

  1805         /* Check that there is a queue containing at least one non-null, non zero length AL Buffer */

  1806         BufferList = Source->queue;

  1807         while(BufferList)

  1808         {

  1809             if(BufferList->buffer != NULL && BufferList->buffer->size)

  1810                 break;

  1811             BufferList = BufferList->next;

  1812         }

  1813 

  1814         /* If there's nothing to play, or device is disconnected, go right to

  1815          * stopped */

  1816         if(!BufferList || !Context->Device->Connected)

  1817         {

  1818             SetSourceState(Source, Context, AL_STOPPED);

  1819             return;

  1820         }

  1821 

  1822         if(Source->state != AL_PLAYING)

  1823         {

  1824             for(j = 0;j < MAXCHANNELS;j++)

  1825             {

  1826                 for(k = 0;k < SRC_HISTORY_LENGTH;k++)

  1827                     Source->HrtfHistory[j][k] = 0.0f;

  1828                 for(k = 0;k < HRIR_LENGTH;k++)

  1829                 {

  1830                     Source->HrtfValues[j][k][0] = 0.0f;

  1831                     Source->HrtfValues[j][k][1] = 0.0f;

  1832                 }

  1833             }

  1834         }

  1835 

  1836         if(Source->state != AL_PAUSED)

  1837         {

  1838             Source->state = AL_PLAYING;

  1839             Source->position = 0;

  1840             Source->position_fraction = 0;

  1841             Source->BuffersPlayed = 0;

  1842 

  1843             Source->Buffer = Source->queue->buffer;

  1844         }

  1845         else

  1846             Source->state = AL_PLAYING;

  1847 

  1848         // Check if an Offset has been set

  1849         if(Source->lOffset != -1)

  1850             ApplyOffset(Source);

  1851 

  1852         for(j = 0;j < Context->ActiveSourceCount;j++)

  1853         {

  1854             if(Context->ActiveSources[j] == Source)

  1855                 break;

  1856         }

  1857         if(j == Context->ActiveSourceCount)

  1858             Context->ActiveSources[Context->ActiveSourceCount++] = Source;

  1859     }

  1860     else if(state == AL_PAUSED)

  1861     {

  1862         if(Source->state == AL_PLAYING)

  1863         {

  1864             Source->state = AL_PAUSED;

  1865             Source->HrtfMoving = AL_FALSE;

  1866             Source->HrtfCounter = 0;

  1867         }

  1868     }

  1869     else if(state == AL_STOPPED)

  1870     {

  1871         if(Source->state != AL_INITIAL)

  1872         {

  1873             Source->state = AL_STOPPED;

  1874             Source->BuffersPlayed = Source->BuffersInQueue;

  1875             Source->HrtfMoving = AL_FALSE;

  1876             Source->HrtfCounter = 0;

  1877         }

  1878         Source->lOffset = -1;

  1879     }

  1880     else if(state == AL_INITIAL)

  1881     {

  1882         if(Source->state != AL_INITIAL)

  1883         {

  1884             Source->state = AL_INITIAL;

  1885             Source->position = 0;

  1886             Source->position_fraction = 0;

  1887             Source->BuffersPlayed = 0;

  1888             if(Source->queue)

  1889                 Source->Buffer = Source->queue->buffer;

  1890             Source->HrtfMoving = AL_FALSE;

  1891             Source->HrtfCounter = 0;

  1892         }

  1893         Source->lOffset = -1;

  1894     }

  1895 }

  1896 

  1897 /*

  1898     GetSourceOffset

  1899 

  1900     Gets the current playback position in the given Source, in the appropriate format (Bytes, Samples or MilliSeconds)

  1901     The offset is relative to the start of the queue (not the start of the current buffer)

  1902 */

  1903 static ALvoid GetSourceOffset(ALsource *Source, ALenum name, ALdouble *offset, ALdouble updateLen)

  1904 {

  1905     const ALbufferlistitem *BufferList;

  1906     const ALbuffer         *Buffer = NULL;

  1907     enum UserFmtType OriginalType;

  1908     ALsizei BufferFreq;

  1909     ALint   Channels, Bytes;

  1910     ALuint  readPos, writePos;

  1911     ALuint  TotalBufferDataSize;

  1912     ALuint  i;

  1913 

  1914     // Find the first non-NULL Buffer in the Queue

  1915     BufferList = Source->queue;

  1916     while(BufferList)

  1917     {

  1918         if(BufferList->buffer)

  1919         {

  1920             Buffer = BufferList->buffer;

  1921             break;

  1922         }

  1923         BufferList = BufferList->next;

  1924     }

  1925 

  1926     if((Source->state != AL_PLAYING && Source->state != AL_PAUSED) || !Buffer)

  1927     {

  1928         offset[0] = 0.0;

  1929         offset[1] = 0.0;

  1930         return;

  1931     }

  1932 

  1933     // Get Current Buffer Size and frequency (in milliseconds)

  1934     BufferFreq = Buffer->Frequency;

  1935     OriginalType = Buffer->OriginalType;

  1936     Channels = ChannelsFromFmt(Buffer->FmtChannels);

  1937     Bytes = BytesFromFmt(Buffer->FmtType);

  1938 

  1939     // Get Current BytesPlayed (NOTE : This is the byte offset into the *current* buffer)

  1940     readPos = Source->position * Channels * Bytes;

  1941     // Add byte length of any processed buffers in the queue

  1942     TotalBufferDataSize = 0;

  1943     BufferList = Source->queue;

  1944     for(i = 0;BufferList;i++)

  1945     {

  1946         if(BufferList->buffer)

  1947         {

  1948             if(i < Source->BuffersPlayed)

  1949                 readPos += BufferList->buffer->size;

  1950             TotalBufferDataSize += BufferList->buffer->size;

  1951         }

  1952         BufferList = BufferList->next;

  1953     }

  1954     if(Source->state == AL_PLAYING)

  1955         writePos = readPos + ((ALuint)(updateLen*BufferFreq) * Channels * Bytes);

  1956     else

  1957         writePos = readPos;

  1958 

  1959     if(Source->bLooping)

  1960     {

  1961         readPos %= TotalBufferDataSize;

  1962         writePos %= TotalBufferDataSize;

  1963     }

  1964     else

  1965     {

  1966         // Wrap positions back to 0

  1967         if(readPos >= TotalBufferDataSize)

  1968             readPos = 0;

  1969         if(writePos >= TotalBufferDataSize)

  1970             writePos = 0;

  1971     }

  1972 

  1973     switch(name)

  1974     {

  1975         case AL_SEC_OFFSET:

  1976             offset[0] = (ALdouble)readPos / (Channels * Bytes * BufferFreq);

  1977             offset[1] = (ALdouble)writePos / (Channels * Bytes * BufferFreq);

  1978             break;

  1979         case AL_SAMPLE_OFFSET:

  1980         case AL_SAMPLE_RW_OFFSETS_SOFT:

  1981             offset[0] = (ALdouble)(readPos / (Channels * Bytes));

  1982             offset[1] = (ALdouble)(writePos / (Channels * Bytes));

  1983             break;

  1984         case AL_BYTE_OFFSET:

  1985         case AL_BYTE_RW_OFFSETS_SOFT:

  1986             // Take into account the original format of the Buffer

  1987             if(OriginalType == UserFmtIMA4)

  1988             {

  1989                 ALuint FrameBlockSize = 65 * Bytes * Channels;

  1990                 ALuint BlockSize = 36 * Channels;

  1991 

  1992                 // Round down to nearest ADPCM block

  1993                 offset[0] = (ALdouble)(readPos / FrameBlockSize * BlockSize);

  1994                 if(Source->state != AL_PLAYING)

  1995                     offset[1] = offset[0];

  1996                 else

  1997                 {

  1998                     // Round up to nearest ADPCM block

  1999                     offset[1] = (ALdouble)((writePos+FrameBlockSize-1) /

  2000                                            FrameBlockSize * BlockSize);

  2001                 }

  2002             }

  2003             else

  2004             {

  2005                 ALuint OrigBytes = BytesFromUserFmt(OriginalType);

  2006                 offset[0] = (ALdouble)(readPos / Bytes * OrigBytes);

  2007                 offset[1] = (ALdouble)(writePos / Bytes * OrigBytes);

  2008             }

  2009             break;

  2010     }

  2011 }

  2012 

  2013 

  2014 /*

  2015     ApplyOffset

  2016 

  2017     Apply a playback offset to the Source.  This function will update the queue (to correctly

  2018     mark buffers as 'pending' or 'processed' depending upon the new offset.

  2019 */

  2020 ALboolean ApplyOffset(ALsource *Source)

  2021 {

  2022     const ALbufferlistitem *BufferList;

  2023     const ALbuffer         *Buffer;

  2024     ALint lBufferSize, lTotalBufferSize;

  2025     ALint BuffersPlayed;

  2026     ALint lByteOffset;

  2027 

  2028     // Get true byte offset

  2029     lByteOffset = GetByteOffset(Source);

  2030 

  2031     // If the offset is invalid, don't apply it

  2032     if(lByteOffset == -1)

  2033         return AL_FALSE;

  2034 

  2035     // Sort out the queue (pending and processed states)

  2036     BufferList = Source->queue;

  2037     lTotalBufferSize = 0;

  2038     BuffersPlayed = 0;

  2039 

  2040     while(BufferList)

  2041     {

  2042         Buffer = BufferList->buffer;

  2043         lBufferSize = Buffer ? Buffer->size : 0;

  2044 

  2045         if(lBufferSize <= lByteOffset-lTotalBufferSize)

  2046         {

  2047             // Offset is past this buffer so increment BuffersPlayed

  2048             BuffersPlayed++;

  2049         }

  2050         else if(lTotalBufferSize <= lByteOffset)

  2051         {

  2052             // Offset is within this buffer

  2053             // Set Current Buffer

  2054             Source->Buffer = BufferList->buffer;

  2055             Source->BuffersPlayed = BuffersPlayed;

  2056 

  2057             // SW Mixer Positions are in Samples

  2058             Source->position = (lByteOffset - lTotalBufferSize) /

  2059                                 FrameSizeFromFmt(Buffer->FmtChannels, Buffer->FmtType);

  2060             return AL_TRUE;

  2061         }

  2062 

  2063         // Increment the TotalBufferSize

  2064         lTotalBufferSize += lBufferSize;

  2065 

  2066         // Move on to next buffer in the Queue

  2067         BufferList = BufferList->next;

  2068     }

  2069     // Offset is out of range of the buffer queue

  2070     return AL_FALSE;

  2071 }

  2072 

  2073 

  2074 /*

  2075     GetByteOffset

  2076 

  2077     Returns the 'true' byte offset into the Source's queue (from the Sample, Byte or Millisecond

  2078     offset supplied by the application).   This takes into account the fact that the buffer format

  2079     may have been modifed by AL (e.g 8bit samples are converted to float)

  2080 */

  2081 static ALint GetByteOffset(ALsource *Source)

  2082 {

  2083     const ALbuffer *Buffer = NULL;

  2084     const ALbufferlistitem *BufferList;

  2085     ALint ByteOffset = -1;

  2086 

  2087     // Find the first non-NULL Buffer in the Queue

  2088     BufferList = Source->queue;

  2089     while(BufferList)

  2090     {

  2091         if(BufferList->buffer)

  2092         {

  2093             Buffer = BufferList->buffer;

  2094             break;

  2095         }

  2096         BufferList = BufferList->next;

  2097     }

  2098 

  2099     if(!Buffer)

  2100     {

  2101         Source->lOffset = -1;

  2102         return -1;

  2103     }

  2104 

  2105     // Determine the ByteOffset (and ensure it is block aligned)

  2106     switch(Source->lOffsetType)

  2107     {

  2108     case AL_BYTE_OFFSET:

  2109         // Take into consideration the original format

  2110         ByteOffset = Source->lOffset;

  2111         if(Buffer->OriginalType == UserFmtIMA4)

  2112         {

  2113             // Round down to nearest ADPCM block

  2114             ByteOffset /= 36 * ChannelsFromUserFmt(Buffer->OriginalChannels);

  2115             // Multiply by compression rate (65 sample frames per block)

  2116             ByteOffset *= 65;

  2117         }

  2118         else

  2119             ByteOffset /= FrameSizeFromUserFmt(Buffer->OriginalChannels, Buffer->OriginalType);

  2120         ByteOffset *= FrameSizeFromFmt(Buffer->FmtChannels, Buffer->FmtType);

  2121         break;

  2122 

  2123     case AL_SAMPLE_OFFSET:

  2124         ByteOffset = Source->lOffset * FrameSizeFromFmt(Buffer->FmtChannels, Buffer->FmtType);

  2125         break;

  2126 

  2127     case AL_SEC_OFFSET:

  2128         // Note - lOffset is internally stored as Milliseconds

  2129         ByteOffset  = (ALint)(Source->lOffset / 1000.0 * Buffer->Frequency);

  2130         ByteOffset *= FrameSizeFromFmt(Buffer->FmtChannels, Buffer->FmtType);

  2131         break;

  2132     }

  2133     // Clear Offset

  2134     Source->lOffset = -1;

  2135 

  2136     return ByteOffset;

  2137 }

  2138 

  2139 

  2140 ALvoid ReleaseALSources(ALCcontext *Context)

  2141 {

  2142     ALsizei pos;

  2143     ALuint j;

  2144     for(pos = 0;pos < Context->SourceMap.size;pos++)

  2145     {

  2146         ALsource *temp = Context->SourceMap.array[pos].value;

  2147         Context->SourceMap.array[pos].value = NULL;

  2148 

  2149         // For each buffer in the source's queue, decrement its reference counter and remove it

  2150         while(temp->queue != NULL)

  2151         {

  2152             ALbufferlistitem *BufferList = temp->queue;

  2153             temp->queue = BufferList->next;

  2154 

  2155             if(BufferList->buffer != NULL)

  2156                 BufferList->buffer->refcount--;

  2157             free(BufferList);

  2158         }

  2159 

  2160         for(j = 0;j < MAX_SENDS;++j)

  2161         {

  2162             if(temp->Send[j].Slot)

  2163                 temp->Send[j].Slot->refcount--;

  2164             temp->Send[j].Slot = NULL;

  2165         }

  2166 

  2167         // Release source structure

  2168         FreeThunkEntry(temp->source);

  2169         memset(temp, 0, sizeof(ALsource));

  2170         free(temp);

  2171     }

  2172 }
author	Robert McIntyre <rlm@mit.edu>
date	Tue, 25 Oct 2011 13:02:31 -0700
parents
children