kcat/openal-soft
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Pass samplesToDo as size_t to effects

Browse Source
This commit is contained in:
Chris Robinson 2019-08-20 14:30:04 -07:00
parent 3e499e70fd
commit bb46cec0b1
14 changed files with 104 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
alc/effects/autowah.cpp
View File

@ -71,7 +71,7 @@ struct ALautowahState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(ALautowahState)
};
@ -126,7 +126,7 @@ void ALautowahState::update(const ALCcontext *context, const ALeffectslot *slot,
}
}
void ALautowahState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void ALautowahState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
const ALfloat attack_rate = mAttackRate;
const ALfloat release_rate = mReleaseRate;
@ -136,7 +136,7 @@ void ALautowahState::process(const ALsizei samplesToDo, const FloatBufferLine *R
const ALfloat bandwidth = mBandwidthNorm;
ALfloat env_delay{mEnvDelay};
for(ALsizei i{0};i < samplesToDo;i++)
for(size_t i{0u};i < samplesToDo;i++)
{
ALfloat w0, sample, a;
@ -166,7 +166,7 @@ void ALautowahState::process(const ALsizei samplesToDo, const FloatBufferLine *R
ALfloat z1{mChans[c].Filter.z1};
ALfloat z2{mChans[c].Filter.z2};
for(ALsizei i{0};i < samplesToDo;i++)
for(size_t i{0u};i < samplesToDo;i++)
{
const ALfloat alpha = mEnv[i].alpha;
const ALfloat cos_w0 = mEnv[i].cos_w0;
@ -190,7 +190,7 @@ void ALautowahState::process(const ALsizei samplesToDo, const FloatBufferLine *R
mChans[c].Filter.z2 = z2;
/* Now, mix the processed sound data to the output. */
MixSamples({mBufferOut, mBufferOut+samplesToDo}, samplesOut, mChans[c].CurrentGains,
MixSamples({mBufferOut, samplesToDo}, samplesOut, mChans[c].CurrentGains,
mChans[c].TargetGains, samplesToDo, 0);
}
}

4
alc/effects/base.h
View File

@ -1,6 +1,8 @@
#ifndef EFFECTS_BASE_H
#define EFFECTS_BASE_H
#include <cstddef>
#include "alcmain.h"
#include "almalloc.h"
#include "alspan.h"
@ -157,7 +159,7 @@ struct EffectState : public al::intrusive_ref<EffectState> {
virtual ALboolean deviceUpdate(const ALCdevice *device) = 0;
virtual void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) = 0;
virtual void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) = 0;
virtual void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) = 0;
};

16
alc/effects/chorus.cpp
View File

@ -55,7 +55,7 @@ enum class WaveForm {
};
void GetTriangleDelays(ALint *delays, const ALsizei start_offset, const ALsizei lfo_range,
const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const ALsizei todo)
const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const size_t todo)
{
ASSUME(start_offset >= 0);
ASSUME(lfo_range > 0);
@ -71,7 +71,7 @@ void GetTriangleDelays(ALint *delays, const ALsizei start_offset, const ALsizei
}
void GetSinusoidDelays(ALint *delays, const ALsizei start_offset, const ALsizei lfo_range,
const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const ALsizei todo)
const ALfloat lfo_scale, const ALfloat depth, const ALsizei delay, const size_t todo)
{
ASSUME(start_offset >= 0);
ASSUME(lfo_range > 0);
@ -111,7 +111,7 @@ struct ChorusState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(ChorusState)
};
@ -207,7 +207,7 @@ void ChorusState::update(const ALCcontext *Context, const ALeffectslot *Slot, co
}
}
void ChorusState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void ChorusState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
const auto bufmask = static_cast<ALsizei>(mSampleBuffer.size()-1);
const ALfloat feedback{mFeedback};
@ -215,9 +215,9 @@ void ChorusState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
ALfloat *RESTRICT delaybuf{mSampleBuffer.data()};
ALsizei offset{mOffset};
for(ALsizei base{0};base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
const ALsizei todo = mini(256, samplesToDo-base);
const size_t todo{minz(256, samplesToDo-base)};
ALint moddelays[2][256];
if(mWaveform == WaveForm::Sinusoid)
@ -237,7 +237,7 @@ void ChorusState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
mLfoOffset = (mLfoOffset+todo) % mLfoRange;
alignas(16) ALfloat temps[2][256];
for(ALsizei i{0};i < todo;i++)
for(size_t i{0u};i < todo;i++)
{
// Feed the buffer's input first (necessary for delays < 1).
delaybuf[offset&bufmask] = samplesIn[0][base+i];
@ -262,7 +262,7 @@ void ChorusState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
}
for(ALsizei c{0};c < 2;c++)
MixSamples({temps[c], temps[c]+todo}, samplesOut, mGains[c].Current, mGains[c].Target,
MixSamples({temps[c], todo}, samplesOut, mGains[c].Current, mGains[c].Target,
samplesToDo-base, base);
base += todo;

14
alc/effects/compressor.cpp
View File

@ -51,7 +51,7 @@ struct CompressorState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(CompressorState)
};
@ -85,18 +85,18 @@ void CompressorState::update(const ALCcontext*, const ALeffectslot *slot, const
}
}
void CompressorState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void CompressorState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
for(ALsizei base{0};base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
ALfloat gains[256];
const ALsizei td{mini(256, samplesToDo-base)};
const size_t td{minz(256, samplesToDo-base)};
/* Generate the per-sample gains from the signal envelope. */
ALfloat env{mEnvFollower};
if(mEnabled)
{
for(ALsizei i{0};i < td;++i)
for(size_t i{0u};i < td;++i)
{
/* Clamp the absolute amplitude to the defined envelope limits,
* then attack or release the envelope to reach it.
@ -120,7 +120,7 @@ void CompressorState::process(const ALsizei samplesToDo, const FloatBufferLine *
* ensure smooth gain changes when the compressor is turned on and
* off.
*/
for(ALsizei i{0};i < td;++i)
for(size_t i{0u};i < td;++i)
{
const ALfloat amplitude{1.0f};
if(amplitude > env)
@ -144,7 +144,7 @@ void CompressorState::process(const ALsizei samplesToDo, const FloatBufferLine *
if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
continue;
for(ALsizei i{0};i < td;i++)
for(size_t i{0u};i < td;i++)
output[base+i] += samplesIn[j][base+i] * gains[i] * gain;
}
}

8
alc/effects/dedicated.cpp
View File

@ -39,7 +39,7 @@ struct DedicatedState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(DedicatedState)
};
@ -86,10 +86,10 @@ void DedicatedState::update(const ALCcontext*, const ALeffectslot *slot, const E
}
}
void DedicatedState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void DedicatedState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
MixSamples({samplesIn[0].data(), samplesIn[0].data()+samplesToDo}, samplesOut, mCurrentGains,
mTargetGains, samplesToDo, 0);
MixSamples({samplesIn[0].data(), samplesToDo}, samplesOut, mCurrentGains, mTargetGains,
samplesToDo, 0);
}

14
alc/effects/distortion.cpp
View File

@ -49,7 +49,7 @@ struct DistortionState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(DistortionState)
};
@ -93,22 +93,22 @@ void DistortionState::update(const ALCcontext *context, const ALeffectslot *slot
ComputePanGains(target.Main, coeffs, slot->Params.Gain*props->Distortion.Gain, mGain);
}
void DistortionState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void DistortionState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
const ALfloat fc{mEdgeCoeff};
for(ALsizei base{0};base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
/* Perform 4x oversampling to avoid aliasing. Oversampling greatly
* improves distortion quality and allows to implement lowpass and
* bandpass filters using high frequencies, at which classic IIR
* filters became unstable.
*/
ALsizei todo{mini(BUFFERSIZE, (samplesToDo-base) * 4)};
size_t todo{minz(BUFFERSIZE, (samplesToDo-base) * 4)};
/* Fill oversample buffer using zero stuffing. Multiply the sample by
* the amount of oversampling to maintain the signal's power.
*/
for(ALsizei i{0};i < todo;i++)
for(size_t i{0u};i < todo;i++)
mBuffer[0][i] = !(i&3) ? samplesIn[0][(i>>2)+base] * 4.0f : 0.0f;
/* First step, do lowpass filtering of original signal. Additionally
@ -123,7 +123,7 @@ void DistortionState::process(const ALsizei samplesToDo, const FloatBufferLine *
* waveshaping are intended to modify waveform without boost/clipping/
* attenuation process.
*/
for(ALsizei i{0};i < todo;i++)
for(size_t i{0u};i < todo;i++)
{
ALfloat smp{mBuffer[1][i]};
@ -148,7 +148,7 @@ void DistortionState::process(const ALsizei samplesToDo, const FloatBufferLine *
if(!(std::fabs(gain) > GAIN_SILENCE_THRESHOLD))
continue;
for(ALsizei i{0};i < todo;i++)
for(size_t i{0u};i < todo;i++)
output[base+i] += gain * mBuffer[1][i*4];
}

23
alc/effects/echo.cpp
View File

@ -42,9 +42,9 @@ struct EchoState final : public EffectState {
// The echo is two tap. The delay is the number of samples from before the
// current offset
struct {
ALsizei delay{0};
size_t delay{0u};
} mTap[2];
ALsizei mOffset{0};
size_t mOffset{0u};
/* The panning gains for the two taps */
struct {
@ -59,7 +59,7 @@ struct EchoState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(EchoState)
};
@ -117,26 +117,25 @@ void EchoState::update(const ALCcontext *context, const ALeffectslot *slot, cons
ComputePanGains(target.Main, coeffs[1], slot->Params.Gain, mGains[1].Target);
}
void EchoState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void EchoState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
const auto mask = static_cast<ALsizei>(mSampleBuffer.size()-1);
ALfloat *RESTRICT delaybuf{mSampleBuffer.data()};
ALsizei offset{mOffset};
ALsizei tap1{offset - mTap[0].delay};
ALsizei tap2{offset - mTap[1].delay};
size_t offset{mOffset};
size_t tap1{offset - mTap[0].delay};
size_t tap2{offset - mTap[1].delay};
ALfloat z1, z2;
ASSUME(samplesToDo > 0);
ASSUME(mask > 0);
std::tie(z1, z2) = mFilter.getComponents();
for(ALsizei i{0};i < samplesToDo;)
for(size_t i{0u};i < samplesToDo;)
{
offset &= mask;
tap1 &= mask;
tap2 &= mask;
ALsizei td{mini(mask+1 - maxi(offset, maxi(tap1, tap2)), samplesToDo-i)};
size_t td{minz(mask+1 - maxz(offset, maxz(tap1, tap2)), samplesToDo-i)};
do {
/* Feed the delay buffer's input first. */
delaybuf[offset] = samplesIn[0][i];
@ -156,8 +155,8 @@ void EchoState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRI
mOffset = offset;
for(ALsizei c{0};c < 2;c++)
MixSamples({mTempBuffer[c], mTempBuffer[c]+samplesToDo}, samplesOut, mGains[c].Current,
mGains[c].Target, samplesToDo, 0);
MixSamples({mTempBuffer[c], samplesToDo}, samplesOut, mGains[c].Current, mGains[c].Target,
samplesToDo, 0);
}

6
alc/effects/equalizer.cpp
View File

@ -93,7 +93,7 @@ struct EqualizerState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(EqualizerState)
};
@ -157,7 +157,7 @@ void EqualizerState::update(const ALCcontext *context, const ALeffectslot *slot,
}
}
void EqualizerState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void EqualizerState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
ASSUME(numInput > 0);
for(ALsizei c{0};c < numInput;c++)
@ -167,7 +167,7 @@ void EqualizerState::process(const ALsizei samplesToDo, const FloatBufferLine *R
mChans[c].filter[2].process(mSampleBuffer, mSampleBuffer, samplesToDo);
mChans[c].filter[3].process(mSampleBuffer, mSampleBuffer, samplesToDo);
MixSamples({mSampleBuffer, mSampleBuffer+samplesToDo}, samplesOut, mChans[c].CurrentGains,
MixSamples({mSampleBuffer, samplesToDo}, samplesOut, mChans[c].CurrentGains,
mChans[c].TargetGains, samplesToDo, 0);
}
}

18
alc/effects/fshifter.cpp
View File

@ -61,7 +61,7 @@ alignas(16) const std::array<ALdouble,HIL_SIZE> HannWindow = InitHannWindow();
struct FshifterState final : public EffectState {
/* Effect parameters */
ALsizei mCount{};
size_t mCount{};
ALsizei mPhaseStep[2]{};
ALsizei mPhase[2]{};
ALdouble mSign[2]{};
@ -85,7 +85,7 @@ struct FshifterState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(FshifterState)
};
@ -117,7 +117,7 @@ void FshifterState::update(const ALCcontext *context, const ALeffectslot *slot,
const ALCdevice *device{context->mDevice.get()};
ALfloat step{props->Fshifter.Frequency / static_cast<ALfloat>(device->Frequency)};
mPhaseStep[0] = mPhaseStep[1] = fastf2i(minf(step, 0.5f) * FRACTIONONE);
mPhaseStep[0] = mPhaseStep[1] = fastf2i(minf(step, 0.5f) * FRACTIONONE);
switch(props->Fshifter.LeftDirection)
{
@ -160,15 +160,15 @@ void FshifterState::update(const ALCcontext *context, const ALeffectslot *slot,
ComputePanGains(target.Main, coeffs[1], slot->Params.Gain, mGains[1].Target);
}
void FshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void FshifterState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
static constexpr complex_d complex_zero{0.0, 0.0};
ALfloat *RESTRICT BufferOut = mBufferOut;
ALsizei j, k, base;
size_t j, k;
for(base = 0;base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
const ALsizei todo{mini(HIL_SIZE-mCount, samplesToDo-base)};
const size_t todo{minz(HIL_SIZE-mCount, samplesToDo-base)};
ASSUME(todo > 0);
@ -222,8 +222,8 @@ void FshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
}
/* Now, mix the processed sound data to the output. */
MixSamples({BufferOut, BufferOut+samplesToDo}, samplesOut, mGains[c].Current,
mGains[c].Target, maxi(samplesToDo, 512), 0);
MixSamples({BufferOut, samplesToDo}, samplesOut, mGains[c].Current, mGains[c].Target,
maxz(samplesToDo, 512), 0);
}
}

24
alc/effects/modulator.cpp
View File

@ -64,10 +64,9 @@ inline ALfloat One(ALsizei)
}
template<ALfloat func(ALsizei)>
void Modulate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, ALsizei todo)
void Modulate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, size_t todo)
{
ALsizei i;
for(i = 0;i < todo;i++)
for(size_t i{0u};i < todo;i++)
{
index += step;
index &= WAVEFORM_FRACMASK;
@ -77,7 +76,7 @@ void Modulate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, ALsizei
struct ModulatorState final : public EffectState {
void (*mGetSamples)(ALfloat*RESTRICT, ALsizei, const ALsizei, ALsizei){};
void (*mGetSamples)(ALfloat*RESTRICT, ALsizei, const ALsizei, size_t){};
ALsizei mIndex{0};
ALsizei mStep{1};
@ -92,7 +91,7 @@ struct ModulatorState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(ModulatorState)
};
@ -139,29 +138,28 @@ void ModulatorState::update(const ALCcontext *context, const ALeffectslot *slot,
}
}
void ModulatorState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void ModulatorState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
for(ALsizei base{0};base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
alignas(16) ALfloat modsamples[MAX_UPDATE_SAMPLES];
ALsizei td = mini(MAX_UPDATE_SAMPLES, samplesToDo-base);
ALsizei c, i;
size_t td{minz(MAX_UPDATE_SAMPLES, samplesToDo-base)};
mGetSamples(modsamples, mIndex, mStep, td);
mIndex += (mStep*td) & WAVEFORM_FRACMASK;
mIndex &= WAVEFORM_FRACMASK;
ASSUME(numInput > 0);
for(c = 0;c < numInput;c++)
for(ALsizei c{0};c < numInput;c++)
{
alignas(16) ALfloat temps[MAX_UPDATE_SAMPLES];
mChans[c].Filter.process(temps, &samplesIn[c][base], td);
for(i = 0;i < td;i++)
for(size_t i{0u};i < td;i++)
temps[i] *= modsamples[i];
MixSamples({temps, temps+td}, samplesOut, mChans[c].CurrentGains,
mChans[c].TargetGains, samplesToDo-base, base);
MixSamples({temps, td}, samplesOut, mChans[c].CurrentGains, mChans[c].TargetGains,
samplesToDo-base, base);
}
base += td;

4
alc/effects/null.cpp
View File

@ -20,7 +20,7 @@ struct NullState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(NullState)
};
@ -57,7 +57,7 @@ void NullState::update(const ALCcontext* /*context*/, const ALeffectslot* /*slot
* input to the output buffer. The result should be added to the output buffer,
* not replace it.
*/
void NullState::process(const ALsizei /*samplesToDo*/,
void NullState::process(const size_t/*samplesToDo*/,
const FloatBufferLine *RESTRICT /*samplesIn*/, const ALsizei /*numInput*/,
const al::span<FloatBufferLine> /*samplesOut*/)
{

32
alc/effects/pshifter.cpp
View File

@ -92,7 +92,7 @@ inline complex_d polar2rect(const ALphasor &number)
struct PshifterState final : public EffectState {
/* Effect parameters */
ALsizei mCount;
size_t mCount;
ALsizei mPitchShiftI;
ALfloat mPitchShift;
ALfloat mFreqPerBin;
@ -118,7 +118,7 @@ struct PshifterState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(PshifterState)
};
@ -161,7 +161,7 @@ void PshifterState::update(const ALCcontext*, const ALeffectslot *slot, const Ef
ComputePanGains(target.Main, coeffs, slot->Params.Gain, mTargetGains);
}
void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
void PshifterState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei /*numInput*/, const al::span<FloatBufferLine> samplesOut)
{
/* Pitch shifter engine based on the work of Stephan Bernsee.
* http://blogs.zynaptiq.com/bernsee/pitch-shifting-using-the-ft/
@ -170,9 +170,9 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
static constexpr ALdouble expected{al::MathDefs<double>::Tau() / OVERSAMP};
const ALdouble freq_per_bin{mFreqPerBin};
ALfloat *RESTRICT bufferOut{mBufferOut};
ALsizei count{mCount};
size_t count{mCount};
for(ALsizei i{0};i < samplesToDo;)
for(size_t i{0u};i < samplesToDo;)
{
do {
/* Fill FIFO buffer with samples data */
@ -187,7 +187,7 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
count = FIFO_LATENCY;
/* Real signal windowing and store in FFTbuffer */
for(ALsizei k{0};k < STFT_SIZE;k++)
for(size_t k{0u};k < STFT_SIZE;k++)
{
mFFTbuffer[k].real(mInFIFO[k] * HannWindow[k]);
mFFTbuffer[k].imag(0.0);
@ -200,7 +200,7 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
/* Analyze the obtained data. Since the real FFT is symmetric, only
* STFT_HALF_SIZE+1 samples are needed.
*/
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
for(size_t k{0u};k < STFT_HALF_SIZE+1;k++)
{
/* Compute amplitude and phase */
ALphasor component{rect2polar(mFFTbuffer[k])};
@ -228,15 +228,15 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
/* PROCESSING */
/* pitch shifting */
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
for(size_t k{0u};k < STFT_HALF_SIZE+1;k++)
{
mSyntesis_buffer[k].Amplitude = 0.0;
mSyntesis_buffer[k].Frequency = 0.0;
}
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
for(size_t k{0u};k < STFT_HALF_SIZE+1;k++)
{
ALsizei j{(k*mPitchShiftI) >> FRACTIONBITS};
size_t j{(k*mPitchShiftI) >> FRACTIONBITS};
if(j >= STFT_HALF_SIZE+1) break;
mSyntesis_buffer[j].Amplitude += mAnalysis_buffer[k].Amplitude;
@ -245,7 +245,7 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
/* SYNTHESIS */
/* Synthesis the processing data */
for(ALsizei k{0};k < STFT_HALF_SIZE+1;k++)
for(size_t k{0u};k < STFT_HALF_SIZE+1;k++)
{
ALphasor component;
ALdouble tmp;
@ -263,19 +263,19 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
mFFTbuffer[k] = polar2rect(component);
}
/* zero negative frequencies for recontruct a real signal */
for(ALsizei k{STFT_HALF_SIZE+1};k < STFT_SIZE;k++)
for(size_t k{STFT_HALF_SIZE+1};k < STFT_SIZE;k++)
mFFTbuffer[k] = complex_d{};
/* Apply iFFT to buffer data */
complex_fft(mFFTbuffer, 1.0);
/* Windowing and add to output */
for(ALsizei k{0};k < STFT_SIZE;k++)
for(size_t k{0u};k < STFT_SIZE;k++)
mOutputAccum[k] += HannWindow[k] * mFFTbuffer[k].real() /
(0.5 * STFT_HALF_SIZE * OVERSAMP);
/* Shift accumulator, input & output FIFO */
ALsizei j, k;
size_t j, k;
for(k = 0;k < STFT_STEP;k++) mOutFIFO[k] = static_cast<ALfloat>(mOutputAccum[k]);
for(j = 0;k < STFT_SIZE;k++,j++) mOutputAccum[j] = mOutputAccum[k];
for(;j < STFT_SIZE;j++) mOutputAccum[j] = 0.0;
@ -285,8 +285,8 @@ void PshifterState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
mCount = count;
/* Now, mix the processed sound data to the output. */
MixSamples({bufferOut, bufferOut+samplesToDo}, samplesOut, mCurrentGains, mTargetGains,
maxi(samplesToDo, 512), 0);
MixSamples({bufferOut, samplesToDo}, samplesOut, mCurrentGains, mTargetGains,
maxz(samplesToDo, 512), 0);
}

12
alc/effects/reverb.cpp
View File

@ -484,7 +484,7 @@ struct ReverbState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
DEF_NEWDEL(ReverbState)
};
@ -1442,7 +1442,7 @@ void LateReverb_Faded(ReverbState *State, const size_t offset, const size_t todo
VectorScatterRevDelayIn(late_delay, offset, mixX, mixY, 0, temps, todo);
}
void ReverbState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void ReverbState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
size_t offset{mOffset};
size_t fadeCount{mFadeCount};
@ -1450,7 +1450,7 @@ void ReverbState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
ASSUME(samplesToDo > 0);
/* Convert B-Format to A-Format for processing. */
const al::span<float> tmpspan{mTempLine.data(), mTempLine.data()+samplesToDo};
const al::span<float> tmpspan{mTempLine.data(), samplesToDo};
for(size_t c{0u};c < NUM_LINES;c++)
{
std::fill(tmpspan.begin(), tmpspan.end(), 0.0f);
@ -1463,14 +1463,14 @@ void ReverbState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
}
/* Process reverb for these samples. */
for(size_t base{0};base < static_cast<size_t>(samplesToDo);)
for(size_t base{0};base < samplesToDo;)
{
/* Calculate the number of samples we can do this iteration. */
size_t todo{minz(samplesToDo - base, minz(mMaxUpdate[0], mMaxUpdate[1]))};
/* Some mixers require maintaining a 4-sample alignment, so ensure that
* if it's not the last iteration.
*/
if(base+todo < static_cast<size_t>(samplesToDo)) todo &= ~3;
if(base+todo < samplesToDo) todo &= ~3;
ASSUME(todo > 0);
/* Process the samples for reverb. */
@ -1518,7 +1518,7 @@ void ReverbState::process(const ALsizei samplesToDo, const FloatBufferLine *REST
}
/* Finally, mix early reflections and late reverb. */
(this->*mMixOut)(samplesOut, static_cast<size_t>(samplesToDo)-base, base, todo);
(this->*mMixOut)(samplesOut, samplesToDo-base, base, todo);
base += todo;
}

24
alc/effects/vmorpher.cpp
View File

@ -66,9 +66,9 @@ inline ALfloat Half(ALsizei)
}
template<ALfloat func(ALsizei)>
void Oscillate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, ALsizei todo)
void Oscillate(ALfloat *RESTRICT dst, ALsizei index, const ALsizei step, size_t todo)
{
for(ALsizei i{0};i < todo;i++)
for(size_t i{0u};i < todo;i++)
{
index += step;
index &= WAVEFORM_FRACMASK;
@ -86,7 +86,7 @@ struct FormantFilter
FormantFilter() = default;
FormantFilter(ALfloat f0norm_, ALfloat gain) : f0norm{f0norm_}, fGain{gain} { }
inline void process(const ALfloat* samplesIn, ALfloat* samplesOut, const ALsizei numInput)
inline void process(const ALfloat* samplesIn, ALfloat* samplesOut, const size_t numInput)
{
/* A state variable filter from a topology-preserving transform.
* Based on a talk given by Ivan Cohen: https://www.youtube.com/watch?v=esjHXGPyrhg
@ -94,7 +94,7 @@ struct FormantFilter
const ALfloat g = std::tan(al::MathDefs<float>::Pi() * f0norm);
const ALfloat h = 1.0f / (1 + (g / Q_FACTOR) + (g * g));
for (ALsizei i{0};i < numInput;i++)
for(size_t i{0u};i < numInput;i++)
{
const ALfloat H = h * (samplesIn[i] - (1.0f / Q_FACTOR + g) * s1 - s2);
const ALfloat B = g * H + s1;
@ -126,7 +126,7 @@ struct VmorpherState final : public EffectState {
ALfloat TargetGains[MAX_OUTPUT_CHANNELS]{};
} mChans[MAX_AMBI_CHANNELS];
void (*mGetSamples)(ALfloat* RESTRICT, ALsizei, const ALsizei, ALsizei) {};
void (*mGetSamples)(ALfloat* RESTRICT, ALsizei, const ALsizei, size_t){};
ALsizei mIndex{0};
ALsizei mStep{1};
@ -137,7 +137,7 @@ struct VmorpherState final : public EffectState {
ALboolean deviceUpdate(const ALCdevice *device) override;
void update(const ALCcontext *context, const ALeffectslot *slot, const EffectProps *props, const EffectTarget target) override;
void process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
void process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut) override;
static std::array<FormantFilter,4> getFiltersByPhoneme(ALenum phoneme, ALfloat frequency, ALfloat pitch);
@ -244,15 +244,15 @@ void VmorpherState::update(const ALCcontext *context, const ALeffectslot *slot,
}
}
void VmorpherState::process(const ALsizei samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
void VmorpherState::process(const size_t samplesToDo, const FloatBufferLine *RESTRICT samplesIn, const ALsizei numInput, const al::span<FloatBufferLine> samplesOut)
{
/* Following the EFX specification for a conformant implementation which describes
* the effect as a pair of 4-band formant filters blended together using an LFO.
*/
for(ALsizei base{0};base < samplesToDo;)
for(size_t base{0u};base < samplesToDo;)
{
alignas(16) ALfloat lfo[MAX_UPDATE_SAMPLES];
const ALsizei td = mini(MAX_UPDATE_SAMPLES, samplesToDo-base);
const size_t td{minz(MAX_UPDATE_SAMPLES, samplesToDo-base)};
mGetSamples(lfo, mIndex, mStep, td);
mIndex += (mStep * td) & WAVEFORM_FRACMASK;
@ -280,12 +280,12 @@ void VmorpherState::process(const ALsizei samplesToDo, const FloatBufferLine *RE
vowelB[3].process(&samplesIn[c][base], mSampleBufferB, td);
alignas(16) ALfloat blended[MAX_UPDATE_SAMPLES];
for(ALsizei i{0};i < td;i++)
for(size_t i{0u};i < td;i++)
blended[i] = lerp(mSampleBufferA[i], mSampleBufferB[i], lfo[i]);
/* Now, mix the processed sound data to the output. */
MixSamples({blended, blended+td}, samplesOut, mChans[c].CurrentGains,
mChans[c].TargetGains, samplesToDo-base, base);
MixSamples({blended, td}, samplesOut, mChans[c].CurrentGains, mChans[c].TargetGains,
samplesToDo-base, base);
}
base += td;