Skip to content

M
miniaudio
Commit 2209234a authored by David Reid's avatar David Reid
Browse files
Options

Remove ma_effect.

parent 0e8a19ee
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 527 deletions
research/miniaudio_engine.h
View file @ 2209234a
...@@ -948,62 +948,6 @@ MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_al ...@@ -948,62 +948,6 @@ MA_API void ma_splitter_node_uninit(ma_splitter_node* pSplitterNode, const ma_al
/*
Effects
=======
The `ma_effect` API is a mid-level API for chaining together effects. This is a wrapper around lower level APIs which you can continue to use by themselves if
this API does not work for you.
Effects can be linked together as a chain, with one input and one output. When processing audio data through an effect, it starts at the top of the chain and
works it's way down.
Usage
-----
To apply the effect to some audio data, do something like the following:
```c
ma_uint64 framesToProcessIn = availableInputFrameCount;
ma_uint64 framesToProcessOut = frameCountOut;
ma_result result = ma_effect_process_pcm_frames(pEffect, pFramesIn, &framesToProcessIn, pFramesOut, &framesToProcessOut);
if (result != MA_SUCCESS) {
// Error.
}
// At this point framesToProcessIn contains the number of input frames that were consumed and framesToProcessOut contains the number of output frames that
// were processed.
```
Some effects can change the sample rate, which means the number of output frames may be different to the number of input frames consumed. Therefore they both
need to be specified when processing a chunk of audio data.
*/
#define MA_EFFECT_MIN_INPUT_STREAM_COUNT 1
#define MA_EFFECT_MAX_INPUT_STREAM_COUNT 4
typedef void ma_effect;
typedef struct ma_effect_base ma_effect_base;
struct ma_effect_base
{
ma_result (* onProcessPCMFrames)(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
ma_uint64 (* onGetRequiredInputFrameCount)(ma_effect* pEffect, ma_uint64 outputFrameCount);
ma_uint64 (* onGetExpectedOutputFrameCount)(ma_effect* pEffect, ma_uint64 inputFrameCount);
ma_result (* onGetInputDataFormat)(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
ma_result (* onGetOutputDataFormat)(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
};
MA_API ma_result ma_effect_process_pcm_frames(ma_effect* pEffect, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
MA_API ma_result ma_effect_process_pcm_frames_ex(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut);
MA_API ma_result ma_effect_process_pcm_frames_with_conversion(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut, ma_format formatIn, ma_uint32 channelsIn, ma_format formatOut, ma_uint32 channelsOut);
MA_API ma_uint64 ma_effect_get_required_input_frame_count(ma_effect* pEffect, ma_uint64 outputFrameCount);
MA_API ma_uint64 ma_effect_get_expected_output_frame_count(ma_effect* pEffect, ma_uint64 inputFrameCount);
MA_API ma_result ma_effect_get_output_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
MA_API ma_result ma_effect_get_input_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate);
/* /*
Resource Manager Data Source Flags Resource Manager Data Source Flags
================================== ==================================
...@@ -3714,247 +3658,6 @@ static ma_uint32 ma_ffs_32(ma_uint32 x) ...@@ -3714,247 +3658,6 @@ static ma_uint32 ma_ffs_32(ma_uint32 x)
MA_API ma_result ma_effect_process_pcm_frames(ma_effect* pEffect, const void* pFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
{
return ma_effect_process_pcm_frames_ex(pEffect, 1, &pFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
}
MA_API ma_result ma_effect_process_pcm_frames_ex(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
{
ma_effect_base* pBase = (ma_effect_base*)pEffect;
if (pEffect == NULL || pBase->onProcessPCMFrames == NULL) {
return MA_INVALID_ARGS;
}
return pBase->onProcessPCMFrames(pEffect, inputStreamCount, ppFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
}
MA_API ma_result ma_effect_process_pcm_frames_with_conversion(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut, ma_format formatIn, ma_uint32 channelsIn, ma_format formatOut, ma_uint32 channelsOut)
{
ma_result result;
ma_format effectFormatIn;
ma_uint32 effectChannelsIn;
ma_format effectFormatOut;
ma_uint32 effectChannelsOut;
if (inputStreamCount < MA_EFFECT_MIN_INPUT_STREAM_COUNT || inputStreamCount > MA_EFFECT_MAX_INPUT_STREAM_COUNT) {
return MA_INVALID_ARGS;
}
/* First thing to retrieve the effect's input and output format to determine if conversion is necessary. */
result = ma_effect_get_input_data_format(pEffect, &effectFormatIn, &effectChannelsIn, NULL);
if (result != MA_SUCCESS) {
return result;
}
result = ma_effect_get_output_data_format(pEffect, &effectFormatOut, &effectChannelsOut, NULL);
if (result != MA_SUCCESS) {
return result;
}
if (effectFormatIn == formatIn && effectChannelsIn == channelsIn && effectFormatOut == formatOut && effectChannelsOut == channelsOut) {
/* Fast path. No need for any data conversion. */
return ma_effect_process_pcm_frames_ex(pEffect, inputStreamCount, ppFramesIn, pFrameCountIn, pFramesOut, pFrameCountOut);
} else {
/* Slow path. Getting here means we need to do pre- and/or post-data conversion. */
ma_uint8 effectInBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 effectInBufferCap = sizeof(effectInBuffer) / ma_get_bytes_per_frame(effectFormatIn, effectChannelsIn) / inputStreamCount;
ma_uint8 effectOutBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 effectOutBufferCap = sizeof(effectOutBuffer) / ma_get_bytes_per_frame(effectFormatOut, effectChannelsOut);
ma_uint64 totalFramesProcessedIn = 0;
ma_uint64 totalFramesProcessedOut = 0;
ma_uint64 frameCountIn = *pFrameCountIn;
ma_uint64 frameCountOut = *pFrameCountOut;
while (totalFramesProcessedIn < frameCountIn && totalFramesProcessedOut < frameCountOut) {
ma_uint32 iInputStream;
ma_uint64 framesToProcessThisIterationIn;
ma_uint64 framesToProcessThisIterationOut;
const void* ppRunningFramesIn[MA_EFFECT_MAX_INPUT_STREAM_COUNT];
/* */ void* pRunningFramesOut = ma_offset_ptr(pFramesOut, totalFramesProcessedOut * ma_get_bytes_per_frame(formatOut, channelsOut));
for (iInputStream = 0; iInputStream < inputStreamCount; iInputStream += 1) {
ppRunningFramesIn[iInputStream] = ma_offset_ptr(ppFramesIn[iInputStream], totalFramesProcessedIn * ma_get_bytes_per_frame(formatIn, channelsIn));
}
framesToProcessThisIterationOut = frameCountOut - totalFramesProcessedOut;
if (framesToProcessThisIterationOut > effectOutBufferCap) {
framesToProcessThisIterationOut = effectOutBufferCap;
}
framesToProcessThisIterationIn = ma_effect_get_required_input_frame_count(pEffect, framesToProcessThisIterationOut);
if (framesToProcessThisIterationIn > (frameCountIn - totalFramesProcessedIn)) {
framesToProcessThisIterationIn = (frameCountIn - totalFramesProcessedIn);
}
if (framesToProcessThisIterationIn > effectInBufferCap) {
framesToProcessThisIterationIn = effectInBufferCap;
}
/* At this point our input data has been converted to the effect's input format, so now we need to run the effect, making sure we output to the intermediary buffer. */
if (effectFormatIn == formatIn && effectChannelsIn == channelsIn) {
/* Fast path. No input conversion required. */
if (effectFormatOut == formatOut && effectChannelsOut == channelsOut) {
/* Fast path. Neither input nor output data conversion required. */
ma_effect_process_pcm_frames_ex(pEffect, inputStreamCount, ppRunningFramesIn, &framesToProcessThisIterationIn, pRunningFramesOut, &framesToProcessThisIterationOut);
} else {
/* Slow path. Output conversion required. */
ma_effect_process_pcm_frames_ex(pEffect, inputStreamCount, ppRunningFramesIn, &framesToProcessThisIterationIn, effectOutBuffer, &framesToProcessThisIterationOut);
ma_convert_pcm_frames_format_and_channels(pRunningFramesOut, formatOut, channelsOut, effectOutBuffer, effectFormatOut, effectChannelsOut, framesToProcessThisIterationOut, ma_dither_mode_none);
}
} else {
/* Slow path. Input conversion required. */
void* ppEffectInBuffer[MA_EFFECT_MAX_INPUT_STREAM_COUNT];
for (iInputStream = 0; iInputStream < inputStreamCount; iInputStream += 1) {
ppEffectInBuffer[iInputStream] = ma_offset_ptr(effectInBuffer, effectInBufferCap * iInputStream);
ma_convert_pcm_frames_format_and_channels(ppEffectInBuffer[iInputStream], effectFormatIn, effectChannelsIn, ppRunningFramesIn[iInputStream], formatIn, channelsIn, framesToProcessThisIterationIn, ma_dither_mode_none);
}
if (effectFormatOut == formatOut && effectChannelsOut == channelsOut) {
/* Fast path. No output format conversion required. */
ma_effect_process_pcm_frames_ex(pEffect, inputStreamCount, (const void**)&ppEffectInBuffer[0], &framesToProcessThisIterationIn, pRunningFramesOut, &framesToProcessThisIterationOut);
} else {
/* Slow path. Output format conversion required. */
ma_effect_process_pcm_frames_ex(pEffect, inputStreamCount, (const void**)&ppEffectInBuffer[0], &framesToProcessThisIterationIn, effectOutBuffer, &framesToProcessThisIterationOut);
ma_convert_pcm_frames_format_and_channels(pRunningFramesOut, formatOut, channelsOut, effectOutBuffer, effectFormatOut, effectChannelsOut, framesToProcessThisIterationOut, ma_dither_mode_none);
}
}
totalFramesProcessedIn += framesToProcessThisIterationIn;
totalFramesProcessedOut += framesToProcessThisIterationOut;
}
}
return MA_SUCCESS;
}
static ma_uint64 ma_effect_get_required_input_frame_count_local(ma_effect* pEffect, ma_uint64 outputFrameCount)
{
ma_effect_base* pBase = (ma_effect_base*)pEffect;
MA_ASSERT(pEffect != NULL);
if (pBase->onGetRequiredInputFrameCount) {
return pBase->onGetRequiredInputFrameCount(pEffect, outputFrameCount);
} else {
/* If there is no callback, assume a 1:1 mapping. */
return outputFrameCount;
}
}
MA_API ma_uint64 ma_effect_get_required_input_frame_count(ma_effect* pEffect, ma_uint64 outputFrameCount)
{
if (pEffect == NULL) {
return 0;
}
return ma_effect_get_required_input_frame_count_local(pEffect, outputFrameCount);
}
static ma_uint64 ma_effect_get_expected_output_frame_count_local(ma_effect* pEffect, ma_uint64 inputFrameCount)
{
ma_effect_base* pBase = (ma_effect_base*)pEffect;
MA_ASSERT(pEffect != NULL);
if (pBase->onGetExpectedOutputFrameCount) {
return pBase->onGetExpectedOutputFrameCount(pEffect, inputFrameCount);
} else {
/* If there is no callback, assume a 1:1 mapping. */
return inputFrameCount;
}
}
MA_API ma_uint64 ma_effect_get_expected_output_frame_count(ma_effect* pEffect, ma_uint64 inputFrameCount)
{
if (pEffect == NULL) {
return 0;
}
return ma_effect_get_expected_output_frame_count_local(pEffect, inputFrameCount);
}
MA_API ma_result ma_effect_get_output_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
ma_effect_base* pBaseEffect = (ma_effect_base*)pEffect;
ma_result result;
ma_format format;
ma_uint32 channels;
ma_uint32 sampleRate;
if (pFormat != NULL) {
*pFormat = ma_format_unknown;
}
if (pChannels != NULL) {
*pChannels = 0;
}
if (pSampleRate != NULL) {
*pSampleRate = 0;
}
if (pBaseEffect == NULL || pBaseEffect->onGetOutputDataFormat == NULL) {
return MA_INVALID_ARGS;
}
result = pBaseEffect->onGetOutputDataFormat(pEffect, &format, &channels, &sampleRate);
if (result != MA_SUCCESS) {
return result;
}
if (pFormat != NULL) {
*pFormat = format;
}
if (pChannels != NULL) {
*pChannels = channels;
}
if (pSampleRate != NULL) {
*pSampleRate = sampleRate;
}
return MA_SUCCESS;
}
MA_API ma_result ma_effect_get_input_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
ma_effect_base* pBase = (ma_effect_base*)pEffect;
ma_result result;
ma_format format;
ma_uint32 channels;
ma_uint32 sampleRate;
if (pFormat != NULL) {
*pFormat = ma_format_unknown;
}
if (pChannels != NULL) {
*pChannels = 0;
}
if (pSampleRate != NULL) {
*pSampleRate = 0;
}
result = pBase->onGetInputDataFormat(pEffect, &format, &channels, &sampleRate);
if (result != MA_SUCCESS) {
return result;
}
if (pFormat != NULL) {
*pFormat = format;
}
if (pChannels != NULL) {
*pChannels = channels;
}
if (pSampleRate != NULL) {
*pSampleRate = sampleRate;
}
return MA_SUCCESS;
}
#if 0 #if 0
static void ma_accumulate_and_clip_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count) static void ma_accumulate_and_clip_u8(ma_uint8* pDst, const ma_int16* pSrc, ma_uint64 count)
{ {
...@@ -4512,136 +4215,6 @@ static ma_result ma_volume_and_accumulate_and_clip_pcm_frames(void* pDst, const ...@@ -4512,136 +4215,6 @@ static ma_result ma_volume_and_accumulate_and_clip_pcm_frames(void* pDst, const
} }
#endif #endif
static ma_result ma_volume_and_clip_and_effect_pcm_frames(void* pDst, ma_format formatOut, ma_uint32 channelsOut, ma_uint64 frameCountOut, const void* pSrc, ma_format formatIn, ma_uint32 channelsIn, ma_uint64 frameCountIn, float volume, ma_effect* pEffect, ma_bool32 isAccumulation)
{
ma_result result;
ma_uint8 effectBufferIn[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 effectBufferInCapInFrames;
ma_uint8 effectBufferOut[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 effectBufferOutCapInFrames;
ma_format effectFormatIn;
ma_uint32 effectChannelsIn;
ma_format effectFormatOut;
ma_uint32 effectChannelsOut;
ma_uint64 totalFramesProcessedOut = 0;
ma_uint64 totalFramesProcessedIn = 0;
/* */ void* pRunningDst = pDst;
const void* pRunningSrc = pSrc;
if (pDst == NULL || pSrc == NULL || pEffect == NULL) {
return MA_INVALID_ARGS;
}
/* No op if silent. */
if (volume == 0) {
return MA_SUCCESS;
}
/* We need to know the effect's input and output formats so we can do pre- and post-effect data conversion if necessary. */
ma_effect_get_input_data_format( pEffect, &effectFormatIn, &effectChannelsIn, NULL);
ma_effect_get_output_data_format(pEffect, &effectFormatOut, &effectChannelsOut, NULL);
effectBufferInCapInFrames = sizeof(effectBufferIn ) / ma_get_bytes_per_frame(effectFormatIn, effectChannelsIn );
effectBufferOutCapInFrames = sizeof(effectBufferOut) / ma_get_bytes_per_frame(effectFormatOut, effectChannelsOut);
while (totalFramesProcessedOut < frameCountOut && totalFramesProcessedIn < frameCountIn) {
ma_uint64 effectFrameCountIn;
ma_uint64 effectFrameCountOut;
effectFrameCountOut = frameCountOut - totalFramesProcessedOut;
if (effectFrameCountOut > effectBufferOutCapInFrames) {
effectFrameCountOut = effectBufferOutCapInFrames;
}
effectFrameCountIn = ma_effect_get_required_input_frame_count(pEffect, effectFrameCountOut);
if (effectFrameCountIn > frameCountIn - totalFramesProcessedIn) {
effectFrameCountIn = frameCountIn - totalFramesProcessedIn;
}
if (effectFrameCountIn > effectBufferInCapInFrames) {
effectFrameCountIn = effectBufferInCapInFrames;
}
/*
The first step is to get the data ready for the effect. If the effect's input format and channels are the same as the source buffer, we just
clip the accumulation buffer straight input the effect's input buffer. Otherwise need to do a conversion.
*/
if (effectFormatIn == formatIn && effectChannelsIn == channelsIn) {
/* Fast path. No data conversion required for the input data except clipping. */
ma_volume_and_clip_pcm_frames(effectBufferIn, pRunningSrc, effectFrameCountIn, formatIn, channelsIn, volume);
} else {
/* Slow path. Data conversion required between the input data and the effect input data. */
ma_uint8 clippedSrcBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 clippedSrcBufferCapInFrames = sizeof(clippedSrcBuffer) / ma_get_bytes_per_frame(formatIn, channelsIn);
if (effectFrameCountIn > clippedSrcBufferCapInFrames) {
effectFrameCountIn = clippedSrcBufferCapInFrames;
}
ma_volume_and_clip_pcm_frames(clippedSrcBuffer, pRunningSrc, effectFrameCountIn, formatIn, channelsIn, volume);
/* At this point the input data has had volume and clipping applied. We can now convert this to the effect's input format. */
ma_convert_pcm_frames_format_and_channels(effectBufferIn, effectFormatIn, effectChannelsIn, clippedSrcBuffer, formatIn, channelsIn, effectFrameCountIn, ma_dither_mode_none);
}
/* At this point we have our input data in the effect's input format and we can now apply it. */
result = ma_effect_process_pcm_frames(pEffect, effectBufferIn, &effectFrameCountIn, effectBufferOut, &effectFrameCountOut);
if (result != MA_SUCCESS) {
return result; /* Failed to process the effect. */
}
/*
The effect has been applied. If the effect's output format is the same as the final output we can just accumulate straight into the output buffer,
otherwise we need to convert.
*/
if (effectFormatOut == formatOut && effectChannelsOut == channelsOut) {
/* Fast path. No data conversion required for output data. Just accumulate or overwrite. */
if (isAccumulation) {
ma_unclipped_accumulate_pcm_frames(pRunningDst, effectBufferOut, effectFrameCountOut, effectFormatOut, effectChannelsOut);
} else {
ma_clip_pcm_frames(pRunningDst, effectBufferOut, effectFrameCountOut, effectFormatOut, effectChannelsOut);
}
} else {
/* Slow path. Data conversion required before accumulating. */
ma_uint8 accumulationInBuffer[MA_DATA_CONVERTER_STACK_BUFFER_SIZE];
ma_uint32 accumulationInBufferCapInFrames = sizeof(accumulationInBuffer) / ma_get_bytes_per_frame(formatOut, channelsOut);
ma_uint64 totalFramesAccumulated = 0;
ma_uint8* pRunningEffectBufferOut = effectBufferOut;
while (totalFramesAccumulated < effectFrameCountOut) {
ma_uint64 framesToAccumulate = effectFrameCountOut - totalFramesAccumulated;
if (framesToAccumulate > accumulationInBufferCapInFrames) {
framesToAccumulate = accumulationInBufferCapInFrames;
}
/* We know how many frames to process in this iteration, so first of all do the conversion from the effect's output to the final output format.*/
ma_convert_pcm_frames_format_and_channels(accumulationInBuffer, formatOut, channelsOut, pRunningEffectBufferOut, effectFormatOut, effectChannelsOut, framesToAccumulate, ma_dither_mode_none);
/* We have the data in the final output format, so now we just accumulate or overwrite. */
if (isAccumulation) {
ma_unclipped_accumulate_pcm_frames(ma_offset_ptr(pRunningDst, totalFramesAccumulated * ma_get_accumulation_bytes_per_frame(formatOut, channelsOut)), accumulationInBuffer, framesToAccumulate, formatOut, channelsOut);
} else {
ma_clip_pcm_frames(ma_offset_ptr(pRunningDst, totalFramesAccumulated * ma_get_bytes_per_frame(formatOut, channelsOut)), accumulationInBuffer, framesToAccumulate, formatOut, channelsOut);
}
totalFramesAccumulated += framesToAccumulate;
pRunningEffectBufferOut = ma_offset_ptr(pRunningEffectBufferOut, framesToAccumulate * ma_get_bytes_per_frame(formatOut, channelsOut));
}
}
totalFramesProcessedIn += effectFrameCountIn;
totalFramesProcessedOut += effectFrameCountOut;
pRunningSrc = ma_offset_ptr(pRunningSrc, effectFrameCountIn * ma_get_accumulation_bytes_per_frame(formatIn, channelsIn));
if (isAccumulation) {
pRunningDst = ma_offset_ptr(pRunningDst, effectFrameCountOut * ma_get_accumulation_bytes_per_frame(formatIn, channelsIn));
} else {
pRunningDst = ma_offset_ptr(pRunningDst, effectFrameCountOut * ma_get_bytes_per_frame(formatOut, channelsOut));
}
}
return MA_SUCCESS;
}
static void ma_mix_accumulation_buffers_u8(ma_int16* pDst, const ma_int16* pSrc, ma_uint64 sampleCount, float volume) static void ma_mix_accumulation_buffers_u8(ma_int16* pDst, const ma_int16* pSrc, ma_uint64 sampleCount, float volume)
...@@ -8208,37 +7781,6 @@ MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channe ...@@ -8208,37 +7781,6 @@ MA_API ma_panner_config ma_panner_config_init(ma_format format, ma_uint32 channe
} }
static ma_result ma_panner_effect__on_process_pcm_frames(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
{
ma_panner* pPanner = (ma_panner*)pEffect;
ma_result result;
ma_uint64 frameCount;
(void)inputStreamCount;
/* The panner has a 1:1 relationship between input and output frame counts. */
frameCount = ma_min(*pFrameCountIn, *pFrameCountOut);
/* Only the first input stream is considered. Extra streams are ignored. */
result = ma_panner_process_pcm_frames(pPanner, pFramesOut, ppFramesIn[0], ma_min(*pFrameCountIn, *pFrameCountOut));
*pFrameCountIn = frameCount;
*pFrameCountOut = frameCount;
return result;
}
static ma_result ma_panner_effect__on_get_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
ma_panner* pPanner = (ma_panner*)pEffect;
*pFormat = pPanner->format;
*pChannels = pPanner->channels;
*pSampleRate = 0; /* There's no notion of sample rate with this effect. */
return MA_SUCCESS;
}
MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner) MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPanner)
{ {
if (pPanner == NULL) { if (pPanner == NULL) {
...@@ -8259,8 +7801,6 @@ MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPan ...@@ -8259,8 +7801,6 @@ MA_API ma_result ma_panner_init(const ma_panner_config* pConfig, ma_panner* pPan
return MA_SUCCESS; return MA_SUCCESS;
} }
static void ma_stereo_balance_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan) static void ma_stereo_balance_pcm_frames_f32(float* pFramesOut, const float* pFramesIn, ma_uint64 frameCount, float pan)
{ {
ma_uint64 iFrame; ma_uint64 iFrame;
...@@ -8436,48 +7976,6 @@ MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma ...@@ -8436,48 +7976,6 @@ MA_API ma_spatializer_config ma_spatializer_config_init(ma_uint32 channelsIn, ma
} }
static ma_result ma_spatializer_effect__on_process_pcm_frames(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
{
ma_spatializer* pSpatializer = (ma_spatializer*)pEffect;
ma_result result;
ma_uint64 frameCount;
(void)inputStreamCount;
/* The spatializer has a 1:1 relationship between input and output frame counts. */
frameCount = ma_min(*pFrameCountIn, *pFrameCountOut);
/* Only the first input stream is considered. Extra streams are ignored. */
result = ma_spatializer_process_pcm_frames(pSpatializer, pFramesOut, ppFramesIn[0], frameCount);
*pFrameCountIn = frameCount;
*pFrameCountOut = frameCount;
return result;
}
static ma_result ma_spatializer_effect__on_get_data_format_in(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
ma_spatializer* pSpatializer = (ma_spatializer*)pEffect;
*pFormat = ma_format_f32;
*pChannels = pSpatializer->channelsIn;
*pSampleRate = 0; /* There's no notion of sample rate with this effect. */
return MA_SUCCESS;
}
static ma_result ma_spatializer_effect__on_get_data_format_out(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
ma_spatializer* pSpatializer = (ma_spatializer*)pEffect;
*pFormat = ma_format_f32;
*pChannels = pSpatializer->channelsOut;
*pSampleRate = 0; /* There's no notion of sample rate with this effect. */
return MA_SUCCESS;
}
MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, ma_spatializer* pSpatializer) MA_API ma_result ma_spatializer_init(const ma_spatializer_config* pConfig, ma_spatializer* pSpatializer)
{ {
if (pSpatializer == NULL) { if (pSpatializer == NULL) {
...@@ -8551,31 +8049,6 @@ MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels ...@@ -8551,31 +8049,6 @@ MA_API ma_fader_config ma_fader_config_init(ma_format format, ma_uint32 channels
} }
static ma_result ma_fader_effect__on_process_pcm_frames(ma_effect* pEffect, ma_uint32 inputStreamCount, const void** ppFramesIn, ma_uint64* pFrameCountIn, void* pFramesOut, ma_uint64* pFrameCountOut)
{
ma_fader* pFader = (ma_fader*)pEffect;
ma_result result;
ma_uint64 frameCount;
(void)inputStreamCount;
/* The fader has a 1:1 relationship between input and output frame counts. */
frameCount = ma_min(*pFrameCountIn, *pFrameCountOut);
result = ma_fader_process_pcm_frames(pFader, pFramesOut, ppFramesIn[0], frameCount);
*pFrameCountIn = frameCount;
*pFrameCountOut = frameCount;
return result;
}
static ma_result ma_fader_effect__on_get_data_format(ma_effect* pEffect, ma_format* pFormat, ma_uint32* pChannels, ma_uint32* pSampleRate)
{
return ma_fader_get_data_format((ma_fader*)pEffect, pFormat, pChannels, pSampleRate);
}
MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader) MA_API ma_result ma_fader_init(const ma_fader_config* pConfig, ma_fader* pFader)
{ {
if (pFader == NULL) { if (pFader == NULL) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment