Subversion Repositories Games.Carmageddon

/*

Audio playback and capture library. Choice of public domain or MIT-0. See license statements at the end of this file.

miniaudio - v0.11.21 - 2023-11-15

David Reid - mackron@gmail.com

Website:       https://miniaud.io

Documentation: https://miniaud.io/docs

GitHub:        https://github.com/mackron/miniaudio

*/

#ifndef miniaudio_h

#define miniaudio_h

#ifdef __cplusplus

extern "C" {

#endif

#define MA_STRINGIFY(x)     #x

#define MA_XSTRINGIFY(x)    MA_STRINGIFY(x)

#define MA_VERSION_MAJOR    0

#define MA_VERSION_MINOR    11

#define MA_VERSION_REVISION 21

#define MA_VERSION_STRING   MA_XSTRINGIFY(MA_VERSION_MAJOR) "." MA_XSTRINGIFY(MA_VERSION_MINOR) "." MA_XSTRINGIFY(MA_VERSION_REVISION)

#if defined(_MSC_VER) && !defined(__clang__)

    #pragma warning(push)

    #pragma warning(disable:4201)   /* nonstandard extension used: nameless struct/union */

    #pragma warning(disable:4214)   /* nonstandard extension used: bit field types other than int */

    #pragma warning(disable:4324)   /* structure was padded due to alignment specifier */

#elif defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)))

    #pragma GCC diagnostic push

    #pragma GCC diagnostic ignored "-Wpedantic" /* For ISO C99 doesn't support unnamed structs/unions [-Wpedantic] */

    #if defined(__clang__)

        #pragma GCC diagnostic ignored "-Wc11-extensions"   /* anonymous unions are a C11 extension */

    #endif

#endif

#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__)) || defined(_M_X64) || defined(__ia64) || defined(_M_IA64) || defined(__aarch64__) || defined(_M_ARM64) || defined(__powerpc64__)

    #define MA_SIZEOF_PTR   8

#else

    #define MA_SIZEOF_PTR   4

#endif

#include <stddef.h> /* For size_t. */

/* Sized types. */

#if defined(MA_USE_STDINT)

    #include <stdint.h>

    typedef int8_t   ma_int8;

    typedef uint8_t  ma_uint8;

    typedef int16_t  ma_int16;

    typedef uint16_t ma_uint16;

    typedef int32_t  ma_int32;

    typedef uint32_t ma_uint32;

    typedef int64_t  ma_int64;

    typedef uint64_t ma_uint64;

#else

    typedef   signed char           ma_int8;

    typedef unsigned char           ma_uint8;

    typedef   signed short          ma_int16;

    typedef unsigned short          ma_uint16;

    typedef   signed int            ma_int32;

    typedef unsigned int            ma_uint32;

    #if defined(_MSC_VER) && !defined(__clang__)

        typedef   signed __int64    ma_int64;

        typedef unsigned __int64    ma_uint64;

    #else

        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))

            #pragma GCC diagnostic push

            #pragma GCC diagnostic ignored "-Wlong-long"

            #if defined(__clang__)

                #pragma GCC diagnostic ignored "-Wc++11-long-long"

            #endif

        #endif

        typedef   signed long long  ma_int64;

        typedef unsigned long long  ma_uint64;

        #if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)))

            #pragma GCC diagnostic pop

        #endif

    #endif

#endif  /* MA_USE_STDINT */

#if MA_SIZEOF_PTR == 8

    typedef ma_uint64           ma_uintptr;

#else

    typedef ma_uint32           ma_uintptr;

#endif

typedef ma_uint8    ma_bool8;

typedef ma_uint32   ma_bool32;

#define MA_TRUE     1

#define MA_FALSE    0

/* These float types are not used universally by miniaudio. It's to simplify some macro expansion for atomic types. */

typedef float       ma_float;

typedef double      ma_double;

typedef void* ma_handle;

typedef void* ma_ptr;

/*

ma_proc is annoying because when compiling with GCC we get pendantic warnings about converting

between `void*` and `void (*)()`. We can't use `void (*)()` with MSVC however, because we'll get

warning C4191 about "type cast between incompatible function types". To work around this I'm going

to use a different data type depending on the compiler.

*/

#if defined(__GNUC__)

typedef void (*ma_proc)(void);

#else

typedef void* ma_proc;

#endif

#if defined(_MSC_VER) && !defined(_WCHAR_T_DEFINED)

typedef ma_uint16 wchar_t;

#endif

/* Define NULL for some compilers. */

#ifndef NULL

#define NULL 0

#endif

#if defined(SIZE_MAX)

    #define MA_SIZE_MAX    SIZE_MAX

#else

    #define MA_SIZE_MAX    0xFFFFFFFF  /* When SIZE_MAX is not defined by the standard library just default to the maximum 32-bit unsigned integer. */

#endif

/* Platform/backend detection. */

#if defined(_WIN32) || defined(__COSMOPOLITAN__)

    #define MA_WIN32

    #if defined(MA_FORCE_UWP) || (defined(WINAPI_FAMILY) && ((defined(WINAPI_FAMILY_PC_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) || (defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)))

        #define MA_WIN32_UWP

    #elif defined(WINAPI_FAMILY) && (defined(WINAPI_FAMILY_GAMES) && WINAPI_FAMILY == WINAPI_FAMILY_GAMES)

        #define MA_WIN32_GDK

    #else

        #define MA_WIN32_DESKTOP

    #endif

#endif

#if !defined(_WIN32)    /* If it's not Win32, assume POSIX. */

    #define MA_POSIX

    /*

    Use the MA_NO_PTHREAD_IN_HEADER option at your own risk. This is intentionally undocumented.

    You can use this to avoid including pthread.h in the header section. The downside is that it

    results in some fixed sized structures being declared for the various types that are used in

    miniaudio. The risk here is that these types might be too small for a given platform. This

    risk is yours to take and no support will be offered if you enable this option.

    */

    #ifndef MA_NO_PTHREAD_IN_HEADER

        #include <pthread.h>    /* Unfortunate #include, but needed for pthread_t, pthread_mutex_t and pthread_cond_t types. */

        typedef pthread_t       ma_pthread_t;

        typedef pthread_mutex_t ma_pthread_mutex_t;

        typedef pthread_cond_t  ma_pthread_cond_t;

    #else

        typedef ma_uintptr      ma_pthread_t;

        typedef union           ma_pthread_mutex_t { char __data[40]; ma_uint64 __alignment; } ma_pthread_mutex_t;

        typedef union           ma_pthread_cond_t  { char __data[48]; ma_uint64 __alignment; } ma_pthread_cond_t;

    #endif

    #if defined(__unix__)

        #define MA_UNIX

    #endif

    #if defined(__linux__)

        #define MA_LINUX

    #endif

    #if defined(__APPLE__)

        #define MA_APPLE

    #endif

    #if defined(__DragonFly__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)

        #define MA_BSD

    #endif

    #if defined(__ANDROID__)

        #define MA_ANDROID

    #endif

    #if defined(__EMSCRIPTEN__)

        #define MA_EMSCRIPTEN

    #endif

    #if defined(__ORBIS__)

        #define MA_ORBIS

    #endif

    #if defined(__PROSPERO__)

        #define MA_PROSPERO

    #endif

    #if defined(__NX__)

        #define MA_NX

    #endif

    #if defined(__BEOS__) || defined(__HAIKU__)

        #define MA_BEOS

    #endif

    #if defined(__HAIKU__)

        #define MA_HAIKU

    #endif

#endif

#if defined(__has_c_attribute)

    #if __has_c_attribute(fallthrough)

        #define MA_FALLTHROUGH [[fallthrough]]

    #endif

#endif

#if !defined(MA_FALLTHROUGH) && defined(__has_attribute) && (defined(__clang__) || defined(__GNUC__))

    #if __has_attribute(fallthrough)

        #define MA_FALLTHROUGH __attribute__((fallthrough))

    #endif

#endif

#if !defined(MA_FALLTHROUGH)

    #define MA_FALLTHROUGH ((void)0)

#endif

#ifdef _MSC_VER

    #define MA_INLINE __forceinline

    /* noinline was introduced in Visual Studio 2005. */

    #if _MSC_VER >= 1400

        #define MA_NO_INLINE __declspec(noinline)

    #else

        #define MA_NO_INLINE

    #endif

#elif defined(__GNUC__)

    /*

    I've had a bug report where GCC is emitting warnings about functions possibly not being inlineable. This warning happens when

    the __attribute__((always_inline)) attribute is defined without an "inline" statement. I think therefore there must be some

    case where "__inline__" is not always defined, thus the compiler emitting these warnings. When using -std=c89 or -ansi on the

    command line, we cannot use the "inline" keyword and instead need to use "__inline__". In an attempt to work around this issue

    I am using "__inline__" only when we're compiling in strict ANSI mode.

    */

    #if defined(__STRICT_ANSI__)

        #define MA_GNUC_INLINE_HINT __inline__

    #else

        #define MA_GNUC_INLINE_HINT inline

    #endif

    #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)

        #define MA_INLINE MA_GNUC_INLINE_HINT __attribute__((always_inline))

        #define MA_NO_INLINE __attribute__((noinline))

    #else

        #define MA_INLINE MA_GNUC_INLINE_HINT

        #define MA_NO_INLINE __attribute__((noinline))

    #endif

#elif defined(__WATCOMC__)

    #define MA_INLINE __inline

    #define MA_NO_INLINE

#else

    #define MA_INLINE

    #define MA_NO_INLINE

#endif

/* MA_DLL is not officially supported. You're on your own if you want to use this. */

#if defined(MA_DLL)

    #if defined(_WIN32)

        #define MA_DLL_IMPORT  __declspec(dllimport)

        #define MA_DLL_EXPORT  __declspec(dllexport)

        #define MA_DLL_PRIVATE static

    #else

        #if defined(__GNUC__) && __GNUC__ >= 4

            #define MA_DLL_IMPORT  __attribute__((visibility("default")))

            #define MA_DLL_EXPORT  __attribute__((visibility("default")))

            #define MA_DLL_PRIVATE __attribute__((visibility("hidden")))

        #else

            #define MA_DLL_IMPORT

            #define MA_DLL_EXPORT

            #define MA_DLL_PRIVATE static

        #endif

    #endif

#endif

#if !defined(MA_API)

    #if defined(MA_DLL)

        #if defined(MINIAUDIO_IMPLEMENTATION) || defined(MA_IMPLEMENTATION)

            #define MA_API  MA_DLL_EXPORT

        #else

            #define MA_API  MA_DLL_IMPORT

        #endif

    #else

        #define MA_API extern

    #endif

#endif

#if !defined(MA_STATIC)

    #if defined(MA_DLL)

        #define MA_PRIVATE MA_DLL_PRIVATE

    #else

        #define MA_PRIVATE static

    #endif

#endif

/* SIMD alignment in bytes. Currently set to 32 bytes in preparation for future AVX optimizations. */

#define MA_SIMD_ALIGNMENT  32

/*

Special wchar_t type to ensure any structures in the public sections that reference it have a

consistent size across all platforms.

On Windows, wchar_t is 2 bytes, whereas everywhere else it's 4 bytes. Since Windows likes to use

wchar_t for it's IDs, we need a special explicitly sized wchar type that is always 2 bytes on all

platforms.

*/

#if !defined(MA_POSIX) && defined(MA_WIN32)

typedef wchar_t     ma_wchar_win32;

#else

typedef ma_uint16   ma_wchar_win32;

#endif

/*

Logging Levels

==============

Log levels are only used to give logging callbacks some context as to the severity of a log message

so they can do filtering. All log levels will be posted to registered logging callbacks. If you

don't want to output a certain log level you can discriminate against the log level in the callback.

MA_LOG_LEVEL_DEBUG

    Used for debugging. Useful for debug and test builds, but should be disabled in release builds.

MA_LOG_LEVEL_INFO

    Informational logging. Useful for debugging. This will never be called from within the data

    callback.

MA_LOG_LEVEL_WARNING

    Warnings. You should enable this in you development builds and action them when encounted. These

    logs usually indicate a potential problem or misconfiguration, but still allow you to keep

    running. This will never be called from within the data callback.

MA_LOG_LEVEL_ERROR

    Error logging. This will be fired when an operation fails and is subsequently aborted. This can

    be fired from within the data callback, in which case the device will be stopped. You should

    always have this log level enabled.

*/

typedef enum

{

    MA_LOG_LEVEL_DEBUG   = 4,

    MA_LOG_LEVEL_INFO    = 3,

    MA_LOG_LEVEL_WARNING = 2,

    MA_LOG_LEVEL_ERROR   = 1

} ma_log_level;

/*

Variables needing to be accessed atomically should be declared with this macro for two reasons:

    1) It allows people who read the code to identify a variable as such; and

    2) It forces alignment on platforms where it's required or optimal.

Note that for x86/64, alignment is not strictly necessary, but does have some performance

implications. Where supported by the compiler, alignment will be used, but otherwise if the CPU

architecture does not require it, it will simply leave it unaligned. This is the case with old

versions of Visual Studio, which I've confirmed with at least VC6.

*/

#if !defined(_MSC_VER) && defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)

    #include <stdalign.h>

    #define MA_ATOMIC(alignment, type)            _Alignas(alignment) type

#else

    #if defined(__GNUC__)

        /* GCC-style compilers. */

        #define MA_ATOMIC(alignment, type)        type __attribute__((aligned(alignment)))

    #elif defined(_MSC_VER) && _MSC_VER > 1200  /* 1200 = VC6. Alignment not supported, but not necessary because x86 is the only supported target. */

        /* MSVC. */

        #define MA_ATOMIC(alignment, type)        __declspec(align(alignment)) type

    #else

        /* Other compilers. */

        #define MA_ATOMIC(alignment, type)        type

    #endif

#endif

typedef struct ma_context ma_context;

typedef struct ma_device ma_device;

typedef ma_uint8 ma_channel;

typedef enum

{

    MA_CHANNEL_NONE               = 0,

    MA_CHANNEL_MONO               = 1,

    MA_CHANNEL_FRONT_LEFT         = 2,

    MA_CHANNEL_FRONT_RIGHT        = 3,

    MA_CHANNEL_FRONT_CENTER       = 4,

    MA_CHANNEL_LFE                = 5,

    MA_CHANNEL_BACK_LEFT          = 6,

    MA_CHANNEL_BACK_RIGHT         = 7,

    MA_CHANNEL_FRONT_LEFT_CENTER  = 8,

    MA_CHANNEL_FRONT_RIGHT_CENTER = 9,

    MA_CHANNEL_BACK_CENTER        = 10,

    MA_CHANNEL_SIDE_LEFT          = 11,

    MA_CHANNEL_SIDE_RIGHT         = 12,

    MA_CHANNEL_TOP_CENTER         = 13,

    MA_CHANNEL_TOP_FRONT_LEFT     = 14,

    MA_CHANNEL_TOP_FRONT_CENTER   = 15,

    MA_CHANNEL_TOP_FRONT_RIGHT    = 16,

    MA_CHANNEL_TOP_BACK_LEFT      = 17,

    MA_CHANNEL_TOP_BACK_CENTER    = 18,

    MA_CHANNEL_TOP_BACK_RIGHT     = 19,

    MA_CHANNEL_AUX_0              = 20,

    MA_CHANNEL_AUX_1              = 21,

    MA_CHANNEL_AUX_2              = 22,

    MA_CHANNEL_AUX_3              = 23,

    MA_CHANNEL_AUX_4              = 24,

    MA_CHANNEL_AUX_5              = 25,

    MA_CHANNEL_AUX_6              = 26,

    MA_CHANNEL_AUX_7              = 27,

    MA_CHANNEL_AUX_8              = 28,

    MA_CHANNEL_AUX_9              = 29,

    MA_CHANNEL_AUX_10             = 30,

    MA_CHANNEL_AUX_11             = 31,

    MA_CHANNEL_AUX_12             = 32,

    MA_CHANNEL_AUX_13             = 33,

    MA_CHANNEL_AUX_14             = 34,

    MA_CHANNEL_AUX_15             = 35,

    MA_CHANNEL_AUX_16             = 36,

    MA_CHANNEL_AUX_17             = 37,

    MA_CHANNEL_AUX_18             = 38,

    MA_CHANNEL_AUX_19             = 39,

    MA_CHANNEL_AUX_20             = 40,

    MA_CHANNEL_AUX_21             = 41,

    MA_CHANNEL_AUX_22             = 42,

    MA_CHANNEL_AUX_23             = 43,

    MA_CHANNEL_AUX_24             = 44,

    MA_CHANNEL_AUX_25             = 45,

    MA_CHANNEL_AUX_26             = 46,

    MA_CHANNEL_AUX_27             = 47,

    MA_CHANNEL_AUX_28             = 48,

    MA_CHANNEL_AUX_29             = 49,

    MA_CHANNEL_AUX_30             = 50,

    MA_CHANNEL_AUX_31             = 51,

    MA_CHANNEL_LEFT               = MA_CHANNEL_FRONT_LEFT,

    MA_CHANNEL_RIGHT              = MA_CHANNEL_FRONT_RIGHT,

    MA_CHANNEL_POSITION_COUNT     = (MA_CHANNEL_AUX_31 + 1)

} _ma_channel_position; /* Do not use `_ma_channel_position` directly. Use `ma_channel` instead. */

typedef enum

{

    MA_SUCCESS                        =  0,

    MA_ERROR                          = -1,  /* A generic error. */

    MA_INVALID_ARGS                   = -2,

    MA_INVALID_OPERATION              = -3,

    MA_OUT_OF_MEMORY                  = -4,

    MA_OUT_OF_RANGE                   = -5,

    MA_ACCESS_DENIED                  = -6,

    MA_DOES_NOT_EXIST                 = -7,

    MA_ALREADY_EXISTS                 = -8,

    MA_TOO_MANY_OPEN_FILES            = -9,

    MA_INVALID_FILE                   = -10,

    MA_TOO_BIG                        = -11,

    MA_PATH_TOO_LONG                  = -12,

    MA_NAME_TOO_LONG                  = -13,

    MA_NOT_DIRECTORY                  = -14,

    MA_IS_DIRECTORY                   = -15,

    MA_DIRECTORY_NOT_EMPTY            = -16,

    MA_AT_END                         = -17,

    MA_NO_SPACE                       = -18,

    MA_BUSY                           = -19,

    MA_IO_ERROR                       = -20,

    MA_INTERRUPT                      = -21,

    MA_UNAVAILABLE                    = -22,

    MA_ALREADY_IN_USE                 = -23,

    MA_BAD_ADDRESS                    = -24,

    MA_BAD_SEEK                       = -25,

    MA_BAD_PIPE                       = -26,

    MA_DEADLOCK                       = -27,

    MA_TOO_MANY_LINKS                 = -28,

    MA_NOT_IMPLEMENTED                = -29,

    MA_NO_MESSAGE                     = -30,

    MA_BAD_MESSAGE                    = -31,

    MA_NO_DATA_AVAILABLE              = -32,

    MA_INVALID_DATA                   = -33,

    MA_TIMEOUT                        = -34,

    MA_NO_NETWORK                     = -35,

    MA_NOT_UNIQUE                     = -36,

    MA_NOT_SOCKET                     = -37,

    MA_NO_ADDRESS                     = -38,

    MA_BAD_PROTOCOL                   = -39,

    MA_PROTOCOL_UNAVAILABLE           = -40,

    MA_PROTOCOL_NOT_SUPPORTED         = -41,

    MA_PROTOCOL_FAMILY_NOT_SUPPORTED  = -42,

    MA_ADDRESS_FAMILY_NOT_SUPPORTED   = -43,

    MA_SOCKET_NOT_SUPPORTED           = -44,

    MA_CONNECTION_RESET               = -45,

    MA_ALREADY_CONNECTED              = -46,

    MA_NOT_CONNECTED                  = -47,

    MA_CONNECTION_REFUSED             = -48,

    MA_NO_HOST                        = -49,

    MA_IN_PROGRESS                    = -50,

    MA_CANCELLED                      = -51,

    MA_MEMORY_ALREADY_MAPPED          = -52,

    /* General non-standard errors. */

    MA_CRC_MISMATCH                   = -100,

    /* General miniaudio-specific errors. */

    MA_FORMAT_NOT_SUPPORTED           = -200,

    MA_DEVICE_TYPE_NOT_SUPPORTED      = -201,

    MA_SHARE_MODE_NOT_SUPPORTED       = -202,

    MA_NO_BACKEND                     = -203,

    MA_NO_DEVICE                      = -204,

    MA_API_NOT_FOUND                  = -205,

    MA_INVALID_DEVICE_CONFIG          = -206,

    MA_LOOP                           = -207,

    MA_BACKEND_NOT_ENABLED            = -208,

    /* State errors. */

    MA_DEVICE_NOT_INITIALIZED         = -300,

    MA_DEVICE_ALREADY_INITIALIZED     = -301,

    MA_DEVICE_NOT_STARTED             = -302,

    MA_DEVICE_NOT_STOPPED             = -303,

    /* Operation errors. */

    MA_FAILED_TO_INIT_BACKEND         = -400,

    MA_FAILED_TO_OPEN_BACKEND_DEVICE  = -401,

    MA_FAILED_TO_START_BACKEND_DEVICE = -402,

    MA_FAILED_TO_STOP_BACKEND_DEVICE  = -403

} ma_result;

#define MA_MIN_CHANNELS                 1

#ifndef MA_MAX_CHANNELS

#define MA_MAX_CHANNELS                 254

#endif

#ifndef MA_MAX_FILTER_ORDER

#define MA_MAX_FILTER_ORDER             8

#endif

typedef enum

{

    ma_stream_format_pcm = 0

} ma_stream_format;

typedef enum

{

    ma_stream_layout_interleaved = 0,

    ma_stream_layout_deinterleaved

} ma_stream_layout;

typedef enum

{

    ma_dither_mode_none = 0,

    ma_dither_mode_rectangle,

    ma_dither_mode_triangle

} ma_dither_mode;

typedef enum

{

    /*

    I like to keep these explicitly defined because they're used as a key into a lookup table. When items are

    added to this, make sure there are no gaps and that they're added to the lookup table in ma_get_bytes_per_sample().

    */

    ma_format_unknown = 0,     /* Mainly used for indicating an error, but also used as the default for the output format for decoders. */

    ma_format_u8      = 1,

    ma_format_s16     = 2,     /* Seems to be the most widely supported format. */

    ma_format_s24     = 3,     /* Tightly packed. 3 bytes per sample. */

    ma_format_s32     = 4,

    ma_format_f32     = 5,

    ma_format_count

} ma_format;

typedef enum

{

    /* Standard rates need to be in priority order. */

    ma_standard_sample_rate_48000  = 48000,     /* Most common */

    ma_standard_sample_rate_44100  = 44100,

    ma_standard_sample_rate_32000  = 32000,     /* Lows */

    ma_standard_sample_rate_24000  = 24000,

    ma_standard_sample_rate_22050  = 22050,

    ma_standard_sample_rate_88200  = 88200,     /* Highs */

    ma_standard_sample_rate_96000  = 96000,

    ma_standard_sample_rate_176400 = 176400,

    ma_standard_sample_rate_192000 = 192000,

    ma_standard_sample_rate_16000  = 16000,     /* Extreme lows */

    ma_standard_sample_rate_11025  = 11025,

    ma_standard_sample_rate_8000   = 8000,

    ma_standard_sample_rate_352800 = 352800,    /* Extreme highs */

    ma_standard_sample_rate_384000 = 384000,

    ma_standard_sample_rate_min    = ma_standard_sample_rate_8000,

    ma_standard_sample_rate_max    = ma_standard_sample_rate_384000,

    ma_standard_sample_rate_count  = 14         /* Need to maintain the count manually. Make sure this is updated if items are added to enum. */

} ma_standard_sample_rate;

typedef enum

{

    ma_channel_mix_mode_rectangular = 0,   /* Simple averaging based on the plane(s) the channel is sitting on. */

    ma_channel_mix_mode_simple,            /* Drop excess channels; zeroed out extra channels. */

    ma_channel_mix_mode_custom_weights,    /* Use custom weights specified in ma_channel_converter_config. */

    ma_channel_mix_mode_default = ma_channel_mix_mode_rectangular

} ma_channel_mix_mode;

typedef enum

{

    ma_standard_channel_map_microsoft,

    ma_standard_channel_map_alsa,

    ma_standard_channel_map_rfc3551,   /* Based off AIFF. */

    ma_standard_channel_map_flac,

    ma_standard_channel_map_vorbis,

    ma_standard_channel_map_sound4,    /* FreeBSD's sound(4). */

    ma_standard_channel_map_sndio,     /* www.sndio.org/tips.html */

    ma_standard_channel_map_webaudio = ma_standard_channel_map_flac, /* https://webaudio.github.io/web-audio-api/#ChannelOrdering. Only 1, 2, 4 and 6 channels are defined, but can fill in the gaps with logical assumptions. */

    ma_standard_channel_map_default = ma_standard_channel_map_microsoft

} ma_standard_channel_map;

typedef enum

{

    ma_performance_profile_low_latency = 0,

    ma_performance_profile_conservative

} ma_performance_profile;

typedef struct

{

    void* pUserData;

    void* (* onMalloc)(size_t sz, void* pUserData);

    void* (* onRealloc)(void* p, size_t sz, void* pUserData);

    void  (* onFree)(void* p, void* pUserData);

} ma_allocation_callbacks;

typedef struct

{

    ma_int32 state;

} ma_lcg;

/*

Atomics.

These are typesafe structures to prevent errors as a result of forgetting to reference variables atomically. It's too

easy to introduce subtle bugs where you accidentally do a regular assignment instead of an atomic load/store, etc. By

using a struct we can enforce the use of atomics at compile time.

These types are declared in the header section because we need to reference them in structs below, but functions for

using them are only exposed in the implementation section. I do not want these to be part of the public API.

There's a few downsides to this system. The first is that you need to declare a new struct for each type. Below are

some macros to help with the declarations. They will be named like so:

    ma_atomic_uint32 - atomic ma_uint32

    ma_atomic_int32  - atomic ma_int32

    ma_atomic_uint64 - atomic ma_uint64

    ma_atomic_float  - atomic float

    ma_atomic_bool32 - atomic ma_bool32

The other downside is that atomic pointers are extremely messy. You need to declare a new struct for each specific

type of pointer you need to make atomic. For example, an atomic ma_node* will look like this:

    MA_ATOMIC_SAFE_TYPE_IMPL_PTR(node)

Which will declare a type struct that's named like so:

    ma_atomic_ptr_node

Functions to use the atomic types are declared in the implementation section. All atomic functions are prefixed with

the name of the struct. For example:

    ma_atomic_uint32_set() - Atomic store of ma_uint32

    ma_atomic_uint32_get() - Atomic load of ma_uint32

    etc.

For pointer types it's the same, which makes them a bit messy to use due to the length of each function name, but in

return you get type safety and enforcement of atomic operations.

*/

#define MA_ATOMIC_SAFE_TYPE_DECL(c89TypeExtension, typeSize, type) \

    typedef struct \

    { \

        MA_ATOMIC(typeSize, ma_##type) value; \

    } ma_atomic_##type; \

#define MA_ATOMIC_SAFE_TYPE_DECL_PTR(type) \

    typedef struct \

    { \

        MA_ATOMIC(MA_SIZEOF_PTR, ma_##type*) value; \

    } ma_atomic_ptr_##type; \

MA_ATOMIC_SAFE_TYPE_DECL(32,  4, uint32)

MA_ATOMIC_SAFE_TYPE_DECL(i32, 4, int32)

MA_ATOMIC_SAFE_TYPE_DECL(64,  8, uint64)

MA_ATOMIC_SAFE_TYPE_DECL(f32, 4, float)

MA_ATOMIC_SAFE_TYPE_DECL(32,  4, bool32)

/* Spinlocks are 32-bit for compatibility reasons. */

typedef ma_uint32 ma_spinlock;

#ifndef MA_NO_THREADING

    /* Thread priorities should be ordered such that the default priority of the worker thread is 0. */

    typedef enum

    {

        ma_thread_priority_idle     = -5,

        ma_thread_priority_lowest   = -4,

        ma_thread_priority_low      = -3,

        ma_thread_priority_normal   = -2,

        ma_thread_priority_high     = -1,

        ma_thread_priority_highest  =  0,

        ma_thread_priority_realtime =  1,

        ma_thread_priority_default  =  0

    } ma_thread_priority;

    #if defined(MA_POSIX)

        typedef ma_pthread_t ma_thread;

    #elif defined(MA_WIN32)

        typedef ma_handle ma_thread;

    #endif

    #if defined(MA_POSIX)

        typedef ma_pthread_mutex_t ma_mutex;

    #elif defined(MA_WIN32)

        typedef ma_handle ma_mutex;

    #endif

    #if defined(MA_POSIX)

        typedef struct

        {

            ma_uint32 value;

            ma_pthread_mutex_t lock;

            ma_pthread_cond_t cond;

        } ma_event;

    #elif defined(MA_WIN32)

        typedef ma_handle ma_event;

    #endif

    #if defined(MA_POSIX)

        typedef struct

        {

            int value;

            ma_pthread_mutex_t lock;

            ma_pthread_cond_t cond;

        } ma_semaphore;

    #elif defined(MA_WIN32)

        typedef ma_handle ma_semaphore;

    #endif

#else

    /* MA_NO_THREADING is set which means threading is disabled. Threading is required by some API families. If any of these are enabled we need to throw an error. */

    #ifndef MA_NO_DEVICE_IO

        #error "MA_NO_THREADING cannot be used without MA_NO_DEVICE_IO";

    #endif

#endif  /* MA_NO_THREADING */

/*

Retrieves the version of miniaudio as separated integers. Each component can be NULL if it's not required.

*/

MA_API void ma_version(ma_uint32* pMajor, ma_uint32* pMinor, ma_uint32* pRevision);

/*

Retrieves the version of miniaudio as a string which can be useful for logging purposes.

*/

MA_API const char* ma_version_string(void);

/**************************************************************************************************************************************************************

Logging

**************************************************************************************************************************************************************/

#include <stdarg.h> /* For va_list. */

#if defined(__has_attribute)

    #if __has_attribute(format)

        #define MA_ATTRIBUTE_FORMAT(fmt, va) __attribute__((format(printf, fmt, va)))

    #endif

#endif

#ifndef MA_ATTRIBUTE_FORMAT

#define MA_ATTRIBUTE_FORMAT(fmt, va)

#endif

#ifndef MA_MAX_LOG_CALLBACKS

#define MA_MAX_LOG_CALLBACKS    4

#endif

/*

The callback for handling log messages.

Parameters

----------

pUserData (in)

    The user data pointer that was passed into ma_log_register_callback().

logLevel (in)

    The log level. This can be one of the following:

    +----------------------+

    | Log Level            |

    +----------------------+

    | MA_LOG_LEVEL_DEBUG   |

    | MA_LOG_LEVEL_INFO    |

    | MA_LOG_LEVEL_WARNING |

    | MA_LOG_LEVEL_ERROR   |

    +----------------------+

pMessage (in)

    The log message.

*/

typedef void (* ma_log_callback_proc)(void* pUserData, ma_uint32 level, const char* pMessage);

typedef struct

{

    ma_log_callback_proc onLog;

    void* pUserData;

} ma_log_callback;

MA_API ma_log_callback ma_log_callback_init(ma_log_callback_proc onLog, void* pUserData);

typedef struct

{

    ma_log_callback callbacks[MA_MAX_LOG_CALLBACKS];

    ma_uint32 callbackCount;

    ma_allocation_callbacks allocationCallbacks;    /* Need to store these persistently because ma_log_postv() might need to allocate a buffer on the heap. */

#ifndef MA_NO_THREADING

    ma_mutex lock;  /* For thread safety just to make it easier and safer for the logging implementation. */

#endif

} ma_log;

MA_API ma_result ma_log_init(const ma_allocation_callbacks* pAllocationCallbacks, ma_log* pLog);

MA_API void ma_log_uninit(ma_log* pLog);

MA_API ma_result ma_log_register_callback(ma_log* pLog, ma_log_callback callback);

MA_API ma_result ma_log_unregister_callback(ma_log* pLog, ma_log_callback callback);

MA_API ma_result ma_log_post(ma_log* pLog, ma_uint32 level, const char* pMessage);

MA_API ma_result ma_log_postv(ma_log* pLog, ma_uint32 level, const char* pFormat, va_list args);

MA_API ma_result ma_log_postf(ma_log* pLog, ma_uint32 level, const char* pFormat, ...) MA_ATTRIBUTE_FORMAT(3, 4);

/**************************************************************************************************************************************************************

Biquad Filtering

**************************************************************************************************************************************************************/

typedef union

{

    float    f32;

    ma_int32 s32;

} ma_biquad_coefficient;

typedef struct

{

    ma_format format;

    ma_uint32 channels;

    double b0;

    double b1;

    double b2;

    double a0;

    double a1;

    double a2;

} ma_biquad_config;

MA_API ma_biquad_config ma_biquad_config_init(ma_format format, ma_uint32 channels, double b0, double b1, double b2, double a0, double a1, double a2);

typedef struct

{

    ma_format format;

    ma_uint32 channels;

    ma_biquad_coefficient b0;

    ma_biquad_coefficient b1;

    ma_biquad_coefficient b2;

    ma_biquad_coefficient a1;

    ma_biquad_coefficient a2;

    ma_biquad_coefficient* pR1;

    ma_biquad_coefficient* pR2;

    /* Memory management. */

    void* _pHeap;

    ma_bool32 _ownsHeap;

} ma_biquad;

MA_API ma_result ma_biquad_get_heap_size(const ma_biquad_config* pConfig, size_t* pHeapSizeInBytes);

MA_API ma_result ma_biquad_init_preallocated(const ma_biquad_config* pConfig, void* pHeap, ma_biquad* pBQ);

MA_API ma_result ma_biquad_init(const ma_biquad_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_biquad* pBQ);

MA_API void ma_biquad_uninit(ma_biquad* pBQ, const ma_allocation_callbacks* pAllocationCallbacks);

MA_API ma_result ma_biquad_reinit(const ma_biquad_config* pConfig, ma_biquad* pBQ);

MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ);

MA_API ma_result ma_biquad_process_pcm_frames(ma_biquad* pBQ, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);

MA_API ma_uint32 ma_biquad_get_latency(const ma_biquad* pBQ);

/**************************************************************************************************************************************************************

Low-Pass Filtering

**************************************************************************************************************************************************************/

typedef struct

{

    ma_format format;

    ma_uint32 channels;

    ma_uint32 sampleRate;

    double cutoffFrequency;

    double q;

} ma_lpf1_config, ma_lpf2_config;

MA_API ma_lpf1_config ma_lpf1_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency);

MA_API ma_lpf2_config ma_lpf2_config_init(ma_format format, ma_uint32 channels, ma_uint32 sampleRate, double cutoffFrequency, double q);

typedef struct

{

    ma_format format;

    ma_uint32 channels;

    ma_biquad_coefficient a;

    ma_biquad_coefficient* pR1;

    /* Memory management. */

    void* _pHeap;

    ma_bool32 _ownsHeap;

} ma_lpf1;

MA_API ma_result ma_lpf1_get_heap_size(const ma_lpf1_config* pConfig, size_t* pHeapSizeInBytes);

MA_API ma_result ma_lpf1_init_preallocated(const ma_lpf1_config* pConfig, void* pHeap, ma_lpf1* pLPF);

MA_API ma_result ma_lpf1_init(const ma_lpf1_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf1* pLPF);

MA_API void ma_lpf1_uninit(ma_lpf1* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);

MA_API ma_result ma_lpf1_reinit(const ma_lpf1_config* pConfig, ma_lpf1* pLPF);

MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF);

MA_API ma_result ma_lpf1_process_pcm_frames(ma_lpf1* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);

MA_API ma_uint32 ma_lpf1_get_latency(const ma_lpf1* pLPF);

typedef struct

{

    ma_biquad bq;   /* The second order low-pass filter is implemented as a biquad filter. */

} ma_lpf2;

MA_API ma_result ma_lpf2_get_heap_size(const ma_lpf2_config* pConfig, size_t* pHeapSizeInBytes);