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 <math.h>

    24 #include <stdlib.h>

    25 #include <stdio.h>

    26 #include <memory.h>

    27 #include <ctype.h>

    28 

    29 #include "alMain.h"

    30 #include "alSource.h"

    31 #include "AL/al.h"

    32 #include "AL/alc.h"

    33 #include "alThunk.h"

    34 #include "alSource.h"

    35 #include "alBuffer.h"

    36 #include "alAuxEffectSlot.h"

    37 #include "bs2b.h"

    38 #include "alu.h"

    39 

    40 // RLM: try to include the file here.

    41 

    42 

    43 

    44 #define EmptyFuncs { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }

    45 static struct BackendInfo BackendList[] = {

    46 #ifdef HAVE_PULSEAUDIO

    47     { "pulse", alc_pulse_init, alc_pulse_deinit, alc_pulse_probe, EmptyFuncs },

    48 #endif

    49 #ifdef HAVE_ALSA

    50     { "alsa", alc_alsa_init, alc_alsa_deinit, alc_alsa_probe, EmptyFuncs },

    51 #endif

    52 #ifdef HAVE_COREAUDIO

    53     { "core", alc_ca_init, alc_ca_deinit, alc_ca_probe, EmptyFuncs },

    54 #endif

    55 #ifdef HAVE_OSS

    56     { "oss", alc_oss_init, alc_oss_deinit, alc_oss_probe, EmptyFuncs },

    57 #endif

    58 #ifdef HAVE_SOLARIS

    59     { "solaris", alc_solaris_init, alc_solaris_deinit, alc_solaris_probe, EmptyFuncs },

    60 #endif

    61 #ifdef HAVE_SNDIO

    62     { "sndio", alc_sndio_init, alc_sndio_deinit, alc_sndio_probe, EmptyFuncs },

    63 #endif

    64 #ifdef HAVE_MMDEVAPI

    65     { "mmdevapi", alcMMDevApiInit, alcMMDevApiDeinit, alcMMDevApiProbe, EmptyFuncs },

    66 #endif

    67 #ifdef HAVE_DSOUND

    68     { "dsound", alcDSoundInit, alcDSoundDeinit, alcDSoundProbe, EmptyFuncs },

    69 #endif

    70 #ifdef HAVE_WINMM

    71     { "winmm", alcWinMMInit, alcWinMMDeinit, alcWinMMProbe, EmptyFuncs },

    72 #endif

    73 #ifdef HAVE_PORTAUDIO

    74     { "port", alc_pa_init, alc_pa_deinit, alc_pa_probe, EmptyFuncs },

    75 #endif

    76 #ifdef HAVE_OPENSL

    77     { "opensl", alc_opensl_init, alc_opensl_deinit, alc_opensl_probe, EmptyFuncs },

    78 #endif

    79 

    80     { "null", alc_null_init, alc_null_deinit, alc_null_probe, EmptyFuncs },

    81 #ifdef HAVE_WAVE

    82     { "wave", alc_wave_init, alc_wave_deinit, alc_wave_probe, EmptyFuncs },

    83 #endif

    84     { "send", alc_send_init, alc_send_deinit, alc_send_probe, EmptyFuncs },

    85     // this entry is so that the list is terminated by a "null" object,

    86     // and helps things to tell when they've reached the end of the list.

    87     { NULL, NULL, NULL, NULL, EmptyFuncs }

    88 };

    89 static struct BackendInfo BackendLoopback = {

    90     "loopback", alc_loopback_init, alc_loopback_deinit, alc_loopback_probe, EmptyFuncs

    91 };

    92 #undef EmptyFuncs

    93 

    94 static struct BackendInfo PlaybackBackend;

    95 static struct BackendInfo CaptureBackend;

    96 

    97 ///////////////////////////////////////////////////////

    98 // STRING and EXTENSIONS

    99 

   100 typedef struct ALCfunction {

   101     const ALCchar *funcName;

   102     ALCvoid *address;

   103 } ALCfunction;

   104 

   105 typedef struct ALCenums {

   106     const ALCchar *enumName;

   107     ALCenum value;

   108 } ALCenums;

   109 

   110 

   111 static const ALCfunction alcFunctions[] = {

   112     { "alcCreateContext",           (ALCvoid *) alcCreateContext         },

   113     { "alcMakeContextCurrent",      (ALCvoid *) alcMakeContextCurrent    },

   114     { "alcProcessContext",          (ALCvoid *) alcProcessContext        },

   115     { "alcSuspendContext",          (ALCvoid *) alcSuspendContext        },

   116     { "alcDestroyContext",          (ALCvoid *) alcDestroyContext        },

   117     { "alcGetCurrentContext",       (ALCvoid *) alcGetCurrentContext     },

   118     { "alcGetContextsDevice",       (ALCvoid *) alcGetContextsDevice     },

   119     { "alcOpenDevice",              (ALCvoid *) alcOpenDevice            },

   120     { "alcCloseDevice",             (ALCvoid *) alcCloseDevice           },

   121     { "alcGetError",                (ALCvoid *) alcGetError              },

   122     { "alcIsExtensionPresent",      (ALCvoid *) alcIsExtensionPresent    },

   123     { "alcGetProcAddress",          (ALCvoid *) alcGetProcAddress        },

   124     { "alcGetEnumValue",            (ALCvoid *) alcGetEnumValue          },

   125     { "alcGetString",               (ALCvoid *) alcGetString             },

   126     { "alcGetIntegerv",             (ALCvoid *) alcGetIntegerv           },

   127     { "alcCaptureOpenDevice",       (ALCvoid *) alcCaptureOpenDevice     },

   128     { "alcCaptureCloseDevice",      (ALCvoid *) alcCaptureCloseDevice    },

   129     { "alcCaptureStart",            (ALCvoid *) alcCaptureStart          },

   130     { "alcCaptureStop",             (ALCvoid *) alcCaptureStop           },

   131     { "alcCaptureSamples",          (ALCvoid *) alcCaptureSamples        },

   132 

   133     { "alcSetThreadContext",        (ALCvoid *) alcSetThreadContext      },

   134     { "alcGetThreadContext",        (ALCvoid *) alcGetThreadContext      },

   135 

   136     { "alcLoopbackOpenDeviceSOFT",  (ALCvoid *) alcLoopbackOpenDeviceSOFT},

   137     { "alcIsRenderFormatSupportedSOFT",(ALCvoid *) alcIsRenderFormatSupportedSOFT},

   138     { "alcRenderSamplesSOFT",       (ALCvoid *) alcRenderSamplesSOFT         },

   139 

   140     { "alEnable",                   (ALCvoid *) alEnable                 },

   141     { "alDisable",                  (ALCvoid *) alDisable                },

   142     { "alIsEnabled",                (ALCvoid *) alIsEnabled              },

   143     { "alGetString",                (ALCvoid *) alGetString              },

   144     { "alGetBooleanv",              (ALCvoid *) alGetBooleanv            },

   145     { "alGetIntegerv",              (ALCvoid *) alGetIntegerv            },

   146     { "alGetFloatv",                (ALCvoid *) alGetFloatv              },

   147     { "alGetDoublev",               (ALCvoid *) alGetDoublev             },

   148     { "alGetBoolean",               (ALCvoid *) alGetBoolean             },

   149     { "alGetInteger",               (ALCvoid *) alGetInteger             },

   150     { "alGetFloat",                 (ALCvoid *) alGetFloat               },

   151     { "alGetDouble",                (ALCvoid *) alGetDouble              },

   152     { "alGetError",                 (ALCvoid *) alGetError               },

   153     { "alIsExtensionPresent",       (ALCvoid *) alIsExtensionPresent     },

   154     { "alGetProcAddress",           (ALCvoid *) alGetProcAddress         },

   155     { "alGetEnumValue",             (ALCvoid *) alGetEnumValue           },

   156     { "alListenerf",                (ALCvoid *) alListenerf              },

   157     { "alListener3f",               (ALCvoid *) alListener3f             },

   158     { "alListenerfv",               (ALCvoid *) alListenerfv             },

   159     { "alListeneri",                (ALCvoid *) alListeneri              },

   160     { "alListener3i",               (ALCvoid *) alListener3i             },

   161     { "alListeneriv",               (ALCvoid *) alListeneriv             },

   162     { "alGetListenerf",             (ALCvoid *) alGetListenerf           },

   163     { "alGetListener3f",            (ALCvoid *) alGetListener3f          },

   164     { "alGetListenerfv",            (ALCvoid *) alGetListenerfv          },

   165     { "alGetListeneri",             (ALCvoid *) alGetListeneri           },

   166     { "alGetListener3i",            (ALCvoid *) alGetListener3i          },

   167     { "alGetListeneriv",            (ALCvoid *) alGetListeneriv          },

   168     { "alGenSources",               (ALCvoid *) alGenSources             },

   169     { "alDeleteSources",            (ALCvoid *) alDeleteSources          },

   170     { "alIsSource",                 (ALCvoid *) alIsSource               },

   171     { "alSourcef",                  (ALCvoid *) alSourcef                },

   172     { "alSource3f",                 (ALCvoid *) alSource3f               },

   173     { "alSourcefv",                 (ALCvoid *) alSourcefv               },

   174     { "alSourcei",                  (ALCvoid *) alSourcei                },

   175     { "alSource3i",                 (ALCvoid *) alSource3i               },

   176     { "alSourceiv",                 (ALCvoid *) alSourceiv               },

   177     { "alGetSourcef",               (ALCvoid *) alGetSourcef             },

   178     { "alGetSource3f",              (ALCvoid *) alGetSource3f            },

   179     { "alGetSourcefv",              (ALCvoid *) alGetSourcefv            },

   180     { "alGetSourcei",               (ALCvoid *) alGetSourcei             },

   181     { "alGetSource3i",              (ALCvoid *) alGetSource3i            },

   182     { "alGetSourceiv",              (ALCvoid *) alGetSourceiv            },

   183     { "alSourcePlayv",              (ALCvoid *) alSourcePlayv            },

   184     { "alSourceStopv",              (ALCvoid *) alSourceStopv            },

   185     { "alSourceRewindv",            (ALCvoid *) alSourceRewindv          },

   186     { "alSourcePausev",             (ALCvoid *) alSourcePausev           },

   187     { "alSourcePlay",               (ALCvoid *) alSourcePlay             },

   188     { "alSourceStop",               (ALCvoid *) alSourceStop             },

   189     { "alSourceRewind",             (ALCvoid *) alSourceRewind           },

   190     { "alSourcePause",              (ALCvoid *) alSourcePause            },

   191     { "alSourceQueueBuffers",       (ALCvoid *) alSourceQueueBuffers     },

   192     { "alSourceUnqueueBuffers",     (ALCvoid *) alSourceUnqueueBuffers   },

   193     { "alGenBuffers",               (ALCvoid *) alGenBuffers             },

   194     { "alDeleteBuffers",            (ALCvoid *) alDeleteBuffers          },

   195     { "alIsBuffer",                 (ALCvoid *) alIsBuffer               },

   196     { "alBufferData",               (ALCvoid *) alBufferData             },

   197     { "alBufferf",                  (ALCvoid *) alBufferf                },

   198     { "alBuffer3f",                 (ALCvoid *) alBuffer3f               },

   199     { "alBufferfv",                 (ALCvoid *) alBufferfv               },

   200     { "alBufferi",                  (ALCvoid *) alBufferi                },

   201     { "alBuffer3i",                 (ALCvoid *) alBuffer3i               },

   202     { "alBufferiv",                 (ALCvoid *) alBufferiv               },

   203     { "alGetBufferf",               (ALCvoid *) alGetBufferf             },

   204     { "alGetBuffer3f",              (ALCvoid *) alGetBuffer3f            },

   205     { "alGetBufferfv",              (ALCvoid *) alGetBufferfv            },

   206     { "alGetBufferi",               (ALCvoid *) alGetBufferi             },

   207     { "alGetBuffer3i",              (ALCvoid *) alGetBuffer3i            },

   208     { "alGetBufferiv",              (ALCvoid *) alGetBufferiv            },

   209     { "alDopplerFactor",            (ALCvoid *) alDopplerFactor          },

   210     { "alDopplerVelocity",          (ALCvoid *) alDopplerVelocity        },

   211     { "alSpeedOfSound",             (ALCvoid *) alSpeedOfSound           },

   212     { "alDistanceModel",            (ALCvoid *) alDistanceModel          },

   213 

   214     { "alGenFilters",               (ALCvoid *) alGenFilters             },

   215     { "alDeleteFilters",            (ALCvoid *) alDeleteFilters          },

   216     { "alIsFilter",                 (ALCvoid *) alIsFilter               },

   217     { "alFilteri",                  (ALCvoid *) alFilteri                },

   218     { "alFilteriv",                 (ALCvoid *) alFilteriv               },

   219     { "alFilterf",                  (ALCvoid *) alFilterf                },

   220     { "alFilterfv",                 (ALCvoid *) alFilterfv               },

   221     { "alGetFilteri",               (ALCvoid *) alGetFilteri             },

   222     { "alGetFilteriv",              (ALCvoid *) alGetFilteriv            },

   223     { "alGetFilterf",               (ALCvoid *) alGetFilterf             },

   224     { "alGetFilterfv",              (ALCvoid *) alGetFilterfv            },

   225     { "alGenEffects",               (ALCvoid *) alGenEffects             },

   226     { "alDeleteEffects",            (ALCvoid *) alDeleteEffects          },

   227     { "alIsEffect",                 (ALCvoid *) alIsEffect               },

   228     { "alEffecti",                  (ALCvoid *) alEffecti                },

   229     { "alEffectiv",                 (ALCvoid *) alEffectiv               },

   230     { "alEffectf",                  (ALCvoid *) alEffectf                },

   231     { "alEffectfv",                 (ALCvoid *) alEffectfv               },

   232     { "alGetEffecti",               (ALCvoid *) alGetEffecti             },

   233     { "alGetEffectiv",              (ALCvoid *) alGetEffectiv            },

   234     { "alGetEffectf",               (ALCvoid *) alGetEffectf             },

   235     { "alGetEffectfv",              (ALCvoid *) alGetEffectfv            },

   236     { "alGenAuxiliaryEffectSlots",  (ALCvoid *) alGenAuxiliaryEffectSlots},

   237     { "alDeleteAuxiliaryEffectSlots",(ALCvoid *) alDeleteAuxiliaryEffectSlots},

   238     { "alIsAuxiliaryEffectSlot",    (ALCvoid *) alIsAuxiliaryEffectSlot  },

   239     { "alAuxiliaryEffectSloti",     (ALCvoid *) alAuxiliaryEffectSloti   },

   240     { "alAuxiliaryEffectSlotiv",    (ALCvoid *) alAuxiliaryEffectSlotiv  },

   241     { "alAuxiliaryEffectSlotf",     (ALCvoid *) alAuxiliaryEffectSlotf   },

   242     { "alAuxiliaryEffectSlotfv",    (ALCvoid *) alAuxiliaryEffectSlotfv  },

   243     { "alGetAuxiliaryEffectSloti",  (ALCvoid *) alGetAuxiliaryEffectSloti},

   244     { "alGetAuxiliaryEffectSlotiv", (ALCvoid *) alGetAuxiliaryEffectSlotiv},

   245     { "alGetAuxiliaryEffectSlotf",  (ALCvoid *) alGetAuxiliaryEffectSlotf},

   246     { "alGetAuxiliaryEffectSlotfv", (ALCvoid *) alGetAuxiliaryEffectSlotfv},

   247 

   248     { "alBufferSubDataSOFT",        (ALCvoid *) alBufferSubDataSOFT      },

   249 

   250     { "alBufferSamplesSOFT",        (ALCvoid *) alBufferSamplesSOFT      },

   251     { "alBufferSubSamplesSOFT",     (ALCvoid *) alBufferSubSamplesSOFT   },

   252     { "alGetBufferSamplesSOFT",     (ALCvoid *) alGetBufferSamplesSOFT   },

   253     { "alIsBufferFormatSupportedSOFT",(ALCvoid *) alIsBufferFormatSupportedSOFT},

   254 

   255     { "alDeferUpdatesSOFT",         (ALCvoid *) alDeferUpdatesSOFT       },

   256     { "alProcessUpdatesSOFT",       (ALCvoid *) alProcessUpdatesSOFT     },

   257 

   258     { NULL,                         (ALCvoid *) NULL                     }

   259 };

   260 

   261 static const ALCenums enumeration[] = {

   262     // Types

   263     { "ALC_INVALID",                          ALC_INVALID                         },

   264     { "ALC_FALSE",                            ALC_FALSE                           },

   265     { "ALC_TRUE",                             ALC_TRUE                            },

   266 

   267     // ALC Properties

   268     { "ALC_MAJOR_VERSION",                    ALC_MAJOR_VERSION                   },

   269     { "ALC_MINOR_VERSION",                    ALC_MINOR_VERSION                   },

   270     { "ALC_ATTRIBUTES_SIZE",                  ALC_ATTRIBUTES_SIZE                 },

   271     { "ALC_ALL_ATTRIBUTES",                   ALC_ALL_ATTRIBUTES                  },

   272     { "ALC_DEFAULT_DEVICE_SPECIFIER",         ALC_DEFAULT_DEVICE_SPECIFIER        },

   273     { "ALC_DEVICE_SPECIFIER",                 ALC_DEVICE_SPECIFIER                },

   274     { "ALC_ALL_DEVICES_SPECIFIER",            ALC_ALL_DEVICES_SPECIFIER           },

   275     { "ALC_DEFAULT_ALL_DEVICES_SPECIFIER",    ALC_DEFAULT_ALL_DEVICES_SPECIFIER   },

   276     { "ALC_EXTENSIONS",                       ALC_EXTENSIONS                      },

   277     { "ALC_FREQUENCY",                        ALC_FREQUENCY                       },

   278     { "ALC_REFRESH",                          ALC_REFRESH                         },

   279     { "ALC_SYNC",                             ALC_SYNC                            },

   280     { "ALC_MONO_SOURCES",                     ALC_MONO_SOURCES                    },

   281     { "ALC_STEREO_SOURCES",                   ALC_STEREO_SOURCES                  },

   282     { "ALC_CAPTURE_DEVICE_SPECIFIER",         ALC_CAPTURE_DEVICE_SPECIFIER        },

   283     { "ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER", ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER},

   284     { "ALC_CAPTURE_SAMPLES",                  ALC_CAPTURE_SAMPLES                 },

   285     { "ALC_CONNECTED",                        ALC_CONNECTED                       },

   286 

   287     // EFX Properties

   288     { "ALC_EFX_MAJOR_VERSION",                ALC_EFX_MAJOR_VERSION               },

   289     { "ALC_EFX_MINOR_VERSION",                ALC_EFX_MINOR_VERSION               },

   290     { "ALC_MAX_AUXILIARY_SENDS",              ALC_MAX_AUXILIARY_SENDS             },

   291 

   292     // Loopback device Properties

   293     { "ALC_FORMAT_CHANNELS_SOFT",             ALC_FORMAT_CHANNELS_SOFT            },

   294     { "ALC_FORMAT_TYPE_SOFT",                 ALC_FORMAT_TYPE_SOFT                },

   295 

   296     // Buffer Channel Configurations

   297     { "ALC_MONO",                             ALC_MONO                            },

   298     { "ALC_STEREO",                           ALC_STEREO                          },

   299     { "ALC_QUAD",                             ALC_QUAD                            },

   300     { "ALC_5POINT1",                          ALC_5POINT1                         },

   301     { "ALC_6POINT1",                          ALC_6POINT1                         },

   302     { "ALC_7POINT1",                          ALC_7POINT1                         },

   303 

   304     // Buffer Sample Types

   305     { "ALC_BYTE",                             ALC_BYTE                            },

   306     { "ALC_UNSIGNED_BYTE",                    ALC_UNSIGNED_BYTE                   },

   307     { "ALC_SHORT",                            ALC_SHORT                           },

   308     { "ALC_UNSIGNED_SHORT",                   ALC_UNSIGNED_SHORT                  },

   309     { "ALC_INT",                              ALC_INT                             },

   310     { "ALC_UNSIGNED_INT",                     ALC_UNSIGNED_INT                    },

   311     { "ALC_FLOAT",                            ALC_FLOAT                           },

   312 

   313     // ALC Error Message

   314     { "ALC_NO_ERROR",                         ALC_NO_ERROR                        },

   315     { "ALC_INVALID_DEVICE",                   ALC_INVALID_DEVICE                  },

   316     { "ALC_INVALID_CONTEXT",                  ALC_INVALID_CONTEXT                 },

   317     { "ALC_INVALID_ENUM",                     ALC_INVALID_ENUM                    },

   318     { "ALC_INVALID_VALUE",                    ALC_INVALID_VALUE                   },

   319     { "ALC_OUT_OF_MEMORY",                    ALC_OUT_OF_MEMORY                   },

   320 

   321     { NULL,                                   (ALCenum)0 }

   322 };

   323 // Error strings

   324 static const ALCchar alcNoError[] = "No Error";

   325 static const ALCchar alcErrInvalidDevice[] = "Invalid Device";

   326 static const ALCchar alcErrInvalidContext[] = "Invalid Context";

   327 static const ALCchar alcErrInvalidEnum[] = "Invalid Enum";

   328 static const ALCchar alcErrInvalidValue[] = "Invalid Value";

   329 static const ALCchar alcErrOutOfMemory[] = "Out of Memory";

   330 

   331 /* Device lists. Sizes only include the first ending null character, not the

   332  * second */

   333 static ALCchar *alcDeviceList;

   334 static size_t alcDeviceListSize;

   335 static ALCchar *alcAllDeviceList;

   336 static size_t alcAllDeviceListSize;

   337 static ALCchar *alcCaptureDeviceList;

   338 static size_t alcCaptureDeviceListSize;

   339 /* Default is always the first in the list */

   340 static ALCchar *alcDefaultDeviceSpecifier;

   341 static ALCchar *alcDefaultAllDeviceSpecifier;

   342 static ALCchar *alcCaptureDefaultDeviceSpecifier;

   343 

   344 

   345 static const ALCchar alcNoDeviceExtList[] =

   346     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "

   347     "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";

   348 static const ALCchar alcExtensionList[] =

   349     "ALC_ENUMERATE_ALL_EXT ALC_ENUMERATION_EXT ALC_EXT_CAPTURE "

   350     "ALC_EXT_DEDICATED ALC_EXT_disconnect ALC_EXT_EFX "

   351     "ALC_EXT_thread_local_context ALC_SOFTX_loopback_device";

   352 static const ALCint alcMajorVersion = 1;

   353 static const ALCint alcMinorVersion = 1;

   354 

   355 static const ALCint alcEFXMajorVersion = 1;

   356 static const ALCint alcEFXMinorVersion = 0;

   357 

   358 ///////////////////////////////////////////////////////

   359 

   360 

   361 ///////////////////////////////////////////////////////

   362 // Global Variables

   363 

   364 static CRITICAL_SECTION ListLock;

   365 

   366 /* Device List */

   367 static ALCdevice *g_pDeviceList = NULL;

   368 static ALCuint    g_ulDeviceCount = 0;

   369 

   370 // Context List

   371 static ALCcontext *g_pContextList = NULL;

   372 static ALCuint     g_ulContextCount = 0;

   373 

   374 // Thread-local current context

   375 static tls_type LocalContext;

   376 // Process-wide current context

   377 static ALCcontext *GlobalContext;

   378 

   379 // Context Error

   380 static ALCenum g_eLastNullDeviceError = ALC_NO_ERROR;

   381 

   382 // Default context extensions

   383 static const ALchar alExtList[] =

   384     "AL_EXT_DOUBLE AL_EXT_EXPONENT_DISTANCE AL_EXT_FLOAT32 AL_EXT_IMA4 "

   385     "AL_EXT_LINEAR_DISTANCE AL_EXT_MCFORMATS AL_EXT_MULAW "

   386     "AL_EXT_MULAW_MCFORMATS AL_EXT_OFFSET AL_EXT_source_distance_model "

   387     "AL_LOKI_quadriphonic AL_SOFTX_buffer_samples AL_SOFT_buffer_sub_data "

   388     "AL_SOFTX_deferred_updates AL_SOFT_loop_points "

   389     "AL_SOFTX_non_virtual_channels";

   390 

   391 // Mixing Priority Level

   392 ALint RTPrioLevel;

   393 

   394 // Output Log File

   395 FILE *LogFile;

   396 

   397 // Output Log Level

   398 #ifdef _DEBUG

   399 enum LogLevel LogLevel = LogWarning;

   400 #else

   401 enum LogLevel LogLevel = LogError;

   402 #endif

   403 

   404 // Cone scalar

   405 ALdouble ConeScale = 0.5;

   406 

   407 // Localized Z scalar for mono sources

   408 ALdouble ZScale = 1.0;

   409 

   410 /* One-time configuration init control */

   411 static pthread_once_t alc_config_once = PTHREAD_ONCE_INIT;

   412 

   413 ///////////////////////////////////////////////////////

   414 

   415 

   416 ///////////////////////////////////////////////////////

   417 // ALC Related helper functions

   418 static void ReleaseALC(ALCboolean doclose);

   419 

   420 static void alc_initconfig(void);

   421 #define DO_INITCONFIG() pthread_once(&alc_config_once, alc_initconfig)

   422 

   423 #if defined(_WIN32)

   424 static void alc_init(void);

   425 static void alc_deinit(void);

   426 static void alc_deinit_safe(void);

   427 

   428 #ifndef AL_LIBTYPE_STATIC

   429 BOOL APIENTRY DllMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID lpReserved)

   430 {

   431     // Perform actions based on the reason for calling.

   432     switch(ul_reason_for_call)

   433     {

   434         case DLL_PROCESS_ATTACH:

   435             DisableThreadLibraryCalls(hModule);

   436             alc_init();

   437             break;

   438 

   439         case DLL_PROCESS_DETACH:

   440             if(!lpReserved)

   441                 alc_deinit();

   442             else

   443                 alc_deinit_safe();

   444             break;

   445     }

   446     return TRUE;

   447 }

   448 #elif defined(_MSC_VER)

   449 #pragma section(".CRT$XCU",read)

   450 static void alc_constructor(void);

   451 static void alc_destructor(void);

   452 __declspec(allocate(".CRT$XCU")) void (__cdecl* alc_constructor_)(void) = alc_constructor;

   453 

   454 static void alc_constructor(void)

   455 {

   456     atexit(alc_destructor);

   457     alc_init();

   458 }

   459 

   460 static void alc_destructor(void)

   461 {

   462     alc_deinit();

   463 }

   464 #elif defined(HAVE_GCC_DESTRUCTOR)

   465 static void alc_init(void) __attribute__((constructor));

   466 static void alc_deinit(void) __attribute__((destructor));

   467 #else

   468 #error "No static initialization available on this platform!"

   469 #endif

   470 #elif defined(HAVE_GCC_DESTRUCTOR)

   471 static void alc_init(void) __attribute__((constructor));

   472 static void alc_deinit(void) __attribute__((destructor));

   473 #else

   474 #error "No global initialization available on this platform!"

   475 #endif

   476 

   477 static void alc_init(void)

   478 {

   479     const char *str;

   480 

   481     LogFile = stderr;

   482 

   483     str = getenv("__ALSOFT_HALF_ANGLE_CONES");

   484     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))

   485         ConeScale = 1.0;

   486 

   487     str = getenv("__ALSOFT_REVERSE_Z");

   488     if(str && (strcasecmp(str, "true") == 0 || strtol(str, NULL, 0) == 1))

   489         ZScale = -1.0;

   490 

   491     tls_create(&LocalContext);

   492     InitializeCriticalSection(&ListLock);

   493     ThunkInit();

   494 }

   495 

   496 static void alc_deinit_safe(void)

   497 {

   498     ReleaseALC(ALC_FALSE);

   499 

   500     FreeALConfig();

   501 

   502     ThunkExit();

   503     DeleteCriticalSection(&ListLock);

   504     tls_delete(LocalContext);

   505 

   506     if(LogFile != stderr)

   507         fclose(LogFile);

   508     LogFile = NULL;

   509 }

   510 

   511 static void alc_deinit(void)

   512 {

   513     int i;

   514 

   515     ReleaseALC(ALC_TRUE);

   516 

   517     memset(&PlaybackBackend, 0, sizeof(PlaybackBackend));

   518     memset(&CaptureBackend, 0, sizeof(CaptureBackend));

   519 

   520     for(i = 0;BackendList[i].Deinit;i++)

   521         BackendList[i].Deinit();

   522     BackendLoopback.Deinit();

   523 

   524     alc_deinit_safe();

   525 }

   526 

   527 static void alc_initconfig(void)

   528 {

   529   printf("OPENAL-AURELLEM: alc_init_config!!\n");

   530     const char *devs, *str;

   531     int i, n;

   532 

   533     str = getenv("ALSOFT_LOGLEVEL");

   534     if(str)

   535     {

   536         long lvl = strtol(str, NULL, 0);

   537         if(lvl >= NoLog && lvl <= LogTrace)

   538             LogLevel = lvl;

   539     }

   540 

   541     str = getenv("ALSOFT_LOGFILE");

   542     if(str && str[0])

   543     {

   544         FILE *logfile = fopen(str, "wat");

   545         if(logfile) LogFile = logfile;

   546         else ERR("Failed to open log file '%s'\n", str);

   547     }

   548 

   549     ReadALConfig();

   550 

   551     InitHrtf();

   552 

   553 #ifdef _WIN32

   554     RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 1);

   555 #else

   556     RTPrioLevel = GetConfigValueInt(NULL, "rt-prio", 0);

   557 #endif

   558 

   559     DefaultResampler = GetConfigValueInt(NULL, "resampler", RESAMPLER_DEFAULT);

   560     if(DefaultResampler >= RESAMPLER_MAX || DefaultResampler <= RESAMPLER_MIN)

   561         DefaultResampler = RESAMPLER_DEFAULT;

   562 

   563     ReverbBoost *= aluPow(10.0f, GetConfigValueFloat("reverb", "boost", 0.0f) /

   564                                  20.0f);

   565     EmulateEAXReverb = GetConfigValueBool("reverb", "emulate-eax", AL_FALSE);

   566 

   567     devs = GetConfigValue(NULL, "drivers", "");

   568     //printf("these are the devices: %s\n", devs);

   569 

   570     if(devs[0])

   571     {

   572         int n;

   573         size_t len;

   574         const char *next = devs;

   575         int endlist, delitem;

   576 

   577         i = 0;

   578         do {

   579             devs = next;

   580 	    //printf("AURELLEM: devs is %s\n",devs);

   581             next = strchr(devs, ',');

   582 

   583             delitem = (devs[0] == '-');

   584             if(devs[0] == '-') devs++;

   585 

   586             if(!devs[0] || devs[0] == ',')

   587             {

   588                 endlist = 0;

   589                 continue;

   590             }

   591             endlist = 1;

   592 

   593             len = (next ? ((size_t)(next-devs)) : strlen(devs));

   594             for(n = i;BackendList[n].Init;n++)

   595             {

   596 	      //printf("AURELLEM: device-name -- %s\n",BackendList[n].name);

   597                 if(len == strlen(BackendList[n].name) &&

   598                    strncmp(BackendList[n].name, devs, len) == 0)

   599                 {

   600                     if(delitem)

   601                     {

   602                         do {

   603                             BackendList[n] = BackendList[n+1];

   604                             ++n;

   605                         } 

   606 			// this relies on the last entry being terminated by an

   607 			// entry with all nulls.  

   608 			while(BackendList[n].Init);

   609                     }

   610                     else

   611                     {

   612                         struct BackendInfo Bkp = BackendList[n];

   613                         while(n > i)

   614                         {

   615                             BackendList[n] = BackendList[n-1];

   616                             --n;

   617                         }

   618                         BackendList[n] = Bkp;

   619 

   620                         i++;

   621                     }

   622                     break;

   623                 }

   624             }

   625         } while(next++);

   626 

   627         if(endlist)

   628         {

   629             BackendList[i].name = NULL;

   630             BackendList[i].Init = NULL;

   631             BackendList[i].Deinit = NULL;

   632             BackendList[i].Probe = NULL;

   633         }

   634     }

   635 

   636     for(i = 0;BackendList[i].Init && (!PlaybackBackend.name || !CaptureBackend.name);i++)

   637     {

   638         if(!BackendList[i].Init(&BackendList[i].Funcs))

   639         {

   640             WARN("Failed to initialize backend \"%s\"\n", BackendList[i].name);

   641             continue;

   642         }

   643 

   644         TRACE("Initialized backend \"%s\"\n", BackendList[i].name);

   645         if(BackendList[i].Funcs.OpenPlayback && !PlaybackBackend.name)

   646         {

   647             PlaybackBackend = BackendList[i];

   648             TRACE("Added \"%s\" for playback\n", PlaybackBackend.name);

   649         }

   650         if(BackendList[i].Funcs.OpenCapture && !CaptureBackend.name)

   651         {

   652             CaptureBackend = BackendList[i];

   653             TRACE("Added \"%s\" for capture\n", CaptureBackend.name);

   654         }

   655     }

   656     BackendLoopback.Init(&BackendLoopback.Funcs);

   657 

   658     str = GetConfigValue(NULL, "excludefx", "");

   659     if(str[0])

   660     {

   661         size_t len;

   662         const char *next = str;

   663 

   664         do {

   665             str = next;

   666             next = strchr(str, ',');

   667 

   668             if(!str[0] || next == str)

   669                 continue;

   670 

   671             len = (next ? ((size_t)(next-str)) : strlen(str));

   672             for(n = 0;EffectList[n].name;n++)

   673             {

   674                 if(len == strlen(EffectList[n].name) &&

   675                    strncmp(EffectList[n].name, str, len) == 0)

   676                     DisabledEffects[EffectList[n].type] = AL_TRUE;

   677             }

   678         } while(next++);

   679     }

   680 }

   681 

   682 

   683 static void ProbeList(ALCchar **list, size_t *listsize, enum DevProbe type)

   684 {

   685     free(*list);

   686     *list = NULL;

   687     *listsize = 0;

   688 

   689     DO_INITCONFIG();

   690     if(type == CAPTURE_DEVICE_PROBE)

   691         CaptureBackend.Probe(type);

   692     else

   693         PlaybackBackend.Probe(type);

   694 }

   695 

   696 static void ProbeDeviceList(void)

   697 { ProbeList(&alcDeviceList, &alcDeviceListSize, DEVICE_PROBE); }

   698 static void ProbeAllDeviceList(void)

   699 { ProbeList(&alcAllDeviceList, &alcAllDeviceListSize, ALL_DEVICE_PROBE); }

   700 static void ProbeCaptureDeviceList(void)

   701 { ProbeList(&alcCaptureDeviceList, &alcCaptureDeviceListSize, CAPTURE_DEVICE_PROBE); }

   702 

   703 

   704 static void AppendList(const ALCchar *name, ALCchar **List, size_t *ListSize)

   705 {

   706     size_t len = strlen(name);

   707     void *temp;

   708 

   709     if(len == 0)

   710         return;

   711 

   712     temp = realloc(*List, (*ListSize) + len + 2);

   713     if(!temp)

   714     {

   715         ERR("Realloc failed to add %s!\n", name);

   716         return;

   717     }

   718     *List = temp;

   719 

   720     memcpy((*List)+(*ListSize), name, len+1);

   721     *ListSize += len+1;

   722     (*List)[*ListSize] = 0;

   723 }

   724 

   725 #define DECL_APPEND_LIST_FUNC(type)                                          \

   726 void Append##type##List(const ALCchar *name)                                 \

   727 { AppendList(name, &alc##type##List, &alc##type##ListSize); }

   728 

   729 DECL_APPEND_LIST_FUNC(Device)

   730 DECL_APPEND_LIST_FUNC(AllDevice)

   731 DECL_APPEND_LIST_FUNC(CaptureDevice)

   732 

   733 #undef DECL_APPEND_LIST_FUNC

   734 

   735 

   736 /* Sets the default channel order used by most non-WaveFormatEx-based APIs */

   737 void SetDefaultChannelOrder(ALCdevice *device)

   738 {

   739     switch(device->FmtChans)

   740     {

   741     case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;

   742                     device->DevChannels[1] = FRONT_RIGHT;

   743                     device->DevChannels[2] = BACK_LEFT;

   744                     device->DevChannels[3] = BACK_RIGHT;

   745                     device->DevChannels[4] = FRONT_CENTER;

   746                     device->DevChannels[5] = LFE;

   747                     return;

   748 

   749     case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;

   750                     device->DevChannels[1] = FRONT_RIGHT;

   751                     device->DevChannels[2] = BACK_LEFT;

   752                     device->DevChannels[3] = BACK_RIGHT;

   753                     device->DevChannels[4] = FRONT_CENTER;

   754                     device->DevChannels[5] = LFE;

   755                     device->DevChannels[6] = SIDE_LEFT;

   756                     device->DevChannels[7] = SIDE_RIGHT;

   757                     return;

   758 

   759     /* Same as WFX order */

   760     case DevFmtMono:

   761     case DevFmtStereo:

   762     case DevFmtQuad:

   763     case DevFmtX51Side:

   764     case DevFmtX61:

   765         break;

   766     }

   767     SetDefaultWFXChannelOrder(device);

   768 }

   769 /* Sets the default order used by WaveFormatEx */

   770 void SetDefaultWFXChannelOrder(ALCdevice *device)

   771 {

   772     switch(device->FmtChans)

   773     {

   774     case DevFmtMono: device->DevChannels[0] = FRONT_CENTER; break;

   775 

   776     case DevFmtStereo: device->DevChannels[0] = FRONT_LEFT;

   777                        device->DevChannels[1] = FRONT_RIGHT; break;

   778 

   779     case DevFmtQuad: device->DevChannels[0] = FRONT_LEFT;

   780                      device->DevChannels[1] = FRONT_RIGHT;

   781                      device->DevChannels[2] = BACK_LEFT;

   782                      device->DevChannels[3] = BACK_RIGHT; break;

   783 

   784     case DevFmtX51: device->DevChannels[0] = FRONT_LEFT;

   785                     device->DevChannels[1] = FRONT_RIGHT;

   786                     device->DevChannels[2] = FRONT_CENTER;

   787                     device->DevChannels[3] = LFE;

   788                     device->DevChannels[4] = BACK_LEFT;

   789                     device->DevChannels[5] = BACK_RIGHT; break;

   790 

   791     case DevFmtX51Side: device->DevChannels[0] = FRONT_LEFT;

   792                         device->DevChannels[1] = FRONT_RIGHT;

   793                         device->DevChannels[2] = FRONT_CENTER;

   794                         device->DevChannels[3] = LFE;

   795                         device->DevChannels[4] = SIDE_LEFT;

   796                         device->DevChannels[5] = SIDE_RIGHT; break;

   797 

   798     case DevFmtX61: device->DevChannels[0] = FRONT_LEFT;

   799                     device->DevChannels[1] = FRONT_RIGHT;

   800                     device->DevChannels[2] = FRONT_CENTER;

   801                     device->DevChannels[3] = LFE;

   802                     device->DevChannels[4] = BACK_CENTER;

   803                     device->DevChannels[5] = SIDE_LEFT;

   804                     device->DevChannels[6] = SIDE_RIGHT; break;

   805 

   806     case DevFmtX71: device->DevChannels[0] = FRONT_LEFT;

   807                     device->DevChannels[1] = FRONT_RIGHT;

   808                     device->DevChannels[2] = FRONT_CENTER;

   809                     device->DevChannels[3] = LFE;

   810                     device->DevChannels[4] = BACK_LEFT;

   811                     device->DevChannels[5] = BACK_RIGHT;

   812                     device->DevChannels[6] = SIDE_LEFT;

   813                     device->DevChannels[7] = SIDE_RIGHT; break;

   814     }

   815 }

   816 

   817 

   818 const ALCchar *DevFmtTypeString(enum DevFmtType type)

   819 {

   820     switch(type)

   821     {

   822     case DevFmtByte: return "Signed Byte";

   823     case DevFmtUByte: return "Unsigned Byte";

   824     case DevFmtShort: return "Signed Short";

   825     case DevFmtUShort: return "Unsigned Short";

   826     case DevFmtFloat: return "Float";

   827     }

   828     return "(unknown type)";

   829 }

   830 const ALCchar *DevFmtChannelsString(enum DevFmtChannels chans)

   831 {

   832     switch(chans)

   833     {

   834     case DevFmtMono: return "Mono";

   835     case DevFmtStereo: return "Stereo";

   836     case DevFmtQuad: return "Quadraphonic";

   837     case DevFmtX51: return "5.1 Surround";

   838     case DevFmtX51Side: return "5.1 Side";

   839     case DevFmtX61: return "6.1 Surround";

   840     case DevFmtX71: return "7.1 Surround";

   841     }

   842     return "(unknown channels)";

   843 }

   844 

   845 ALuint BytesFromDevFmt(enum DevFmtType type)

   846 {

   847     switch(type)

   848     {

   849     case DevFmtByte: return sizeof(ALbyte);

   850     case DevFmtUByte: return sizeof(ALubyte);

   851     case DevFmtShort: return sizeof(ALshort);

   852     case DevFmtUShort: return sizeof(ALushort);

   853     case DevFmtFloat: return sizeof(ALfloat);

   854     }

   855     return 0;

   856 }

   857 ALuint ChannelsFromDevFmt(enum DevFmtChannels chans)

   858 {

   859     switch(chans)

   860     {

   861     case DevFmtMono: return 1;

   862     case DevFmtStereo: return 2;

   863     case DevFmtQuad: return 4;

   864     case DevFmtX51: return 6;

   865     case DevFmtX51Side: return 6;

   866     case DevFmtX61: return 7;

   867     case DevFmtX71: return 8;

   868     }

   869     return 0;

   870 }

   871 ALboolean DecomposeDevFormat(ALenum format, enum DevFmtChannels *chans,

   872                              enum DevFmtType *type)

   873 {

   874     switch(format)

   875     {

   876         case AL_FORMAT_MONO8:

   877             *chans = DevFmtMono;

   878             *type  = DevFmtUByte;

   879             return AL_TRUE;

   880         case AL_FORMAT_MONO16:

   881             *chans = DevFmtMono;

   882             *type  = DevFmtShort;

   883             return AL_TRUE;

   884         case AL_FORMAT_MONO_FLOAT32:

   885             *chans = DevFmtMono;

   886             *type  = DevFmtFloat;

   887             return AL_TRUE;

   888         case AL_FORMAT_STEREO8:

   889             *chans = DevFmtStereo;

   890             *type  = DevFmtUByte;

   891             return AL_TRUE;

   892         case AL_FORMAT_STEREO16:

   893             *chans = DevFmtStereo;

   894             *type  = DevFmtShort;

   895             return AL_TRUE;

   896         case AL_FORMAT_STEREO_FLOAT32:

   897             *chans = DevFmtStereo;

   898             *type  = DevFmtFloat;

   899             return AL_TRUE;

   900         case AL_FORMAT_QUAD8:

   901             *chans = DevFmtQuad;

   902             *type  = DevFmtUByte;

   903             return AL_TRUE;

   904         case AL_FORMAT_QUAD16:

   905             *chans = DevFmtQuad;

   906             *type  = DevFmtShort;

   907             return AL_TRUE;

   908         case AL_FORMAT_QUAD32:

   909             *chans = DevFmtQuad;

   910             *type  = DevFmtFloat;

   911             return AL_TRUE;

   912         case AL_FORMAT_51CHN8:

   913             *chans = DevFmtX51;

   914             *type  = DevFmtUByte;

   915             return AL_TRUE;

   916         case AL_FORMAT_51CHN16:

   917             *chans = DevFmtX51;

   918             *type  = DevFmtShort;

   919             return AL_TRUE;

   920         case AL_FORMAT_51CHN32:

   921             *chans = DevFmtX51;

   922             *type  = DevFmtFloat;

   923             return AL_TRUE;

   924         case AL_FORMAT_61CHN8:

   925             *chans = DevFmtX61;

   926             *type  = DevFmtUByte;

   927             return AL_TRUE;

   928         case AL_FORMAT_61CHN16:

   929             *chans = DevFmtX61;

   930             *type  = DevFmtShort;

   931             return AL_TRUE;

   932         case AL_FORMAT_61CHN32:

   933             *chans = DevFmtX61;

   934             *type  = DevFmtFloat;

   935             return AL_TRUE;

   936         case AL_FORMAT_71CHN8:

   937             *chans = DevFmtX71;

   938             *type  = DevFmtUByte;

   939             return AL_TRUE;

   940         case AL_FORMAT_71CHN16:

   941             *chans = DevFmtX71;

   942             *type  = DevFmtShort;

   943             return AL_TRUE;

   944         case AL_FORMAT_71CHN32:

   945             *chans = DevFmtX71;

   946             *type  = DevFmtFloat;

   947             return AL_TRUE;

   948     }

   949     return AL_FALSE;

   950 }

   951 

   952 static ALCboolean IsValidALCType(ALCenum type)

   953 {

   954     switch(type)

   955     {

   956         case ALC_BYTE:

   957         case ALC_UNSIGNED_BYTE:

   958         case ALC_SHORT:

   959         case ALC_UNSIGNED_SHORT:

   960         case ALC_INT:

   961         case ALC_UNSIGNED_INT:

   962         case ALC_FLOAT:

   963             return ALC_TRUE;

   964     }

   965     return ALC_FALSE;

   966 }

   967 

   968 static ALCboolean IsValidALCChannels(ALCenum channels)

   969 {

   970     switch(channels)

   971     {

   972         case ALC_MONO:

   973         case ALC_STEREO:

   974         case ALC_QUAD:

   975         case ALC_5POINT1:

   976         case ALC_6POINT1:

   977         case ALC_7POINT1:

   978             return ALC_TRUE;

   979     }

   980     return ALC_FALSE;

   981 }

   982 

   983 

   984 static void LockLists(void)

   985 {

   986     EnterCriticalSection(&ListLock);

   987 }

   988 

   989 static void UnlockLists(void)

   990 {

   991     LeaveCriticalSection(&ListLock);

   992 }

   993 

   994 /*

   995     IsDevice

   996 

   997     Check pDevice is a valid Device pointer

   998 */

   999 static ALCboolean IsDevice(ALCdevice *pDevice)

  1000 {

  1001     ALCdevice *pTempDevice;

  1002 

  1003     pTempDevice = g_pDeviceList;

  1004     while(pTempDevice && pTempDevice != pDevice)

  1005         pTempDevice = pTempDevice->next;

  1006 

  1007     return (pTempDevice ? ALC_TRUE : ALC_FALSE);

  1008 }

  1009 

  1010 /*

  1011     IsContext

  1012 

  1013     Check pContext is a valid Context pointer

  1014 */

  1015 static ALCboolean IsContext(ALCcontext *pContext)

  1016 {

  1017     ALCcontext *pTempContext;

  1018 

  1019     pTempContext = g_pContextList;

  1020     while (pTempContext && pTempContext != pContext)

  1021         pTempContext = pTempContext->next;

  1022 

  1023     return (pTempContext ? ALC_TRUE : ALC_FALSE);

  1024 }

  1025 

  1026 

  1027 /*

  1028     alcSetError

  1029 

  1030     Store latest ALC Error

  1031 */

  1032 ALCvoid alcSetError(ALCdevice *device, ALenum errorCode)

  1033 {

  1034     LockLists();

  1035     if(IsDevice(device))

  1036         device->LastError = errorCode;

  1037     else

  1038         g_eLastNullDeviceError = errorCode;

  1039     UnlockLists();

  1040 }

  1041 

  1042 

  1043 /* UpdateDeviceParams:

  1044  *

  1045  * Updates device parameters according to the attribute list.

  1046  */

  1047 static ALCboolean UpdateDeviceParams(ALCdevice *device, const ALCint *attrList)

  1048 {

  1049     ALuint i;

  1050 

  1051     // Check for attributes

  1052     if(attrList && attrList[0])

  1053     {

  1054         ALCuint freq, numMono, numStereo, numSends;

  1055         enum DevFmtChannels schans;

  1056         enum DevFmtType stype;

  1057         ALuint attrIdx;

  1058 

  1059         // If a context is already running on the device, stop playback so the

  1060         // device attributes can be updated

  1061         if((device->Flags&DEVICE_RUNNING))

  1062             ALCdevice_StopPlayback(device);

  1063         device->Flags &= ~DEVICE_RUNNING;

  1064 

  1065         freq = device->Frequency;

  1066         schans = device->FmtChans;

  1067         stype = device->FmtType;

  1068         numMono = device->NumMonoSources;

  1069         numStereo = device->NumStereoSources;

  1070         numSends = device->NumAuxSends;

  1071 

  1072         freq = GetConfigValueInt(NULL, "frequency", freq);

  1073         if(freq < 8000) freq = 8000;

  1074 

  1075         attrIdx = 0;

  1076         while(attrList[attrIdx])

  1077         {

  1078             if(attrList[attrIdx] == ALC_FORMAT_CHANNELS_SOFT &&

  1079                device->IsLoopbackDevice)

  1080             {

  1081                 ALCint val = attrList[attrIdx + 1];

  1082                 if(!IsValidALCChannels(val) || !ChannelsFromDevFmt(val))

  1083                 {

  1084                     alcSetError(device, ALC_INVALID_VALUE);

  1085                     return ALC_FALSE;

  1086                 }

  1087                 schans = val;

  1088             }

  1089 

  1090             if(attrList[attrIdx] == ALC_FORMAT_TYPE_SOFT &&

  1091                device->IsLoopbackDevice)

  1092             {

  1093                 ALCint val = attrList[attrIdx + 1];

  1094                 if(!IsValidALCType(val) || !BytesFromDevFmt(val))

  1095                 {

  1096                     alcSetError(device, ALC_INVALID_VALUE);

  1097                     return ALC_FALSE;

  1098                 }

  1099                 stype = val;

  1100             }

  1101 

  1102             if(attrList[attrIdx] == ALC_FREQUENCY)

  1103             {

  1104                 if(device->IsLoopbackDevice)

  1105                 {

  1106                     freq = attrList[attrIdx + 1];

  1107                     if(freq < 8000)

  1108                     {

  1109                         alcSetError(device, ALC_INVALID_VALUE);

  1110                         return ALC_FALSE;

  1111                     }

  1112                 }

  1113                 else if(!ConfigValueExists(NULL, "frequency"))

  1114                 {

  1115                     freq = attrList[attrIdx + 1];

  1116                     if(freq < 8000) freq = 8000;

  1117                     device->Flags |= DEVICE_FREQUENCY_REQUEST;

  1118                 }

  1119             }

  1120 

  1121             if(attrList[attrIdx] == ALC_STEREO_SOURCES)

  1122             {

  1123                 numStereo = attrList[attrIdx + 1];

  1124                 if(numStereo > device->MaxNoOfSources)

  1125                     numStereo = device->MaxNoOfSources;

  1126 

  1127                 numMono = device->MaxNoOfSources - numStereo;

  1128             }

  1129 

  1130             if(attrList[attrIdx] == ALC_MAX_AUXILIARY_SENDS &&

  1131                !ConfigValueExists(NULL, "sends"))

  1132             {

  1133                 numSends = attrList[attrIdx + 1];

  1134                 if(numSends > MAX_SENDS)

  1135                     numSends = MAX_SENDS;

  1136             }

  1137 

  1138             attrIdx += 2;

  1139         }

  1140 

  1141         device->UpdateSize = (ALuint64)device->UpdateSize * freq /

  1142                              device->Frequency;

  1143 

  1144         device->Frequency = freq;

  1145         device->FmtChans = schans;

  1146         device->FmtType = stype;

  1147         device->NumMonoSources = numMono;

  1148         device->NumStereoSources = numStereo;

  1149         device->NumAuxSends = numSends;

  1150     }

  1151 

  1152     if((device->Flags&DEVICE_RUNNING))

  1153         return ALC_TRUE;

  1154 

  1155     LockDevice(device);

  1156     TRACE("Format pre-setup: %s%s, %s, %uhz%s, %u update size x%d\n",

  1157           DevFmtChannelsString(device->FmtChans),

  1158           (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",

  1159           DevFmtTypeString(device->FmtType), device->Frequency,

  1160           (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",

  1161           device->UpdateSize, device->NumUpdates);

  1162     if(ALCdevice_ResetPlayback(device) == ALC_FALSE)

  1163     {

  1164         UnlockDevice(device);

  1165         return ALC_FALSE;

  1166     }

  1167     device->Flags |= DEVICE_RUNNING;

  1168     TRACE("Format post-setup: %s%s, %s, %uhz%s, %u update size x%d\n",

  1169           DevFmtChannelsString(device->FmtChans),

  1170           (device->Flags&DEVICE_CHANNELS_REQUEST)?" (requested)":"",

  1171           DevFmtTypeString(device->FmtType), device->Frequency,

  1172           (device->Flags&DEVICE_FREQUENCY_REQUEST)?" (requested)":"",

  1173           device->UpdateSize, device->NumUpdates);

  1174 

  1175     aluInitPanning(device);

  1176 

  1177     for(i = 0;i < MAXCHANNELS;i++)

  1178     {

  1179         device->ClickRemoval[i] = 0.0f;

  1180         device->PendingClicks[i] = 0.0f;

  1181     }

  1182 

  1183     if(!device->IsLoopbackDevice && GetConfigValueBool(NULL, "hrtf", AL_FALSE))

  1184         device->Flags |= DEVICE_USE_HRTF;

  1185     if((device->Flags&DEVICE_USE_HRTF) && !IsHrtfCompatible(device))

  1186         device->Flags &= ~DEVICE_USE_HRTF;

  1187     TRACE("HRTF %s\n", (device->Flags&DEVICE_USE_HRTF)?"enabled":"disabled");

  1188 

  1189     if(!(device->Flags&DEVICE_USE_HRTF) && device->Bs2bLevel > 0 && device->Bs2bLevel <= 6)

  1190     {

  1191         if(!device->Bs2b)

  1192         {

  1193             device->Bs2b = calloc(1, sizeof(*device->Bs2b));

  1194             bs2b_clear(device->Bs2b);

  1195         }

  1196         bs2b_set_srate(device->Bs2b, device->Frequency);

  1197         bs2b_set_level(device->Bs2b, device->Bs2bLevel);

  1198         TRACE("BS2B level %d\n", device->Bs2bLevel);

  1199     }

  1200     else

  1201     {

  1202         free(device->Bs2b);

  1203         device->Bs2b = NULL;

  1204         TRACE("BS2B disabled\n");

  1205     }

  1206 

  1207     device->Flags &= ~DEVICE_DUPLICATE_STEREO;

  1208     switch(device->FmtChans)

  1209     {

  1210         case DevFmtMono:

  1211         case DevFmtStereo:

  1212             break;

  1213         case DevFmtQuad:

  1214         case DevFmtX51:

  1215         case DevFmtX51Side:

  1216         case DevFmtX61:

  1217         case DevFmtX71:

  1218             if(GetConfigValueBool(NULL, "stereodup", AL_TRUE))

  1219                 device->Flags |= DEVICE_DUPLICATE_STEREO;

  1220             break;

  1221     }

  1222     TRACE("Stereo duplication %s\n", (device->Flags&DEVICE_DUPLICATE_STEREO)?"enabled":"disabled");

  1223 

  1224     for(i = 0;i < device->NumContexts;i++)

  1225     {

  1226         ALCcontext *context = device->Contexts[i];

  1227         ALsizei pos;

  1228 

  1229         context->UpdateSources = AL_FALSE;

  1230         for(pos = 0;pos < context->EffectSlotMap.size;pos++)

  1231         {

  1232             ALeffectslot *slot = context->EffectSlotMap.array[pos].value;

  1233 

  1234             if(ALEffect_DeviceUpdate(slot->EffectState, device) == AL_FALSE)

  1235             {

  1236                 UnlockDevice(device);

  1237                 ALCdevice_StopPlayback(device);

  1238                 device->Flags &= ~DEVICE_RUNNING;

  1239                 return ALC_FALSE;

  1240             }

  1241             slot->NeedsUpdate = AL_FALSE;

  1242             ALEffect_Update(slot->EffectState, context, slot);

  1243         }

  1244 

  1245         for(pos = 0;pos < context->SourceMap.size;pos++)

  1246         {

  1247             ALsource *source = context->SourceMap.array[pos].value;

  1248             ALuint s = device->NumAuxSends;

  1249             while(s < MAX_SENDS)

  1250             {

  1251                 if(source->Send[s].Slot)

  1252                     source->Send[s].Slot->refcount--;

  1253                 source->Send[s].Slot = NULL;

  1254                 source->Send[s].WetFilter.type = 0;

  1255                 source->Send[s].WetFilter.filter = 0;

  1256                 s++;

  1257             }

  1258             source->NeedsUpdate = AL_FALSE;

  1259             ALsource_Update(source, context);

  1260         }

  1261     }

  1262     UnlockDevice(device);

  1263 

  1264     return ALC_TRUE;

  1265 }

  1266 

  1267 

  1268 ALCvoid LockDevice(ALCdevice *device)

  1269 {

  1270     EnterCriticalSection(&device->Mutex);

  1271 }

  1272 

  1273 ALCvoid UnlockDevice(ALCdevice *device)

  1274 {

  1275     LeaveCriticalSection(&device->Mutex);

  1276 }

  1277 

  1278 /*

  1279     LockContext

  1280 

  1281     Thread-safe entry

  1282 */

  1283 ALCvoid LockContext(ALCcontext *context)

  1284 {

  1285     EnterCriticalSection(&context->Device->Mutex);

  1286 }

  1287 

  1288 

  1289 /*

  1290     UnlockContext

  1291 

  1292     Thread-safe exit

  1293 */

  1294 ALCvoid UnlockContext(ALCcontext *context)

  1295 {

  1296     LeaveCriticalSection(&context->Device->Mutex);

  1297 }

  1298 

  1299 

  1300 /*

  1301     GetLockedContext

  1302 

  1303     Returns the currently active Context, in a locked state

  1304 */

  1305 ALCcontext *GetLockedContext(void)

  1306 {

  1307     ALCcontext *pContext = NULL;

  1308 

  1309     LockLists();

  1310 

  1311     pContext = tls_get(LocalContext);

  1312     if(pContext && !IsContext(pContext))

  1313     {

  1314         tls_set(LocalContext, NULL);

  1315         pContext = NULL;

  1316     }

  1317     if(!pContext)

  1318         pContext = GlobalContext;

  1319     if(pContext)

  1320         LockContext(pContext);

  1321 

  1322     UnlockLists();

  1323 

  1324     return pContext;

  1325 }

  1326 

  1327 

  1328 /*

  1329     InitContext

  1330 

  1331     Initialize Context variables

  1332 */

  1333 static ALvoid InitContext(ALCcontext *pContext)

  1334 {

  1335     //Initialise listener

  1336     pContext->Listener.Gain = 1.0f;

  1337     pContext->Listener.MetersPerUnit = 1.0f;

  1338     pContext->Listener.Position[0] = 0.0f;

  1339     pContext->Listener.Position[1] = 0.0f;

  1340     pContext->Listener.Position[2] = 0.0f;

  1341     pContext->Listener.Velocity[0] = 0.0f;

  1342     pContext->Listener.Velocity[1] = 0.0f;

  1343     pContext->Listener.Velocity[2] = 0.0f;

  1344     pContext->Listener.Forward[0] = 0.0f;

  1345     pContext->Listener.Forward[1] = 0.0f;

  1346     pContext->Listener.Forward[2] = -1.0f;

  1347     pContext->Listener.Up[0] = 0.0f;

  1348     pContext->Listener.Up[1] = 1.0f;

  1349     pContext->Listener.Up[2] = 0.0f;

  1350 

  1351     //Validate pContext

  1352     pContext->LastError = AL_NO_ERROR;

  1353     pContext->UpdateSources = AL_FALSE;

  1354     pContext->ActiveSourceCount = 0;

  1355     InitUIntMap(&pContext->SourceMap);

  1356     InitUIntMap(&pContext->EffectSlotMap);

  1357 

  1358     //Set globals

  1359     pContext->DistanceModel = AL_INVERSE_DISTANCE_CLAMPED;

  1360     pContext->SourceDistanceModel = AL_FALSE;

  1361     pContext->DopplerFactor = 1.0f;

  1362     pContext->DopplerVelocity = 1.0f;

  1363     pContext->flSpeedOfSound = SPEEDOFSOUNDMETRESPERSEC;

  1364     pContext->DeferUpdates = AL_FALSE;

  1365 

  1366     pContext->ExtensionList = alExtList;

  1367 }

  1368 

  1369 

  1370 /*

  1371     FreeContext

  1372 

  1373     Clean up Context, destroy any remaining Sources

  1374 */

  1375 static ALCvoid FreeContext(ALCcontext *context)

  1376 {

  1377     //Invalidate context

  1378     memset(context, 0, sizeof(ALCcontext));

  1379     free(context);

  1380 }

  1381 

  1382 ///////////////////////////////////////////////////////

  1383 

  1384 

  1385 ///////////////////////////////////////////////////////

  1386 // ALC Functions calls

  1387 

  1388 

  1389 // This should probably move to another c file but for now ...

  1390 ALC_API ALCdevice* ALC_APIENTRY alcCaptureOpenDevice(const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)

  1391 {

  1392     ALCdevice *device = NULL;

  1393 

  1394     DO_INITCONFIG();

  1395 

  1396     if(!CaptureBackend.name)

  1397     {

  1398         alcSetError(NULL, ALC_INVALID_VALUE);

  1399         return NULL;

  1400     }

  1401 

  1402     if(SampleSize <= 0)

  1403     {

  1404         alcSetError(NULL, ALC_INVALID_VALUE);

  1405         return NULL;

  1406     }

  1407 

  1408     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))

  1409         deviceName = NULL;

  1410 

  1411     device = calloc(1, sizeof(ALCdevice));

  1412     if(!device)

  1413     {

  1414         alcSetError(NULL, ALC_OUT_OF_MEMORY);

  1415         return NULL;

  1416     }

  1417 

  1418     //Validate device

  1419     device->Funcs = &CaptureBackend.Funcs;

  1420     device->Connected = ALC_TRUE;

  1421     device->IsCaptureDevice = AL_TRUE;

  1422     device->IsLoopbackDevice = AL_FALSE;

  1423     InitializeCriticalSection(&device->Mutex);

  1424 

  1425     device->szDeviceName = NULL;

  1426 

  1427     device->Flags |= DEVICE_FREQUENCY_REQUEST;

  1428     device->Frequency = frequency;

  1429 

  1430     device->Flags |= DEVICE_CHANNELS_REQUEST;

  1431     if(DecomposeDevFormat(format, &device->FmtChans, &device->FmtType) == AL_FALSE)

  1432     {

  1433         free(device);

  1434         alcSetError(NULL, ALC_INVALID_ENUM);

  1435         return NULL;

  1436     }

  1437 

  1438     device->UpdateSize = SampleSize;

  1439     device->NumUpdates = 1;

  1440 

  1441     LockLists();

  1442     if(ALCdevice_OpenCapture(device, deviceName))

  1443     {

  1444         device->next = g_pDeviceList;

  1445         g_pDeviceList = device;

  1446         g_ulDeviceCount++;

  1447     }

  1448     else

  1449     {

  1450         DeleteCriticalSection(&device->Mutex);

  1451         free(device);

  1452         device = NULL;

  1453         alcSetError(NULL, ALC_INVALID_VALUE);

  1454     }

  1455     UnlockLists();

  1456 

  1457     return device;

  1458 }

  1459 

  1460 ALC_API ALCboolean ALC_APIENTRY alcCaptureCloseDevice(ALCdevice *pDevice)

  1461 {

  1462     ALCdevice **list;

  1463 

  1464     LockLists();

  1465     list = &g_pDeviceList;

  1466     while(*list && *list != pDevice)

  1467         list = &(*list)->next;

  1468 

  1469     if(!*list || !(*list)->IsCaptureDevice)

  1470     {

  1471         alcSetError(*list, ALC_INVALID_DEVICE);

  1472         UnlockLists();

  1473         return ALC_FALSE;

  1474     }

  1475 

  1476     *list = (*list)->next;

  1477     g_ulDeviceCount--;

  1478 

  1479     UnlockLists();

  1480 

  1481     LockDevice(pDevice);

  1482     ALCdevice_CloseCapture(pDevice);

  1483     UnlockDevice(pDevice);

  1484 

  1485     free(pDevice->szDeviceName);

  1486     pDevice->szDeviceName = NULL;

  1487 

  1488     DeleteCriticalSection(&pDevice->Mutex);

  1489 

  1490     free(pDevice);

  1491 

  1492     return ALC_TRUE;

  1493 }

  1494 

  1495 ALC_API void ALC_APIENTRY alcCaptureStart(ALCdevice *device)

  1496 {

  1497     LockLists();

  1498     if(!IsDevice(device) || !device->IsCaptureDevice)

  1499     {

  1500         alcSetError(device, ALC_INVALID_DEVICE);

  1501         UnlockLists();

  1502         return;

  1503     }

  1504     LockDevice(device);

  1505     UnlockLists();

  1506     if(device->Connected)

  1507         ALCdevice_StartCapture(device);

  1508     UnlockDevice(device);

  1509 }

  1510 

  1511 ALC_API void ALC_APIENTRY alcCaptureStop(ALCdevice *device)

  1512 {

  1513     LockLists();

  1514     if(!IsDevice(device) || !device->IsCaptureDevice)

  1515     {

  1516         alcSetError(device, ALC_INVALID_DEVICE);

  1517         UnlockLists();

  1518         return;

  1519     }

  1520     LockDevice(device);

  1521     UnlockLists();

  1522     if(device->Connected)

  1523         ALCdevice_StopCapture(device);

  1524     UnlockDevice(device);

  1525 }

  1526 

  1527 ALC_API void ALC_APIENTRY alcCaptureSamples(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)

  1528 {

  1529     LockLists();

  1530     if(!IsDevice(device) || !device->IsCaptureDevice)

  1531     {

  1532         alcSetError(device, ALC_INVALID_DEVICE);

  1533         UnlockLists();

  1534         return;

  1535     }

  1536     LockDevice(device);

  1537     UnlockLists();

  1538     if(device->Connected)

  1539         ALCdevice_CaptureSamples(device, buffer, samples);

  1540     UnlockDevice(device);

  1541 }

  1542 

  1543 /*

  1544     alcGetError

  1545 

  1546     Return last ALC generated error code

  1547 */

  1548 ALC_API ALCenum ALC_APIENTRY alcGetError(ALCdevice *device)

  1549 {

  1550     ALCenum errorCode;

  1551 

  1552     LockLists();

  1553     if(IsDevice(device))

  1554     {

  1555         errorCode = device->LastError;

  1556         device->LastError = ALC_NO_ERROR;

  1557     }

  1558     else

  1559     {

  1560         errorCode = g_eLastNullDeviceError;

  1561         g_eLastNullDeviceError = ALC_NO_ERROR;

  1562     }

  1563     UnlockLists();

  1564     return errorCode;

  1565 }

  1566 

  1567 

  1568 /*

  1569     alcSuspendContext

  1570 

  1571     Not functional

  1572 */

  1573 ALC_API ALCvoid ALC_APIENTRY alcSuspendContext(ALCcontext *Context)

  1574 {

  1575     (void)Context;

  1576 }

  1577 

  1578 

  1579 /*

  1580     alcProcessContext

  1581 

  1582     Not functional

  1583 */

  1584 ALC_API ALCvoid ALC_APIENTRY alcProcessContext(ALCcontext *Context)

  1585 {

  1586     (void)Context;

  1587 }

  1588 

  1589 

  1590 /*

  1591     alcGetString

  1592 

  1593     Returns information about the Device, and error strings

  1594 */

  1595 ALC_API const ALCchar* ALC_APIENTRY alcGetString(ALCdevice *pDevice,ALCenum param)

  1596 {

  1597     const ALCchar *value = NULL;

  1598 

  1599     switch(param)

  1600     {

  1601     case ALC_NO_ERROR:

  1602         value = alcNoError;

  1603         break;

  1604 

  1605     case ALC_INVALID_ENUM:

  1606         value = alcErrInvalidEnum;

  1607         break;

  1608 

  1609     case ALC_INVALID_VALUE:

  1610         value = alcErrInvalidValue;

  1611         break;

  1612 

  1613     case ALC_INVALID_DEVICE:

  1614         value = alcErrInvalidDevice;

  1615         break;

  1616 

  1617     case ALC_INVALID_CONTEXT:

  1618         value = alcErrInvalidContext;

  1619         break;

  1620 

  1621     case ALC_OUT_OF_MEMORY:

  1622         value = alcErrOutOfMemory;

  1623         break;

  1624 

  1625     case ALC_DEVICE_SPECIFIER:

  1626         LockLists();

  1627         if(IsDevice(pDevice))

  1628             value = pDevice->szDeviceName;

  1629         else

  1630         {

  1631             ProbeDeviceList();

  1632             value = alcDeviceList;

  1633         }

  1634         UnlockLists();

  1635         break;

  1636 

  1637     case ALC_ALL_DEVICES_SPECIFIER:

  1638         ProbeAllDeviceList();

  1639         value = alcAllDeviceList;

  1640         break;

  1641 

  1642     case ALC_CAPTURE_DEVICE_SPECIFIER:

  1643         LockLists();

  1644         if(IsDevice(pDevice))

  1645             value = pDevice->szDeviceName;

  1646         else

  1647         {

  1648             ProbeCaptureDeviceList();

  1649             value = alcCaptureDeviceList;

  1650         }

  1651         UnlockLists();

  1652         break;

  1653 

  1654     /* Default devices are always first in the list */

  1655     case ALC_DEFAULT_DEVICE_SPECIFIER:

  1656         if(!alcDeviceList)

  1657             ProbeDeviceList();

  1658 

  1659         free(alcDefaultDeviceSpecifier);

  1660         alcDefaultDeviceSpecifier = strdup(alcDeviceList ? alcDeviceList : "");

  1661         if(!alcDefaultDeviceSpecifier)

  1662             alcSetError(pDevice, ALC_OUT_OF_MEMORY);

  1663         value = alcDefaultDeviceSpecifier;

  1664         break;

  1665 

  1666     case ALC_DEFAULT_ALL_DEVICES_SPECIFIER:

  1667         if(!alcAllDeviceList)

  1668             ProbeAllDeviceList();

  1669 

  1670         free(alcDefaultAllDeviceSpecifier);

  1671         alcDefaultAllDeviceSpecifier = strdup(alcAllDeviceList ?

  1672                                               alcAllDeviceList : "");

  1673         if(!alcDefaultAllDeviceSpecifier)

  1674             alcSetError(pDevice, ALC_OUT_OF_MEMORY);

  1675         value = alcDefaultAllDeviceSpecifier;

  1676         break;

  1677 

  1678     case ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER:

  1679         if(!alcCaptureDeviceList)

  1680             ProbeCaptureDeviceList();

  1681 

  1682         free(alcCaptureDefaultDeviceSpecifier);

  1683         alcCaptureDefaultDeviceSpecifier = strdup(alcCaptureDeviceList ?

  1684                                                   alcCaptureDeviceList : "");

  1685         if(!alcCaptureDefaultDeviceSpecifier)

  1686             alcSetError(pDevice, ALC_OUT_OF_MEMORY);

  1687         value = alcCaptureDefaultDeviceSpecifier;

  1688         break;

  1689 

  1690     case ALC_EXTENSIONS:

  1691         LockLists();

  1692         if(IsDevice(pDevice))

  1693             value = alcExtensionList;

  1694         else

  1695             value = alcNoDeviceExtList;

  1696         UnlockLists();

  1697         break;

  1698 

  1699     default:

  1700         alcSetError(pDevice, ALC_INVALID_ENUM);

  1701         break;

  1702     }

  1703 

  1704     return value;

  1705 }

  1706 

  1707 

  1708 /*

  1709     alcGetIntegerv

  1710 

  1711     Returns information about the Device and the version of Open AL

  1712 */

  1713 ALC_API ALCvoid ALC_APIENTRY alcGetIntegerv(ALCdevice *device,ALCenum param,ALsizei size,ALCint *data)

  1714 {

  1715     if(size == 0 || data == NULL)

  1716     {

  1717         alcSetError(device, ALC_INVALID_VALUE);

  1718         return;

  1719     }

  1720 

  1721     LockLists();

  1722     if(!IsDevice(device))

  1723     {

  1724         switch(param)

  1725         {

  1726             case ALC_MAJOR_VERSION:

  1727                 *data = alcMajorVersion;

  1728                 break;

  1729             case ALC_MINOR_VERSION:

  1730                 *data = alcMinorVersion;

  1731                 break;

  1732 

  1733             case ALC_ATTRIBUTES_SIZE:

  1734             case ALC_ALL_ATTRIBUTES:

  1735             case ALC_FREQUENCY:

  1736             case ALC_REFRESH:

  1737             case ALC_SYNC:

  1738             case ALC_MONO_SOURCES:

  1739             case ALC_STEREO_SOURCES:

  1740             case ALC_CAPTURE_SAMPLES:

  1741             case ALC_FORMAT_CHANNELS_SOFT:

  1742             case ALC_FORMAT_TYPE_SOFT:

  1743                 alcSetError(NULL, ALC_INVALID_DEVICE);

  1744                 break;

  1745 

  1746             default:

  1747                 alcSetError(NULL, ALC_INVALID_ENUM);

  1748                 break;

  1749         }

  1750     }

  1751     else if(device->IsCaptureDevice)

  1752     {

  1753         switch(param)

  1754         {

  1755             case ALC_CAPTURE_SAMPLES:

  1756                 LockDevice(device);

  1757                 *data = ALCdevice_AvailableSamples(device);

  1758                 UnlockDevice(device);

  1759                 break;

  1760 

  1761             case ALC_CONNECTED:

  1762                 *data = device->Connected;

  1763                 break;

  1764 

  1765             default:

  1766                 alcSetError(device, ALC_INVALID_ENUM);

  1767                 break;

  1768         }

  1769     }

  1770     else /* render device */

  1771     {

  1772         switch(param)

  1773         {

  1774             case ALC_MAJOR_VERSION:

  1775                 *data = alcMajorVersion;

  1776                 break;

  1777 

  1778             case ALC_MINOR_VERSION:

  1779                 *data = alcMinorVersion;

  1780                 break;

  1781 

  1782             case ALC_EFX_MAJOR_VERSION:

  1783                 *data = alcEFXMajorVersion;

  1784                 break;

  1785 

  1786             case ALC_EFX_MINOR_VERSION:

  1787                 *data = alcEFXMinorVersion;

  1788                 break;

  1789 

  1790             case ALC_ATTRIBUTES_SIZE:

  1791                 *data = 13;

  1792                 break;

  1793 

  1794             case ALC_ALL_ATTRIBUTES:

  1795                 if(size < 13)

  1796                     alcSetError(device, ALC_INVALID_VALUE);

  1797                 else

  1798                 {

  1799                     int i = 0;

  1800 

  1801                     data[i++] = ALC_FREQUENCY;

  1802                     data[i++] = device->Frequency;

  1803 

  1804                     if(!device->IsLoopbackDevice)

  1805                     {

  1806                         data[i++] = ALC_REFRESH;

  1807                         data[i++] = device->Frequency / device->UpdateSize;

  1808 

  1809                         data[i++] = ALC_SYNC;

  1810                         data[i++] = ALC_FALSE;

  1811                     }

  1812                     else

  1813                     {

  1814                         data[i++] = ALC_FORMAT_CHANNELS_SOFT;

  1815                         data[i++] = device->FmtChans;

  1816 

  1817                         data[i++] = ALC_FORMAT_TYPE_SOFT;

  1818                         data[i++] = device->FmtType;

  1819                     }

  1820 

  1821                     data[i++] = ALC_MONO_SOURCES;

  1822                     data[i++] = device->NumMonoSources;

  1823 

  1824                     data[i++] = ALC_STEREO_SOURCES;

  1825                     data[i++] = device->NumStereoSources;

  1826 

  1827                     data[i++] = ALC_MAX_AUXILIARY_SENDS;

  1828                     data[i++] = device->NumAuxSends;

  1829 

  1830                     data[i++] = 0;

  1831                 }

  1832                 break;

  1833 

  1834             case ALC_FREQUENCY:

  1835                 *data = device->Frequency;

  1836                 break;

  1837 

  1838             case ALC_REFRESH:

  1839                 if(device->IsLoopbackDevice)

  1840                     alcSetError(device, ALC_INVALID_DEVICE);

  1841                 else

  1842                     *data = device->Frequency / device->UpdateSize;

  1843                 break;

  1844 

  1845             case ALC_SYNC:

  1846                 if(device->IsLoopbackDevice)

  1847                     alcSetError(device, ALC_INVALID_DEVICE);

  1848                 else

  1849                     *data = ALC_FALSE;

  1850                 break;

  1851 

  1852             case ALC_FORMAT_CHANNELS_SOFT:

  1853                 if(!device->IsLoopbackDevice)

  1854                     alcSetError(device, ALC_INVALID_DEVICE);

  1855                 else

  1856                     *data = device->FmtChans;

  1857                 break;

  1858 

  1859             case ALC_FORMAT_TYPE_SOFT:

  1860                 if(!device->IsLoopbackDevice)

  1861                     alcSetError(device, ALC_INVALID_DEVICE);

  1862                 else

  1863                     *data = device->FmtType;

  1864                 break;

  1865 

  1866             case ALC_MONO_SOURCES:

  1867                 *data = device->NumMonoSources;

  1868                 break;

  1869 

  1870             case ALC_STEREO_SOURCES:

  1871                 *data = device->NumStereoSources;

  1872                 break;

  1873 

  1874             case ALC_MAX_AUXILIARY_SENDS:

  1875                 *data = device->NumAuxSends;

  1876                 break;

  1877 

  1878             case ALC_CONNECTED:

  1879                 *data = device->Connected;

  1880                 break;

  1881 

  1882             default:

  1883                 alcSetError(device, ALC_INVALID_ENUM);

  1884                 break;

  1885         }

  1886     }

  1887     UnlockLists();

  1888 }

  1889 

  1890 

  1891 /*

  1892     alcIsExtensionPresent

  1893 

  1894     Determines if there is support for a particular extension

  1895 */

  1896 ALC_API ALCboolean ALC_APIENTRY alcIsExtensionPresent(ALCdevice *device, const ALCchar *extName)

  1897 {

  1898     ALCboolean bResult = ALC_FALSE;

  1899     const char *ptr;

  1900     size_t len;

  1901 

  1902     if(!extName)

  1903     {

  1904         alcSetError(device, ALC_INVALID_VALUE);

  1905         return ALC_FALSE;

  1906     }

  1907 

  1908     len = strlen(extName);

  1909     LockLists();

  1910     ptr = (IsDevice(device) ? alcExtensionList : alcNoDeviceExtList);

  1911     UnlockLists();

  1912     while(ptr && *ptr)

  1913     {

  1914         if(strncasecmp(ptr, extName, len) == 0 &&

  1915            (ptr[len] == '\0' || isspace(ptr[len])))

  1916         {

  1917             bResult = ALC_TRUE;

  1918             break;

  1919         }

  1920         if((ptr=strchr(ptr, ' ')) != NULL)

  1921         {

  1922             do {

  1923                 ++ptr;

  1924             } while(isspace(*ptr));

  1925         }

  1926     }

  1927 

  1928     return bResult;

  1929 }

  1930 

  1931 

  1932 /*

  1933     alcGetProcAddress

  1934 

  1935     Retrieves the function address for a particular extension function

  1936 */

  1937 ALC_API ALCvoid* ALC_APIENTRY alcGetProcAddress(ALCdevice *device, const ALCchar *funcName)

  1938 {

  1939     ALsizei i = 0;

  1940 

  1941     if(!funcName)

  1942     {

  1943         alcSetError(device, ALC_INVALID_VALUE);

  1944         return NULL;

  1945     }

  1946 

  1947     while(alcFunctions[i].funcName && strcmp(alcFunctions[i].funcName,funcName) != 0)

  1948         i++;

  1949     return alcFunctions[i].address;

  1950 }

  1951 

  1952 

  1953 /*

  1954     alcGetEnumValue

  1955 

  1956     Get the value for a particular ALC Enumerated Value

  1957 */

  1958 ALC_API ALCenum ALC_APIENTRY alcGetEnumValue(ALCdevice *device, const ALCchar *enumName)

  1959 {

  1960     ALsizei i = 0;

  1961 

  1962     if(!enumName)

  1963     {

  1964         alcSetError(device, ALC_INVALID_VALUE);

  1965         return (ALCenum)0;

  1966     }

  1967 

  1968     while(enumeration[i].enumName && strcmp(enumeration[i].enumName,enumName) != 0)

  1969         i++;

  1970     return enumeration[i].value;

  1971 }

  1972 

  1973 

  1974 /*

  1975     alcCreateContext

  1976 

  1977     Create and attach a Context to a particular Device.

  1978 */

  1979 ALC_API ALCcontext* ALC_APIENTRY alcCreateContext(ALCdevice *device, const ALCint *attrList)

  1980 {

  1981     ALCcontext *ALContext;

  1982     void *temp;

  1983 

  1984     LockLists();

  1985     if(!IsDevice(device) || device->IsCaptureDevice || !device->Connected)

  1986     {

  1987         alcSetError(device, ALC_INVALID_DEVICE);

  1988         UnlockLists();

  1989         return NULL;

  1990     }

  1991 

  1992     // Reset Context Last Error code

  1993     device->LastError = ALC_NO_ERROR;

  1994 

  1995     if(UpdateDeviceParams(device, attrList) == ALC_FALSE)

  1996     {

  1997         alcSetError(device, ALC_INVALID_DEVICE);

  1998         aluHandleDisconnect(device);

  1999         UnlockLists();

  2000         return NULL;

  2001     }

  2002 

  2003     LockDevice(device);

  2004     ALContext = NULL;

  2005     temp = realloc(device->Contexts, (device->NumContexts+1) * sizeof(*device->Contexts));

  2006     if(temp)

  2007     {

  2008         device->Contexts = temp;

  2009 

  2010         ALContext = calloc(1, sizeof(ALCcontext));

  2011         if(ALContext)

  2012         {

  2013             ALContext->MaxActiveSources = 256;

  2014             ALContext->ActiveSources = malloc(sizeof(ALContext->ActiveSources[0]) *

  2015                                               ALContext->MaxActiveSources);

  2016         }

  2017     }

  2018     if(!ALContext || !ALContext->ActiveSources)

  2019     {

  2020         free(ALContext);

  2021         alcSetError(device, ALC_OUT_OF_MEMORY);

  2022         UnlockDevice(device);

  2023         if(device->NumContexts == 0)

  2024         {

  2025             ALCdevice_StopPlayback(device);

  2026             device->Flags &= ~DEVICE_RUNNING;

  2027         }

  2028         UnlockLists();

  2029         return NULL;

  2030     }

  2031 

  2032     device->Contexts[device->NumContexts++] = ALContext;

  2033     ALContext->Device = device;

  2034 

  2035     InitContext(ALContext);

  2036     UnlockDevice(device);

  2037 

  2038     ALContext->next = g_pContextList;

  2039     g_pContextList = ALContext;

  2040     g_ulContextCount++;

  2041 

  2042     UnlockLists();

  2043 

  2044     return ALContext;

  2045 }

  2046 

  2047 

  2048 /*

  2049     alcDestroyContext

  2050 

  2051     Remove a Context

  2052 */

  2053 ALC_API ALCvoid ALC_APIENTRY alcDestroyContext(ALCcontext *context)

  2054 {

  2055     ALCdevice *Device;

  2056     ALCcontext **list;

  2057     ALuint i;

  2058 

  2059     LockLists();

  2060     list = &g_pContextList;

  2061     while(*list && *list != context)

  2062         list = &(*list)->next;

  2063 

  2064     if(!*list)

  2065     {

  2066         alcSetError(NULL, ALC_INVALID_CONTEXT);

  2067         UnlockLists();

  2068         return;

  2069     }

  2070 

  2071     *list = (*list)->next;

  2072     g_ulContextCount--;

  2073 

  2074     if(context == tls_get(LocalContext))

  2075         tls_set(LocalContext, NULL);

  2076     if(context == GlobalContext)

  2077         GlobalContext = NULL;

  2078 

  2079     Device = context->Device;

  2080     LockDevice(Device);

  2081     for(i = 0;i < Device->NumContexts;i++)

  2082     {

  2083         if(Device->Contexts[i] == context)

  2084         {

  2085             Device->Contexts[i] = Device->Contexts[Device->NumContexts-1];

  2086             Device->NumContexts--;

  2087             break;

  2088         }

  2089     }

  2090     UnlockDevice(Device);

  2091 

  2092     if(Device->NumContexts == 0)

  2093     {

  2094         ALCdevice_StopPlayback(Device);

  2095         Device->Flags &= ~DEVICE_RUNNING;

  2096     }

  2097     UnlockLists();

  2098 

  2099     if(context->SourceMap.size > 0)

  2100     {

  2101         ERR("alcDestroyContext(): deleting %d Source(s)\n", context->SourceMap.size);

  2102         ReleaseALSources(context);

  2103     }

  2104     ResetUIntMap(&context->SourceMap);

  2105 

  2106     if(context->EffectSlotMap.size > 0)

  2107     {

  2108         ERR("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", context->EffectSlotMap.size);

  2109         ReleaseALAuxiliaryEffectSlots(context);

  2110     }

  2111     ResetUIntMap(&context->EffectSlotMap);

  2112 

  2113     free(context->ActiveSources);

  2114     context->ActiveSources = NULL;

  2115     context->MaxActiveSources = 0;

  2116     context->ActiveSourceCount = 0;

  2117 

  2118     FreeContext(context);

  2119 }

  2120 

  2121 

  2122 /*

  2123     alcGetCurrentContext

  2124 

  2125     Returns the currently active Context

  2126 */

  2127 ALC_API ALCcontext* ALC_APIENTRY alcGetCurrentContext(ALCvoid)

  2128 {

  2129     ALCcontext *Context;

  2130 

  2131     LockLists();

  2132     Context = tls_get(LocalContext);

  2133     if(Context && !IsContext(Context))

  2134     {

  2135         tls_set(LocalContext, NULL);

  2136         Context = NULL;

  2137     }

  2138     if(!Context)

  2139         Context = GlobalContext;

  2140     UnlockLists();

  2141 

  2142     return Context;

  2143 }

  2144 

  2145 /*

  2146     alcGetThreadContext

  2147 

  2148     Returns the currently active thread-local Context

  2149 */

  2150 ALC_API ALCcontext* ALC_APIENTRY alcGetThreadContext(void)

  2151 {

  2152     ALCcontext *pContext = NULL;

  2153 

  2154     LockLists();

  2155 

  2156     pContext = tls_get(LocalContext);

  2157     if(pContext && !IsContext(pContext))

  2158     {

  2159         tls_set(LocalContext, NULL);

  2160         pContext = NULL;

  2161     }

  2162 

  2163     UnlockLists();

  2164 

  2165     return pContext;

  2166 }

  2167 

  2168 

  2169 /*

  2170     alcGetContextsDevice

  2171 

  2172     Returns the Device that a particular Context is attached to

  2173 */

  2174 ALC_API ALCdevice* ALC_APIENTRY alcGetContextsDevice(ALCcontext *pContext)

  2175 {

  2176     ALCdevice *pDevice = NULL;

  2177 

  2178     LockLists();

  2179     if(IsContext(pContext))

  2180         pDevice = pContext->Device;

  2181     else

  2182         alcSetError(NULL, ALC_INVALID_CONTEXT);

  2183     UnlockLists();

  2184 

  2185     return pDevice;

  2186 }

  2187 

  2188 

  2189 /*

  2190     alcMakeContextCurrent

  2191 

  2192     Makes the given Context the active Context

  2193 */

  2194 ALC_API ALCboolean ALC_APIENTRY alcMakeContextCurrent(ALCcontext *context)

  2195 {

  2196     ALboolean bReturn = AL_TRUE;

  2197 

  2198     LockLists();

  2199 

  2200     // context must be a valid Context or NULL

  2201     if(context == NULL || IsContext(context))

  2202     {

  2203         GlobalContext = context;

  2204         tls_set(LocalContext, NULL);

  2205     }

  2206     else

  2207     {

  2208         alcSetError(NULL, ALC_INVALID_CONTEXT);

  2209         bReturn = AL_FALSE;

  2210     }

  2211 

  2212     UnlockLists();

  2213 

  2214     return bReturn;

  2215 }

  2216 

  2217 /*

  2218     alcSetThreadContext

  2219 

  2220     Makes the given Context the active Context for the current thread

  2221 */

  2222 ALC_API ALCboolean ALC_APIENTRY alcSetThreadContext(ALCcontext *context)

  2223 {

  2224     ALboolean bReturn = AL_TRUE;

  2225 

  2226     LockLists();

  2227 

  2228     // context must be a valid Context or NULL

  2229     if(context == NULL || IsContext(context))

  2230         tls_set(LocalContext, context);

  2231     else

  2232     {

  2233         alcSetError(NULL, ALC_INVALID_CONTEXT);

  2234         bReturn = AL_FALSE;

  2235     }

  2236 

  2237     UnlockLists();

  2238 

  2239     return bReturn;

  2240 }

  2241 

  2242 

  2243 static void GetFormatFromString(const char *str, enum DevFmtChannels *chans, enum DevFmtType *type)

  2244 {

  2245     if(strcasecmp(str, "AL_FORMAT_MONO32") == 0)

  2246     {

  2247         *chans = DevFmtMono;

  2248         *type = DevFmtFloat;

  2249         return;

  2250     }

  2251     if(strcasecmp(str, "AL_FORMAT_STEREO32") == 0)

  2252     {

  2253         *chans = DevFmtStereo;

  2254         *type = DevFmtFloat;

  2255         return;

  2256     }

  2257     if(strcasecmp(str, "AL_FORMAT_QUAD32") == 0)

  2258     {

  2259         *chans = DevFmtQuad;

  2260         *type = DevFmtFloat;

  2261         return;

  2262     }

  2263     if(strcasecmp(str, "AL_FORMAT_51CHN32") == 0)

  2264     {

  2265         *chans = DevFmtX51;

  2266         *type = DevFmtFloat;

  2267         return;

  2268     }

  2269     if(strcasecmp(str, "AL_FORMAT_61CHN32") == 0)

  2270     {

  2271         *chans = DevFmtX61;

  2272         *type = DevFmtFloat;

  2273         return;

  2274     }

  2275     if(strcasecmp(str, "AL_FORMAT_71CHN32") == 0)

  2276     {

  2277         *chans = DevFmtX71;

  2278         *type = DevFmtFloat;

  2279         return;

  2280     }

  2281 

  2282     if(strcasecmp(str, "AL_FORMAT_MONO16") == 0)

  2283     {

  2284         *chans = DevFmtMono;

  2285         *type = DevFmtShort;

  2286         return;

  2287     }

  2288     if(strcasecmp(str, "AL_FORMAT_STEREO16") == 0)

  2289     {

  2290         *chans = DevFmtStereo;

  2291         *type = DevFmtShort;

  2292         return;

  2293     }

  2294     if(strcasecmp(str, "AL_FORMAT_QUAD16") == 0)

  2295     {

  2296         *chans = DevFmtQuad;

  2297         *type = DevFmtShort;

  2298         return;

  2299     }

  2300     if(strcasecmp(str, "AL_FORMAT_51CHN16") == 0)

  2301     {

  2302         *chans = DevFmtX51;

  2303         *type = DevFmtShort;

  2304         return;

  2305     }

  2306     if(strcasecmp(str, "AL_FORMAT_61CHN16") == 0)

  2307     {

  2308         *chans = DevFmtX61;

  2309         *type = DevFmtShort;

  2310         return;

  2311     }

  2312     if(strcasecmp(str, "AL_FORMAT_71CHN16") == 0)

  2313     {

  2314         *chans = DevFmtX71;

  2315         *type = DevFmtShort;

  2316         return;

  2317     }

  2318 

  2319     if(strcasecmp(str, "AL_FORMAT_MONO8") == 0)

  2320     {

  2321         *chans = DevFmtMono;

  2322         *type = DevFmtByte;

  2323         return;

  2324     }

  2325     if(strcasecmp(str, "AL_FORMAT_STEREO8") == 0)

  2326     {

  2327         *chans = DevFmtStereo;

  2328         *type = DevFmtByte;

  2329         return;

  2330     }

  2331     if(strcasecmp(str, "AL_FORMAT_QUAD8") == 0)

  2332     {

  2333         *chans = DevFmtQuad;

  2334         *type = DevFmtByte;

  2335         return;

  2336     }

  2337     if(strcasecmp(str, "AL_FORMAT_51CHN8") == 0)

  2338     {

  2339         *chans = DevFmtX51;

  2340         *type = DevFmtByte;

  2341         return;

  2342     }

  2343     if(strcasecmp(str, "AL_FORMAT_61CHN8") == 0)

  2344     {

  2345         *chans = DevFmtX61;

  2346         *type = DevFmtByte;

  2347         return;

  2348     }

  2349     if(strcasecmp(str, "AL_FORMAT_71CHN8") == 0)

  2350     {

  2351         *chans = DevFmtX71;

  2352         *type = DevFmtByte;

  2353         return;

  2354     }

  2355 

  2356     ERR("Unknown format: \"%s\"\n", str);

  2357     *chans = DevFmtStereo;

  2358     *type = DevFmtShort;

  2359 }

  2360 

  2361 /*

  2362     alcOpenDevice

  2363 

  2364     Open the Device specified.

  2365 */

  2366 ALC_API ALCdevice* ALC_APIENTRY alcOpenDevice(const ALCchar *deviceName)

  2367 {

  2368     const ALCchar *fmt;

  2369     ALCdevice *device;

  2370 

  2371     DO_INITCONFIG();

  2372 

  2373     if(!PlaybackBackend.name)

  2374     {

  2375         alcSetError(NULL, ALC_INVALID_VALUE);

  2376         return NULL;

  2377     }

  2378 

  2379     if(deviceName && (!deviceName[0] || strcasecmp(deviceName, "openal soft") == 0 || strcasecmp(deviceName, "openal-soft") == 0))

  2380         deviceName = NULL;

  2381 

  2382     device = calloc(1, sizeof(ALCdevice));

  2383     if(!device)

  2384     {

  2385         alcSetError(NULL, ALC_OUT_OF_MEMORY);

  2386         return NULL;

  2387     }

  2388 

  2389     //Validate device

  2390     device->Funcs = &PlaybackBackend.Funcs;

  2391     device->Connected = ALC_TRUE;

  2392     device->IsCaptureDevice = AL_FALSE;

  2393     device->IsLoopbackDevice = AL_FALSE;

  2394     InitializeCriticalSection(&device->Mutex);

  2395     device->LastError = ALC_NO_ERROR;

  2396 

  2397     device->Flags = 0;

  2398     device->Bs2b = NULL;

  2399     device->szDeviceName = NULL;

  2400 

  2401     device->Contexts = NULL;

  2402     device->NumContexts = 0;

  2403 

  2404     InitUIntMap(&device->BufferMap);

  2405     InitUIntMap(&device->EffectMap);

  2406     InitUIntMap(&device->FilterMap);

  2407 

  2408     //Set output format

  2409     if(ConfigValueExists(NULL, "frequency"))

  2410         device->Flags |= DEVICE_FREQUENCY_REQUEST;

  2411     device->Frequency = GetConfigValueInt(NULL, "frequency", DEFAULT_OUTPUT_RATE);

  2412     if(device->Frequency < 8000)

  2413         device->Frequency = 8000;

  2414 

  2415     if(ConfigValueExists(NULL, "format"))

  2416         device->Flags |= DEVICE_CHANNELS_REQUEST;

  2417     fmt = GetConfigValue(NULL, "format", "AL_FORMAT_STEREO16");

  2418     GetFormatFromString(fmt, &device->FmtChans, &device->FmtType);

  2419 

  2420     device->NumUpdates = GetConfigValueInt(NULL, "periods", 4);

  2421     if(device->NumUpdates < 2)

  2422         device->NumUpdates = 4;

  2423 

  2424     device->UpdateSize = GetConfigValueInt(NULL, "period_size", 1024);

  2425     if(device->UpdateSize <= 0)

  2426         device->UpdateSize = 1024;

  2427 

  2428     device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);

  2429     if(device->MaxNoOfSources <= 0)

  2430         device->MaxNoOfSources = 256;

  2431 

  2432     device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);

  2433     if(device->AuxiliaryEffectSlotMax <= 0)

  2434         device->AuxiliaryEffectSlotMax = 4;

  2435 

  2436     device->NumStereoSources = 1;

  2437     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;

  2438 

  2439     device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);

  2440     if(device->NumAuxSends > MAX_SENDS)

  2441         device->NumAuxSends = MAX_SENDS;

  2442 

  2443     device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);

  2444 

  2445     // Find a playback device to open

  2446     LockLists();

  2447     if(ALCdevice_OpenPlayback(device, deviceName))

  2448     {

  2449         device->next = g_pDeviceList;

  2450         g_pDeviceList = device;

  2451         g_ulDeviceCount++;

  2452     }

  2453     else

  2454     {

  2455         // No suitable output device found

  2456         DeleteCriticalSection(&device->Mutex);

  2457         free(device);

  2458         device = NULL;

  2459         alcSetError(NULL, ALC_INVALID_VALUE);

  2460     }

  2461     UnlockLists();

  2462 

  2463     return device;

  2464 }

  2465 

  2466 

  2467 /*

  2468     alcCloseDevice

  2469 

  2470     Close the specified Device

  2471 */

  2472 ALC_API ALCboolean ALC_APIENTRY alcCloseDevice(ALCdevice *pDevice)

  2473 {

  2474     ALCdevice **list;

  2475 

  2476     LockLists();

  2477     list = &g_pDeviceList;

  2478     while(*list && *list != pDevice)

  2479         list = &(*list)->next;

  2480 

  2481     if(!*list || (*list)->IsCaptureDevice)

  2482     {

  2483         alcSetError(*list, ALC_INVALID_DEVICE);

  2484         UnlockLists();

  2485         return ALC_FALSE;

  2486     }

  2487 

  2488     *list = (*list)->next;

  2489     g_ulDeviceCount--;

  2490 

  2491     UnlockLists();

  2492 

  2493     if(pDevice->NumContexts > 0)

  2494     {

  2495         WARN("alcCloseDevice(): destroying %u Context(s)\n", pDevice->NumContexts);

  2496         while(pDevice->NumContexts > 0)

  2497             alcDestroyContext(pDevice->Contexts[0]);

  2498     }

  2499     ALCdevice_ClosePlayback(pDevice);

  2500 

  2501     if(pDevice->BufferMap.size > 0)

  2502     {

  2503         WARN("alcCloseDevice(): deleting %d Buffer(s)\n", pDevice->BufferMap.size);

  2504         ReleaseALBuffers(pDevice);

  2505     }

  2506     ResetUIntMap(&pDevice->BufferMap);

  2507 

  2508     if(pDevice->EffectMap.size > 0)

  2509     {

  2510         WARN("alcCloseDevice(): deleting %d Effect(s)\n", pDevice->EffectMap.size);

  2511         ReleaseALEffects(pDevice);

  2512     }

  2513     ResetUIntMap(&pDevice->EffectMap);

  2514 

  2515     if(pDevice->FilterMap.size > 0)

  2516     {

  2517         WARN("alcCloseDevice(): deleting %d Filter(s)\n", pDevice->FilterMap.size);

  2518         ReleaseALFilters(pDevice);

  2519     }

  2520     ResetUIntMap(&pDevice->FilterMap);

  2521 

  2522     free(pDevice->Bs2b);

  2523     pDevice->Bs2b = NULL;

  2524 

  2525     free(pDevice->szDeviceName);

  2526     pDevice->szDeviceName = NULL;

  2527 

  2528     free(pDevice->Contexts);

  2529     pDevice->Contexts = NULL;

  2530 

  2531     DeleteCriticalSection(&pDevice->Mutex);

  2532 

  2533     //Release device structure

  2534     memset(pDevice, 0, sizeof(ALCdevice));

  2535     free(pDevice);

  2536 

  2537     return ALC_TRUE;

  2538 }

  2539 

  2540 

  2541 ALC_API ALCdevice* ALC_APIENTRY alcLoopbackOpenDeviceSOFT(void)

  2542 {

  2543     ALCdevice *device;

  2544 

  2545     DO_INITCONFIG();

  2546 

  2547     device = calloc(1, sizeof(ALCdevice));

  2548     if(!device)

  2549     {

  2550         alcSetError(NULL, ALC_OUT_OF_MEMORY);

  2551         return NULL;

  2552     }

  2553 

  2554     //Validate device

  2555     device->Funcs = &BackendLoopback.Funcs;

  2556     device->Connected = ALC_TRUE;

  2557     device->IsCaptureDevice = AL_FALSE;

  2558     device->IsLoopbackDevice = AL_TRUE;

  2559     InitializeCriticalSection(&device->Mutex);

  2560     device->LastError = ALC_NO_ERROR;

  2561 

  2562     device->Flags = 0;

  2563     device->Bs2b = NULL;

  2564     device->szDeviceName = NULL;

  2565 

  2566     device->Contexts = NULL;

  2567     device->NumContexts = 0;

  2568 

  2569     InitUIntMap(&device->BufferMap);

  2570     InitUIntMap(&device->EffectMap);

  2571     InitUIntMap(&device->FilterMap);

  2572 

  2573     //Set output format

  2574     device->Frequency = 44100;

  2575     device->FmtChans = DevFmtStereo;

  2576     device->FmtType = DevFmtShort;

  2577 

  2578     device->NumUpdates = 0;

  2579     device->UpdateSize = 0;

  2580 

  2581     device->MaxNoOfSources = GetConfigValueInt(NULL, "sources", 256);

  2582     if(device->MaxNoOfSources <= 0)

  2583         device->MaxNoOfSources = 256;

  2584 

  2585     device->AuxiliaryEffectSlotMax = GetConfigValueInt(NULL, "slots", 4);

  2586     if(device->AuxiliaryEffectSlotMax <= 0)

  2587         device->AuxiliaryEffectSlotMax = 4;

  2588 

  2589     device->NumStereoSources = 1;

  2590     device->NumMonoSources = device->MaxNoOfSources - device->NumStereoSources;

  2591 

  2592     device->NumAuxSends = GetConfigValueInt(NULL, "sends", MAX_SENDS);

  2593     if(device->NumAuxSends > MAX_SENDS)

  2594         device->NumAuxSends = MAX_SENDS;

  2595 

  2596     device->Bs2bLevel = GetConfigValueInt(NULL, "cf_level", 0);

  2597 

  2598     // Open the "backend"

  2599     LockLists();

  2600     ALCdevice_OpenPlayback(device, "Loopback");

  2601 

  2602     device->next = g_pDeviceList;

  2603     g_pDeviceList = device;

  2604     g_ulDeviceCount++;

  2605     UnlockLists();

  2606 

  2607     return device;

  2608 }

  2609 

  2610 ALC_API ALCboolean ALC_APIENTRY alcIsRenderFormatSupportedSOFT(ALCdevice *device, ALCsizei freq, ALCenum channels, ALCenum type)

  2611 {

  2612     ALCboolean ret = ALC_FALSE;

  2613 

  2614     LockLists();

  2615     if(!IsDevice(device) || !device->IsLoopbackDevice)

  2616         alcSetError(device, ALC_INVALID_DEVICE);

  2617     else if(freq <= 0)

  2618         alcSetError(device, ALC_INVALID_VALUE);

  2619     else if(!IsValidALCType(type) || !IsValidALCChannels(channels))

  2620         alcSetError(device, ALC_INVALID_ENUM);

  2621     else

  2622     {

  2623         if(BytesFromDevFmt(type) > 0 && ChannelsFromDevFmt(channels) > 0 &&

  2624            freq >= 8000)

  2625             ret = ALC_TRUE;

  2626     }

  2627     UnlockLists();

  2628 

  2629     return ret;

  2630 }

  2631 

  2632 ALC_API void ALC_APIENTRY alcRenderSamplesSOFT(ALCdevice *device, ALCvoid *buffer, ALCsizei samples)

  2633 {

  2634     LockLists();

  2635     if(!IsDevice(device) || !device->IsLoopbackDevice)

  2636         alcSetError(device, ALC_INVALID_DEVICE);

  2637     else if(samples < 0 || (samples > 0 && buffer == NULL))

  2638         alcSetError(device, ALC_INVALID_VALUE);

  2639     else

  2640         aluMixData(device, buffer, samples);

  2641     UnlockLists();

  2642 }

  2643 

  2644 

  2645 static void ReleaseALC(ALCboolean doclose)

  2646 {

  2647     free(alcDeviceList); alcDeviceList = NULL;

  2648     alcDeviceListSize = 0;

  2649     free(alcAllDeviceList); alcAllDeviceList = NULL;

  2650     alcAllDeviceListSize = 0;

  2651     free(alcCaptureDeviceList); alcCaptureDeviceList = NULL;

  2652     alcCaptureDeviceListSize = 0;

  2653 

  2654     free(alcDefaultDeviceSpecifier);

  2655     alcDefaultDeviceSpecifier = NULL;

  2656     free(alcDefaultAllDeviceSpecifier);

  2657     alcDefaultAllDeviceSpecifier = NULL;

  2658     free(alcCaptureDefaultDeviceSpecifier);

  2659     alcCaptureDefaultDeviceSpecifier = NULL;

  2660 

  2661     if(doclose)

  2662     {

  2663         if(g_ulDeviceCount > 0)

  2664             WARN("ReleaseALC(): closing %u Device%s\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");

  2665 

  2666         while(g_pDeviceList)

  2667         {

  2668             if(g_pDeviceList->IsCaptureDevice)

  2669                 alcCaptureCloseDevice(g_pDeviceList);

  2670             else

  2671                 alcCloseDevice(g_pDeviceList);

  2672         }

  2673     }

  2674     else

  2675     {

  2676         if(g_ulDeviceCount > 0)

  2677             WARN("ReleaseALC(): %u Device%s not closed\n", g_ulDeviceCount, (g_ulDeviceCount>1)?"s":"");

  2678     }

  2679 }

  2680 

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