3rdparty/SoundTouch/RateTransposer.cpp

////////////////////////////////////////////////////////////////////////////////
///
/// Sample rate transposer. Changes sample rate by using linear interpolation
/// together with anti-alias filtering (first order interpolation with anti-
/// alias filtering should be quite adequate for this application)
///
/// Author        : Copyright (c) Olli Parviainen
/// Author e-mail : oparviai 'at' iki.fi
/// SoundTouch WWW: http://www.surina.net/soundtouch
///
////////////////////////////////////////////////////////////////////////////////
//
// Last changed  : $Date: 2009-10-31 16:37:24 +0200 (Sat, 31 Oct 2009) $
// File revision : $Revision: 4 $
//
// $Id: RateTransposer.cpp 74 2009-10-31 14:37:24Z oparviai $
//
////////////////////////////////////////////////////////////////////////////////
//
// License :
//
//  SoundTouch audio processing library
//  Copyright (c) Olli Parviainen
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library 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
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
////////////////////////////////////////////////////////////////////////////////

#include <memory.h>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdexcept>
#include "RateTransposer.h"
#include "AAFilter.h"

using namespace std;
using namespace soundtouch;


/// A linear samplerate transposer class that uses integer arithmetics.
/// for the transposing.
class RateTransposerInteger : public RateTransposer
{
protected:
    int iSlopeCount;
    int iRate;
    SAMPLETYPE sPrevSampleL, sPrevSampleR;

    virtual void resetRegisters();

    virtual uint transposeStereo(SAMPLETYPE *dest,
                         const SAMPLETYPE *src,
                         uint numSamples);
    virtual uint transposeMono(SAMPLETYPE *dest,
                       const SAMPLETYPE *src,
                       uint numSamples);

public:
    RateTransposerInteger();
    virtual ~RateTransposerInteger();

    /// Sets new target rate. Normal rate = 1.0, smaller values represent slower
    /// rate, larger faster rates.
    virtual void setRate(float newRate);

};


/// A linear samplerate transposer class that uses floating point arithmetics
/// for the transposing.
class RateTransposerFloat : public RateTransposer
{
protected:
    float fSlopeCount;
    SAMPLETYPE sPrevSampleL, sPrevSampleR;

    virtual void resetRegisters();

    virtual uint transposeStereo(SAMPLETYPE *dest,
                         const SAMPLETYPE *src,
                         uint numSamples);
    virtual uint transposeMono(SAMPLETYPE *dest,
                       const SAMPLETYPE *src,
                       uint numSamples);

public:
    RateTransposerFloat();
    virtual ~RateTransposerFloat();
};


// Operator 'new' is overloaded so that it automatically creates a suitable instance
// depending on if we've a MMX/SSE/etc-capable CPU available or not.
void * RateTransposer::operator new(size_t s)
{
    throw runtime_error("Error in RateTransoser::new: don't use \"new TDStretch\" directly, use \"newInstance\" to create a new instance instead!");
    return NULL;
}


RateTransposer *RateTransposer::newInstance()
{
#ifdef INTEGER_SAMPLES
    return ::new RateTransposerInteger;
#else
    return ::new RateTransposerFloat;
#endif
}


// Constructor
RateTransposer::RateTransposer() : FIFOProcessor(&outputBuffer)
{
    numChannels = 2;
    bUseAAFilter = TRUE;
    fRate = 0;

    // Instantiates the anti-alias filter with default tap length
    // of 32
    pAAFilter = new AAFilter(32);
}


RateTransposer::~RateTransposer()
{
    delete pAAFilter;
}


/// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
void RateTransposer::enableAAFilter(BOOL newMode)
{
    bUseAAFilter = newMode;
}


/// Returns nonzero if anti-alias filter is enabled.
BOOL RateTransposer::isAAFilterEnabled() const
{
    return bUseAAFilter;
}


AAFilter *RateTransposer::getAAFilter()
{
    return pAAFilter;
}


// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
// iRate, larger faster iRates.
void RateTransposer::setRate(float newRate)
{
    double fCutoff;

    fRate = newRate;

    // design a new anti-alias filter
    if (newRate > 1.0f)
    {
        fCutoff = 0.5f / newRate;
    }
    else
    {
        fCutoff = 0.5f * newRate;
    }
    pAAFilter->setCutoffFreq(fCutoff);
}


// Outputs as many samples of the 'outputBuffer' as possible, and if there's
// any room left, outputs also as many of the incoming samples as possible.
// The goal is to drive the outputBuffer empty.
//
// It's allowed for 'output' and 'input' parameters to point to the same
// memory position.
/*
void RateTransposer::flushStoreBuffer()
{
    if (storeBuffer.isEmpty()) return;

    outputBuffer.moveSamples(storeBuffer);
}
*/


// Adds 'nSamples' pcs of samples from the 'samples' memory position into
// the input of the object.
void RateTransposer::putSamples(const SAMPLETYPE *samples, uint nSamples)
{
    processSamples(samples, nSamples);
}


// Transposes up the sample rate, causing the observed playback 'rate' of the
// sound to decrease
void RateTransposer::upsample(const SAMPLETYPE *src, uint nSamples)
{
    uint count, sizeTemp, num;

    // If the parameter 'uRate' value is smaller than 'SCALE', first transpose
    // the samples and then apply the anti-alias filter to remove aliasing.

    // First check that there's enough room in 'storeBuffer'
    // (+16 is to reserve some slack in the destination buffer)
    sizeTemp = (uint)((float)nSamples / fRate + 16.0f);

    // Transpose the samples, store the result into the end of "storeBuffer"
    count = transpose(storeBuffer.ptrEnd(sizeTemp), src, nSamples);
    storeBuffer.putSamples(count);

    // Apply the anti-alias filter to samples in "store output", output the
    // result to "dest"
    num = storeBuffer.numSamples();
    count = pAAFilter->evaluate(outputBuffer.ptrEnd(num),
        storeBuffer.ptrBegin(), num, (uint)numChannels);
    outputBuffer.putSamples(count);

    // Remove the processed samples from "storeBuffer"
    storeBuffer.receiveSamples(count);
}


// Transposes down the sample rate, causing the observed playback 'rate' of the
// sound to increase
void RateTransposer::downsample(const SAMPLETYPE *src, uint nSamples)
{
    uint count, sizeTemp;

    // If the parameter 'uRate' value is larger than 'SCALE', first apply the
    // anti-alias filter to remove high frequencies (prevent them from folding
    // over the lover frequencies), then transpose.

    // Add the new samples to the end of the storeBuffer
    storeBuffer.putSamples(src, nSamples);

    // Anti-alias filter the samples to prevent folding and output the filtered
    // data to tempBuffer. Note : because of the FIR filter length, the
    // filtering routine takes in 'filter_length' more samples than it outputs.
    assert(tempBuffer.isEmpty());
    sizeTemp = storeBuffer.numSamples();

    count = pAAFilter->evaluate(tempBuffer.ptrEnd(sizeTemp),
        storeBuffer.ptrBegin(), sizeTemp, (uint)numChannels);

        if (count == 0) return;

    // Remove the filtered samples from 'storeBuffer'
    storeBuffer.receiveSamples(count);

    // Transpose the samples (+16 is to reserve some slack in the destination buffer)
    sizeTemp = (uint)((float)nSamples / fRate + 16.0f);
    count = transpose(outputBuffer.ptrEnd(sizeTemp), tempBuffer.ptrBegin(), count);
    outputBuffer.putSamples(count);
}


// Transposes sample rate by applying anti-alias filter to prevent folding.
// Returns amount of samples returned in the "dest" buffer.
// The maximum amount of samples that can be returned at a time is set by
// the 'set_returnBuffer_size' function.
void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
{
    uint count;
    uint sizeReq;

    if (nSamples == 0) return;
    assert(pAAFilter);

    // If anti-alias filter is turned off, simply transpose without applying
    // the filter
    if (bUseAAFilter == FALSE)
    {
        sizeReq = (uint)((float)nSamples / fRate + 1.0f);
        count = transpose(outputBuffer.ptrEnd(sizeReq), src, nSamples);
        outputBuffer.putSamples(count);
        return;
    }

    // Transpose with anti-alias filter
    if (fRate < 1.0f)
    {
        upsample(src, nSamples);
    }
    else
    {
        downsample(src, nSamples);
    }
}


// Transposes the sample rate of the given samples using linear interpolation.
// Returns the number of samples returned in the "dest" buffer
inline uint RateTransposer::transpose(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples)
{
    if (numChannels == 2)
    {
        return transposeStereo(dest, src, nSamples);
    }
    else
    {
        return transposeMono(dest, src, nSamples);
    }
}


// Sets the number of channels, 1 = mono, 2 = stereo
void RateTransposer::setChannels(int nChannels)
{
    assert(nChannels > 0);
    if (numChannels == nChannels) return;

    assert(nChannels == 1 || nChannels == 2);
    numChannels = nChannels;

    storeBuffer.setChannels(numChannels);
    tempBuffer.setChannels(numChannels);
    outputBuffer.setChannels(numChannels);

    // Inits the linear interpolation registers
    resetRegisters();
}


// Clears all the samples in the object
void RateTransposer::clear()
{
    outputBuffer.clear();
    storeBuffer.clear();
}


// Returns nonzero if there aren't any samples available for outputting.
int RateTransposer::isEmpty() const
{
    int res;

    res = FIFOProcessor::isEmpty();
    if (res == 0) return 0;
    return storeBuffer.isEmpty();
}


//////////////////////////////////////////////////////////////////////////////
//
// RateTransposerInteger - integer arithmetic implementation
//

/// fixed-point interpolation routine precision
#define SCALE    65536

// Constructor
RateTransposerInteger::RateTransposerInteger() : RateTransposer()
{
    // Notice: use local function calling syntax for sake of clarity,
    // to indicate the fact that C++ constructor can't call virtual functions.
    RateTransposerInteger::resetRegisters();
    RateTransposerInteger::setRate(1.0f);
}


RateTransposerInteger::~RateTransposerInteger()
{
}


void RateTransposerInteger::resetRegisters()
{
    iSlopeCount = 0;
    sPrevSampleL =
    sPrevSampleR = 0;
}


// Transposes the sample rate of the given samples using linear interpolation.
// 'Mono' version of the routine. Returns the number of samples returned in
// the "dest" buffer
uint RateTransposerInteger::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples)
{
    unsigned int i, used;
    LONG_SAMPLETYPE temp, vol1;

    if (nSamples == 0) return 0;  // no samples, no work

        used = 0;
    i = 0;

    // Process the last sample saved from the previous call first...
    while (iSlopeCount <= SCALE)
    {
        vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
        temp = vol1 * sPrevSampleL + iSlopeCount * src[0];
        dest[i] = (SAMPLETYPE)(temp / SCALE);
        i++;
        iSlopeCount += iRate;
    }
    // now always (iSlopeCount > SCALE)
    iSlopeCount -= SCALE;

    while (1)
    {
        while (iSlopeCount > SCALE)
        {
            iSlopeCount -= SCALE;
            used ++;
            if (used >= nSamples - 1) goto end;
        }
        vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
        temp = src[used] * vol1 + iSlopeCount * src[used + 1];
        dest[i] = (SAMPLETYPE)(temp / SCALE);

        i++;
        iSlopeCount += iRate;
    }
end:
    // Store the last sample for the next round
    sPrevSampleL = src[nSamples - 1];

    return i;
}


// Transposes the sample rate of the given samples using linear interpolation.
// 'Stereo' version of the routine. Returns the number of samples returned in
// the "dest" buffer
uint RateTransposerInteger::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples)
{
    unsigned int srcPos, i, used;
    LONG_SAMPLETYPE temp, vol1;

    if (nSamples == 0) return 0;  // no samples, no work

    used = 0;
    i = 0;

    // Process the last sample saved from the sPrevSampleLious call first...
    while (iSlopeCount <= SCALE)
    {
        vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
        temp = vol1 * sPrevSampleL + iSlopeCount * src[0];
        dest[2 * i] = (SAMPLETYPE)(temp / SCALE);
        temp = vol1 * sPrevSampleR + iSlopeCount * src[1];
        dest[2 * i + 1] = (SAMPLETYPE)(temp / SCALE);
        i++;
        iSlopeCount += iRate;
    }
    // now always (iSlopeCount > SCALE)
    iSlopeCount -= SCALE;

    while (1)
    {
        while (iSlopeCount > SCALE)
        {
            iSlopeCount -= SCALE;
            used ++;
            if (used >= nSamples - 1) goto end;
        }
        srcPos = 2 * used;
        vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
        temp = src[srcPos] * vol1 + iSlopeCount * src[srcPos + 2];
        dest[2 * i] = (SAMPLETYPE)(temp / SCALE);
        temp = src[srcPos + 1] * vol1 + iSlopeCount * src[srcPos + 3];
        dest[2 * i + 1] = (SAMPLETYPE)(temp / SCALE);

        i++;
        iSlopeCount += iRate;
    }
end:
    // Store the last sample for the next round
    sPrevSampleL = src[2 * nSamples - 2];
    sPrevSampleR = src[2 * nSamples - 1];

    return i;
}


// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
// iRate, larger faster iRates.
void RateTransposerInteger::setRate(float newRate)
{
    iRate = (int)(newRate * SCALE + 0.5f);
    RateTransposer::setRate(newRate);
}


//////////////////////////////////////////////////////////////////////////////
//
// RateTransposerFloat - floating point arithmetic implementation
//
//////////////////////////////////////////////////////////////////////////////

// Constructor
RateTransposerFloat::RateTransposerFloat() : RateTransposer()
{
    // Notice: use local function calling syntax for sake of clarity,
    // to indicate the fact that C++ constructor can't call virtual functions.
    RateTransposerFloat::resetRegisters();
    RateTransposerFloat::setRate(1.0f);
}


RateTransposerFloat::~RateTransposerFloat()
{
}


void RateTransposerFloat::resetRegisters()
{
    fSlopeCount = 0;
    sPrevSampleL =
    sPrevSampleR = 0;
}


// Transposes the sample rate of the given samples using linear interpolation.
// 'Mono' version of the routine. Returns the number of samples returned in
// the "dest" buffer
uint RateTransposerFloat::transposeMono(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples)
{
    unsigned int i, used;

    used = 0;
    i = 0;

    // Process the last sample saved from the previous call first...
    while (fSlopeCount <= 1.0f)
    {
        dest[i] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleL + fSlopeCount * src[0]);
        i++;
        fSlopeCount += fRate;
    }
    fSlopeCount -= 1.0f;

    if (nSamples > 1)
    {
        while (1)
        {
            while (fSlopeCount > 1.0f)
            {
                fSlopeCount -= 1.0f;
                used ++;
                if (used >= nSamples - 1) goto end;
            }
            dest[i] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[used] + fSlopeCount * src[used + 1]);
            i++;
            fSlopeCount += fRate;
        }
    }
end:
    // Store the last sample for the next round
    sPrevSampleL = src[nSamples - 1];

    return i;
}


// Transposes the sample rate of the given samples using linear interpolation.
// 'Mono' version of the routine. Returns the number of samples returned in
// the "dest" buffer
uint RateTransposerFloat::transposeStereo(SAMPLETYPE *dest, const SAMPLETYPE *src, uint nSamples)
{
    unsigned int srcPos, i, used;

    if (nSamples == 0) return 0;  // no samples, no work

    used = 0;
    i = 0;

    // Process the last sample saved from the sPrevSampleLious call first...
    while (fSlopeCount <= 1.0f)
    {
        dest[2 * i] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleL + fSlopeCount * src[0]);
        dest[2 * i + 1] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleR + fSlopeCount * src[1]);
        i++;
        fSlopeCount += fRate;
    }
    // now always (iSlopeCount > 1.0f)
    fSlopeCount -= 1.0f;

    if (nSamples > 1)
    {
        while (1)
        {
            while (fSlopeCount > 1.0f)
            {
                fSlopeCount -= 1.0f;
                used ++;
                if (used >= nSamples - 1) goto end;
            }
            srcPos = 2 * used;

            dest[2 * i] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[srcPos]
                + fSlopeCount * src[srcPos + 2]);
            dest[2 * i + 1] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[srcPos + 1]
                + fSlopeCount * src[srcPos + 3]);

            i++;
            fSlopeCount += fRate;
        }
    }
end:
    // Store the last sample for the next round
    sPrevSampleL = src[2 * nSamples - 2];
    sPrevSampleR = src[2 * nSamples - 1];

    return i;
}
1	william	31	////////////////////////////////////////////////////////////////////////////////
2			///
3			/// Sample rate transposer. Changes sample rate by using linear interpolation
4			/// together with anti-alias filtering (first order interpolation with anti-
5			/// alias filtering should be quite adequate for this application)
6			///
7			/// Author : Copyright (c) Olli Parviainen
8			/// Author e-mail : oparviai 'at' iki.fi
9			/// SoundTouch WWW: http://www.surina.net/soundtouch
10			///
11			////////////////////////////////////////////////////////////////////////////////
12			//
13			// Last changed : $Date: 2009-10-31 16:37:24 +0200 (Sat, 31 Oct 2009) $
14			// File revision : $Revision: 4 $
15			//
16			// $Id: RateTransposer.cpp 74 2009-10-31 14:37:24Z oparviai $
17			//
18			////////////////////////////////////////////////////////////////////////////////
19			//
20			// License :
21			//
22			// SoundTouch audio processing library
23			// Copyright (c) Olli Parviainen
24			//
25			// This library is free software; you can redistribute it and/or
26			// modify it under the terms of the GNU Lesser General Public
27			// License as published by the Free Software Foundation; either
28			// version 2.1 of the License, or (at your option) any later version.
29			//
30			// This library is distributed in the hope that it will be useful,
31			// but WITHOUT ANY WARRANTY; without even the implied warranty of
32			// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
33			// Lesser General Public License for more details.
34			//
35			// You should have received a copy of the GNU Lesser General Public
36			// License along with this library; if not, write to the Free Software
37			// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
38			//
39			////////////////////////////////////////////////////////////////////////////////
40
41			#include <memory.h>
42			#include <assert.h>
43			#include <stdlib.h>
44			#include <stdio.h>
45			#include <stdexcept>
46			#include "RateTransposer.h"
47			#include "AAFilter.h"
48
49			using namespace std;
50			using namespace soundtouch;
51
52
53			/// A linear samplerate transposer class that uses integer arithmetics.
54			/// for the transposing.
55			class RateTransposerInteger : public RateTransposer
56			{
57			protected:
58			int iSlopeCount;
59			int iRate;
60			SAMPLETYPE sPrevSampleL, sPrevSampleR;
61
62			virtual void resetRegisters();
63
64			virtual uint transposeStereo(SAMPLETYPE *dest,
65			const SAMPLETYPE *src,
66			uint numSamples);
67			virtual uint transposeMono(SAMPLETYPE *dest,
68			const SAMPLETYPE *src,
69			uint numSamples);
70
71			public:
72			RateTransposerInteger();
73			virtual ~RateTransposerInteger();
74
75			/// Sets new target rate. Normal rate = 1.0, smaller values represent slower
76			/// rate, larger faster rates.
77			virtual void setRate(float newRate);
78
79			};
80
81
82			/// A linear samplerate transposer class that uses floating point arithmetics
83			/// for the transposing.
84			class RateTransposerFloat : public RateTransposer
85			{
86			protected:
87			float fSlopeCount;
88			SAMPLETYPE sPrevSampleL, sPrevSampleR;
89
90			virtual void resetRegisters();
91
92			virtual uint transposeStereo(SAMPLETYPE *dest,
93			const SAMPLETYPE *src,
94			uint numSamples);
95			virtual uint transposeMono(SAMPLETYPE *dest,
96			const SAMPLETYPE *src,
97			uint numSamples);
98
99			public:
100			RateTransposerFloat();
101			virtual ~RateTransposerFloat();
102			};
103
104
105
106
107			// Operator 'new' is overloaded so that it automatically creates a suitable instance
108			// depending on if we've a MMX/SSE/etc-capable CPU available or not.
109			void * RateTransposer::operator new(size_t s)
110			{
111			throw runtime_error("Error in RateTransoser::new: don't use \"new TDStretch\" directly, use \"newInstance\" to create a new instance instead!");
112			return NULL;
113			}
114
115
116			RateTransposer *RateTransposer::newInstance()
117			{
118			#ifdef INTEGER_SAMPLES
119			return ::new RateTransposerInteger;
120			#else
121			return ::new RateTransposerFloat;
122			#endif
123			}
124
125
126			// Constructor
127			RateTransposer::RateTransposer() : FIFOProcessor(&outputBuffer)
128			{
129			numChannels = 2;
130			bUseAAFilter = TRUE;
131			fRate = 0;
132
133			// Instantiates the anti-alias filter with default tap length
134			// of 32
135			pAAFilter = new AAFilter(32);
136			}
137
138
139
140			RateTransposer::~RateTransposer()
141			{
142			delete pAAFilter;
143			}
144
145
146
147			/// Enables/disables the anti-alias filter. Zero to disable, nonzero to enable
148			void RateTransposer::enableAAFilter(BOOL newMode)
149			{
150			bUseAAFilter = newMode;
151			}
152
153
154			/// Returns nonzero if anti-alias filter is enabled.
155			BOOL RateTransposer::isAAFilterEnabled() const
156			{
157			return bUseAAFilter;
158			}
159
160
161			AAFilter *RateTransposer::getAAFilter()
162			{
163			return pAAFilter;
164			}
165
166
167
168			// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
169			// iRate, larger faster iRates.
170			void RateTransposer::setRate(float newRate)
171			{
172			double fCutoff;
173
174			fRate = newRate;
175
176			// design a new anti-alias filter
177			if (newRate > 1.0f)
178			{
179			fCutoff = 0.5f / newRate;
180			}
181			else
182			{
183			fCutoff = 0.5f * newRate;
184			}
185			pAAFilter->setCutoffFreq(fCutoff);
186			}
187
188
189			// Outputs as many samples of the 'outputBuffer' as possible, and if there's
190			// any room left, outputs also as many of the incoming samples as possible.
191			// The goal is to drive the outputBuffer empty.
192			//
193			// It's allowed for 'output' and 'input' parameters to point to the same
194			// memory position.
195			/*
196			void RateTransposer::flushStoreBuffer()
197			{
198			if (storeBuffer.isEmpty()) return;
199
200			outputBuffer.moveSamples(storeBuffer);
201			}
202			*/
203
204
205			// Adds 'nSamples' pcs of samples from the 'samples' memory position into
206			// the input of the object.
207			void RateTransposer::putSamples(const SAMPLETYPE *samples, uint nSamples)
208			{
209			processSamples(samples, nSamples);
210			}
211
212
213
214			// Transposes up the sample rate, causing the observed playback 'rate' of the
215			// sound to decrease
216			void RateTransposer::upsample(const SAMPLETYPE *src, uint nSamples)
217			{
218			uint count, sizeTemp, num;
219
220			// If the parameter 'uRate' value is smaller than 'SCALE', first transpose
221			// the samples and then apply the anti-alias filter to remove aliasing.
222
223			// First check that there's enough room in 'storeBuffer'
224			// (+16 is to reserve some slack in the destination buffer)
225			sizeTemp = (uint)((float)nSamples / fRate + 16.0f);
226
227			// Transpose the samples, store the result into the end of "storeBuffer"
228			count = transpose(storeBuffer.ptrEnd(sizeTemp), src, nSamples);
229			storeBuffer.putSamples(count);
230
231			// Apply the anti-alias filter to samples in "store output", output the
232			// result to "dest"
233			num = storeBuffer.numSamples();
234			count = pAAFilter->evaluate(outputBuffer.ptrEnd(num),
235			storeBuffer.ptrBegin(), num, (uint)numChannels);
236			outputBuffer.putSamples(count);
237
238			// Remove the processed samples from "storeBuffer"
239			storeBuffer.receiveSamples(count);
240			}
241
242
243			// Transposes down the sample rate, causing the observed playback 'rate' of the
244			// sound to increase
245			void RateTransposer::downsample(const SAMPLETYPE *src, uint nSamples)
246			{
247			uint count, sizeTemp;
248
249			// If the parameter 'uRate' value is larger than 'SCALE', first apply the
250			// anti-alias filter to remove high frequencies (prevent them from folding
251			// over the lover frequencies), then transpose.
252
253			// Add the new samples to the end of the storeBuffer
254			storeBuffer.putSamples(src, nSamples);
255
256			// Anti-alias filter the samples to prevent folding and output the filtered
257			// data to tempBuffer. Note : because of the FIR filter length, the
258			// filtering routine takes in 'filter_length' more samples than it outputs.
259			assert(tempBuffer.isEmpty());
260			sizeTemp = storeBuffer.numSamples();
261
262			count = pAAFilter->evaluate(tempBuffer.ptrEnd(sizeTemp),
263			storeBuffer.ptrBegin(), sizeTemp, (uint)numChannels);
264
265			if (count == 0) return;
266
267			// Remove the filtered samples from 'storeBuffer'
268			storeBuffer.receiveSamples(count);
269
270			// Transpose the samples (+16 is to reserve some slack in the destination buffer)
271			sizeTemp = (uint)((float)nSamples / fRate + 16.0f);
272			count = transpose(outputBuffer.ptrEnd(sizeTemp), tempBuffer.ptrBegin(), count);
273			outputBuffer.putSamples(count);
274			}
275
276
277			// Transposes sample rate by applying anti-alias filter to prevent folding.
278			// Returns amount of samples returned in the "dest" buffer.
279			// The maximum amount of samples that can be returned at a time is set by
280			// the 'set_returnBuffer_size' function.
281			void RateTransposer::processSamples(const SAMPLETYPE *src, uint nSamples)
282			{
283			uint count;
284			uint sizeReq;
285
286			if (nSamples == 0) return;
287			assert(pAAFilter);
288
289			// If anti-alias filter is turned off, simply transpose without applying
290			// the filter
291			if (bUseAAFilter == FALSE)
292			{
293			sizeReq = (uint)((float)nSamples / fRate + 1.0f);
294			count = transpose(outputBuffer.ptrEnd(sizeReq), src, nSamples);
295			outputBuffer.putSamples(count);
296			return;
297			}
298
299			// Transpose with anti-alias filter
300			if (fRate < 1.0f)
301			{
302			upsample(src, nSamples);
303			}
304			else
305			{
306			downsample(src, nSamples);
307			}
308			}
309
310
311			// Transposes the sample rate of the given samples using linear interpolation.
312			// Returns the number of samples returned in the "dest" buffer
313			inline uint RateTransposer::transpose(SAMPLETYPE dest, const SAMPLETYPE src, uint nSamples)
314			{
315			if (numChannels == 2)
316			{
317			return transposeStereo(dest, src, nSamples);
318			}
319			else
320			{
321			return transposeMono(dest, src, nSamples);
322			}
323			}
324
325
326			// Sets the number of channels, 1 = mono, 2 = stereo
327			void RateTransposer::setChannels(int nChannels)
328			{
329			assert(nChannels > 0);
330			if (numChannels == nChannels) return;
331
332			assert(nChannels == 1 \|\| nChannels == 2);
333			numChannels = nChannels;
334
335			storeBuffer.setChannels(numChannels);
336			tempBuffer.setChannels(numChannels);
337			outputBuffer.setChannels(numChannels);
338
339			// Inits the linear interpolation registers
340			resetRegisters();
341			}
342
343
344			// Clears all the samples in the object
345			void RateTransposer::clear()
346			{
347			outputBuffer.clear();
348			storeBuffer.clear();
349			}
350
351
352			// Returns nonzero if there aren't any samples available for outputting.
353			int RateTransposer::isEmpty() const
354			{
355			int res;
356
357			res = FIFOProcessor::isEmpty();
358			if (res == 0) return 0;
359			return storeBuffer.isEmpty();
360			}
361
362
363			//////////////////////////////////////////////////////////////////////////////
364			//
365			// RateTransposerInteger - integer arithmetic implementation
366			//
367
368			/// fixed-point interpolation routine precision
369			#define SCALE 65536
370
371			// Constructor
372			RateTransposerInteger::RateTransposerInteger() : RateTransposer()
373			{
374			// Notice: use local function calling syntax for sake of clarity,
375			// to indicate the fact that C++ constructor can't call virtual functions.
376			RateTransposerInteger::resetRegisters();
377			RateTransposerInteger::setRate(1.0f);
378			}
379
380
381			RateTransposerInteger::~RateTransposerInteger()
382			{
383			}
384
385
386			void RateTransposerInteger::resetRegisters()
387			{
388			iSlopeCount = 0;
389			sPrevSampleL =
390			sPrevSampleR = 0;
391			}
392
393
394
395			// Transposes the sample rate of the given samples using linear interpolation.
396			// 'Mono' version of the routine. Returns the number of samples returned in
397			// the "dest" buffer
398			uint RateTransposerInteger::transposeMono(SAMPLETYPE dest, const SAMPLETYPE src, uint nSamples)
399			{
400			unsigned int i, used;
401			LONG_SAMPLETYPE temp, vol1;
402
403			if (nSamples == 0) return 0; // no samples, no work
404
405			used = 0;
406			i = 0;
407
408			// Process the last sample saved from the previous call first...
409			while (iSlopeCount <= SCALE)
410			{
411			vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
412			temp = vol1 * sPrevSampleL + iSlopeCount * src[0];
413			dest[i] = (SAMPLETYPE)(temp / SCALE);
414			i++;
415			iSlopeCount += iRate;
416			}
417			// now always (iSlopeCount > SCALE)
418			iSlopeCount -= SCALE;
419
420			while (1)
421			{
422			while (iSlopeCount > SCALE)
423			{
424			iSlopeCount -= SCALE;
425			used ++;
426			if (used >= nSamples - 1) goto end;
427			}
428			vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
429			temp = src[used] * vol1 + iSlopeCount * src[used + 1];
430			dest[i] = (SAMPLETYPE)(temp / SCALE);
431
432			i++;
433			iSlopeCount += iRate;
434			}
435			end:
436			// Store the last sample for the next round
437			sPrevSampleL = src[nSamples - 1];
438
439			return i;
440			}
441
442
443			// Transposes the sample rate of the given samples using linear interpolation.
444			// 'Stereo' version of the routine. Returns the number of samples returned in
445			// the "dest" buffer
446			uint RateTransposerInteger::transposeStereo(SAMPLETYPE dest, const SAMPLETYPE src, uint nSamples)
447			{
448			unsigned int srcPos, i, used;
449			LONG_SAMPLETYPE temp, vol1;
450
451			if (nSamples == 0) return 0; // no samples, no work
452
453			used = 0;
454			i = 0;
455
456			// Process the last sample saved from the sPrevSampleLious call first...
457			while (iSlopeCount <= SCALE)
458			{
459			vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
460			temp = vol1 * sPrevSampleL + iSlopeCount * src[0];
461			dest[2 * i] = (SAMPLETYPE)(temp / SCALE);
462			temp = vol1 * sPrevSampleR + iSlopeCount * src[1];
463			dest[2 * i + 1] = (SAMPLETYPE)(temp / SCALE);
464			i++;
465			iSlopeCount += iRate;
466			}
467			// now always (iSlopeCount > SCALE)
468			iSlopeCount -= SCALE;
469
470			while (1)
471			{
472			while (iSlopeCount > SCALE)
473			{
474			iSlopeCount -= SCALE;
475			used ++;
476			if (used >= nSamples - 1) goto end;
477			}
478			srcPos = 2 * used;
479			vol1 = (LONG_SAMPLETYPE)(SCALE - iSlopeCount);
480			temp = src[srcPos] * vol1 + iSlopeCount * src[srcPos + 2];
481			dest[2 * i] = (SAMPLETYPE)(temp / SCALE);
482			temp = src[srcPos + 1] * vol1 + iSlopeCount * src[srcPos + 3];
483			dest[2 * i + 1] = (SAMPLETYPE)(temp / SCALE);
484
485			i++;
486			iSlopeCount += iRate;
487			}
488			end:
489			// Store the last sample for the next round
490			sPrevSampleL = src[2 * nSamples - 2];
491			sPrevSampleR = src[2 * nSamples - 1];
492
493			return i;
494			}
495
496
497			// Sets new target iRate. Normal iRate = 1.0, smaller values represent slower
498			// iRate, larger faster iRates.
499			void RateTransposerInteger::setRate(float newRate)
500			{
501			iRate = (int)(newRate * SCALE + 0.5f);
502			RateTransposer::setRate(newRate);
503			}
504
505
506			//////////////////////////////////////////////////////////////////////////////
507			//
508			// RateTransposerFloat - floating point arithmetic implementation
509			//
510			//////////////////////////////////////////////////////////////////////////////
511
512			// Constructor
513			RateTransposerFloat::RateTransposerFloat() : RateTransposer()
514			{
515			// Notice: use local function calling syntax for sake of clarity,
516			// to indicate the fact that C++ constructor can't call virtual functions.
517			RateTransposerFloat::resetRegisters();
518			RateTransposerFloat::setRate(1.0f);
519			}
520
521
522			RateTransposerFloat::~RateTransposerFloat()
523			{
524			}
525
526
527			void RateTransposerFloat::resetRegisters()
528			{
529			fSlopeCount = 0;
530			sPrevSampleL =
531			sPrevSampleR = 0;
532			}
533
534
535
536			// Transposes the sample rate of the given samples using linear interpolation.
537			// 'Mono' version of the routine. Returns the number of samples returned in
538			// the "dest" buffer
539			uint RateTransposerFloat::transposeMono(SAMPLETYPE dest, const SAMPLETYPE src, uint nSamples)
540			{
541			unsigned int i, used;
542
543			used = 0;
544			i = 0;
545
546			// Process the last sample saved from the previous call first...
547			while (fSlopeCount <= 1.0f)
548			{
549			dest[i] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleL + fSlopeCount * src[0]);
550			i++;
551			fSlopeCount += fRate;
552			}
553			fSlopeCount -= 1.0f;
554
555			if (nSamples > 1)
556			{
557			while (1)
558			{
559			while (fSlopeCount > 1.0f)
560			{
561			fSlopeCount -= 1.0f;
562			used ++;
563			if (used >= nSamples - 1) goto end;
564			}
565			dest[i] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[used] + fSlopeCount * src[used + 1]);
566			i++;
567			fSlopeCount += fRate;
568			}
569			}
570			end:
571			// Store the last sample for the next round
572			sPrevSampleL = src[nSamples - 1];
573
574			return i;
575			}
576
577
578			// Transposes the sample rate of the given samples using linear interpolation.
579			// 'Mono' version of the routine. Returns the number of samples returned in
580			// the "dest" buffer
581			uint RateTransposerFloat::transposeStereo(SAMPLETYPE dest, const SAMPLETYPE src, uint nSamples)
582			{
583			unsigned int srcPos, i, used;
584
585			if (nSamples == 0) return 0; // no samples, no work
586
587			used = 0;
588			i = 0;
589
590			// Process the last sample saved from the sPrevSampleLious call first...
591			while (fSlopeCount <= 1.0f)
592			{
593			dest[2 * i] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleL + fSlopeCount * src[0]);
594			dest[2 * i + 1] = (SAMPLETYPE)((1.0f - fSlopeCount) * sPrevSampleR + fSlopeCount * src[1]);
595			i++;
596			fSlopeCount += fRate;
597			}
598			// now always (iSlopeCount > 1.0f)
599			fSlopeCount -= 1.0f;
600
601			if (nSamples > 1)
602			{
603			while (1)
604			{
605			while (fSlopeCount > 1.0f)
606			{
607			fSlopeCount -= 1.0f;
608			used ++;
609			if (used >= nSamples - 1) goto end;
610			}
611			srcPos = 2 * used;
612
613			dest[2 * i] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[srcPos]
614			+ fSlopeCount * src[srcPos + 2]);
615			dest[2 * i + 1] = (SAMPLETYPE)((1.0f - fSlopeCount) * src[srcPos + 1]
616			+ fSlopeCount * src[srcPos + 3]);
617
618			i++;
619			fSlopeCount += fRate;
620			}
621			}
622			end:
623			// Store the last sample for the next round
624			sPrevSampleL = src[2 * nSamples - 2];
625			sPrevSampleR = src[2 * nSamples - 1];
626
627			return i;
628			}