3rdparty/SoundTouch/SoundTouch.cpp

//////////////////////////////////////////////////////////////////////////////
///
/// SoundTouch - main class for tempo/pitch/rate adjusting routines.
///
/// Notes:
/// - Initialize the SoundTouch object instance by setting up the sound stream
///   parameters with functions 'setSampleRate' and 'setChannels', then set
///   desired tempo/pitch/rate settings with the corresponding functions.
///
/// - The SoundTouch class behaves like a first-in-first-out pipeline: The
///   samples that are to be processed are fed into one of the pipe by calling
///   function 'putSamples', while the ready processed samples can be read
///   from the other end of the pipeline with function 'receiveSamples'.
///
/// - The SoundTouch processing classes require certain sized 'batches' of
///   samples in order to process the sound. For this reason the classes buffer
///   incoming samples until there are enough of samples available for
///   processing, then they carry out the processing step and consequently
///   make the processed samples available for outputting.
///
/// - For the above reason, the processing routines introduce a certain
///   'latency' between the input and output, so that the samples input to
///   SoundTouch may not be immediately available in the output, and neither
///   the amount of outputtable samples may not immediately be in direct
///   relationship with the amount of previously input samples.
///
/// - The tempo/pitch/rate control parameters can be altered during processing.
///   Please notice though that they aren't currently protected by semaphores,
///   so in multi-thread application external semaphore protection may be
///   required.
///
/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
///   pitch) and 'RateTransposer' for changing the playback rate (that is, both
///   tempo and pitch in the same ratio) of the sound. The third available control
///   'pitch' (change pitch but maintain tempo) is produced by a combination of
///   combining the two other controls.
///
/// Author        : Copyright (c) Olli Parviainen
/// Author e-mail : oparviai 'at' iki.fi
/// SoundTouch WWW: http://www.surina.net/soundtouch
///
////////////////////////////////////////////////////////////////////////////////
//
// Last changed  : $Date: 2009-05-19 07:57:30 +0300 (Tue, 19 May 2009) $
// File revision : $Revision: 4 $
//
// $Id: SoundTouch.cpp 73 2009-05-19 04:57:30Z 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 <assert.h>
#include <stdlib.h>
#include <memory.h>
#include <math.h>
#include <stdexcept>
#include <stdio.h>

#include "SoundTouch.h"
#include "TDStretch.h"
#include "RateTransposer.h"
#include "cpu_detect.h"

using namespace soundtouch;

/// test if two floating point numbers are equal
#define TEST_FLOAT_EQUAL(a, b)  (fabs(a - b) < 1e-10)


/// Print library version string for autoconf
extern "C" void soundtouch_ac_test()
{
    printf("SoundTouch Version: %s\n",SOUNDTOUCH_VERSION);
}


SoundTouch::SoundTouch()
{
    // Initialize rate transposer and tempo changer instances

    pRateTransposer = RateTransposer::newInstance();
    pTDStretch = TDStretch::newInstance();

    setOutPipe(pTDStretch);

    rate = tempo = 0;

    virtualPitch =
    virtualRate =
    virtualTempo = 1.0;

    calcEffectiveRateAndTempo();

    channels = 0;
    bSrateSet = FALSE;
}


SoundTouch::~SoundTouch()
{
    delete pRateTransposer;
    delete pTDStretch;
}


/// Get SoundTouch library version string
const char *SoundTouch::getVersionString()
{
    static const char *_version = SOUNDTOUCH_VERSION;

    return _version;
}


/// Get SoundTouch library version Id
uint SoundTouch::getVersionId()
{
    return SOUNDTOUCH_VERSION_ID;
}


// Sets the number of channels, 1 = mono, 2 = stereo
void SoundTouch::setChannels(uint numChannels)
{
    if (numChannels != 1 && numChannels != 2)
    {
        throw std::runtime_error("Illegal number of channels");
    }
    channels = numChannels;
    pRateTransposer->setChannels((int)numChannels);
    pTDStretch->setChannels((int)numChannels);
}


// Sets new rate control value. Normal rate = 1.0, smaller values
// represent slower rate, larger faster rates.
void SoundTouch::setRate(float newRate)
{
    virtualRate = newRate;
    calcEffectiveRateAndTempo();
}


// Sets new rate control value as a difference in percents compared
// to the original rate (-50 .. +100 %)
void SoundTouch::setRateChange(float newRate)
{
    virtualRate = 1.0f + 0.01f * newRate;
    calcEffectiveRateAndTempo();
}


// Sets new tempo control value. Normal tempo = 1.0, smaller values
// represent slower tempo, larger faster tempo.
void SoundTouch::setTempo(float newTempo)
{
    virtualTempo = newTempo;
    calcEffectiveRateAndTempo();
}


// Sets new tempo control value as a difference in percents compared
// to the original tempo (-50 .. +100 %)
void SoundTouch::setTempoChange(float newTempo)
{
    virtualTempo = 1.0f + 0.01f * newTempo;
    calcEffectiveRateAndTempo();
}


// Sets new pitch control value. Original pitch = 1.0, smaller values
// represent lower pitches, larger values higher pitch.
void SoundTouch::setPitch(float newPitch)
{
    virtualPitch = newPitch;
    calcEffectiveRateAndTempo();
}


// Sets pitch change in octaves compared to the original pitch
// (-1.00 .. +1.00)
void SoundTouch::setPitchOctaves(float newPitch)
{
    virtualPitch = (float)exp(0.69314718056f * newPitch);
    calcEffectiveRateAndTempo();
}


// Sets pitch change in semi-tones compared to the original pitch
// (-12 .. +12)
void SoundTouch::setPitchSemiTones(int newPitch)
{
    setPitchOctaves((float)newPitch / 12.0f);
}


void SoundTouch::setPitchSemiTones(float newPitch)
{
    setPitchOctaves(newPitch / 12.0f);
}


// Calculates 'effective' rate and tempo values from the
// nominal control values.
void SoundTouch::calcEffectiveRateAndTempo()
{
    float oldTempo = tempo;
    float oldRate = rate;

    tempo = virtualTempo / virtualPitch;
    rate = virtualPitch * virtualRate;

    if (!TEST_FLOAT_EQUAL(rate,oldRate)) pRateTransposer->setRate(rate);
    if (!TEST_FLOAT_EQUAL(tempo, oldTempo)) pTDStretch->setTempo(tempo);

#ifndef PREVENT_CLICK_AT_RATE_CROSSOVER
    if (rate <= 1.0f)
    {
        if (output != pTDStretch)
        {
            FIFOSamplePipe *tempoOut;

            assert(output == pRateTransposer);
            // move samples in the current output buffer to the output of pTDStretch
            tempoOut = pTDStretch->getOutput();
            tempoOut->moveSamples(*output);
            // move samples in pitch transposer's store buffer to tempo changer's input
            pTDStretch->moveSamples(*pRateTransposer->getStore());

            output = pTDStretch;
        }
    }
    else
#endif
    {
        if (output != pRateTransposer)
        {
            FIFOSamplePipe *transOut;

            assert(output == pTDStretch);
            // move samples in the current output buffer to the output of pRateTransposer
            transOut = pRateTransposer->getOutput();
            transOut->moveSamples(*output);
            // move samples in tempo changer's input to pitch transposer's input
            pRateTransposer->moveSamples(*pTDStretch->getInput());

            output = pRateTransposer;
        }
    }
}


// Sets sample rate.
void SoundTouch::setSampleRate(uint srate)
{
    bSrateSet = TRUE;
    // set sample rate, leave other tempo changer parameters as they are.
    pTDStretch->setParameters((int)srate);
}


// Adds 'numSamples' pcs of samples from the 'samples' memory position into
// the input of the object.
void SoundTouch::putSamples(const SAMPLETYPE *samples, uint nSamples)
{
    if (bSrateSet == FALSE)
    {
        throw std::runtime_error("SoundTouch : Sample rate not defined");
    }
    else if (channels == 0)
    {
        throw std::runtime_error("SoundTouch : Number of channels not defined");
    }

    // Transpose the rate of the new samples if necessary
    /* Bypass the nominal setting - can introduce a click in sound when tempo/pitch control crosses the nominal value...
    if (rate == 1.0f)
    {
        // The rate value is same as the original, simply evaluate the tempo changer.
        assert(output == pTDStretch);
        if (pRateTransposer->isEmpty() == 0)
        {
            // yet flush the last samples in the pitch transposer buffer
            // (may happen if 'rate' changes from a non-zero value to zero)
            pTDStretch->moveSamples(*pRateTransposer);
        }
        pTDStretch->putSamples(samples, nSamples);
    }
    */
#ifndef PREVENT_CLICK_AT_RATE_CROSSOVER
    else if (rate <= 1.0f)
    {
        // transpose the rate down, output the transposed sound to tempo changer buffer
        assert(output == pTDStretch);
        pRateTransposer->putSamples(samples, nSamples);
        pTDStretch->moveSamples(*pRateTransposer);
    }
    else
#endif
    {
        // evaluate the tempo changer, then transpose the rate up,
        assert(output == pRateTransposer);
        pTDStretch->putSamples(samples, nSamples);
        pRateTransposer->moveSamples(*pTDStretch);
    }
}


// Flushes the last samples from the processing pipeline to the output.
// Clears also the internal processing buffers.
//
// Note: This function is meant for extracting the last samples of a sound
// stream. This function may introduce additional blank samples in the end
// of the sound stream, and thus it's not recommended to call this function
// in the middle of a sound stream.
void SoundTouch::flush()
{
    int i;
    uint nOut;
    SAMPLETYPE buff[128];

    nOut = numSamples();

    memset(buff, 0, 128 * sizeof(SAMPLETYPE));
    // "Push" the last active samples out from the processing pipeline by
    // feeding blank samples into the processing pipeline until new,
    // processed samples appear in the output (not however, more than
    // 8ksamples in any case)
    for (i = 0; i < 128; i ++)
    {
        putSamples(buff, 64);
        if (numSamples() != nOut) break;  // new samples have appeared in the output!
    }

    // Clear working buffers
    pRateTransposer->clear();
    pTDStretch->clearInput();
    // yet leave the 'tempoChanger' output intouched as that's where the
    // flushed samples are!
}


// Changes a setting controlling the processing system behaviour. See the
// 'SETTING_...' defines for available setting ID's.
BOOL SoundTouch::setSetting(int settingId, int value)
{
    int sampleRate, sequenceMs, seekWindowMs, overlapMs;

    // read current tdstretch routine parameters
    pTDStretch->getParameters(&sampleRate, &sequenceMs, &seekWindowMs, &overlapMs);

    switch (settingId)
    {
        case SETTING_USE_AA_FILTER :
            // enables / disabless anti-alias filter
            pRateTransposer->enableAAFilter((value != 0) ? TRUE : FALSE);
            return TRUE;

        case SETTING_AA_FILTER_LENGTH :
            // sets anti-alias filter length
            pRateTransposer->getAAFilter()->setLength(value);
            return TRUE;

        case SETTING_USE_QUICKSEEK :
            // enables / disables tempo routine quick seeking algorithm
            pTDStretch->enableQuickSeek((value != 0) ? TRUE : FALSE);
            return TRUE;

        case SETTING_SEQUENCE_MS:
            // change time-stretch sequence duration parameter
            pTDStretch->setParameters(sampleRate, value, seekWindowMs, overlapMs);
            return TRUE;

        case SETTING_SEEKWINDOW_MS:
            // change time-stretch seek window length parameter
            pTDStretch->setParameters(sampleRate, sequenceMs, value, overlapMs);
            return TRUE;

        case SETTING_OVERLAP_MS:
            // change time-stretch overlap length parameter
            pTDStretch->setParameters(sampleRate, sequenceMs, seekWindowMs, value);
            return TRUE;

        default :
            return FALSE;
    }
}


// Reads a setting controlling the processing system behaviour. See the
// 'SETTING_...' defines for available setting ID's.
//
// Returns the setting value.
int SoundTouch::getSetting(int settingId) const
{
    int temp;

    switch (settingId)
    {
        case SETTING_USE_AA_FILTER :
            return (uint)pRateTransposer->isAAFilterEnabled();

        case SETTING_AA_FILTER_LENGTH :
            return pRateTransposer->getAAFilter()->getLength();

        case SETTING_USE_QUICKSEEK :
            return (uint)   pTDStretch->isQuickSeekEnabled();

        case SETTING_SEQUENCE_MS:
            pTDStretch->getParameters(NULL, &temp, NULL, NULL);
            return temp;

        case SETTING_SEEKWINDOW_MS:
            pTDStretch->getParameters(NULL, NULL, &temp, NULL);
            return temp;

        case SETTING_OVERLAP_MS:
            pTDStretch->getParameters(NULL, NULL, NULL, &temp);
            return temp;

        default :
            return 0;
    }
}


// Clears all the samples in the object's output and internal processing
// buffers.
void SoundTouch::clear()
{
    pRateTransposer->clear();
    pTDStretch->clear();
}


/// Returns number of samples currently unprocessed.
uint SoundTouch::numUnprocessedSamples() const
{
    FIFOSamplePipe * psp;
    if (pTDStretch)
    {
        psp = pTDStretch->getInput();
        if (psp)
        {
            return psp->numSamples();
        }
    }
    return 0;
}
1	//////////////////////////////////////////////////////////////////////////////
2	///
3	/// SoundTouch - main class for tempo/pitch/rate adjusting routines.
4	///
5	/// Notes:
6	/// - Initialize the SoundTouch object instance by setting up the sound stream
7	/// parameters with functions 'setSampleRate' and 'setChannels', then set
8	/// desired tempo/pitch/rate settings with the corresponding functions.
9	///
10	/// - The SoundTouch class behaves like a first-in-first-out pipeline: The
11	/// samples that are to be processed are fed into one of the pipe by calling
12	/// function 'putSamples', while the ready processed samples can be read
13	/// from the other end of the pipeline with function 'receiveSamples'.
14	///
15	/// - The SoundTouch processing classes require certain sized 'batches' of
16	/// samples in order to process the sound. For this reason the classes buffer
17	/// incoming samples until there are enough of samples available for
18	/// processing, then they carry out the processing step and consequently
19	/// make the processed samples available for outputting.
20	///
21	/// - For the above reason, the processing routines introduce a certain
22	/// 'latency' between the input and output, so that the samples input to
23	/// SoundTouch may not be immediately available in the output, and neither
24	/// the amount of outputtable samples may not immediately be in direct
25	/// relationship with the amount of previously input samples.
26	///
27	/// - The tempo/pitch/rate control parameters can be altered during processing.
28	/// Please notice though that they aren't currently protected by semaphores,
29	/// so in multi-thread application external semaphore protection may be
30	/// required.
31	///
32	/// - This class utilizes classes 'TDStretch' for tempo change (without modifying
33	/// pitch) and 'RateTransposer' for changing the playback rate (that is, both
34	/// tempo and pitch in the same ratio) of the sound. The third available control
35	/// 'pitch' (change pitch but maintain tempo) is produced by a combination of
36	/// combining the two other controls.
37	///
38	/// Author : Copyright (c) Olli Parviainen
39	/// Author e-mail : oparviai 'at' iki.fi
40	/// SoundTouch WWW: http://www.surina.net/soundtouch
41	///
42	////////////////////////////////////////////////////////////////////////////////
43	//
44	// Last changed : $Date: 2009-05-19 07:57:30 +0300 (Tue, 19 May 2009) $
45	// File revision : $Revision: 4 $
46	//
47	// $Id: SoundTouch.cpp 73 2009-05-19 04:57:30Z oparviai $
48	//
49	////////////////////////////////////////////////////////////////////////////////
50	//
51	// License :
52	//
53	// SoundTouch audio processing library
54	// Copyright (c) Olli Parviainen
55	//
56	// This library is free software; you can redistribute it and/or
57	// modify it under the terms of the GNU Lesser General Public
58	// License as published by the Free Software Foundation; either
59	// version 2.1 of the License, or (at your option) any later version.
60	//
61	// This library is distributed in the hope that it will be useful,
62	// but WITHOUT ANY WARRANTY; without even the implied warranty of
63	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
64	// Lesser General Public License for more details.
65	//
66	// You should have received a copy of the GNU Lesser General Public
67	// License along with this library; if not, write to the Free Software
68	// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
69	//
70	////////////////////////////////////////////////////////////////////////////////
71
72	#include <assert.h>
73	#include <stdlib.h>
74	#include <memory.h>
75	#include <math.h>
76	#include <stdexcept>
77	#include <stdio.h>
78
79	#include "SoundTouch.h"
80	#include "TDStretch.h"
81	#include "RateTransposer.h"
82	#include "cpu_detect.h"
83
84	using namespace soundtouch;
85
86	/// test if two floating point numbers are equal
87	#define TEST_FLOAT_EQUAL(a, b) (fabs(a - b) < 1e-10)
88
89
90	/// Print library version string for autoconf
91	extern "C" void soundtouch_ac_test()
92	{
93	printf("SoundTouch Version: %s\n",SOUNDTOUCH_VERSION);
94	}
95
96
97	SoundTouch::SoundTouch()
98	{
99	// Initialize rate transposer and tempo changer instances
100
101	pRateTransposer = RateTransposer::newInstance();
102	pTDStretch = TDStretch::newInstance();
103
104	setOutPipe(pTDStretch);
105
106	rate = tempo = 0;
107
108	virtualPitch =
109	virtualRate =
110	virtualTempo = 1.0;
111
112	calcEffectiveRateAndTempo();
113
114	channels = 0;
115	bSrateSet = FALSE;
116	}
117
118
119
120	SoundTouch::~SoundTouch()
121	{
122	delete pRateTransposer;
123	delete pTDStretch;
124	}
125
126
127
128	/// Get SoundTouch library version string
129	const char *SoundTouch::getVersionString()
130	{
131	static const char *_version = SOUNDTOUCH_VERSION;
132
133	return _version;
134	}
135
136
137	/// Get SoundTouch library version Id
138	uint SoundTouch::getVersionId()
139	{
140	return SOUNDTOUCH_VERSION_ID;
141	}
142
143
144	// Sets the number of channels, 1 = mono, 2 = stereo
145	void SoundTouch::setChannels(uint numChannels)
146	{
147	if (numChannels != 1 && numChannels != 2)
148	{
149	throw std::runtime_error("Illegal number of channels");
150	}
151	channels = numChannels;
152	pRateTransposer->setChannels((int)numChannels);
153	pTDStretch->setChannels((int)numChannels);
154	}
155
156
157
158	// Sets new rate control value. Normal rate = 1.0, smaller values
159	// represent slower rate, larger faster rates.
160	void SoundTouch::setRate(float newRate)
161	{
162	virtualRate = newRate;
163	calcEffectiveRateAndTempo();
164	}
165
166
167
168	// Sets new rate control value as a difference in percents compared
169	// to the original rate (-50 .. +100 %)
170	void SoundTouch::setRateChange(float newRate)
171	{
172	virtualRate = 1.0f + 0.01f * newRate;
173	calcEffectiveRateAndTempo();
174	}
175
176
177
178	// Sets new tempo control value. Normal tempo = 1.0, smaller values
179	// represent slower tempo, larger faster tempo.
180	void SoundTouch::setTempo(float newTempo)
181	{
182	virtualTempo = newTempo;
183	calcEffectiveRateAndTempo();
184	}
185
186
187
188	// Sets new tempo control value as a difference in percents compared
189	// to the original tempo (-50 .. +100 %)
190	void SoundTouch::setTempoChange(float newTempo)
191	{
192	virtualTempo = 1.0f + 0.01f * newTempo;
193	calcEffectiveRateAndTempo();
194	}
195
196
197
198	// Sets new pitch control value. Original pitch = 1.0, smaller values
199	// represent lower pitches, larger values higher pitch.
200	void SoundTouch::setPitch(float newPitch)
201	{
202	virtualPitch = newPitch;
203	calcEffectiveRateAndTempo();
204	}
205
206
207
208	// Sets pitch change in octaves compared to the original pitch
209	// (-1.00 .. +1.00)
210	void SoundTouch::setPitchOctaves(float newPitch)
211	{
212	virtualPitch = (float)exp(0.69314718056f * newPitch);
213	calcEffectiveRateAndTempo();
214	}
215
216
217
218	// Sets pitch change in semi-tones compared to the original pitch
219	// (-12 .. +12)
220	void SoundTouch::setPitchSemiTones(int newPitch)
221	{
222	setPitchOctaves((float)newPitch / 12.0f);
223	}
224
225
226
227	void SoundTouch::setPitchSemiTones(float newPitch)
228	{
229	setPitchOctaves(newPitch / 12.0f);
230	}
231
232
233	// Calculates 'effective' rate and tempo values from the
234	// nominal control values.
235	void SoundTouch::calcEffectiveRateAndTempo()
236	{
237	float oldTempo = tempo;
238	float oldRate = rate;
239
240	tempo = virtualTempo / virtualPitch;
241	rate = virtualPitch * virtualRate;
242
243	if (!TEST_FLOAT_EQUAL(rate,oldRate)) pRateTransposer->setRate(rate);
244	if (!TEST_FLOAT_EQUAL(tempo, oldTempo)) pTDStretch->setTempo(tempo);
245
246	#ifndef PREVENT_CLICK_AT_RATE_CROSSOVER
247	if (rate <= 1.0f)
248	{
249	if (output != pTDStretch)
250	{
251	FIFOSamplePipe *tempoOut;
252
253	assert(output == pRateTransposer);
254	// move samples in the current output buffer to the output of pTDStretch
255	tempoOut = pTDStretch->getOutput();
256	tempoOut->moveSamples(*output);
257	// move samples in pitch transposer's store buffer to tempo changer's input
258	pTDStretch->moveSamples(*pRateTransposer->getStore());
259
260	output = pTDStretch;
261	}
262	}
263	else
264	#endif
265	{
266	if (output != pRateTransposer)
267	{
268	FIFOSamplePipe *transOut;
269
270	assert(output == pTDStretch);
271	// move samples in the current output buffer to the output of pRateTransposer
272	transOut = pRateTransposer->getOutput();
273	transOut->moveSamples(*output);
274	// move samples in tempo changer's input to pitch transposer's input
275	pRateTransposer->moveSamples(*pTDStretch->getInput());
276
277	output = pRateTransposer;
278	}
279	}
280	}
281
282
283	// Sets sample rate.
284	void SoundTouch::setSampleRate(uint srate)
285	{
286	bSrateSet = TRUE;
287	// set sample rate, leave other tempo changer parameters as they are.
288	pTDStretch->setParameters((int)srate);
289	}
290
291
292	// Adds 'numSamples' pcs of samples from the 'samples' memory position into
293	// the input of the object.
294	void SoundTouch::putSamples(const SAMPLETYPE *samples, uint nSamples)
295	{
296	if (bSrateSet == FALSE)
297	{
298	throw std::runtime_error("SoundTouch : Sample rate not defined");
299	}
300	else if (channels == 0)
301	{
302	throw std::runtime_error("SoundTouch : Number of channels not defined");
303	}
304
305	// Transpose the rate of the new samples if necessary
306	/* Bypass the nominal setting - can introduce a click in sound when tempo/pitch control crosses the nominal value...
307	if (rate == 1.0f)
308	{
309	// The rate value is same as the original, simply evaluate the tempo changer.
310	assert(output == pTDStretch);
311	if (pRateTransposer->isEmpty() == 0)
312	{
313	// yet flush the last samples in the pitch transposer buffer
314	// (may happen if 'rate' changes from a non-zero value to zero)
315	pTDStretch->moveSamples(*pRateTransposer);
316	}
317	pTDStretch->putSamples(samples, nSamples);
318	}
319	*/
320	#ifndef PREVENT_CLICK_AT_RATE_CROSSOVER
321	else if (rate <= 1.0f)
322	{
323	// transpose the rate down, output the transposed sound to tempo changer buffer
324	assert(output == pTDStretch);
325	pRateTransposer->putSamples(samples, nSamples);
326	pTDStretch->moveSamples(*pRateTransposer);
327	}
328	else
329	#endif
330	{
331	// evaluate the tempo changer, then transpose the rate up,
332	assert(output == pRateTransposer);
333	pTDStretch->putSamples(samples, nSamples);
334	pRateTransposer->moveSamples(*pTDStretch);
335	}
336	}
337
338
339	// Flushes the last samples from the processing pipeline to the output.
340	// Clears also the internal processing buffers.
341	//
342	// Note: This function is meant for extracting the last samples of a sound
343	// stream. This function may introduce additional blank samples in the end
344	// of the sound stream, and thus it's not recommended to call this function
345	// in the middle of a sound stream.
346	void SoundTouch::flush()
347	{
348	int i;
349	uint nOut;
350	SAMPLETYPE buff[128];
351
352	nOut = numSamples();
353
354	memset(buff, 0, 128 * sizeof(SAMPLETYPE));
355	// "Push" the last active samples out from the processing pipeline by
356	// feeding blank samples into the processing pipeline until new,
357	// processed samples appear in the output (not however, more than
358	// 8ksamples in any case)
359	for (i = 0; i < 128; i ++)
360	{
361	putSamples(buff, 64);
362	if (numSamples() != nOut) break; // new samples have appeared in the output!
363	}
364
365	// Clear working buffers
366	pRateTransposer->clear();
367	pTDStretch->clearInput();
368	// yet leave the 'tempoChanger' output intouched as that's where the
369	// flushed samples are!
370	}
371
372
373	// Changes a setting controlling the processing system behaviour. See the
374	// 'SETTING_...' defines for available setting ID's.
375	BOOL SoundTouch::setSetting(int settingId, int value)
376	{
377	int sampleRate, sequenceMs, seekWindowMs, overlapMs;
378
379	// read current tdstretch routine parameters
380	pTDStretch->getParameters(&sampleRate, &sequenceMs, &seekWindowMs, &overlapMs);
381
382	switch (settingId)
383	{
384	case SETTING_USE_AA_FILTER :
385	// enables / disabless anti-alias filter
386	pRateTransposer->enableAAFilter((value != 0) ? TRUE : FALSE);
387	return TRUE;
388
389	case SETTING_AA_FILTER_LENGTH :
390	// sets anti-alias filter length
391	pRateTransposer->getAAFilter()->setLength(value);
392	return TRUE;
393
394	case SETTING_USE_QUICKSEEK :
395	// enables / disables tempo routine quick seeking algorithm
396	pTDStretch->enableQuickSeek((value != 0) ? TRUE : FALSE);
397	return TRUE;
398
399	case SETTING_SEQUENCE_MS:
400	// change time-stretch sequence duration parameter
401	pTDStretch->setParameters(sampleRate, value, seekWindowMs, overlapMs);
402	return TRUE;
403
404	case SETTING_SEEKWINDOW_MS:
405	// change time-stretch seek window length parameter
406	pTDStretch->setParameters(sampleRate, sequenceMs, value, overlapMs);
407	return TRUE;
408
409	case SETTING_OVERLAP_MS:
410	// change time-stretch overlap length parameter
411	pTDStretch->setParameters(sampleRate, sequenceMs, seekWindowMs, value);
412	return TRUE;
413
414	default :
415	return FALSE;
416	}
417	}
418
419
420	// Reads a setting controlling the processing system behaviour. See the
421	// 'SETTING_...' defines for available setting ID's.
422	//
423	// Returns the setting value.
424	int SoundTouch::getSetting(int settingId) const
425	{
426	int temp;
427
428	switch (settingId)
429	{
430	case SETTING_USE_AA_FILTER :
431	return (uint)pRateTransposer->isAAFilterEnabled();
432
433	case SETTING_AA_FILTER_LENGTH :
434	return pRateTransposer->getAAFilter()->getLength();
435
436	case SETTING_USE_QUICKSEEK :
437	return (uint) pTDStretch->isQuickSeekEnabled();
438
439	case SETTING_SEQUENCE_MS:
440	pTDStretch->getParameters(NULL, &temp, NULL, NULL);
441	return temp;
442
443	case SETTING_SEEKWINDOW_MS:
444	pTDStretch->getParameters(NULL, NULL, &temp, NULL);
445	return temp;
446
447	case SETTING_OVERLAP_MS:
448	pTDStretch->getParameters(NULL, NULL, NULL, &temp);
449	return temp;
450
451	default :
452	return 0;
453	}
454	}
455
456
457	// Clears all the samples in the object's output and internal processing
458	// buffers.
459	void SoundTouch::clear()
460	{
461	pRateTransposer->clear();
462	pTDStretch->clear();
463	}
464
465
466
467	/// Returns number of samples currently unprocessed.
468	uint SoundTouch::numUnprocessedSamples() const
469	{
470	FIFOSamplePipe * psp;
471	if (pTDStretch)
472	{
473	psp = pTDStretch->getInput();
474	if (psp)
475	{
476	return psp->numSamples();
477	}
478	}
479	return 0;
480	}