diff options
Diffstat (limited to 'Src/external_dependencies/openmpt-trunk/soundlib/FloatMixer.h')
| -rw-r--r-- | Src/external_dependencies/openmpt-trunk/soundlib/FloatMixer.h | 308 |
1 files changed, 308 insertions, 0 deletions
diff --git a/Src/external_dependencies/openmpt-trunk/soundlib/FloatMixer.h b/Src/external_dependencies/openmpt-trunk/soundlib/FloatMixer.h new file mode 100644 index 00000000..d53fbabc --- /dev/null +++ b/Src/external_dependencies/openmpt-trunk/soundlib/FloatMixer.h @@ -0,0 +1,308 @@ +/* + * FloatMixer.h + * ------------ + * Purpose: Floating point mixer classes + * Notes : (currently none) + * Authors: OpenMPT Devs + * The OpenMPT source code is released under the BSD license. Read LICENSE for more details. + */ + + +#pragma once + +#include "openmpt/all/BuildSettings.hpp" + +#include "MixerInterface.h" +#include "Resampler.h" + +OPENMPT_NAMESPACE_BEGIN + +template<int channelsOut, int channelsIn, typename out, typename in, int int2float> +struct IntToFloatTraits : public MixerTraits<channelsOut, channelsIn, out, in> +{ + static_assert(std::numeric_limits<input_t>::is_integer, "Input must be integer"); + static_assert(!std::numeric_limits<output_t>::is_integer, "Output must be floating point"); + + static MPT_CONSTEXPRINLINE output_t Convert(const input_t x) + { + return static_cast<output_t>(x) * (static_cast<output_t>(1) / static_cast<output_t>(int2float)); + } +}; + +typedef IntToFloatTraits<2, 1, mixsample_t, int8, -int8_min> Int8MToFloatS; +typedef IntToFloatTraits<2, 1, mixsample_t, int16, -int16_min> Int16MToFloatS; +typedef IntToFloatTraits<2, 2, mixsample_t, int8, -int8_min> Int8SToFloatS; +typedef IntToFloatTraits<2, 2, mixsample_t, int16, -int16_min> Int16SToFloatS; + + +////////////////////////////////////////////////////////////////////////// +// Interpolation templates + +template<class Traits> +struct LinearInterpolation +{ + MPT_FORCEINLINE LinearInterpolation(const ModChannel &, const CResampler &, unsigned int) { } + + MPT_FORCEINLINE void operator() (typename Traits::outbuf_t &outSample, const typename Traits::input_t * const inBuffer, const uint32 posLo) + { + static_assert(static_cast<int>(Traits::numChannelsIn) <= static_cast<int>(Traits::numChannelsOut), "Too many input channels"); + const typename Traits::output_t fract = posLo / static_cast<typename Traits::output_t>(0x100000000); //CResampler::LinearTablef[posLo >> 24]; + + for(int i = 0; i < Traits::numChannelsIn; i++) + { + typename Traits::output_t srcVol = Traits::Convert(inBuffer[i]); + typename Traits::output_t destVol = Traits::Convert(inBuffer[i + Traits::numChannelsIn]); + + outSample[i] = srcVol + fract * (destVol - srcVol); + } + } +}; + + +template<class Traits> +struct FastSincInterpolation +{ + MPT_FORCEINLINE FastSincInterpolation(const ModChannel &, const CResampler &, unsigned int) { } + + MPT_FORCEINLINE void operator() (typename Traits::outbuf_t &outSample, const typename Traits::input_t * const inBuffer, const uint32 posLo) + { + static_assert(static_cast<int>(Traits::numChannelsIn) <= static_cast<int>(Traits::numChannelsOut), "Too many input channels"); + const typename Traits::output_t *lut = CResampler::FastSincTablef + ((posLo >> 22) & 0x3FC); + + for(int i = 0; i < Traits::numChannelsIn; i++) + { + outSample[i] = + lut[0] * Traits::Convert(inBuffer[i - Traits::numChannelsIn]) + + lut[1] * Traits::Convert(inBuffer[i]) + + lut[2] * Traits::Convert(inBuffer[i + Traits::numChannelsIn]) + + lut[3] * Traits::Convert(inBuffer[i + 2 * Traits::numChannelsIn]); + } + } +}; + + +template<class Traits> +struct PolyphaseInterpolation +{ + const typename Traits::output_t *sinc; + + MPT_FORCEINLINE PolyphaseInterpolation(const ModChannel &chn, const CResampler &resampler, unsigned int) + { + sinc = (((chn.increment > SamplePosition(0x130000000ll)) || (chn.increment < -SamplePosition(-0x130000000ll))) ? + (((chn.increment > SamplePosition(0x180000000ll)) || (chn.increment < SamplePosition(-0x180000000ll))) ? resampler.gDownsample2x : resampler.gDownsample13x) : resampler.gKaiserSinc); + } + + MPT_FORCEINLINE void operator() (typename Traits::outbuf_t &outSample, const typename Traits::input_t * const inBuffer, const uint32 posLo) + { + static_assert(static_cast<int>(Traits::numChannelsIn) <= static_cast<int>(Traits::numChannelsOut), "Too many input channels"); + const typename Traits::output_t *lut = sinc + ((posLo >> (32 - SINC_PHASES_BITS)) & SINC_MASK) * SINC_WIDTH; + + for(int i = 0; i < Traits::numChannelsIn; i++) + { + outSample[i] = + lut[0] * Traits::Convert(inBuffer[i - 3 * Traits::numChannelsIn]) + + lut[1] * Traits::Convert(inBuffer[i - 2 * Traits::numChannelsIn]) + + lut[2] * Traits::Convert(inBuffer[i - Traits::numChannelsIn]) + + lut[3] * Traits::Convert(inBuffer[i]) + + lut[4] * Traits::Convert(inBuffer[i + Traits::numChannelsIn]) + + lut[5] * Traits::Convert(inBuffer[i + 2 * Traits::numChannelsIn]) + + lut[6] * Traits::Convert(inBuffer[i + 3 * Traits::numChannelsIn]) + + lut[7] * Traits::Convert(inBuffer[i + 4 * Traits::numChannelsIn]); + } + } +}; + + +template<class Traits> +struct FIRFilterInterpolation +{ + const typename Traits::output_t *WFIRlut; + + MPT_FORCEINLINE FIRFilterInterpolation(const ModChannel &, const CResampler &resampler, unsigned int) + { + WFIRlut = resampler.m_WindowedFIR.lut; + } + + MPT_FORCEINLINE void operator() (typename Traits::outbuf_t &outSample, const typename Traits::input_t * const inBuffer, const uint32 posLo) + { + static_assert(static_cast<int>(Traits::numChannelsIn) <= static_cast<int>(Traits::numChannelsOut), "Too many input channels"); + const typename Traits::output_t * const lut = WFIRlut + ((((posLo >> 16) + WFIR_FRACHALVE) >> WFIR_FRACSHIFT) & WFIR_FRACMASK); + + for(int i = 0; i < Traits::numChannelsIn; i++) + { + outSample[i] = + lut[0] * Traits::Convert(inBuffer[i - 3 * Traits::numChannelsIn]) + + lut[1] * Traits::Convert(inBuffer[i - 2 * Traits::numChannelsIn]) + + lut[2] * Traits::Convert(inBuffer[i - Traits::numChannelsIn]) + + lut[3] * Traits::Convert(inBuffer[i]) + + lut[4] * Traits::Convert(inBuffer[i + Traits::numChannelsIn]) + + lut[5] * Traits::Convert(inBuffer[i + 2 * Traits::numChannelsIn]) + + lut[6] * Traits::Convert(inBuffer[i + 3 * Traits::numChannelsIn]) + + lut[7] * Traits::Convert(inBuffer[i + 4 * Traits::numChannelsIn]); + } + } +}; + + +////////////////////////////////////////////////////////////////////////// +// Mixing templates (add sample to stereo mix) + +template<class Traits> +struct NoRamp +{ + typename Traits::output_t lVol, rVol; + + MPT_FORCEINLINE NoRamp(const ModChannel &chn) + { + lVol = static_cast<Traits::output_t>(chn.leftVol) * (1.0f / 4096.0f); + rVol = static_cast<Traits::output_t>(chn.rightVol) * (1.0f / 4096.0f); + } +}; + + +struct Ramp +{ + ModChannel &channel; + int32 lRamp, rRamp; + + MPT_FORCEINLINE Ramp(ModChannel &chn) + : channel{chn} + { + lRamp = chn.rampLeftVol; + rRamp = chn.rampRightVol; + } + + MPT_FORCEINLINE ~Ramp() + { + channel.rampLeftVol = lRamp; channel.leftVol = lRamp >> VOLUMERAMPPRECISION; + channel.rampRightVol = rRamp; channel.rightVol = rRamp >> VOLUMERAMPPRECISION; + } +}; + + +// Legacy optimization: If chn.nLeftVol == chn.nRightVol, save one multiplication instruction +template<class Traits> +struct MixMonoFastNoRamp : public NoRamp<Traits> +{ + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &outSample, const ModChannel &chn, typename Traits::output_t * const outBuffer) + { + typename Traits::output_t vol = outSample[0] * lVol; + for(int i = 0; i < Traits::numChannelsOut; i++) + { + outBuffer[i] += vol; + } + } +}; + + +template<class Traits> +struct MixMonoNoRamp : public NoRamp<Traits> +{ + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &outSample, const ModChannel &, typename Traits::output_t * const outBuffer) + { + outBuffer[0] += outSample[0] * lVol; + outBuffer[1] += outSample[0] * rVol; + } +}; + + +template<class Traits> +struct MixMonoRamp : public Ramp +{ + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &outSample, const ModChannel &chn, typename Traits::output_t * const outBuffer) + { + // TODO volume is not float, can we optimize this? + lRamp += chn.leftRamp; + rRamp += chn.rightRamp; + outBuffer[0] += outSample[0] * (lRamp >> VOLUMERAMPPRECISION) * (1.0f / 4096.0f); + outBuffer[1] += outSample[0] * (rRamp >> VOLUMERAMPPRECISION) * (1.0f / 4096.0f); + } +}; + + +template<class Traits> +struct MixStereoNoRamp : public NoRamp<Traits> +{ + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &outSample, const ModChannel &, typename Traits::output_t * const outBuffer) + { + outBuffer[0] += outSample[0] * lVol; + outBuffer[1] += outSample[1] * rVol; + } +}; + + +template<class Traits> +struct MixStereoRamp : public Ramp +{ + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &outSample, const ModChannel &chn, typename Traits::output_t * const outBuffer) + { + // TODO volume is not float, can we optimize this? + lRamp += chn.leftRamp; + rRamp += chn.rightRamp; + outBuffer[0] += outSample[0] * (lRamp >> VOLUMERAMPPRECISION) * (1.0f / 4096.0f); + outBuffer[1] += outSample[1] * (rRamp >> VOLUMERAMPPRECISION) * (1.0f / 4096.0f); + } +}; + + +////////////////////////////////////////////////////////////////////////// +// Filter templates + + +template<class Traits> +struct NoFilter +{ + MPT_FORCEINLINE NoFilter(const ModChannel &) { } + + MPT_FORCEINLINE void operator() (const typename Traits::outbuf_t &, const ModChannel &) { } +}; + + +// Resonant filter +template<class Traits> +struct ResonantFilter +{ + ModChannel &channel; + // Filter history + typename Traits::output_t fy[Traits::numChannelsIn][2]; + + MPT_FORCEINLINE ResonantFilter(ModChannel &chn) + : channel{chn} + { + for(int i = 0; i < Traits::numChannelsIn; i++) + { + fy[i][0] = chn.nFilter_Y[i][0]; + fy[i][1] = chn.nFilter_Y[i][1]; + } + } + + MPT_FORCEINLINE ~ResonantFilter(ModChannel &chn) + { + for(int i = 0; i < Traits::numChannelsIn; i++) + { + channel.nFilter_Y[i][0] = fy[i][0]; + channel.nFilter_Y[i][1] = fy[i][1]; + } + } + + // Filter values are clipped to double the input range +#define ClipFilter(x) Clamp(x, static_cast<Traits::output_t>(-2.0f), static_cast<Traits::output_t>(2.0f)) + + MPT_FORCEINLINE void operator() (typename Traits::outbuf_t &outSample, const ModChannel &chn) + { + static_assert(static_cast<int>(Traits::numChannelsIn) <= static_cast<int>(Traits::numChannelsOut), "Too many input channels"); + + for(int i = 0; i < Traits::numChannelsIn; i++) + { + typename Traits::output_t val = outSample[i] * chn.nFilter_A0 + ClipFilter(fy[i][0]) * chn.nFilter_B0 + ClipFilter(fy[i][1]) * chn.nFilter_B1; + fy[i][1] = fy[i][0]; + fy[i][0] = val - (outSample[i] * chn.nFilter_HP); + outSample[i] = val; + } + } + +#undef ClipFilter +}; + + +OPENMPT_NAMESPACE_END |