/*
Audio playback and capture library. Choice of public domain or MIT-0. See license statements at the end of this file.
-miniaudio - v0.11.6 - 2022-01-22
+miniaudio - v0.11.9 - 2022-04-20
David Reid - mackron@gmail.com
The start/stop time needs to be specified based on the absolute timer which is controlled by the
engine. The current global time time in PCM frames can be retrieved with `ma_engine_get_time()`.
The engine's global time can be changed with `ma_engine_set_time()` for synchronization purposes if
-required.
+required. Note that scheduling a start time still requires an explicit call to `ma_sound_start()`
+before anything will play:
+
+ ```c
+ ma_sound_set_start_time_in_pcm_frames(&sound, ma_engine_get_time(&engine) + (ma_engine_get_sample_rate(&engine) * 2);
+ ma_sound_start(&sound);
+ ```
The third parameter of `ma_sound_init_from_file()` is a set of flags that control how the sound be
loaded and a few options on which features should be enabled for that sound. By default, the sound
+----------------------------------+--------------------------------------------------------------------+
| MA_API | Controls how public APIs should be decorated. Default is `extern`. |
+----------------------------------+--------------------------------------------------------------------+
- | MA_DLL | If set, configures `MA_API` to either import or export APIs |
- | | depending on whether or not the implementation is being defined. |
- | | If defining the implementation, `MA_API` will be configured to |
- | | export. Otherwise it will be configured to import. This has no |
- | | effect if `MA_API` is defined externally. |
- +----------------------------------+--------------------------------------------------------------------+
3. Definitions
ma_sound_set_stop_time_in_pcm_frames(&sound, ma_engine_get_time(&engine) + (ma_engine_get_sample_rate(&engine) * 2));
```
+Note that scheduling a start time still requires an explicit call to `ma_sound_start()` before
+anything will play.
+
The time is specified in global time which is controlled by the engine. You can get the engine's
current time with `ma_engine_get_time()`. The engine's global time is incremented automatically as
audio data is read, but it can be reset with `ma_engine_set_time()` in case it needs to be
#define MA_VERSION_MAJOR 0
#define MA_VERSION_MINOR 11
-#define MA_VERSION_REVISION 6
+#define MA_VERSION_REVISION 9
#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__)
/* Platform/backend detection. */
#ifdef _WIN32
#define MA_WIN32
- #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
+ #if 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) && (WINAPI_FAMILY == WINAPI_FAMILY_GAMES)
+ #elif defined(WINAPI_FAMILY) && (defined(WINAPI_FAMILY_GAMES) && WINAPI_FAMILY == WINAPI_FAMILY_GAMES)
#define MA_WIN32_GDK
#else
#define MA_WIN32_DESKTOP
I am using "__inline__" only when we're compiling in strict ANSI mode.
*/
#if defined(__STRICT_ANSI__)
- #define MA_INLINE __inline__ __attribute__((always_inline))
+ #define MA_GNUC_INLINE_HINT __inline__
#else
- #define MA_INLINE inline __attribute__((always_inline))
+ #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))
+ #else
+ #define MA_INLINE MA_GNUC_INLINE_HINT
#endif
#elif defined(__WATCOMC__)
#define MA_INLINE __inline
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);
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);
MA_API ma_result ma_lpf2_init(const ma_lpf2_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf2* pLPF);
MA_API void ma_lpf2_uninit(ma_lpf2* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
MA_API ma_result ma_lpf2_reinit(const ma_lpf2_config* pConfig, ma_lpf2* pLPF);
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF);
MA_API ma_result ma_lpf2_process_pcm_frames(ma_lpf2* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
MA_API ma_uint32 ma_lpf2_get_latency(const ma_lpf2* pLPF);
MA_API ma_result ma_lpf_init(const ma_lpf_config* pConfig, const ma_allocation_callbacks* pAllocationCallbacks, ma_lpf* pLPF);
MA_API void ma_lpf_uninit(ma_lpf* pLPF, const ma_allocation_callbacks* pAllocationCallbacks);
MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF);
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF);
MA_API ma_result ma_lpf_process_pcm_frames(ma_lpf* pLPF, void* pFramesOut, const void* pFramesIn, ma_uint64 frameCount);
MA_API ma_uint32 ma_lpf_get_latency(const ma_lpf* pLPF);
MA_API ma_uint64 ma_linear_resampler_get_output_latency(const ma_linear_resampler* pResampler);
MA_API ma_result ma_linear_resampler_get_required_input_frame_count(const ma_linear_resampler* pResampler, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount);
MA_API ma_result ma_linear_resampler_get_expected_output_frame_count(const ma_linear_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler);
typedef struct ma_resampler_config ma_resampler_config;
ma_uint64 (* onGetOutputLatency )(void* pUserData, const ma_resampling_backend* pBackend); /* Optional. Latency will be reported as 0. */
ma_result (* onGetRequiredInputFrameCount )(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 outputFrameCount, ma_uint64* pInputFrameCount); /* Optional. Latency mitigation will be disabled. */
ma_result (* onGetExpectedOutputFrameCount)(void* pUserData, const ma_resampling_backend* pBackend, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount); /* Optional. Latency mitigation will be disabled. */
+ ma_result (* onReset )(void* pUserData, ma_resampling_backend* pBackend);
} ma_resampling_backend_vtable;
typedef enum
*/
MA_API ma_result ma_resampler_get_expected_output_frame_count(const ma_resampler* pResampler, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
+/*
+Resets the resampler's timer and clears it's internal cache.
+*/
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler);
+
/**************************************************************************************************************************************************************
MA_API ma_result ma_data_converter_get_expected_output_frame_count(const ma_data_converter* pConverter, ma_uint64 inputFrameCount, ma_uint64* pOutputFrameCount);
MA_API ma_result ma_data_converter_get_input_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
MA_API ma_result ma_data_converter_get_output_channel_map(const ma_data_converter* pConverter, ma_channel* pChannelMap, size_t channelMapCap);
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter);
/************************************************************************************************************************************************************
/*ma_resource_manager_data_buffer_node**/ void* pDataBufferNode;
char* pFilePath;
wchar_t* pFilePathW;
- ma_bool32 decode; /* When set to true, the data buffer will be decoded. Otherwise it'll be encoded and will use a decoder for the connector. */
+ ma_uint32 flags; /* Resource manager data source flags that were used when initializing the data buffer. */
ma_async_notification* pInitNotification; /* Signalled when the data buffer has been initialized and the format/channels/rate can be retrieved. */
ma_async_notification* pDoneNotification; /* Signalled when the data buffer has been fully decoded. Will be passed through to MA_JOB_TYPE_RESOURCE_MANAGER_PAGE_DATA_BUFFER_NODE when decoding. */
ma_fence* pInitFence; /* Released when initialization of the decoder is complete. */
ma_async_notification* pDoneNotification; /* Signalled when the data buffer has been fully decoded. */
ma_fence* pInitFence; /* Released when the data buffer has been initialized and the format/channels/rate can be retrieved. */
ma_fence* pDoneFence; /* Released when the data buffer has been fully decoded. */
+ ma_uint64 rangeBegInPCMFrames;
+ ma_uint64 rangeEndInPCMFrames;
+ ma_uint64 loopPointBegInPCMFrames;
+ ma_uint64 loopPointEndInPCMFrames;
+ ma_uint32 isLooping;
} loadDataBuffer;
struct
{
MA_API ma_result ma_data_source_get_cursor_in_seconds(ma_data_source* pDataSource, float* pCursor);
MA_API ma_result ma_data_source_get_length_in_seconds(ma_data_source* pDataSource, float* pLength);
MA_API ma_result ma_data_source_set_looping(ma_data_source* pDataSource, ma_bool32 isLooping);
-MA_API ma_bool32 ma_data_source_is_looping(ma_data_source* pDataSource);
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource);
MA_API ma_result ma_data_source_set_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 rangeBegInFrames, ma_uint64 rangeEndInFrames);
-MA_API void ma_data_source_get_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames);
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames);
MA_API ma_result ma_data_source_set_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64 loopBegInFrames, ma_uint64 loopEndInFrames);
-MA_API void ma_data_source_get_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames);
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames);
MA_API ma_result ma_data_source_set_current(ma_data_source* pDataSource, ma_data_source* pCurrentDataSource);
-MA_API ma_data_source* ma_data_source_get_current(ma_data_source* pDataSource);
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource);
MA_API ma_result ma_data_source_set_next(ma_data_source* pDataSource, ma_data_source* pNextDataSource);
-MA_API ma_data_source* ma_data_source_get_next(ma_data_source* pDataSource);
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource);
MA_API ma_result ma_data_source_set_next_callback(ma_data_source* pDataSource, ma_data_source_get_next_proc onGetNext);
-MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(ma_data_source* pDataSource);
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource);
typedef struct
ma_data_source_base ds;
ma_format format;
ma_uint32 channels;
+ ma_uint32 sampleRate;
ma_uint64 cursor;
ma_uint64 sizeInFrames;
const void* pData;
{
ma_format format;
ma_uint32 channels;
+ ma_uint32 sampleRate;
ma_uint64 sizeInFrames;
const void* pData; /* If set to NULL, will allocate a block of memory for you. */
ma_allocation_callbacks allocationCallbacks;
typedef enum
{
- MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM = 0x00000001, /* When set, does not load the entire data source in memory. Disk I/O will happen on job threads. */
- MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE = 0x00000002, /* Decode data before storing in memory. When set, decoding is done at the resource manager level rather than the mixing thread. Results in faster mixing, but higher memory usage. */
- MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC = 0x00000004, /* When set, the resource manager will load the data source asynchronously. */
- MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT = 0x00000008 /* When set, waits for initialization of the underlying data source before returning from ma_resource_manager_data_source_init(). */
+ MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_STREAM = 0x00000001, /* When set, does not load the entire data source in memory. Disk I/O will happen on job threads. */
+ MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE = 0x00000002, /* Decode data before storing in memory. When set, decoding is done at the resource manager level rather than the mixing thread. Results in faster mixing, but higher memory usage. */
+ MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_ASYNC = 0x00000004, /* When set, the resource manager will load the data source asynchronously. */
+ MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT = 0x00000008, /* When set, waits for initialization of the underlying data source before returning from ma_resource_manager_data_source_init(). */
+ MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH = 0x00000010 /* Gives the resource manager a hint that the length of the data source is unknown and calling `ma_data_source_get_length_in_pcm_frames()` should be avoided. */
} ma_resource_manager_data_source_flags;
{
ma_engine_node engineNode; /* Must be the first member for compatibility with the ma_node API. */
ma_data_source* pDataSource;
- ma_uint64 seekTarget; /* The PCM frame index to seek to in the mixing thread. Set to (~(ma_uint64)0) to not perform any seeking. */
+ MA_ATOMIC(8, ma_uint64) seekTarget; /* The PCM frame index to seek to in the mixing thread. Set to (~(ma_uint64)0) to not perform any seeking. */
MA_ATOMIC(4, ma_bool32) atEnd;
ma_bool8 ownsDataSource;
#if defined(MA_ARM)
#if !defined(MA_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
#define MA_SUPPORT_NEON
- #endif
-
- /* Fall back to looking for the #include file. */
- #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
- #if !defined(MA_SUPPORT_NEON) && !defined(MA_NO_NEON) && __has_include(<arm_neon.h>)
- #define MA_SUPPORT_NEON
- #endif
- #endif
-
- #if defined(MA_SUPPORT_NEON)
#include <arm_neon.h>
#endif
#endif
static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__dsound(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
{
- /* DirectSound has a minimum period size of 20ms. */
- ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(20, nativeSampleRate);
+ /*
+ DirectSound has a minimum period size of 20ms. In practice, this doesn't seem to be enough for
+ reliable glitch-free processing so going to use 30ms instead.
+ */
+ ma_uint32 minPeriodSizeInFrames = ma_calculate_buffer_size_in_frames_from_milliseconds(30, nativeSampleRate);
ma_uint32 periodSizeInFrames;
periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptor, nativeSampleRate, performanceProfile);
ma_device__on_notification_rerouted(pDevice);
}
+static ma_uint32 ma_calculate_period_size_in_frames_from_descriptor__pulse(const ma_device_descriptor* pDescriptor, ma_uint32 nativeSampleRate, ma_performance_profile performanceProfile)
+{
+ /*
+ There have been reports from users where buffers of < ~20ms result glitches when running through
+ PipeWire. To work around this we're going to have to use a different default buffer size.
+ */
+ const ma_uint32 defaultPeriodSizeInMilliseconds_LowLatency = 25;
+ const ma_uint32 defaultPeriodSizeInMilliseconds_Conservative = MA_DEFAULT_PERIOD_SIZE_IN_MILLISECONDS_CONSERVATIVE;
+
+ MA_ASSERT(nativeSampleRate != 0);
+
+ if (pDescriptor->periodSizeInFrames == 0) {
+ if (pDescriptor->periodSizeInMilliseconds == 0) {
+ if (performanceProfile == ma_performance_profile_low_latency) {
+ return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_LowLatency, nativeSampleRate);
+ } else {
+ return ma_calculate_buffer_size_in_frames_from_milliseconds(defaultPeriodSizeInMilliseconds_Conservative, nativeSampleRate);
+ }
+ } else {
+ return ma_calculate_buffer_size_in_frames_from_milliseconds(pDescriptor->periodSizeInMilliseconds, nativeSampleRate);
+ }
+ } else {
+ return pDescriptor->periodSizeInFrames;
+ }
+}
+
static ma_result ma_device_init__pulse(ma_device* pDevice, const ma_device_config* pConfig, ma_device_descriptor* pDescriptorPlayback, ma_device_descriptor* pDescriptorCapture)
{
/*
}
/* We now have enough information to calculate our actual period size in frames. */
- pDescriptorCapture->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorCapture, ss.rate, pConfig->performanceProfile);
+ pDescriptorCapture->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorCapture, ss.rate, pConfig->performanceProfile);
attr = ma_device__pa_buffer_attr_new(pDescriptorCapture->periodSizeInFrames, pDescriptorCapture->periodCount, &ss);
ma_log_postf(ma_device_get_log(pDevice), MA_LOG_LEVEL_INFO, "[PulseAudio] Capture attr: maxlength=%d, tlength=%d, prebuf=%d, minreq=%d, fragsize=%d; periodSizeInFrames=%d\n", attr.maxlength, attr.tlength, attr.prebuf, attr.minreq, attr.fragsize, pDescriptorCapture->periodSizeInFrames);
}
/* Internal channel map. */
- pActualCMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
- if (pActualCMap != NULL) {
- cmap = *pActualCMap;
- }
- for (iChannel = 0; iChannel < pDescriptorCapture->channels; ++iChannel) {
- pDescriptorCapture->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+ /*
+ Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+ the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+ and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+ all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+ fixed sooner than later. I might remove this hack later.
+ */
+ if (pDescriptorCapture->channels > 2) {
+ pActualCMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamCapture);
+ if (pActualCMap != NULL) {
+ cmap = *pActualCMap;
+ }
+
+ for (iChannel = 0; iChannel < pDescriptorCapture->channels; ++iChannel) {
+ pDescriptorCapture->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+ }
+ } else {
+ /* Hack for mono and stereo. */
+ if (pDescriptorCapture->channels == 1) {
+ pDescriptorCapture->channelMap[0] = MA_CHANNEL_MONO;
+ } else if (pDescriptorCapture->channels == 2) {
+ pDescriptorCapture->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+ pDescriptorCapture->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+ } else {
+ MA_ASSERT(MA_FALSE); /* Should never hit this. */
+ }
}
}
if (attr.fragsize > 0) {
- pDescriptorPlayback->periodCount = ma_max(attr.maxlength / attr.fragsize, 1);
+ pDescriptorCapture->periodCount = ma_max(attr.maxlength / attr.fragsize, 1);
} else {
- pDescriptorPlayback->periodCount = 1;
+ pDescriptorCapture->periodCount = 1;
}
pDescriptorCapture->periodSizeInFrames = attr.maxlength / ma_get_bytes_per_frame(pDescriptorCapture->format, pDescriptorCapture->channels) / pDescriptorCapture->periodCount;
}
/* We now have enough information to calculate the actual buffer size in frames. */
- pDescriptorPlayback->periodSizeInFrames = ma_calculate_buffer_size_in_frames_from_descriptor(pDescriptorPlayback, ss.rate, pConfig->performanceProfile);
+ pDescriptorPlayback->periodSizeInFrames = ma_calculate_period_size_in_frames_from_descriptor__pulse(pDescriptorPlayback, ss.rate, pConfig->performanceProfile);
attr = ma_device__pa_buffer_attr_new(pDescriptorPlayback->periodSizeInFrames, pDescriptorPlayback->periodCount, &ss);
}
/* Internal channel map. */
- pActualCMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
- if (pActualCMap != NULL) {
- cmap = *pActualCMap;
- }
- for (iChannel = 0; iChannel < pDescriptorPlayback->channels; ++iChannel) {
- pDescriptorPlayback->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+ /*
+ Bug in PipeWire. There have been reports that PipeWire is returning AUX channels when reporting
+ the channel map. To somewhat workaround this, I'm hacking in a hard coded channel map for mono
+ and stereo. In this case it should be safe to assume mono = MONO and stereo = LEFT/RIGHT. For
+ all other channel counts we need to just put up with whatever PipeWire reports and hope it gets
+ fixed sooner than later. I might remove this hack later.
+ */
+ if (pDescriptorPlayback->channels > 2) {
+ pActualCMap = ((ma_pa_stream_get_channel_map_proc)pDevice->pContext->pulse.pa_stream_get_channel_map)((ma_pa_stream*)pDevice->pulse.pStreamPlayback);
+ if (pActualCMap != NULL) {
+ cmap = *pActualCMap;
+ }
+
+ for (iChannel = 0; iChannel < pDescriptorPlayback->channels; ++iChannel) {
+ pDescriptorPlayback->channelMap[iChannel] = ma_channel_position_from_pulse(cmap.map[iChannel]);
+ }
+ } else {
+ /* Hack for mono and stereo. */
+ if (pDescriptorPlayback->channels == 1) {
+ pDescriptorPlayback->channelMap[0] = MA_CHANNEL_MONO;
+ } else if (pDescriptorPlayback->channels == 2) {
+ pDescriptorPlayback->channelMap[0] = MA_CHANNEL_FRONT_LEFT;
+ pDescriptorPlayback->channelMap[1] = MA_CHANNEL_FRONT_RIGHT;
+ } else {
+ MA_ASSERT(MA_FALSE); /* Should never hit this. */
+ }
}
-(void)dealloc
{
[self remove_handler];
+
+ #if defined(__has_feature)
+ #if !__has_feature(objc_arc)
+ [super dealloc];
+ #endif
+ #endif
}
-(void)remove_handler
}
if (ma_device_get_state(pDevice) == ma_device_state_started) {
- return MA_INVALID_OPERATION; /* Already started. Returning an error to let the application know because it probably means they're doing something wrong. */
+ return MA_SUCCESS; /* Already started. */
}
ma_mutex_lock(&pDevice->startStopLock);
}
if (ma_device_get_state(pDevice) == ma_device_state_stopped) {
- return MA_INVALID_OPERATION; /* Already stopped. Returning an error to let the application know because it probably means they're doing something wrong. */
+ return MA_SUCCESS; /* Already stopped. */
}
ma_mutex_lock(&pDevice->startStopLock);
return MA_SUCCESS;
}
+MA_API ma_result ma_biquad_clear_cache(ma_biquad* pBQ)
+{
+ if (pBQ == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ if (pBQ->format == ma_format_f32) {
+ pBQ->pR1->f32 = 0;
+ pBQ->pR2->f32 = 0;
+ } else {
+ pBQ->pR1->s32 = 0;
+ pBQ->pR2->s32 = 0;
+ }
+
+ return MA_SUCCESS;
+}
+
static MA_INLINE void ma_biquad_process_pcm_frame_f32__direct_form_2_transposed(ma_biquad* pBQ, float* pY, const float* pX)
{
ma_uint32 c;
return MA_SUCCESS;
}
+MA_API ma_result ma_lpf1_clear_cache(ma_lpf1* pLPF)
+{
+ if (pLPF == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ if (pLPF->format == ma_format_f32) {
+ pLPF->a.f32 = 0;
+ } else {
+ pLPF->a.s32 = 0;
+ }
+
+ return MA_SUCCESS;
+}
+
static MA_INLINE void ma_lpf1_process_pcm_frame_f32(ma_lpf1* pLPF, float* pY, const float* pX)
{
ma_uint32 c;
return MA_SUCCESS;
}
+MA_API ma_result ma_lpf2_clear_cache(ma_lpf2* pLPF)
+{
+ if (pLPF == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ ma_biquad_clear_cache(&pLPF->bq);
+
+ return MA_SUCCESS;
+}
+
static MA_INLINE void ma_lpf2_process_pcm_frame_s16(ma_lpf2* pLPF, ma_int16* pFrameOut, const ma_int16* pFrameIn)
{
ma_biquad_process_pcm_frame_s16(&pLPF->bq, pFrameOut, pFrameIn);
for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
ma_lpf2_uninit(&pLPF->pLPF2[ilpf2], pAllocationCallbacks);
}
+
+ if (pLPF->_ownsHeap) {
+ ma_free(pLPF->_pHeap, pAllocationCallbacks);
+ }
}
MA_API ma_result ma_lpf_reinit(const ma_lpf_config* pConfig, ma_lpf* pLPF)
return ma_lpf_reinit__internal(pConfig, NULL, pLPF, /*isNew*/MA_FALSE);
}
+MA_API ma_result ma_lpf_clear_cache(ma_lpf* pLPF)
+{
+ ma_uint32 ilpf1;
+ ma_uint32 ilpf2;
+
+ if (pLPF == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ for (ilpf1 = 0; ilpf1 < pLPF->lpf1Count; ilpf1 += 1) {
+ ma_lpf1_clear_cache(&pLPF->pLPF1[ilpf1]);
+ }
+
+ for (ilpf2 = 0; ilpf2 < pLPF->lpf2Count; ilpf2 += 1) {
+ ma_lpf2_clear_cache(&pLPF->pLPF2[ilpf2]);
+ }
+
+ return MA_SUCCESS;
+}
+
static MA_INLINE void ma_lpf_process_pcm_frame_f32(ma_lpf* pLPF, float* pY, const void* pX)
{
ma_uint32 ilpf1;
for (ihpf2 = 0; ihpf2 < pHPF->hpf2Count; ihpf2 += 1) {
ma_hpf2_uninit(&pHPF->pHPF2[ihpf2], pAllocationCallbacks);
}
+
+ if (pHPF->_ownsHeap) {
+ ma_free(pHPF->_pHeap, pAllocationCallbacks);
+ }
}
MA_API ma_result ma_hpf_reinit(const ma_hpf_config* pConfig, ma_hpf* pHPF)
for (ibpf2 = 0; ibpf2 < pBPF->bpf2Count; ibpf2 += 1) {
ma_bpf2_uninit(&pBPF->pBPF2[ibpf2], pAllocationCallbacks);
}
+
+ if (pBPF->_ownsHeap) {
+ ma_free(pBPF->_pHeap, pAllocationCallbacks);
+ }
}
MA_API ma_result ma_bpf_reinit(const ma_bpf_config* pConfig, ma_bpf* pBPF)
return MA_SUCCESS;
}
+MA_API ma_result ma_linear_resampler_reset(ma_linear_resampler* pResampler)
+{
+ ma_uint32 iChannel;
+
+ if (pResampler == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ /* Timers need to be cleared back to zero. */
+ pResampler->inTimeInt = 1; /* Set this to one to force an input sample to always be loaded for the first output frame. */
+ pResampler->inTimeFrac = 0;
+
+ /* Cached samples need to be cleared. */
+ if (pResampler->config.format == ma_format_f32) {
+ for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+ pResampler->x0.f32[iChannel] = 0;
+ pResampler->x1.f32[iChannel] = 0;
+ }
+ } else {
+ for (iChannel = 0; iChannel < pResampler->config.channels; iChannel += 1) {
+ pResampler->x0.s16[iChannel] = 0;
+ pResampler->x1.s16[iChannel] = 0;
+ }
+ }
+
+ /* The low pass filter needs to have it's cache reset. */
+ ma_lpf_clear_cache(&pResampler->lpf);
+
+ return MA_SUCCESS;
+}
+
+
/* Linear resampler backend vtable. */
static ma_linear_resampler_config ma_resampling_backend_get_config__linear(const ma_resampler_config* pConfig)
return ma_linear_resampler_get_expected_output_frame_count((const ma_linear_resampler*)pBackend, inputFrameCount, pOutputFrameCount);
}
+static ma_result ma_resampling_backend_reset__linear(void* pUserData, ma_resampling_backend* pBackend)
+{
+ (void)pUserData;
+
+ return ma_linear_resampler_reset((ma_linear_resampler*)pBackend);
+}
+
static ma_resampling_backend_vtable g_ma_linear_resampler_vtable =
{
ma_resampling_backend_get_heap_size__linear,
ma_resampling_backend_get_input_latency__linear,
ma_resampling_backend_get_output_latency__linear,
ma_resampling_backend_get_required_input_frame_count__linear,
- ma_resampling_backend_get_expected_output_frame_count__linear
+ ma_resampling_backend_get_expected_output_frame_count__linear,
+ ma_resampling_backend_reset__linear
};
return pResampler->pBackendVTable->onGetExpectedOutputFrameCount(pResampler->pBackendUserData, pResampler->pBackend, inputFrameCount, pOutputFrameCount);
}
+MA_API ma_result ma_resampler_reset(ma_resampler* pResampler)
+{
+ if (pResampler == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ if (pResampler->pBackendVTable == NULL || pResampler->pBackendVTable->onReset == NULL) {
+ return MA_NOT_IMPLEMENTED;
+ }
+
+ return pResampler->pBackendVTable->onReset(pResampler->pBackendUserData, pResampler->pBackend);
+}
+
/**************************************************************************************************************************************************************
Channel Conversion
MA_ASSERT(pConverter != NULL);
MA_ASSERT(pConverter->resampler.format == pConverter->channelConverter.format);
MA_ASSERT(pConverter->resampler.channels == pConverter->channelConverter.channelsOut);
- MA_ASSERT(pConverter->resampler.channels < pConverter->channelConverter.channelsIn);
+ MA_ASSERT(pConverter->resampler.channels <= pConverter->channelConverter.channelsIn);
frameCountIn = 0;
if (pFrameCountIn != NULL) {
return MA_SUCCESS;
}
+MA_API ma_result ma_data_converter_reset(ma_data_converter* pConverter)
+{
+ if (pConverter == NULL) {
+ return MA_INVALID_ARGS;
+ }
+
+ /* There's nothing to do if we're not resampling. */
+ if (pConverter->hasResampler == MA_FALSE) {
+ return MA_SUCCESS;
+ }
+
+ return ma_resampler_reset(&pConverter->resampler);
+}
+
/**************************************************************************************************************************************************************
return pDataSourceBase->vtable->onSetLooping(pDataSource, isLooping);
}
-MA_API ma_bool32 ma_data_source_is_looping(ma_data_source* pDataSource)
+MA_API ma_bool32 ma_data_source_is_looping(const ma_data_source* pDataSource)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return MA_FALSE;
return MA_SUCCESS;
}
-MA_API void ma_data_source_get_range_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames)
+MA_API void ma_data_source_get_range_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pRangeBegInFrames, ma_uint64* pRangeEndInFrames)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return;
return MA_SUCCESS;
}
-MA_API void ma_data_source_get_loop_point_in_pcm_frames(ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames)
+MA_API void ma_data_source_get_loop_point_in_pcm_frames(const ma_data_source* pDataSource, ma_uint64* pLoopBegInFrames, ma_uint64* pLoopEndInFrames)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return;
return MA_SUCCESS;
}
-MA_API ma_data_source* ma_data_source_get_current(ma_data_source* pDataSource)
+MA_API ma_data_source* ma_data_source_get_current(const ma_data_source* pDataSource)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return NULL;
return MA_SUCCESS;
}
-MA_API ma_data_source* ma_data_source_get_next(ma_data_source* pDataSource)
+MA_API ma_data_source* ma_data_source_get_next(const ma_data_source* pDataSource)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return NULL;
return MA_SUCCESS;
}
-MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(ma_data_source* pDataSource)
+MA_API ma_data_source_get_next_proc ma_data_source_get_next_callback(const ma_data_source* pDataSource)
{
- ma_data_source_base* pDataSourceBase = (ma_data_source_base*)pDataSource;
+ const ma_data_source_base* pDataSourceBase = (const ma_data_source_base*)pDataSource;
if (pDataSource == NULL) {
return NULL;
*pFormat = pAudioBufferRef->format;
*pChannels = pAudioBufferRef->channels;
- *pSampleRate = 0; /* There is no notion of a sample rate with audio buffers. */
+ *pSampleRate = pAudioBufferRef->sampleRate;
ma_channel_map_init_standard(ma_standard_channel_map_default, pChannelMap, channelMapCap, pAudioBufferRef->channels);
return MA_SUCCESS;
pAudioBufferRef->format = format;
pAudioBufferRef->channels = channels;
+ pAudioBufferRef->sampleRate = 0; /* TODO: Version 0.12. Set this to sampleRate. */
pAudioBufferRef->cursor = 0;
pAudioBufferRef->sizeInFrames = sizeInFrames;
pAudioBufferRef->pData = pData;
}
if (pFramesOut != NULL) {
- ma_copy_pcm_frames(pFramesOut, ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), framesToRead, pAudioBufferRef->format, pAudioBufferRef->channels);
+ ma_copy_pcm_frames(ma_offset_ptr(pFramesOut, totalFramesRead * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), ma_offset_ptr(pAudioBufferRef->pData, pAudioBufferRef->cursor * ma_get_bytes_per_frame(pAudioBufferRef->format, pAudioBufferRef->channels)), framesToRead, pAudioBufferRef->format, pAudioBufferRef->channels);
}
totalFramesRead += framesToRead;
ma_audio_buffer_config config;
MA_ZERO_OBJECT(&config);
- config.format = format;
- config.channels = channels;
+ config.format = format;
+ config.channels = channels;
+ config.sampleRate = 0; /* TODO: Version 0.12. Set this to sampleRate. */
config.sizeInFrames = sizeInFrames;
- config.pData = pData;
+ config.pData = pData;
ma_allocation_callbacks_init_copy(&config.allocationCallbacks, pAllocationCallbacks);
return config;
return result;
}
+ /* TODO: Version 0.12. Set this in ma_audio_buffer_ref_init() instead of here. */
+ pAudioBuffer->ref.sampleRate = pConfig->sampleRate;
+
ma_allocation_callbacks_init_copy(&pAudioBuffer->allocationCallbacks, &pConfig->allocationCallbacks);
if (doCopy) {
#define DRWAV_XSTRINGIFY(x) DRWAV_STRINGIFY(x)
#define DRWAV_VERSION_MAJOR 0
#define DRWAV_VERSION_MINOR 13
-#define DRWAV_VERSION_REVISION 4
+#define DRWAV_VERSION_REVISION 6
#define DRWAV_VERSION_STRING DRWAV_XSTRINGIFY(DRWAV_VERSION_MAJOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_MINOR) "." DRWAV_XSTRINGIFY(DRWAV_VERSION_REVISION)
#include <stddef.h>
typedef signed char drwav_int8;
#define DRFLAC_XSTRINGIFY(x) DRFLAC_STRINGIFY(x)
#define DRFLAC_VERSION_MAJOR 0
#define DRFLAC_VERSION_MINOR 12
-#define DRFLAC_VERSION_REVISION 34
+#define DRFLAC_VERSION_REVISION 38
#define DRFLAC_VERSION_STRING DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MAJOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_MINOR) "." DRFLAC_XSTRINGIFY(DRFLAC_VERSION_REVISION)
#include <stddef.h>
typedef signed char drflac_int8;
#define DRMP3_XSTRINGIFY(x) DRMP3_STRINGIFY(x)
#define DRMP3_VERSION_MAJOR 0
#define DRMP3_VERSION_MINOR 6
-#define DRMP3_VERSION_REVISION 32
+#define DRMP3_VERSION_REVISION 33
#define DRMP3_VERSION_STRING DRMP3_XSTRINGIFY(DRMP3_VERSION_MAJOR) "." DRMP3_XSTRINGIFY(DRMP3_VERSION_MINOR) "." DRMP3_XSTRINGIFY(DRMP3_VERSION_REVISION)
#include <stddef.h>
typedef signed char drmp3_int8;
#define DRMP3_INLINE __forceinline
#elif defined(__GNUC__)
#if defined(__STRICT_ANSI__)
- #define DRMP3_INLINE __inline__ __attribute__((always_inline))
+ #define DRMP3_GNUC_INLINE_HINT __inline__
#else
- #define DRMP3_INLINE inline __attribute__((always_inline))
+ #define DRMP3_GNUC_INLINE_HINT inline
+ #endif
+ #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+ #define DRMP3_INLINE DRMP3_GNUC_INLINE_HINT __attribute__((always_inline))
+ #else
+ #define DRMP3_INLINE DRMP3_GNUC_INLINE_HINT
#endif
#elif defined(__WATCOMC__)
#define DRMP3_INLINE __inline
ma_result result;
ma_uint64 internalFrameIndex;
ma_uint32 internalSampleRate;
+ ma_uint64 currentFrameIndex;
result = ma_data_source_get_data_format(pDecoder->pBackend, NULL, NULL, &internalSampleRate, NULL, 0);
if (result != MA_SUCCESS) {
internalFrameIndex = ma_calculate_frame_count_after_resampling(internalSampleRate, pDecoder->outputSampleRate, frameIndex);
}
- result = ma_data_source_seek_to_pcm_frame(pDecoder->pBackend, internalFrameIndex);
- if (result == MA_SUCCESS) {
- pDecoder->readPointerInPCMFrames = frameIndex;
+ /* Only seek if we're requesting a different frame to what we're currently sitting on. */
+ ma_data_source_get_cursor_in_pcm_frames(pDecoder->pBackend, ¤tFrameIndex);
+ if (currentFrameIndex != internalFrameIndex) {
+ result = ma_data_source_seek_to_pcm_frame(pDecoder->pBackend, internalFrameIndex);
+ if (result == MA_SUCCESS) {
+ pDecoder->readPointerInPCMFrames = frameIndex;
+ }
+
+ /* Reset the data converter so that any cached data in the resampler is cleared. */
+ ma_data_converter_reset(&pDecoder->converter);
}
return result;
};
}
-static ma_result ma_resource_manager_data_buffer_init_connector(ma_resource_manager_data_buffer* pDataBuffer, ma_async_notification* pInitNotification, ma_fence* pInitFence)
+static ma_result ma_resource_manager_data_buffer_init_connector(ma_resource_manager_data_buffer* pDataBuffer, const ma_resource_manager_data_source_config* pConfig, ma_async_notification* pInitNotification, ma_fence* pInitFence)
{
ma_result result;
MA_ASSERT(pDataBuffer != NULL);
+ MA_ASSERT(pConfig != NULL);
MA_ASSERT(pDataBuffer->isConnectorInitialized == MA_FALSE);
/* The underlying data buffer must be initialized before we'll be able to know how to initialize the backend. */
Make sure the looping state is set before returning in order to handle the case where the
loop state was set on the data buffer before the connector was initialized.
*/
- ma_data_source_set_looping(ma_resource_manager_data_buffer_get_connector(pDataBuffer), ma_resource_manager_data_buffer_is_looping(pDataBuffer));
+ ma_data_source_set_range_in_pcm_frames(pDataBuffer, pConfig->rangeBegInPCMFrames, pConfig->rangeEndInPCMFrames);
+ ma_data_source_set_loop_point_in_pcm_frames(pDataBuffer, pConfig->loopPointBegInPCMFrames, pConfig->loopPointEndInPCMFrames);
+ ma_data_source_set_looping(pDataBuffer, pConfig->isLooping);
pDataBuffer->isConnectorInitialized = MA_TRUE;
return MA_SUCCESS;
}
-static ma_result ma_resource_manager_data_buffer_node_init_supply_decoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW, ma_decoder** ppDecoder)
+static ma_result ma_resource_manager_data_buffer_node_init_supply_decoded(ma_resource_manager* pResourceManager, ma_resource_manager_data_buffer_node* pDataBufferNode, const char* pFilePath, const wchar_t* pFilePathW, ma_uint32 flags, ma_decoder** ppDecoder)
{
ma_result result = MA_SUCCESS;
ma_decoder* pDecoder;
allocated buffer, whereas a paged buffer is a linked list of paged-sized buffers. The latter
is used when the length of a sound is unknown until a full decode has been performed.
*/
- result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
- if (result != MA_SUCCESS) {
- return result;
+ if ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+ result = ma_decoder_get_length_in_pcm_frames(pDecoder, &totalFrameCount);
+ if (result != MA_SUCCESS) {
+ return result;
+ }
+ } else {
+ totalFrameCount = 0;
}
if (totalFrameCount > 0) {
job.data.resourceManager.loadDataBufferNode.pDataBufferNode = pDataBufferNode;
job.data.resourceManager.loadDataBufferNode.pFilePath = pFilePathCopy;
job.data.resourceManager.loadDataBufferNode.pFilePathW = pFilePathWCopy;
- job.data.resourceManager.loadDataBufferNode.decode = (flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE ) != 0;
+ job.data.resourceManager.loadDataBufferNode.flags = flags;
job.data.resourceManager.loadDataBufferNode.pInitNotification = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? pInitNotification : NULL;
job.data.resourceManager.loadDataBufferNode.pDoneNotification = NULL;
job.data.resourceManager.loadDataBufferNode.pInitFence = pInitFence;
} else {
/* Decoding. We do this the same way as we do when loading asynchronously. */
ma_decoder* pDecoder;
- result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW, &pDecoder);
+ result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pFilePath, pFilePathW, flags, &pDecoder);
if (result != MA_SUCCESS) {
goto done;
}
static ma_result ma_resource_manager_data_buffer_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
{
- return ma_resource_manager_data_buffer_set_looping((ma_resource_manager_data_buffer*)pDataSource, isLooping);
+ ma_resource_manager_data_buffer* pDataBuffer = (ma_resource_manager_data_buffer*)pDataSource;
+ MA_ASSERT(pDataBuffer != NULL);
+
+ c89atomic_exchange_32(&pDataBuffer->isLooping, isLooping);
+
+ /* The looping state needs to be set on the connector as well or else looping won't work when we read audio data. */
+ ma_data_source_set_looping(ma_resource_manager_data_buffer_get_connector(pDataBuffer), isLooping);
+
+ return MA_SUCCESS;
}
static ma_data_source_vtable g_ma_resource_manager_data_buffer_vtable =
/* If we're loading asynchronously we need to post a job to the job queue to initialize the connector. */
if (async == MA_FALSE || ma_resource_manager_data_buffer_node_result(pDataBufferNode) == MA_SUCCESS) {
/* Loading synchronously or the data has already been fully loaded. We can just initialize the connector from here without a job. */
- result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, NULL, NULL);
+ result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, pConfig, NULL, NULL);
c89atomic_exchange_i32(&pDataBuffer->result, result);
ma_resource_manager_pipeline_notifications_signal_all_notifications(¬ifications);
job = ma_job_init(MA_JOB_TYPE_RESOURCE_MANAGER_LOAD_DATA_BUFFER);
job.order = ma_resource_manager_data_buffer_next_execution_order(pDataBuffer);
- job.data.resourceManager.loadDataBuffer.pDataBuffer = pDataBuffer;
- job.data.resourceManager.loadDataBuffer.pInitNotification = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? &initNotification : notifications.init.pNotification;
- job.data.resourceManager.loadDataBuffer.pDoneNotification = notifications.done.pNotification;
- job.data.resourceManager.loadDataBuffer.pInitFence = notifications.init.pFence;
- job.data.resourceManager.loadDataBuffer.pDoneFence = notifications.done.pFence;
+ job.data.resourceManager.loadDataBuffer.pDataBuffer = pDataBuffer;
+ job.data.resourceManager.loadDataBuffer.pInitNotification = ((flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_WAIT_INIT) != 0) ? &initNotification : notifications.init.pNotification;
+ job.data.resourceManager.loadDataBuffer.pDoneNotification = notifications.done.pNotification;
+ job.data.resourceManager.loadDataBuffer.pInitFence = notifications.init.pFence;
+ job.data.resourceManager.loadDataBuffer.pDoneFence = notifications.done.pFence;
+ job.data.resourceManager.loadDataBuffer.rangeBegInPCMFrames = pConfig->rangeBegInPCMFrames;
+ job.data.resourceManager.loadDataBuffer.rangeEndInPCMFrames = pConfig->rangeEndInPCMFrames;
+ job.data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames = pConfig->loopPointBegInPCMFrames;
+ job.data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames = pConfig->loopPointEndInPCMFrames;
+ job.data.resourceManager.loadDataBuffer.isLooping = pConfig->isLooping;
result = ma_resource_manager_post_job(pResourceManager, &job);
if (result != MA_SUCCESS) {
MA_API ma_result ma_resource_manager_data_buffer_set_looping(ma_resource_manager_data_buffer* pDataBuffer, ma_bool32 isLooping)
{
- if (pDataBuffer == NULL) {
- return MA_INVALID_ARGS;
- }
-
- c89atomic_exchange_32(&pDataBuffer->isLooping, isLooping);
-
- /* The looping state needs to be set on the connector as well or else looping won't work when we read audio data. */
- ma_data_source_set_looping(ma_resource_manager_data_buffer_get_connector(pDataBuffer), isLooping);
-
- return MA_SUCCESS;
+ return ma_data_source_set_looping(pDataBuffer, isLooping);
}
MA_API ma_bool32 ma_resource_manager_data_buffer_is_looping(const ma_resource_manager_data_buffer* pDataBuffer)
{
- if (pDataBuffer == NULL) {
- return MA_FALSE;
- }
-
- return c89atomic_load_32((ma_bool32*)&pDataBuffer->isLooping);
+ return ma_data_source_is_looping(pDataBuffer);
}
MA_API ma_result ma_resource_manager_data_buffer_get_available_frames(ma_resource_manager_data_buffer* pDataBuffer, ma_uint64* pAvailableFrames)
static ma_result ma_resource_manager_data_stream_cb__set_looping(ma_data_source* pDataSource, ma_bool32 isLooping)
{
- return ma_resource_manager_data_stream_set_looping((ma_resource_manager_data_stream*)pDataSource, isLooping);
+ ma_resource_manager_data_stream* pDataStream = (ma_resource_manager_data_stream*)pDataSource;
+ MA_ASSERT(pDataStream != NULL);
+
+ c89atomic_exchange_32(&pDataStream->isLooping, isLooping);
+
+ return MA_SUCCESS;
}
static ma_data_source_vtable g_ma_resource_manager_data_stream_vtable =
return MA_INVALID_OPERATION;
}
+ /* If we're not already seeking and we're sitting on the same frame, just make this a no-op. */
+ if (c89atomic_load_32(&pDataStream->seekCounter) == 0) {
+ if (c89atomic_load_64(&pDataStream->absoluteCursor) == frameIndex) {
+ return MA_SUCCESS;
+ }
+ }
+
+
/* Increment the seek counter first to indicate to read_paged_pcm_frames() and map_paged_pcm_frames() that we are in the middle of a seek and MA_BUSY should be returned. */
c89atomic_fetch_add_32(&pDataStream->seekCounter, 1);
MA_API ma_result ma_resource_manager_data_stream_set_looping(ma_resource_manager_data_stream* pDataStream, ma_bool32 isLooping)
{
- if (pDataStream == NULL) {
- return MA_INVALID_ARGS;
- }
-
- c89atomic_exchange_32(&pDataStream->isLooping, isLooping);
-
- return MA_SUCCESS;
+ return ma_data_source_set_looping(pDataStream, isLooping);
}
MA_API ma_bool32 ma_resource_manager_data_stream_is_looping(const ma_resource_manager_data_stream* pDataStream)
will determine that the node is available for data delivery and the data buffer connectors can be
initialized. Therefore, it's important that it is set after the data supply has been initialized.
*/
- if (pJob->data.resourceManager.loadDataBufferNode.decode) {
+ if ((pJob->data.resourceManager.loadDataBufferNode.flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_DECODE) != 0) {
/*
Decoding. This is the complex case because we're not going to be doing the entire decoding
process here. Instead it's going to be split of multiple jobs and loaded in pages. The
ma_job pageDataBufferNodeJob;
/* Allocate the decoder by initializing a decoded data supply. */
- result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW, &pDecoder);
+ result = ma_resource_manager_data_buffer_node_init_supply_decoded(pResourceManager, pDataBufferNode, pJob->data.resourceManager.loadDataBufferNode.pFilePath, pJob->data.resourceManager.loadDataBufferNode.pFilePathW, pJob->data.resourceManager.loadDataBufferNode.flags, &pDecoder);
/*
Don't ever propagate an MA_BUSY result code or else the resource manager will think the
if (dataSupplyType != ma_resource_manager_data_supply_type_unknown) {
/* We can now initialize the connector. If this fails, we need to abort. It's very rare for this to fail. */
- result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, pJob->data.resourceManager.loadDataBuffer.pInitNotification, pJob->data.resourceManager.loadDataBuffer.pInitFence);
+ ma_resource_manager_data_source_config dataSourceConfig; /* For setting initial looping state and range. */
+ dataSourceConfig = ma_resource_manager_data_source_config_init();
+ dataSourceConfig.rangeBegInPCMFrames = pJob->data.resourceManager.loadDataBuffer.rangeBegInPCMFrames;
+ dataSourceConfig.rangeEndInPCMFrames = pJob->data.resourceManager.loadDataBuffer.rangeEndInPCMFrames;
+ dataSourceConfig.loopPointBegInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointBegInPCMFrames;
+ dataSourceConfig.loopPointEndInPCMFrames = pJob->data.resourceManager.loadDataBuffer.loopPointEndInPCMFrames;
+ dataSourceConfig.isLooping = pJob->data.resourceManager.loadDataBuffer.isLooping;
+
+ result = ma_resource_manager_data_buffer_init_connector(pDataBuffer, &dataSourceConfig, pJob->data.resourceManager.loadDataBuffer.pInitNotification, pJob->data.resourceManager.loadDataBuffer.pInitFence);
if (result != MA_SUCCESS) {
ma_log_postf(ma_resource_manager_get_log(pResourceManager), MA_LOG_LEVEL_ERROR, "Failed to initialize connector for data buffer. %s.\n", ma_result_description(result));
goto done;
}
/* Retrieve the total length of the file before marking the decoder are loaded. */
- result = ma_decoder_get_length_in_pcm_frames(&pDataStream->decoder, &pDataStream->totalLengthInPCMFrames);
- if (result != MA_SUCCESS) {
- goto done; /* Failed to retrieve the length. */
+ if ((pDataStream->flags & MA_RESOURCE_MANAGER_DATA_SOURCE_FLAG_UNKNOWN_LENGTH) == 0) {
+ result = ma_decoder_get_length_in_pcm_frames(&pDataStream->decoder, &pDataStream->totalLengthInPCMFrames);
+ if (result != MA_SUCCESS) {
+ goto done; /* Failed to retrieve the length. */
+ }
+ } else {
+ pDataStream->totalLengthInPCMFrames = 0;
}
/*
ma_uint32 dataSourceChannels;
ma_uint8 temp[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 tempCapInFrames;
+ ma_uint64 seekTarget;
/* This is a data source node which means no input buses. */
(void)ppFramesIn;
}
/* If we're seeking, do so now before reading. */
- if (pSound->seekTarget != MA_SEEK_TARGET_NONE) {
- ma_data_source_seek_to_pcm_frame(pSound->pDataSource, pSound->seekTarget);
+ seekTarget = c89atomic_load_64(&pSound->seekTarget);
+ if (seekTarget != MA_SEEK_TARGET_NONE) {
+ ma_data_source_seek_to_pcm_frame(pSound->pDataSource, seekTarget);
/* Any time-dependant effects need to have their times updated. */
- ma_node_set_time(pSound, pSound->seekTarget);
+ ma_node_set_time(pSound, seekTarget);
- pSound->seekTarget = MA_SEEK_TARGET_NONE;
+ c89atomic_exchange_64(&pSound->seekTarget, MA_SEEK_TARGET_NONE);
}
/*
return MA_INVALID_OPERATION;
}
- /*
- Resource manager data sources are thread safe which means we can just seek immediately. However, we cannot guarantee that other data sources are
- thread safe as well so in that case we'll need to get the mixing thread to seek for us to ensure we don't try seeking at the same time as reading.
- */
-#ifndef MA_NO_RESOURCE_MANAGER
- if (pSound->pDataSource == pSound->pResourceManagerDataSource) {
- ma_result result = ma_resource_manager_data_source_seek_to_pcm_frame(pSound->pResourceManagerDataSource, frameIndex);
- if (result != MA_SUCCESS) {
- return result;
- }
-
- /* Time dependant effects need to have their timers updated. */
- return ma_node_set_time(&pSound->engineNode, frameIndex);
- }
-#endif
-
- /* Getting here means the data source is not a resource manager data source so we'll need to get the mixing thread to do the seeking for us. */
- pSound->seekTarget = frameIndex;
+ /* We can't be seeking while reading at the same time. We just set the seek target and get the mixing thread to do the actual seek. */
+ c89atomic_exchange_64(&pSound->seekTarget, frameIndex);
return MA_SUCCESS;
}
#define DRWAV_INLINE __forceinline
#elif defined(__GNUC__)
#if defined(__STRICT_ANSI__)
- #define DRWAV_INLINE __inline__ __attribute__((always_inline))
+ #define DRWAV_GNUC_INLINE_HINT __inline__
+ #else
+ #define DRWAV_GNUC_INLINE_HINT inline
+ #endif
+ #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+ #define DRWAV_INLINE DRWAV_GNUC_INLINE_HINT __attribute__((always_inline))
#else
- #define DRWAV_INLINE inline __attribute__((always_inline))
+ #define DRWAV_INLINE DRWAV_GNUC_INLINE_HINT
#endif
#elif defined(__WATCOMC__)
#define DRWAV_INLINE __inline
fmtOut->extendedSize = 0;
fmtOut->validBitsPerSample = 0;
fmtOut->channelMask = 0;
- memset(fmtOut->subFormat, 0, sizeof(fmtOut->subFormat));
+ DRWAV_ZERO_MEMORY(fmtOut->subFormat, sizeof(fmtOut->subFormat));
if (header.sizeInBytes > 16) {
drwav_uint8 fmt_cbSize[2];
int bytesReadSoFar = 0;
DRWAV_PRIVATE drwav_result drwav__metadata_alloc(drwav__metadata_parser* pParser, drwav_allocation_callbacks* pAllocationCallbacks)
{
if (pParser->extraCapacity != 0 || pParser->metadataCount != 0) {
- free(pParser->pData);
+ pAllocationCallbacks->onFree(pParser->pData, pAllocationCallbacks->pUserData);
pParser->pData = (drwav_uint8*)pAllocationCallbacks->onMalloc(drwav__metadata_memory_capacity(pParser), pAllocationCallbacks->pUserData);
pParser->pDataCursor = pParser->pData;
if (pParser->pData == NULL) {
}
return bytesRead;
}
+DRWAV_PRIVATE size_t drwav__strlen(const char* str)
+{
+ size_t result = 0;
+ while (*str++) {
+ result += 1;
+ }
+ return result;
+}
DRWAV_PRIVATE size_t drwav__strlen_clamped(const char* str, size_t maxToRead)
{
size_t result = 0;
if (len) {
char* result = (char*)drwav__metadata_get_memory(pParser, len + 1, 1);
DRWAV_ASSERT(result != NULL);
- memcpy(result, str, len);
+ DRWAV_COPY_MEMORY(result, str, len);
result[len] = '\0';
return result;
} else {
pMetadata->data.bext.pCodingHistory = (char*)drwav__metadata_get_memory(pParser, extraBytes + 1, 1);
DRWAV_ASSERT(pMetadata->data.bext.pCodingHistory != NULL);
bytesRead += drwav__metadata_parser_read(pParser, pMetadata->data.bext.pCodingHistory, extraBytes, NULL);
- pMetadata->data.bext.codingHistorySize = (drwav_uint32)strlen(pMetadata->data.bext.pCodingHistory);
+ pMetadata->data.bext.codingHistorySize = (drwav_uint32)drwav__strlen(pMetadata->data.bext.pCodingHistory);
} else {
pMetadata->data.bext.pCodingHistory = NULL;
pMetadata->data.bext.codingHistorySize = 0;
if (bytesJustRead != DRWAV_BEXT_DESCRIPTION_BYTES) {
return bytesRead;
}
- allocSizeNeeded += strlen(buffer) + 1;
+ allocSizeNeeded += drwav__strlen(buffer) + 1;
buffer[DRWAV_BEXT_ORIGINATOR_NAME_BYTES] = '\0';
bytesJustRead = drwav__metadata_parser_read(pParser, buffer, DRWAV_BEXT_ORIGINATOR_NAME_BYTES, &bytesRead);
if (bytesJustRead != DRWAV_BEXT_ORIGINATOR_NAME_BYTES) {
return bytesRead;
}
- allocSizeNeeded += strlen(buffer) + 1;
+ allocSizeNeeded += drwav__strlen(buffer) + 1;
buffer[DRWAV_BEXT_ORIGINATOR_REF_BYTES] = '\0';
bytesJustRead = drwav__metadata_parser_read(pParser, buffer, DRWAV_BEXT_ORIGINATOR_REF_BYTES, &bytesRead);
if (bytesJustRead != DRWAV_BEXT_ORIGINATOR_REF_BYTES) {
return bytesRead;
}
- allocSizeNeeded += strlen(buffer) + 1;
+ allocSizeNeeded += drwav__strlen(buffer) + 1;
allocSizeNeeded += (size_t)pChunkHeader->sizeInBytes - DRWAV_BEXT_BYTES;
drwav__metadata_request_extra_memory_for_stage_2(pParser, allocSizeNeeded, 1);
pParser->metadataCount += 1;
if (translatedFormatTag == DR_WAVE_FORMAT_EXTENSIBLE) {
translatedFormatTag = drwav_bytes_to_u16(fmt.subFormat + 0);
}
- memset(&metadataParser, 0, sizeof(metadataParser));
+ DRWAV_ZERO_MEMORY(&metadataParser, sizeof(metadataParser));
if (!sequential && pWav->allowedMetadataTypes != drwav_metadata_type_none && (pWav->container == drwav_container_riff || pWav->container == drwav_container_rf64)) {
drwav_uint64 cursorForMetadata = cursor;
metadataParser.onRead = pWav->onRead;
bytesWritten += drwav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxTruePeakLevel);
bytesWritten += drwav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxMomentaryLoudness);
bytesWritten += drwav__write_or_count_u16ne_to_le(pWav, pMetadata->data.bext.maxShortTermLoudness);
- memset(reservedBuf, 0, sizeof(reservedBuf));
+ DRWAV_ZERO_MEMORY(reservedBuf, sizeof(reservedBuf));
bytesWritten += drwav__write_or_count(pWav, reservedBuf, sizeof(reservedBuf));
if (pMetadata->data.bext.codingHistorySize > 0) {
bytesWritten += drwav__write_or_count(pWav, pMetadata->data.bext.pCodingHistory, pMetadata->data.bext.codingHistorySize);
if (pWav->totalPCMFrameCount == 0) {
return DRWAV_TRUE;
}
- if (targetFrameIndex >= pWav->totalPCMFrameCount) {
- targetFrameIndex = pWav->totalPCMFrameCount - 1;
+ if (targetFrameIndex > pWav->totalPCMFrameCount) {
+ targetFrameIndex = pWav->totalPCMFrameCount;
}
if (drwav__is_compressed_format_tag(pWav->translatedFormatTag)) {
if (targetFrameIndex < pWav->readCursorInPCMFrames) {
#define DRFLAC_INLINE __forceinline
#elif defined(__GNUC__)
#if defined(__STRICT_ANSI__)
- #define DRFLAC_INLINE __inline__ __attribute__((always_inline))
+ #define DRFLAC_GNUC_INLINE_HINT __inline__
+ #else
+ #define DRFLAC_GNUC_INLINE_HINT inline
+ #endif
+ #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 2)) || defined(__clang__)
+ #define DRFLAC_INLINE DRFLAC_GNUC_INLINE_HINT __attribute__((always_inline))
#else
- #define DRFLAC_INLINE inline __attribute__((always_inline))
+ #define DRFLAC_INLINE DRFLAC_GNUC_INLINE_HINT
#endif
#elif defined(__WATCOMC__)
#define DRFLAC_INLINE __inline
#define DRFLAC_X64
#elif defined(__i386) || defined(_M_IX86)
#define DRFLAC_X86
-#elif defined(__arm__) || defined(_M_ARM) || defined(_M_ARM64)
+#elif defined(__arm__) || defined(_M_ARM) || defined(__arm64) || defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64)
#define DRFLAC_ARM
#endif
#if !defined(DR_FLAC_NO_SIMD)
#if defined(DRFLAC_ARM)
#if !defined(DRFLAC_NO_NEON) && (defined(__ARM_NEON) || defined(__aarch64__) || defined(_M_ARM64))
#define DRFLAC_SUPPORT_NEON
- #endif
- #if !defined(__GNUC__) && !defined(__clang__) && defined(__has_include)
- #if !defined(DRFLAC_SUPPORT_NEON) && !defined(DRFLAC_NO_NEON) && __has_include(<arm_neon.h>)
- #define DRFLAC_SUPPORT_NEON
- #endif
- #endif
- #if defined(DRFLAC_SUPPORT_NEON)
#include <arm_neon.h>
#endif
#endif
if (!drflac__reload_cache(bs)) {
return DRFLAC_FALSE;
}
+ if (bitCountLo > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ return DRFLAC_FALSE;
+ }
*pResultOut = (resultHi << bitCountLo) | (drflac_uint32)DRFLAC_CACHE_L1_SELECT_AND_SHIFT(bs, bitCountLo);
bs->consumedBits += bitCountLo;
bs->cache <<= bitCountLo;
return DRFLAC_FALSE;
}
}
+ if (bs->cache == 1) {
+ *pOffsetOut = zeroCounter + (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs) - 1;
+ if (!drflac__reload_cache(bs)) {
+ return DRFLAC_FALSE;
+ }
+ return DRFLAC_TRUE;
+ }
setBitOffsetPlus1 = drflac__clz(bs->cache);
setBitOffsetPlus1 += 1;
+ if (setBitOffsetPlus1 > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ return DRFLAC_FALSE;
+ }
bs->consumedBits += setBitOffsetPlus1;
bs->cache <<= setBitOffsetPlus1;
*pOffsetOut = zeroCounter + setBitOffsetPlus1 - 1;
*pCRCOut = crc;
return DRFLAC_SUCCESS;
}
+static DRFLAC_INLINE drflac_uint32 drflac__ilog2_u32(drflac_uint32 x)
+{
+#if 1
+ drflac_uint32 result = 0;
+ while (x > 0) {
+ result += 1;
+ x >>= 1;
+ }
+ return result;
+#endif
+}
+static DRFLAC_INLINE drflac_bool32 drflac__use_64_bit_prediction(drflac_uint32 bitsPerSample, drflac_uint32 order, drflac_uint32 precision)
+{
+ return bitsPerSample + precision + drflac__ilog2_u32(order) > 32;
+}
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
static DRFLAC_INLINE drflac_int32 drflac__calculate_prediction_32(drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
{
drflac_int32 prediction = 0;
return (drflac_int32)(prediction >> shift);
}
#if 0
-static drflac_bool32 drflac__decode_samples_with_residual__rice__reference(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+static drflac_bool32 drflac__decode_samples_with_residual__rice__reference(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
drflac_uint32 i;
DRFLAC_ASSERT(bs != NULL);
} else {
decodedRice = (decodedRice >> 1);
}
- if (bitsPerSample+shift >= 32) {
- pSamplesOut[i] = decodedRice + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + i);
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[i] = decodedRice + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
} else {
- pSamplesOut[i] = decodedRice + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + i);
+ pSamplesOut[i] = decodedRice + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
}
}
return DRFLAC_TRUE;
if (!drflac__reload_cache(bs)) {
return DRFLAC_FALSE;
}
+ if (bitCountLo > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ return DRFLAC_FALSE;
+ }
}
riceParamPart = (drflac_uint32)(resultHi | DRFLAC_CACHE_L1_SELECT_AND_SHIFT_SAFE(bs, bitCountLo));
bs->consumedBits += bitCountLo;
if (!drflac__reload_cache(bs)) {
return DRFLAC_FALSE;
}
+ if (riceParamPartLoBitCount > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ return DRFLAC_FALSE;
+ }
bs_cache = bs->cache;
bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
}
if (!drflac__reload_cache(bs)) {
return DRFLAC_FALSE;
}
+ if (riceParamPartLoBitCount > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
+ return DRFLAC_FALSE;
+ }
bs_cache = bs->cache;
bs_consumedBits = bs->consumedBits + riceParamPartLoBitCount;
}
}
return DRFLAC_TRUE;
}
-static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+static drflac_bool32 drflac__decode_samples_with_residual__rice__scalar(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
drflac_uint32 t[2] = {0x00000000, 0xFFFFFFFF};
drflac_uint32 zeroCountPart0 = 0;
drflac_uint32 i;
DRFLAC_ASSERT(bs != NULL);
DRFLAC_ASSERT(pSamplesOut != NULL);
- if (order == 0) {
- return drflac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ if (lpcOrder == 0) {
+ return drflac__decode_samples_with_residual__rice__scalar_zeroorder(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
}
riceParamMask = (drflac_uint32)~((~0UL) << riceParam);
pSamplesOutEnd = pSamplesOut + (count & ~3);
- if (bitsPerSample+shift > 32) {
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
while (pSamplesOut < pSamplesOutEnd) {
if (!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart0, &riceParamPart0) ||
!drflac__read_rice_parts_x1(bs, riceParam, &zeroCountPart1, &riceParamPart1) ||
riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
- pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 0);
- pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 1);
- pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 2);
- pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 3);
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+ pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+ pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
pSamplesOut += 4;
}
} else {
riceParamPart1 = (riceParamPart1 >> 1) ^ t[riceParamPart1 & 0x01];
riceParamPart2 = (riceParamPart2 >> 1) ^ t[riceParamPart2 & 0x01];
riceParamPart3 = (riceParamPart3 >> 1) ^ t[riceParamPart3 & 0x01];
- pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 0);
- pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 1);
- pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 2);
- pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 3);
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
+ pSamplesOut[1] = riceParamPart1 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 1);
+ pSamplesOut[2] = riceParamPart2 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 2);
+ pSamplesOut[3] = riceParamPart3 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 3);
pSamplesOut += 4;
}
}
riceParamPart0 &= riceParamMask;
riceParamPart0 |= (zeroCountPart0 << riceParam);
riceParamPart0 = (riceParamPart0 >> 1) ^ t[riceParamPart0 & 0x01];
- if (bitsPerSample+shift > 32) {
- pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + 0);
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
} else {
- pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + 0);
+ pSamplesOut[0] = riceParamPart0 + drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + 0);
}
i += 1;
pSamplesOut += 1;
}
return DRFLAC_TRUE;
}
-static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+static drflac_bool32 drflac__decode_samples_with_residual__rice__sse41(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
DRFLAC_ASSERT(bs != NULL);
DRFLAC_ASSERT(pSamplesOut != NULL);
- if (order > 0 && order <= 12) {
- if (bitsPerSample+shift > 32) {
- return drflac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, order, shift, coefficients, pSamplesOut);
+ if (lpcOrder > 0 && lpcOrder <= 12) {
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ return drflac__decode_samples_with_residual__rice__sse41_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
} else {
- return drflac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__sse41_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
}
} else {
- return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
}
}
#endif
}
return DRFLAC_TRUE;
}
-static drflac_bool32 drflac__decode_samples_with_residual__rice__neon(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+static drflac_bool32 drflac__decode_samples_with_residual__rice__neon(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
DRFLAC_ASSERT(bs != NULL);
DRFLAC_ASSERT(pSamplesOut != NULL);
- if (order > 0 && order <= 12) {
- if (bitsPerSample+shift > 32) {
- return drflac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, order, shift, coefficients, pSamplesOut);
+ if (lpcOrder > 0 && lpcOrder <= 12) {
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ return drflac__decode_samples_with_residual__rice__neon_64(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
} else {
- return drflac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__neon_32(bs, count, riceParam, lpcOrder, lpcShift, coefficients, pSamplesOut);
}
} else {
- return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
}
}
#endif
-static drflac_bool32 drflac__decode_samples_with_residual__rice(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+static drflac_bool32 drflac__decode_samples_with_residual__rice(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 riceParam, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
#if defined(DRFLAC_SUPPORT_SSE41)
if (drflac__gIsSSE41Supported) {
- return drflac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__sse41(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
} else
#elif defined(DRFLAC_SUPPORT_NEON)
if (drflac__gIsNEONSupported) {
- return drflac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__neon(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
} else
#endif
{
#if 0
- return drflac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__reference(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
#else
- return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, order, shift, coefficients, pSamplesOut);
+ return drflac__decode_samples_with_residual__rice__scalar(bs, bitsPerSample, count, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pSamplesOut);
#endif
}
}
}
return DRFLAC_TRUE;
}
-static drflac_bool32 drflac__decode_samples_with_residual__unencoded(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 unencodedBitsPerSample, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
+#if defined(__clang__)
+__attribute__((no_sanitize("signed-integer-overflow")))
+#endif
+static drflac_bool32 drflac__decode_samples_with_residual__unencoded(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 count, drflac_uint8 unencodedBitsPerSample, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pSamplesOut)
{
drflac_uint32 i;
DRFLAC_ASSERT(bs != NULL);
} else {
pSamplesOut[i] = 0;
}
- if (bitsPerSample >= 24) {
- pSamplesOut[i] += drflac__calculate_prediction_64(order, shift, coefficients, pSamplesOut + i);
+ if (drflac__use_64_bit_prediction(bitsPerSample, lpcOrder, lpcPrecision)) {
+ pSamplesOut[i] += drflac__calculate_prediction_64(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
} else {
- pSamplesOut[i] += drflac__calculate_prediction_32(order, shift, coefficients, pSamplesOut + i);
+ pSamplesOut[i] += drflac__calculate_prediction_32(lpcOrder, lpcShift, coefficients, pSamplesOut + i);
}
}
return DRFLAC_TRUE;
}
-static drflac_bool32 drflac__decode_samples_with_residual(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 blockSize, drflac_uint32 order, drflac_int32 shift, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
+static drflac_bool32 drflac__decode_samples_with_residual(drflac_bs* bs, drflac_uint32 bitsPerSample, drflac_uint32 blockSize, drflac_uint32 lpcOrder, drflac_int32 lpcShift, drflac_uint32 lpcPrecision, const drflac_int32* coefficients, drflac_int32* pDecodedSamples)
{
drflac_uint8 residualMethod;
drflac_uint8 partitionOrder;
if (residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE && residualMethod != DRFLAC_RESIDUAL_CODING_METHOD_PARTITIONED_RICE2) {
return DRFLAC_FALSE;
}
- pDecodedSamples += order;
+ pDecodedSamples += lpcOrder;
if (!drflac__read_uint8(bs, 4, &partitionOrder)) {
return DRFLAC_FALSE;
}
if (partitionOrder > 8) {
return DRFLAC_FALSE;
}
- if ((blockSize / (1 << partitionOrder)) < order) {
+ if ((blockSize / (1 << partitionOrder)) < lpcOrder) {
return DRFLAC_FALSE;
}
- samplesInPartition = (blockSize / (1 << partitionOrder)) - order;
+ samplesInPartition = (blockSize / (1 << partitionOrder)) - lpcOrder;
partitionsRemaining = (1 << partitionOrder);
for (;;) {
drflac_uint8 riceParam = 0;
}
}
if (riceParam != 0xFF) {
- if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, order, shift, coefficients, pDecodedSamples)) {
+ if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
return DRFLAC_FALSE;
}
} else {
if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
return DRFLAC_FALSE;
}
- if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, order, shift, coefficients, pDecodedSamples)) {
+ if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
return DRFLAC_FALSE;
}
}
}
pDecodedSamples[i] = sample;
}
- if (!drflac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) {
+ if (!drflac__decode_samples_with_residual(bs, subframeBitsPerSample, blockSize, lpcOrder, 0, 4, lpcCoefficientsTable[lpcOrder], pDecodedSamples)) {
return DRFLAC_FALSE;
}
return DRFLAC_TRUE;
return DRFLAC_FALSE;
}
}
- if (!drflac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, coefficients, pDecodedSamples)) {
+ if (!drflac__decode_samples_with_residual(bs, bitsPerSample, blockSize, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
return DRFLAC_FALSE;
}
return DRFLAC_TRUE;
return DRFLAC_FALSE;
}
crc8 = drflac_crc8(crc8, header->blockSizeInPCMFrames, 16);
+ if (header->blockSizeInPCMFrames == 0xFFFF) {
+ return DRFLAC_FALSE;
+ }
header->blockSizeInPCMFrames += 1;
} else {
DRFLAC_ASSERT(blockSize >= 8);
if (header->bitsPerSample == 0) {
header->bitsPerSample = streaminfoBitsPerSample;
}
+ if (header->bitsPerSample != streaminfoBitsPerSample) {
+ return DRFLAC_FALSE;
+ }
if (!drflac__read_uint8(bs, 8, &header->crc8)) {
return DRFLAC_FALSE;
}
} else if (frame->header.channelAssignment == DRFLAC_CHANNEL_ASSIGNMENT_RIGHT_SIDE && subframeIndex == 0) {
subframeBitsPerSample += 1;
}
+ if (subframeBitsPerSample > 32) {
+ return DRFLAC_FALSE;
+ }
if (pSubframe->wastedBitsPerSample >= subframeBitsPerSample) {
return DRFLAC_FALSE;
}
#ifndef DR_FLAC_NO_OGG
if (init.container == drflac_container_ogg) {
drflac_oggbs* pInternalOggbs = (drflac_oggbs*)((drflac_uint8*)pFlac->pDecodedSamples + decodedSamplesAllocationSize + seektableSize);
- *pInternalOggbs = oggbs;
+ DRFLAC_COPY_MEMORY(pInternalOggbs, &oggbs, sizeof(oggbs));
pFlac->bs.onRead = drflac__on_read_ogg;
pFlac->bs.onSeek = drflac__on_seek_ogg;
pFlac->bs.pUserData = (void*)pInternalOggbs;
vst1_lane_s16(dstl + (49 + i)*nch, pcmb, 2);
#endif
#else
+ #if DRMP3_HAVE_SSE
static const drmp3_f4 g_scale = { 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f, 1.0f/32768.0f };
+ #else
+ const drmp3_f4 g_scale = vdupq_n_f32(1.0f/32768.0f);
+ #endif
a = DRMP3_VMUL(a, g_scale);
b = DRMP3_VMUL(b, g_scale);
#if DRMP3_HAVE_SSE
}
}
}
-#include <math.h>
#if defined(SIZE_MAX)
#define DRMP3_SIZE_MAX SIZE_MAX
#else
}
return a;
}
-static DRMP3_INLINE double drmp3_sin(double x)
-{
- return sin(x);
-}
-static DRMP3_INLINE double drmp3_exp(double x)
-{
- return exp(x);
-}
-static DRMP3_INLINE double drmp3_cos(double x)
-{
- return drmp3_sin((DRMP3_PI_D*0.5) - x);
-}
static void* drmp3__malloc_default(size_t sz, void* pUserData)
{
(void)pUserData;
projects / vg.git / blobdiff