856 lines
26 KiB
C++
856 lines
26 KiB
C++
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
|
|
|
|
/*
|
|
Rubber Band Library
|
|
An audio time-stretching and pitch-shifting library.
|
|
Copyright 2007-2023 Particular Programs Ltd.
|
|
|
|
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 2 of the
|
|
License, or (at your option) any later version. See the file
|
|
COPYING included with this distribution for more information.
|
|
|
|
Alternatively, if you have a valid commercial licence for the
|
|
Rubber Band Library obtained by agreement with the copyright
|
|
holders, you may redistribute and/or modify it under the terms
|
|
described in that licence.
|
|
|
|
If you wish to distribute code using the Rubber Band Library
|
|
under terms other than those of the GNU General Public License,
|
|
you must obtain a valid commercial licence before doing so.
|
|
*/
|
|
|
|
#ifndef BOOST_TEST_DYN_LINK
|
|
#define BOOST_TEST_DYN_LINK
|
|
#endif
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include "../../rubberband/RubberBandStretcher.h"
|
|
|
|
#include <iostream>
|
|
|
|
#include <cmath>
|
|
|
|
using namespace RubberBand;
|
|
|
|
using std::vector;
|
|
using std::cerr;
|
|
using std::endl;
|
|
|
|
namespace tt = boost::test_tools;
|
|
|
|
BOOST_AUTO_TEST_SUITE(TestStretcher)
|
|
|
|
BOOST_AUTO_TEST_CASE(engine_version)
|
|
{
|
|
RubberBandStretcher s2(44100, 1, RubberBandStretcher::OptionEngineFaster);
|
|
BOOST_TEST(s2.getEngineVersion() == 2);
|
|
RubberBandStretcher s3(44100, 1, RubberBandStretcher::OptionEngineFiner);
|
|
BOOST_TEST(s3.getEngineVersion() == 3);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_unchanged_offline_faster)
|
|
{
|
|
int n = 10000;
|
|
float freq = 440.f;
|
|
int rate = 44100;
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFaster);
|
|
|
|
vector<float> in(n), out(n);
|
|
for (int i = 0; i < n; ++i) {
|
|
in[i] = sinf(float(i) * freq * M_PI * 2.f / float(rate));
|
|
}
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n);
|
|
BOOST_TEST(got == n);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
// We now have n samples of a simple sinusoid with stretch factor
|
|
// 1.0; obviously we expect the output to be essentially the same
|
|
// thing. It will have lower precision for a while at the start
|
|
// and end because of windowing factors, so we check those with a
|
|
// threshold of 0.1; in the middle we expect better
|
|
// precision. Note that these are relative tolerances, not
|
|
// absolute, i.e. 0.001 means 0.001x the smaller value - so they
|
|
// are tighter than they appear.
|
|
|
|
// This syntax for comparing containers with a certain tolerance
|
|
// using BOOST_TEST is just bonkers. I can't find the << syntax to
|
|
// combine manipulators documented anywhere other than in a
|
|
// release note, but it does work. Well, sort of - it works this
|
|
// way around but not as per_element << tolerance. And
|
|
// tolerance(0.1) doesn't do what you'd expect if the things
|
|
// you're comparing are floats (it sets the tolerance for doubles,
|
|
// leaving float comparison unchanged). Clever... too clever.
|
|
|
|
BOOST_TEST(out == in,
|
|
tt::tolerance(0.1f) << tt::per_element());
|
|
|
|
BOOST_TEST(vector<float>(out.begin() + 1024, out.begin() + n - 1024) ==
|
|
vector<float>(in.begin() + 1024, in.begin() + n - 1024),
|
|
tt::tolerance(0.001f) << tt::per_element());
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_unchanged_offline_finer)
|
|
{
|
|
int n = 10000;
|
|
float freq = 440.f;
|
|
int rate = 44100;
|
|
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFiner);
|
|
|
|
vector<float> in(n), out(n);
|
|
for (int i = 0; i < n; ++i) {
|
|
in[i] = sinf(float(i) * freq * M_PI * 2.f / float(rate));
|
|
}
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n);
|
|
BOOST_TEST(got == n);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
// The R3 engine is actually less precise than R2 here because of
|
|
// its different windowing design, though see the note above about
|
|
// what these tolerances mean
|
|
|
|
BOOST_TEST(out == in,
|
|
tt::tolerance(0.35f) << tt::per_element());
|
|
|
|
BOOST_TEST(vector<float>(out.begin() + 1024, out.begin() + n - 1024) ==
|
|
vector<float>(in.begin() + 1024, in.begin() + n - 1024),
|
|
tt::tolerance(0.01f) << tt::per_element());
|
|
|
|
// std::cout << "ms\tV" << std::endl;
|
|
// for (int i = 0; i < n; ++i) {
|
|
// std::cout << i << "\t" << out[i] - in[i] << std::endl;
|
|
// }
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_2x_offline_finer)
|
|
{
|
|
int n = 10000;
|
|
float freq = 441.f; // so a cycle is an exact number of samples
|
|
int rate = 44100;
|
|
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFiner);
|
|
|
|
stretcher.setTimeRatio(2.0);
|
|
|
|
vector<float> in(n), out(n*2);
|
|
for (int i = 0; i < n*2; ++i) {
|
|
out[i] = sinf(float(i) * freq * M_PI * 2.f / float(rate));
|
|
if (i < n) {
|
|
in[i] = out[i];
|
|
}
|
|
}
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n*2);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n*2);
|
|
BOOST_TEST(got == n*2);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
int period = -1;
|
|
for (int i = 1000; i < 2000; ++i) {
|
|
if (period >= 0) ++period;
|
|
if (out[i] <= 0.f && out[i+1] > 0.f) {
|
|
if (period == -1) period = 0;
|
|
else break;
|
|
}
|
|
}
|
|
BOOST_TEST(period == 100);
|
|
|
|
int offset = 0;
|
|
for (int i = 0; i < 200; ++i) {
|
|
if (out[i] <= 0.f && out[i+1] > -0.01f) {
|
|
offset = i + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// overall
|
|
|
|
double rms = 0.0;
|
|
for (int i = 0; i < n - offset; ++i) {
|
|
double diff = out[i + offset] - in[i];
|
|
rms += diff * diff;
|
|
}
|
|
rms = sqrt(rms / double(n - offset));
|
|
BOOST_TEST(rms < 0.2);
|
|
|
|
// steady state
|
|
|
|
rms = 0.0;
|
|
for (int i = 1500; i < n - offset - 3000; ++i) {
|
|
double diff = out[i + offset + 1500] - in[i + 1500];
|
|
rms += diff * diff;
|
|
}
|
|
rms = sqrt(rms / double(n - offset - 3000));
|
|
BOOST_TEST(rms < 0.1);
|
|
}
|
|
|
|
static void sinusoid_realtime(RubberBandStretcher::Options options,
|
|
double timeRatio,
|
|
double pitchScale,
|
|
bool printDebug)
|
|
{
|
|
int n = (timeRatio < 1.0 ? 80000 : 40000);
|
|
int nOut = int(ceil(n * timeRatio));
|
|
float freq = 441.f;
|
|
int rate = 44100;
|
|
int bs = 512;
|
|
|
|
// This test simulates block-by-block realtime processing with
|
|
// latency compensation, and checks that the output is all in the
|
|
// expected place
|
|
|
|
RubberBandStretcher stretcher(rate, 1, options, timeRatio, pitchScale);
|
|
stretcher.setMaxProcessSize(bs);
|
|
|
|
if (printDebug) {
|
|
stretcher.setDebugLevel(2);
|
|
}
|
|
|
|
// The input signal is a fixed frequency sinusoid that steps up in
|
|
// amplitude every 1/10 of the total duration - from 0.1 at the
|
|
// start, via increments of 0.1, to 1.0 at the end
|
|
|
|
vector<float> in(n);
|
|
for (int i = 0; i < n; ++i) {
|
|
float amplitude = float((i / (n/10)) + 1) / 10.f;
|
|
float sample = amplitude *
|
|
sinf(float(i) * freq * M_PI * 2.f / float(rate));
|
|
in[i] = sample;
|
|
}
|
|
|
|
vector<float> out(nOut, 0.f);
|
|
|
|
// Prime the start
|
|
{
|
|
float *source = out.data(); // just reuse out because it's silent
|
|
stretcher.process(&source, stretcher.getPreferredStartPad(), false);
|
|
}
|
|
|
|
int toSkip = stretcher.getStartDelay();
|
|
|
|
int inOffset = 0, outOffset = 0;
|
|
|
|
while (outOffset < nOut) {
|
|
|
|
// Obtain a single block of size bs, simulating realtime
|
|
// playback. The following might be the content of a
|
|
// sound-producing callback function
|
|
|
|
int needed = std::min(bs, nOut - outOffset);
|
|
int obtained = 0;
|
|
|
|
while (obtained < needed) {
|
|
|
|
int available = stretcher.available();
|
|
|
|
if (available < 0) { // finished
|
|
for (int i = obtained; i < needed; ++i) {
|
|
out[outOffset++] = 0.f;
|
|
}
|
|
break;
|
|
|
|
} else if (available == 0) { // need to provide more input
|
|
int required = stretcher.getSamplesRequired();
|
|
BOOST_TEST(required > 0); // because available == 0
|
|
int toProcess = std::min(required, n - inOffset);
|
|
float *source = in.data() + inOffset;
|
|
bool final = (toProcess < required);
|
|
stretcher.process(&source, toProcess, final);
|
|
inOffset += toProcess;
|
|
BOOST_TEST(stretcher.available() > 0);
|
|
continue;
|
|
|
|
} else if (toSkip > 0) { // available > 0 && toSkip > 0
|
|
float *target = out.data() + outOffset;
|
|
int toRetrieve = std::min(toSkip, available);
|
|
int retrieved = stretcher.retrieve(&target, toRetrieve);
|
|
BOOST_TEST(retrieved == toRetrieve);
|
|
toSkip -= retrieved;
|
|
|
|
} else { // available > 0
|
|
float *target = out.data() + outOffset;
|
|
int toRetrieve = std::min(needed - obtained, available);
|
|
int retrieved = stretcher.retrieve(&target, toRetrieve);
|
|
BOOST_TEST(retrieved == toRetrieve);
|
|
obtained += retrieved;
|
|
outOffset += retrieved;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (printDebug) {
|
|
// The initial # is to allow grep on the test output
|
|
std::cout << "#sample\tV" << std::endl;
|
|
for (int i = 0; i < nOut; ++i) {
|
|
std::cout << "#" << i << "\t" << out[i] << std::endl;
|
|
}
|
|
}
|
|
|
|
// Step through the output signal in chunk of 1/20 of its duration
|
|
// (i.e. a rather arbitrary two per expected 0.1 increment in
|
|
// amplitude) and for each chunk, verify that the frequency is
|
|
// right and the amplitude is what we expect at that point
|
|
|
|
for (int chunk = 0; chunk < 20; ++chunk) {
|
|
|
|
// cerr << "chunk " << chunk << " of 20" << endl;
|
|
|
|
int i0 = (nOut * chunk) / 20;
|
|
int i1 = (nOut * (chunk + 1)) / 20;
|
|
|
|
// frequency
|
|
|
|
int positiveCrossings = 0;
|
|
for (int i = i0; i + 1 < i1; ++i) {
|
|
if (out[i] <= 0.f && out[i+1] > 0.f) {
|
|
++positiveCrossings;
|
|
}
|
|
}
|
|
|
|
int expectedCrossings = int(round((freq * pitchScale *
|
|
double(i1 - i0)) / rate));
|
|
|
|
bool highSpeedPitch =
|
|
! ((options & RubberBandStretcher::OptionPitchHighQuality) ||
|
|
(options & RubberBandStretcher::OptionPitchHighConsistency));
|
|
|
|
// The check here has to depend on whether we are in Finer or
|
|
// Faster mode. In Finer mode, we expect to be generally exact
|
|
// but in the first and last chunks we can be out by one
|
|
// crossing if slowing, more if speeding up. In Faster mode we
|
|
// need to cut more slack
|
|
|
|
int slack = 0;
|
|
|
|
if (options & RubberBandStretcher::OptionEngineFiner) {
|
|
if (chunk == 0 || chunk == 19 || highSpeedPitch) {
|
|
slack = 1;
|
|
}
|
|
} else {
|
|
slack = 1;
|
|
if (chunk == 0) {
|
|
slack = (timeRatio < 1.0 ? 3 : 2);
|
|
} else if (chunk == 19) {
|
|
// all bets are off, practically
|
|
slack = expectedCrossings / 2;
|
|
} else {
|
|
slack = 1;
|
|
}
|
|
}
|
|
|
|
BOOST_TEST(positiveCrossings <= expectedCrossings + slack);
|
|
BOOST_TEST(positiveCrossings >= expectedCrossings - slack);
|
|
|
|
// amplitude
|
|
|
|
double rms = 0.0;
|
|
for (int i = i0; i < i1; ++i) {
|
|
rms += out[i] * out[i];
|
|
}
|
|
rms = sqrt(rms / double(i1 - i0));
|
|
|
|
double expected = (chunk/2 + 1) * 0.05 * sqrt(2.0);
|
|
|
|
double maxOver = 0.01;
|
|
double maxUnder = 0.1;
|
|
|
|
if (!(options & RubberBandStretcher::OptionEngineFiner)) {
|
|
maxUnder = 0.2;
|
|
}
|
|
|
|
BOOST_TEST(rms - expected < maxOver);
|
|
BOOST_TEST(expected - rms < maxUnder);
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_samepitch_realtime_finer)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
8.0, 1.0,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_samepitch_realtime_faster)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
8.0, 1.0,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_samepitch_realtime_finer)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
0.5, 1.0,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_samepitch_realtime_faster)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
0.5, 1.0,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_finer)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_finer_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_finer_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_faster)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_faster_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_higher_realtime_faster_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
4.0, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_finer)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_finer_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_finer_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_faster)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_faster_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_fast_higher_realtime_faster_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
0.5, 1.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_finer)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_finer_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_finer_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFiner |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_faster)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_faster_hqpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighQuality,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(sinusoid_slow_lower_realtime_faster_hcpitch)
|
|
{
|
|
sinusoid_realtime(RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime |
|
|
RubberBandStretcher::OptionPitchHighConsistency,
|
|
8.0, 0.5,
|
|
false);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(impulses_2x_offline_faster)
|
|
{
|
|
int n = 10000;
|
|
int rate = 44100;
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFaster);
|
|
|
|
stretcher.setTimeRatio(2.0);
|
|
|
|
vector<float> in(n, 0.f), out(n * 2, 0.f);
|
|
|
|
in[100] = 1.f;
|
|
in[101] = -1.f;
|
|
|
|
in[5000] = 1.f;
|
|
in[5001] = -1.f;
|
|
|
|
in[9900] = 1.f;
|
|
in[9901] = -1.f;
|
|
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n * 2);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n * 2);
|
|
BOOST_TEST(got == n * 2);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
int peak0 = -1, peak1 = -1, peak2 = -1;
|
|
float max;
|
|
|
|
max = -2.f;
|
|
for (int i = 0; i < n/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak0 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = n/2; i < (n*3)/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak1 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = (n*3)/2; i < n*2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak2 = i; }
|
|
}
|
|
|
|
BOOST_TEST(peak0 == 100);
|
|
BOOST_TEST(peak1 > n - 400);
|
|
BOOST_TEST(peak1 < n + 50);
|
|
BOOST_TEST(peak2 > n*2 - 600);
|
|
BOOST_TEST(peak2 < n*2);
|
|
/*
|
|
std::cout << "ms\tV" << std::endl;
|
|
for (int i = 0; i < n*2; ++i) {
|
|
std::cout << i << "\t" << out[i] << std::endl;
|
|
}
|
|
*/
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(impulses_2x_offline_finer)
|
|
{
|
|
int n = 10000;
|
|
int rate = 44100;
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFiner);
|
|
|
|
stretcher.setTimeRatio(2.0);
|
|
|
|
vector<float> in(n, 0.f), out(n * 2, 0.f);
|
|
|
|
in[100] = 1.f;
|
|
in[101] = -1.f;
|
|
|
|
in[5000] = 1.f;
|
|
in[5001] = -1.f;
|
|
|
|
in[9900] = 1.f;
|
|
in[9901] = -1.f;
|
|
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n * 2);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n * 2);
|
|
BOOST_TEST(got == n * 2);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
int peak0 = -1, peak1 = -1, peak2 = -1;
|
|
float max;
|
|
|
|
max = -2.f;
|
|
for (int i = 0; i < n/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak0 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = n/2; i < (n*3)/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak1 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = (n*3)/2; i < n*2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak2 = i; }
|
|
}
|
|
|
|
BOOST_TEST(peak0 == 100);
|
|
BOOST_TEST(peak1 > n - 400);
|
|
BOOST_TEST(peak1 < n + 50);
|
|
BOOST_TEST(peak2 > n*2 - 600);
|
|
BOOST_TEST(peak2 < n*2);
|
|
/*
|
|
std::cout << "ms\tV" << std::endl;
|
|
for (int i = 0; i < n*2; ++i) {
|
|
std::cout << i << "\t" << out[i] << std::endl;
|
|
}
|
|
*/
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(impulses_2x_5up_offline_finer)
|
|
{
|
|
int n = 10000;
|
|
int rate = 44100;
|
|
RubberBandStretcher stretcher
|
|
(rate, 1, RubberBandStretcher::OptionEngineFiner);
|
|
|
|
stretcher.setTimeRatio(2.0);
|
|
stretcher.setPitchScale(1.5);
|
|
|
|
vector<float> in(n, 0.f), out(n * 2, 0.f);
|
|
|
|
in[100] = 1.f;
|
|
in[101] = -1.f;
|
|
|
|
in[5000] = 1.f;
|
|
in[5001] = -1.f;
|
|
|
|
in[9900] = 1.f;
|
|
in[9901] = -1.f;
|
|
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(n);
|
|
stretcher.setExpectedInputDuration(n);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.study(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
stretcher.process(&inp, n, true);
|
|
BOOST_TEST(stretcher.available() == n * 2);
|
|
|
|
BOOST_TEST(stretcher.getStartDelay() == 0); // offline mode
|
|
|
|
size_t got = stretcher.retrieve(&outp, n * 2);
|
|
BOOST_TEST(got == n * 2);
|
|
BOOST_TEST(stretcher.available() == -1);
|
|
|
|
int peak0 = -1, peak1 = -1, peak2 = -1;
|
|
float max;
|
|
|
|
max = -2.f;
|
|
for (int i = 0; i < n/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak0 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = n/2; i < (n*3)/2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak1 = i; }
|
|
}
|
|
|
|
max = -2.f;
|
|
for (int i = (n*3)/2; i < n*2; ++i) {
|
|
if (out[i] > max) { max = out[i]; peak2 = i; }
|
|
}
|
|
|
|
BOOST_TEST(peak0 < 100);
|
|
BOOST_TEST(peak1 > n - 400);
|
|
BOOST_TEST(peak1 < n + 50);
|
|
BOOST_TEST(peak2 > n*2 - 600);
|
|
BOOST_TEST(peak2 < n*2);
|
|
/*
|
|
std::cout << "ms\tV" << std::endl;
|
|
for (int i = 0; i < n*2; ++i) {
|
|
std::cout << i << "\t" << out[i] << std::endl;
|
|
}
|
|
*/
|
|
}
|
|
/*
|
|
BOOST_AUTO_TEST_CASE(final_realtime_faster)
|
|
{
|
|
int n = 10000;
|
|
float freq = 440.f;
|
|
int rate = 44100;
|
|
int blocksize = 700;
|
|
RubberBandStretcher stretcher
|
|
(rate, 1,
|
|
RubberBandStretcher::OptionEngineFaster |
|
|
RubberBandStretcher::OptionProcessRealTime);
|
|
|
|
stretcher.setTimeRatio(2.0);
|
|
|
|
int excess = 10000;
|
|
vector<float> in(n, 0.f), out(n * 2 + excess, 0.f);
|
|
|
|
for (int i = n - 100; i < n; ++i) {
|
|
in[i] = sinf(float(i) * freq * M_PI * 2.f / float(rate));
|
|
}
|
|
float *inp = in.data(), *outp = out.data();
|
|
|
|
stretcher.setMaxProcessSize(blocksize);
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
int incount = 0, outcount = 0;
|
|
while (incount < n) {
|
|
|
|
int inbs = std::min(blocksize, n - incount);
|
|
BOOST_TEST(inbs > 0);
|
|
|
|
bool final = (incount + inbs >= n);
|
|
float *in = inp + incount;
|
|
stretcher.process(&in, inbs, final);
|
|
|
|
int avail = stretcher.available();
|
|
BOOST_TEST(avail >= 0);
|
|
BOOST_TEST(outcount + avail < n + excess);
|
|
|
|
float *out = outp + outcount;
|
|
size_t got = stretcher.retrieve(&out, avail);
|
|
BOOST_TEST(got == size_t(avail));
|
|
BOOST_TEST(stretcher.available() == 0);
|
|
|
|
incount += inbs;
|
|
outcount += got;
|
|
}
|
|
}
|
|
*/
|
|
BOOST_AUTO_TEST_SUITE_END()
|