mirror of
https://github.com/libretro/scummvm.git
synced 2025-01-05 17:20:30 +00:00
5ca776639f
The RateConverter class has been modified to allow for variable input and output rates. The optimized code paths for copy/simple conversions are retained, but have been moved inside separate functions instead of subclasses. The templatization of the stereo parameters has been maintained, and is implemented via the newly-added RateConverter_Impl template class. Internal variables have been renamed to be more readable. The flow() function has been renamed to convert(). The drain() function has been removed, since it was never implemented or used anywhere.
316 lines
9.9 KiB
C++
316 lines
9.9 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* The code in this file is based on code with Copyright 1998 Fabrice Bellard
|
|
* Fabrice original code is part of SoX (http://sox.sourceforge.net).
|
|
* Max Horn adapted that code to the needs of ScummVM and rewrote it partial,
|
|
* in the process removing any use of floating point arithmetic. Various other
|
|
* improvements over the original code were made.
|
|
*/
|
|
|
|
#include "audio/audiostream.h"
|
|
#include "audio/rate.h"
|
|
#include "audio/mixer.h"
|
|
#include "common/util.h"
|
|
|
|
namespace Audio {
|
|
|
|
/**
|
|
* The default fractional type in frac.h (with 16 fractional bits) limits
|
|
* the rate conversion code to 65536Hz audio: we need to able to handle
|
|
* 96kHz audio, so we use fewer fractional bits in this code.
|
|
*/
|
|
enum {
|
|
FRAC_BITS_LOW = 15,
|
|
FRAC_ONE_LOW = (1L << FRAC_BITS_LOW),
|
|
FRAC_HALF_LOW = (1L << (FRAC_BITS_LOW-1))
|
|
};
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
class RateConverter_Impl : public RateConverter {
|
|
private:
|
|
/** Input and output rates */
|
|
st_rate_t _inRate, _outRate;
|
|
|
|
/**
|
|
* The intermediate input cache. Bigger values may increase performance,
|
|
* but only until some point (depends largely on cache size, target
|
|
* processor and various other factors), at which it will decrease again.
|
|
*/
|
|
st_sample_t _buffer[512];
|
|
|
|
/** Current position inside the buffer */
|
|
const st_sample_t *_bufferPos;
|
|
|
|
/** Size of data currently loaded into the buffer */
|
|
int _bufferSize;
|
|
|
|
/** How far output is ahead of input when doing simple conversion */
|
|
frac_t _outPos;
|
|
|
|
/** Fractional position of the output stream in input stream unit */
|
|
frac_t _outPosFrac;
|
|
|
|
/** Last sample(s) in the input stream (left/right channel) */
|
|
st_sample_t _inLastL, _inLastR;
|
|
|
|
/** Current sample(s) in the input stream (left/right channel) */
|
|
st_sample_t _inCurL, _inCurR;
|
|
|
|
int copyConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t vol_l, st_volume_t vol_r);
|
|
int simpleConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t vol_l, st_volume_t vol_r);
|
|
int interpolateConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t vol_l, st_volume_t vol_r);
|
|
|
|
public:
|
|
RateConverter_Impl(st_rate_t inputRate, st_rate_t outputRate);
|
|
virtual ~RateConverter_Impl() {}
|
|
|
|
int convert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t vol_l, st_volume_t vol_r) override;
|
|
|
|
void setInputRate(st_rate_t inputRate) override { _inRate = inputRate; }
|
|
void setOutputRate(st_rate_t outputRate) override { _outRate = outputRate; }
|
|
|
|
st_rate_t getInputRate() const override { return _inRate; }
|
|
st_rate_t getOutputRate() const override { return _outRate; }
|
|
};
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
int RateConverter_Impl<inStereo, outStereo, reverseStereo>::copyConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t volL, st_volume_t volR) {
|
|
st_sample_t *outStart, *outEnd;
|
|
|
|
outStart = outBuffer;
|
|
outEnd = outBuffer + numSamples * (outStereo ? 2 : 1);
|
|
|
|
while (outBuffer < outEnd) {
|
|
// Check if we have to refill the buffer
|
|
if (_bufferSize == 0) {
|
|
_bufferPos = _buffer;
|
|
_bufferSize = input.readBuffer(_buffer, ARRAYSIZE(_buffer));
|
|
|
|
if (_bufferSize <= 0)
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
// Mix the data into the output buffer
|
|
st_sample_t inL, inR;
|
|
inL = *_bufferPos++;
|
|
inR = (inStereo ? *_bufferPos++ : inL);
|
|
_bufferSize -= (inStereo ? 2 : 1);
|
|
|
|
st_sample_t outL, outR;
|
|
outL = (inL * (int)volL) / Audio::Mixer::kMaxMixerVolume;
|
|
outR = (inR * (int)volR) / Audio::Mixer::kMaxMixerVolume;
|
|
|
|
if (outStereo) {
|
|
// Output left channel
|
|
clampedAdd(outBuffer[reverseStereo ], outL);
|
|
|
|
// Output right channel
|
|
clampedAdd(outBuffer[reverseStereo ^ 1], outR);
|
|
|
|
outBuffer += 2;
|
|
} else {
|
|
// Output mono channel
|
|
clampedAdd(outBuffer[0], (outL + outR) / 2);
|
|
|
|
outBuffer += 1;
|
|
}
|
|
}
|
|
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
int RateConverter_Impl<inStereo, outStereo, reverseStereo>::simpleConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t volL, st_volume_t volR) {
|
|
// How much to increment _outPos by
|
|
frac_t outPos_inc = _inRate / _outRate;
|
|
|
|
st_sample_t *outStart, *outEnd;
|
|
|
|
outStart = outBuffer;
|
|
outEnd = outBuffer + numSamples * (outStereo ? 2 : 1);
|
|
|
|
while (outBuffer < outEnd) {
|
|
// Read enough input samples so that _outPos >= 0
|
|
do {
|
|
// Check if we have to refill the buffer
|
|
if (_bufferSize == 0) {
|
|
_bufferPos = _buffer;
|
|
_bufferSize = input.readBuffer(_buffer, ARRAYSIZE(_buffer));
|
|
|
|
if (_bufferSize <= 0)
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
_bufferSize -= (inStereo ? 2 : 1);
|
|
_outPos--;
|
|
|
|
if (_outPos >= 0) {
|
|
_bufferPos += (inStereo ? 2 : 1);
|
|
}
|
|
} while (_outPos >= 0);
|
|
|
|
st_sample_t inL, inR;
|
|
inL = *_bufferPos++;
|
|
inR = (inStereo ? *_bufferPos++ : inL);
|
|
|
|
// Increment output position
|
|
_outPos += outPos_inc;
|
|
|
|
st_sample_t outL, outR;
|
|
outL = (inL * (int)volL) / Audio::Mixer::kMaxMixerVolume;
|
|
outR = (inR * (int)volR) / Audio::Mixer::kMaxMixerVolume;
|
|
|
|
if (outStereo) {
|
|
// output left channel
|
|
clampedAdd(outBuffer[reverseStereo ], outL);
|
|
|
|
// output right channel
|
|
clampedAdd(outBuffer[reverseStereo ^ 1], outR);
|
|
|
|
outBuffer += 2;
|
|
} else {
|
|
// output mono channel
|
|
clampedAdd(outBuffer[0], (outL + outR) / 2);
|
|
|
|
outBuffer += 1;
|
|
}
|
|
}
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
int RateConverter_Impl<inStereo, outStereo, reverseStereo>::interpolateConvert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t volL, st_volume_t volR) {
|
|
// How much to increment _outPosFrac by
|
|
frac_t outPos_inc = (_inRate << FRAC_BITS_LOW) / _outRate;
|
|
|
|
st_sample_t *outStart, *outEnd;
|
|
outStart = outBuffer;
|
|
outEnd = outBuffer + numSamples * (outStereo ? 2 : 1);
|
|
|
|
while (outBuffer < outEnd) {
|
|
// Read enough input samples so that _outPosFrac < 0
|
|
while ((frac_t)FRAC_ONE_LOW <= _outPosFrac) {
|
|
// Check if we have to refill the buffer
|
|
if (_bufferSize == 0) {
|
|
_bufferPos = _buffer;
|
|
_bufferSize = input.readBuffer(_buffer, ARRAYSIZE(_buffer));
|
|
|
|
if (_bufferSize <= 0)
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
_bufferSize -= (inStereo ? 2 : 1);
|
|
_inLastL = _inCurL;
|
|
_inCurL = *_bufferPos++;
|
|
|
|
if (inStereo) {
|
|
_inLastR = _inCurR;
|
|
_inCurR = *_bufferPos++;
|
|
}
|
|
|
|
_outPosFrac -= FRAC_ONE_LOW;
|
|
}
|
|
|
|
// Loop as long as the _outPos trails behind, and as long as there is
|
|
// still space in the output buffer.
|
|
while (_outPosFrac < (frac_t)FRAC_ONE_LOW && outBuffer < outEnd) {
|
|
// Interpolate
|
|
st_sample_t inL, inR;
|
|
inL = (st_sample_t)(_inLastL + (((_inCurL - _inLastL) * _outPosFrac + FRAC_HALF_LOW) >> FRAC_BITS_LOW));
|
|
inR = (inStereo ?
|
|
(st_sample_t)(_inLastR + (((_inCurR - _inLastR) * _outPosFrac + FRAC_HALF_LOW) >> FRAC_BITS_LOW)) :
|
|
inL);
|
|
|
|
st_sample_t outL, outR;
|
|
outL = (inL * (int)volL) / Audio::Mixer::kMaxMixerVolume;
|
|
outR = (inR * (int)volR) / Audio::Mixer::kMaxMixerVolume;
|
|
|
|
if (outStereo) {
|
|
// Output left channel
|
|
clampedAdd(outBuffer[reverseStereo ], outL);
|
|
|
|
// Output right channel
|
|
clampedAdd(outBuffer[reverseStereo ^ 1], outR);
|
|
|
|
outBuffer += 2;
|
|
} else {
|
|
// Output mono channel
|
|
clampedAdd(outBuffer[0], (outL + outR) / 2);
|
|
|
|
outBuffer += 1;
|
|
}
|
|
|
|
// Increment output position
|
|
_outPosFrac += outPos_inc;
|
|
}
|
|
}
|
|
return (outBuffer - outStart) / (outStereo ? 2 : 1);
|
|
}
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
RateConverter_Impl<inStereo, outStereo, reverseStereo>::RateConverter_Impl(st_rate_t inputRate, st_rate_t outputRate) :
|
|
_inRate(inputRate),
|
|
_outRate(outputRate),
|
|
_outPos(1),
|
|
_outPosFrac(FRAC_ONE_LOW),
|
|
_inLastL(0),
|
|
_inLastR(0),
|
|
_inCurL(0),
|
|
_inCurR(0),
|
|
_bufferSize(0),
|
|
_bufferPos(nullptr) {}
|
|
|
|
template<bool inStereo, bool outStereo, bool reverseStereo>
|
|
int RateConverter_Impl<inStereo, outStereo, reverseStereo>::convert(AudioStream &input, st_sample_t *outBuffer, st_size_t numSamples, st_volume_t volL, st_volume_t volR) {
|
|
assert(input.isStereo() == inStereo);
|
|
|
|
if (_inRate == _outRate) {
|
|
return copyConvert(input, outBuffer, numSamples, volL, volR);
|
|
} else {
|
|
if ((_inRate % _outRate) == 0 && (_inRate < 65536)) {
|
|
return simpleConvert(input, outBuffer, numSamples, volL, volR);
|
|
} else {
|
|
return interpolateConvert(input, outBuffer, numSamples, volL, volR);
|
|
}
|
|
}
|
|
}
|
|
|
|
RateConverter *makeRateConverter(st_rate_t inRate, st_rate_t outRate, bool inStereo, bool outStereo, bool reverseStereo) {
|
|
if (inStereo) {
|
|
if (outStereo) {
|
|
if (reverseStereo)
|
|
return new RateConverter_Impl<true, true, true>(inRate, outRate);
|
|
else
|
|
return new RateConverter_Impl<true, true, false>(inRate, outRate);
|
|
} else
|
|
return new RateConverter_Impl<true, false, false>(inRate, outRate);
|
|
} else {
|
|
if (outStereo) {
|
|
return new RateConverter_Impl<false, true, false>(inRate, outRate);
|
|
} else
|
|
return new RateConverter_Impl<false, false, false>(inRate, outRate);
|
|
}
|
|
}
|
|
|
|
} // End of namespace Audio
|