App-MHFS
view release on metacpan or search on metacpan
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
{
ma_int32 state;
} ma_lcg;
/* 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_WIN32)
typedef ma_handle ma_thread;
#endif
#if defined(MA_POSIX)
typedef ma_pthread_t ma_thread;
#endif
#if defined(MA_WIN32)
typedef ma_handle ma_mutex;
#endif
#if defined(MA_POSIX)
typedef ma_pthread_mutex_t ma_mutex;
#endif
#if defined(MA_WIN32)
typedef ma_handle ma_event;
#endif
#if defined(MA_POSIX)
typedef struct
{
ma_uint32 value;
ma_pthread_mutex_t lock;
ma_pthread_cond_t cond;
} ma_event;
#endif /* MA_POSIX */
#if defined(MA_WIN32)
typedef ma_handle ma_semaphore;
#endif
#if defined(MA_POSIX)
typedef struct
{
int value;
ma_pthread_mutex_t lock;
ma_pthread_cond_t cond;
} ma_semaphore;
#endif /* MA_POSIX */
#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)
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
MA_API ma_result ma_semaphore_init(int initialValue, ma_semaphore* pSemaphore)
{
if (pSemaphore == NULL) {
MA_ASSERT(MA_FALSE); /* Fire an assert so the caller is aware of this bug. */
return MA_INVALID_ARGS;
}
#ifdef MA_WIN32
return ma_semaphore_init__win32(initialValue, pSemaphore);
#endif
#ifdef MA_POSIX
return ma_semaphore_init__posix(initialValue, pSemaphore);
#endif
}
MA_API void ma_semaphore_uninit(ma_semaphore* pSemaphore)
{
if (pSemaphore == NULL) {
MA_ASSERT(MA_FALSE); /* Fire an assert so the caller is aware of this bug. */
return;
}
#ifdef MA_WIN32
ma_semaphore_uninit__win32(pSemaphore);
#endif
#ifdef MA_POSIX
ma_semaphore_uninit__posix(pSemaphore);
#endif
}
MA_API ma_result ma_semaphore_wait(ma_semaphore* pSemaphore)
{
if (pSemaphore == NULL) {
MA_ASSERT(MA_FALSE); /* Fire an assert so the caller is aware of this bug. */
return MA_INVALID_ARGS;
}
#ifdef MA_WIN32
return ma_semaphore_wait__win32(pSemaphore);
#endif
#ifdef MA_POSIX
return ma_semaphore_wait__posix(pSemaphore);
#endif
}
MA_API ma_result ma_semaphore_release(ma_semaphore* pSemaphore)
{
if (pSemaphore == NULL) {
MA_ASSERT(MA_FALSE); /* Fire an assert so the caller is aware of this bug. */
return MA_INVALID_ARGS;
}
#ifdef MA_WIN32
return ma_semaphore_release__win32(pSemaphore);
#endif
#ifdef MA_POSIX
return ma_semaphore_release__posix(pSemaphore);
#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 */
#define MA_FENCE_COUNTER_MAX 0x7FFFFFFF
MA_API ma_result ma_fence_init(ma_fence* pFence)
{
if (pFence == NULL) {
return MA_INVALID_ARGS;
}
MA_ZERO_OBJECT(pFence);
pFence->counter = 0;
#ifndef MA_NO_THREADING
{
ma_result result;
result = ma_event_init(&pFence->e);
if (result != MA_SUCCESS) {
return result;
}
}
#endif
return MA_SUCCESS;
}
MA_API void ma_fence_uninit(ma_fence* pFence)
{
if (pFence == NULL) {
return;
}
#ifndef MA_NO_THREADING
{
ma_event_uninit(&pFence->e);
}
#endif
MA_ZERO_OBJECT(pFence);
}
MA_API ma_result ma_fence_acquire(ma_fence* pFence)
{
if (pFence == NULL) {
return MA_INVALID_ARGS;
}
for (;;) {
ma_uint32 oldCounter = c89atomic_load_32(&pFence->counter);
ma_uint32 newCounter = oldCounter + 1;
/* Make sure we're not about to exceed our maximum value. */
if (newCounter > MA_FENCE_COUNTER_MAX) {
MA_ASSERT(MA_FALSE);
share/public_html/static/music_worklet_inprogress/decoder/deps/miniaudio/miniaudio.h view on Meta::CPAN
static ma_result ma_context_uninit__jack(ma_context* pContext)
{
MA_ASSERT(pContext != NULL);
MA_ASSERT(pContext->backend == ma_backend_jack);
ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
pContext->jack.pClientName = NULL;
#ifndef MA_NO_RUNTIME_LINKING
ma_dlclose(pContext, pContext->jack.jackSO);
#endif
return MA_SUCCESS;
}
static ma_result ma_context_init__jack(ma_context* pContext, const ma_context_config* pConfig, ma_backend_callbacks* pCallbacks)
{
#ifndef MA_NO_RUNTIME_LINKING
const char* libjackNames[] = {
#ifdef MA_WIN32
"libjack.dll",
"libjack64.dll"
#else
"libjack.so",
"libjack.so.0"
#endif
};
size_t i;
for (i = 0; i < ma_countof(libjackNames); ++i) {
pContext->jack.jackSO = ma_dlopen(pContext, libjackNames[i]);
if (pContext->jack.jackSO != NULL) {
break;
}
}
if (pContext->jack.jackSO == NULL) {
return MA_NO_BACKEND;
}
pContext->jack.jack_client_open = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_client_open");
pContext->jack.jack_client_close = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_client_close");
pContext->jack.jack_client_name_size = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_client_name_size");
pContext->jack.jack_set_process_callback = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_set_process_callback");
pContext->jack.jack_set_buffer_size_callback = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_set_buffer_size_callback");
pContext->jack.jack_on_shutdown = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_on_shutdown");
pContext->jack.jack_get_sample_rate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_get_sample_rate");
pContext->jack.jack_get_buffer_size = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_get_buffer_size");
pContext->jack.jack_get_ports = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_get_ports");
pContext->jack.jack_activate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_activate");
pContext->jack.jack_deactivate = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_deactivate");
pContext->jack.jack_connect = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_connect");
pContext->jack.jack_port_register = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_register");
pContext->jack.jack_port_name = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_name");
pContext->jack.jack_port_get_buffer = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_port_get_buffer");
pContext->jack.jack_free = (ma_proc)ma_dlsym(pContext, pContext->jack.jackSO, "jack_free");
#else
/*
This strange assignment system is here just to ensure type safety of miniaudio's function pointer
types. If anything differs slightly the compiler should throw a warning.
*/
ma_jack_client_open_proc _jack_client_open = jack_client_open;
ma_jack_client_close_proc _jack_client_close = jack_client_close;
ma_jack_client_name_size_proc _jack_client_name_size = jack_client_name_size;
ma_jack_set_process_callback_proc _jack_set_process_callback = jack_set_process_callback;
ma_jack_set_buffer_size_callback_proc _jack_set_buffer_size_callback = jack_set_buffer_size_callback;
ma_jack_on_shutdown_proc _jack_on_shutdown = jack_on_shutdown;
ma_jack_get_sample_rate_proc _jack_get_sample_rate = jack_get_sample_rate;
ma_jack_get_buffer_size_proc _jack_get_buffer_size = jack_get_buffer_size;
ma_jack_get_ports_proc _jack_get_ports = jack_get_ports;
ma_jack_activate_proc _jack_activate = jack_activate;
ma_jack_deactivate_proc _jack_deactivate = jack_deactivate;
ma_jack_connect_proc _jack_connect = jack_connect;
ma_jack_port_register_proc _jack_port_register = jack_port_register;
ma_jack_port_name_proc _jack_port_name = jack_port_name;
ma_jack_port_get_buffer_proc _jack_port_get_buffer = jack_port_get_buffer;
ma_jack_free_proc _jack_free = jack_free;
pContext->jack.jack_client_open = (ma_proc)_jack_client_open;
pContext->jack.jack_client_close = (ma_proc)_jack_client_close;
pContext->jack.jack_client_name_size = (ma_proc)_jack_client_name_size;
pContext->jack.jack_set_process_callback = (ma_proc)_jack_set_process_callback;
pContext->jack.jack_set_buffer_size_callback = (ma_proc)_jack_set_buffer_size_callback;
pContext->jack.jack_on_shutdown = (ma_proc)_jack_on_shutdown;
pContext->jack.jack_get_sample_rate = (ma_proc)_jack_get_sample_rate;
pContext->jack.jack_get_buffer_size = (ma_proc)_jack_get_buffer_size;
pContext->jack.jack_get_ports = (ma_proc)_jack_get_ports;
pContext->jack.jack_activate = (ma_proc)_jack_activate;
pContext->jack.jack_deactivate = (ma_proc)_jack_deactivate;
pContext->jack.jack_connect = (ma_proc)_jack_connect;
pContext->jack.jack_port_register = (ma_proc)_jack_port_register;
pContext->jack.jack_port_name = (ma_proc)_jack_port_name;
pContext->jack.jack_port_get_buffer = (ma_proc)_jack_port_get_buffer;
pContext->jack.jack_free = (ma_proc)_jack_free;
#endif
if (pConfig->jack.pClientName != NULL) {
pContext->jack.pClientName = ma_copy_string(pConfig->jack.pClientName, &pContext->allocationCallbacks);
}
pContext->jack.tryStartServer = pConfig->jack.tryStartServer;
/*
Getting here means the JACK library is installed, but it doesn't necessarily mean it's usable. We need to quickly test this by connecting
a temporary client.
*/
{
ma_jack_client_t* pDummyClient;
ma_result result = ma_context_open_client__jack(pContext, &pDummyClient);
if (result != MA_SUCCESS) {
ma_free(pContext->jack.pClientName, &pContext->allocationCallbacks);
#ifndef MA_NO_RUNTIME_LINKING
ma_dlclose(pContext, pContext->jack.jackSO);
#endif
return MA_NO_BACKEND;
}
((ma_jack_client_close_proc)pContext->jack.jack_client_close)((ma_jack_client_t*)pDummyClient);
}
( run in 1.553 second using v1.01-cache-2.11-cpan-5837b0d9d2c )