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 

    25 #include "AL/al.h"

    26 #include "AL/alc.h"

    27 #include "alMain.h"

    28 #include "alFilter.h"

    29 #include "alThunk.h"

    30 #include "alError.h"

    31 

    32 

    33 static void InitFilterParams(ALfilter *filter, ALenum type);

    34 

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

    36 

    37 AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)

    38 {

    39     ALCcontext *Context;

    40     ALsizei i=0;

    41 

    42     Context = GetLockedContext();

    43     if(!Context) return;

    44 

    45     if(n < 0 || IsBadWritePtr((void*)filters, n * sizeof(ALuint)))

    46         alSetError(Context, AL_INVALID_VALUE);

    47     else

    48     {

    49         ALCdevice *device = Context->Device;

    50         ALenum err;

    51 

    52         while(i < n)

    53         {

    54             ALfilter *filter = calloc(1, sizeof(ALfilter));

    55             if(!filter)

    56             {

    57                 alSetError(Context, AL_OUT_OF_MEMORY);

    58                 alDeleteFilters(i, filters);

    59                 break;

    60             }

    61 

    62             err = NewThunkEntry(&filter->filter);

    63             if(err == AL_NO_ERROR)

    64                 err = InsertUIntMapEntry(&device->FilterMap, filter->filter, filter);

    65             if(err != AL_NO_ERROR)

    66             {

    67                 FreeThunkEntry(filter->filter);

    68                 memset(filter, 0, sizeof(ALfilter));

    69                 free(filter);

    70 

    71                 alSetError(Context, err);

    72                 alDeleteFilters(i, filters);

    73                 break;

    74             }

    75 

    76             filters[i++] = filter->filter;

    77             InitFilterParams(filter, AL_FILTER_NULL);

    78         }

    79     }

    80 

    81     UnlockContext(Context);

    82 }

    83 

    84 AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)

    85 {

    86     ALCcontext *Context;

    87     ALCdevice *device;

    88     ALfilter *ALFilter;

    89     ALboolean Failed;

    90     ALsizei i;

    91 

    92     Context = GetLockedContext();

    93     if(!Context) return;

    94 

    95     Failed = AL_TRUE;

    96     device = Context->Device;

    97     if(n < 0)

    98         alSetError(Context, AL_INVALID_VALUE);

    99     else

   100     {

   101         Failed = AL_FALSE;

   102         // Check that all filters are valid

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

   104         {

   105             if(!filters[i])

   106                 continue;

   107 

   108             if(LookupFilter(device->FilterMap, filters[i]) == NULL)

   109             {

   110                 alSetError(Context, AL_INVALID_NAME);

   111                 Failed = AL_TRUE;

   112                 break;

   113             }

   114         }

   115     }

   116 

   117     if(!Failed)

   118     {

   119         // All filters are valid

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

   121         {

   122             // Recheck that the filter is valid, because there could be duplicated names

   123             if((ALFilter=LookupFilter(device->FilterMap, filters[i])) == NULL)

   124                 continue;

   125 

   126             RemoveUIntMapKey(&device->FilterMap, ALFilter->filter);

   127             FreeThunkEntry(ALFilter->filter);

   128 

   129             memset(ALFilter, 0, sizeof(ALfilter));

   130             free(ALFilter);

   131         }

   132     }

   133 

   134     UnlockContext(Context);

   135 }

   136 

   137 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)

   138 {

   139     ALCcontext *Context;

   140     ALboolean  result;

   141 

   142     Context = GetLockedContext();

   143     if(!Context) return AL_FALSE;

   144 

   145     result = ((!filter || LookupFilter(Context->Device->FilterMap, filter)) ?

   146               AL_TRUE : AL_FALSE);

   147 

   148     UnlockContext(Context);

   149 

   150     return result;

   151 }

   152 

   153 AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)

   154 {

   155     ALCcontext *Context;

   156     ALCdevice  *Device;

   157     ALfilter   *ALFilter;

   158 

   159     Context = GetLockedContext();

   160     if(!Context) return;

   161 

   162     Device = Context->Device;

   163     if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)

   164     {

   165         switch(param)

   166         {

   167         case AL_FILTER_TYPE:

   168             if(iValue == AL_FILTER_NULL ||

   169                iValue == AL_FILTER_LOWPASS)

   170                 InitFilterParams(ALFilter, iValue);

   171             else

   172                 alSetError(Context, AL_INVALID_VALUE);

   173             break;

   174 

   175         default:

   176             alSetError(Context, AL_INVALID_ENUM);

   177             break;

   178         }

   179     }

   180     else

   181         alSetError(Context, AL_INVALID_NAME);

   182 

   183     UnlockContext(Context);

   184 }

   185 

   186 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)

   187 {

   188     ALCcontext *Context;

   189     ALCdevice  *Device;

   190 

   191     switch(param)

   192     {

   193         case AL_FILTER_TYPE:

   194             alFilteri(filter, param, piValues[0]);

   195             return;

   196     }

   197 

   198     Context = GetLockedContext();

   199     if(!Context) return;

   200 

   201     Device = Context->Device;

   202     if(LookupFilter(Device->FilterMap, filter) != NULL)

   203     {

   204         switch(param)

   205         {

   206         default:

   207             alSetError(Context, AL_INVALID_ENUM);

   208             break;

   209         }

   210     }

   211     else

   212         alSetError(Context, AL_INVALID_NAME);

   213 

   214     UnlockContext(Context);

   215 }

   216 

   217 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)

   218 {

   219     ALCcontext *Context;

   220     ALCdevice  *Device;

   221     ALfilter   *ALFilter;

   222 

   223     Context = GetLockedContext();

   224     if(!Context) return;

   225 

   226     Device = Context->Device;

   227     if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)

   228     {

   229         switch(ALFilter->type)

   230         {

   231         case AL_FILTER_LOWPASS:

   232             switch(param)

   233             {

   234             case AL_LOWPASS_GAIN:

   235                 if(flValue >= AL_LOWPASS_MIN_GAIN &&

   236                    flValue <= AL_LOWPASS_MAX_GAIN)

   237                     ALFilter->Gain = flValue;

   238                 else

   239                     alSetError(Context, AL_INVALID_VALUE);

   240                 break;

   241 

   242             case AL_LOWPASS_GAINHF:

   243                 if(flValue >= AL_LOWPASS_MIN_GAINHF &&

   244                    flValue <= AL_LOWPASS_MAX_GAINHF)

   245                     ALFilter->GainHF = flValue;

   246                 else

   247                     alSetError(Context, AL_INVALID_VALUE);

   248                 break;

   249 

   250             default:

   251                 alSetError(Context, AL_INVALID_ENUM);

   252                 break;

   253             }

   254             break;

   255 

   256         default:

   257             alSetError(Context, AL_INVALID_ENUM);

   258             break;

   259         }

   260     }

   261     else

   262         alSetError(Context, AL_INVALID_NAME);

   263 

   264     UnlockContext(Context);

   265 }

   266 

   267 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)

   268 {

   269     /* There are currently no multi-value filter parameters */

   270     alFilterf(filter, param, pflValues[0]);

   271 }

   272 

   273 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)

   274 {

   275     ALCcontext *Context;

   276     ALCdevice  *Device;

   277     ALfilter   *ALFilter;

   278 

   279     Context = GetLockedContext();

   280     if(!Context) return;

   281 

   282     Device = Context->Device;

   283     if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)

   284     {

   285         switch(param)

   286         {

   287         case AL_FILTER_TYPE:

   288             *piValue = ALFilter->type;

   289             break;

   290 

   291         default:

   292             alSetError(Context, AL_INVALID_ENUM);

   293             break;

   294         }

   295     }

   296     else

   297         alSetError(Context, AL_INVALID_NAME);

   298 

   299     UnlockContext(Context);

   300 }

   301 

   302 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)

   303 {

   304     ALCcontext *Context;

   305     ALCdevice  *Device;

   306 

   307     switch(param)

   308     {

   309         case AL_FILTER_TYPE:

   310             alGetFilteri(filter, param, piValues);

   311             return;

   312     }

   313 

   314     Context = GetLockedContext();

   315     if(!Context) return;

   316 

   317     Device = Context->Device;

   318     if(LookupFilter(Device->FilterMap, filter) != NULL)

   319     {

   320         switch(param)

   321         {

   322         default:

   323             alSetError(Context, AL_INVALID_ENUM);

   324             break;

   325         }

   326     }

   327     else

   328         alSetError(Context, AL_INVALID_NAME);

   329 

   330     UnlockContext(Context);

   331 }

   332 

   333 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)

   334 {

   335     ALCcontext *Context;

   336     ALCdevice  *Device;

   337     ALfilter   *ALFilter;

   338 

   339     Context = GetLockedContext();

   340     if(!Context) return;

   341 

   342     Device = Context->Device;

   343     if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)

   344     {

   345         switch(ALFilter->type)

   346         {

   347         case AL_FILTER_LOWPASS:

   348             switch(param)

   349             {

   350             case AL_LOWPASS_GAIN:

   351                 *pflValue = ALFilter->Gain;

   352                 break;

   353 

   354             case AL_LOWPASS_GAINHF:

   355                 *pflValue = ALFilter->GainHF;

   356                 break;

   357 

   358             default:

   359                 alSetError(Context, AL_INVALID_ENUM);

   360                 break;

   361             }

   362             break;

   363 

   364         default:

   365             alSetError(Context, AL_INVALID_ENUM);

   366             break;

   367         }

   368     }

   369     else

   370         alSetError(Context, AL_INVALID_NAME);

   371 

   372     UnlockContext(Context);

   373 }

   374 

   375 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)

   376 {

   377     /* There are currently no multi-value filter parameters */

   378     alGetFilterf(filter, param, pflValues);

   379 }

   380 

   381 

   382 ALfloat lpCoeffCalc(ALfloat g, ALfloat cw)

   383 {

   384     ALfloat a = 0.0f;

   385 

   386     /* Be careful with gains < 0.01, as that causes the coefficient

   387      * head towards 1, which will flatten the signal */

   388     if(g < 0.9999f) /* 1-epsilon */

   389     {

   390         g = maxf(g, 0.01f);

   391         a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) /

   392             (1 - g);

   393     }

   394 

   395     return a;

   396 }

   397 

   398 ALvoid ReleaseALFilters(ALCdevice *device)

   399 {

   400     ALsizei i;

   401     for(i = 0;i < device->FilterMap.size;i++)

   402     {

   403         ALfilter *temp = device->FilterMap.array[i].value;

   404         device->FilterMap.array[i].value = NULL;

   405 

   406         // Release filter structure

   407         FreeThunkEntry(temp->filter);

   408         memset(temp, 0, sizeof(ALfilter));

   409         free(temp);

   410     }

   411 }

   412 

   413 

   414 static void InitFilterParams(ALfilter *filter, ALenum type)

   415 {

   416     filter->type = type;

   417 

   418     filter->Gain = AL_LOWPASS_DEFAULT_GAIN;

   419     filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;

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