const float kHysteresisLevel = 0.25f;

int zeroCrossingCount = 0;

int state = 0; // can be -1, 0, +1

for (int i = 0; i < numSamples; i++) {

if (input[i] >= kHysteresisLevel) {

if (state < 0) {

zeroCrossingCount++;

}

state = 1;

} else if (input[i] <= -kHysteresisLevel) {

if (state > 0) {

zeroCrossingCount++;

}

state = -1;

}

}

return zeroCrossingCount;

MultiChannelResampler::Quality quality) {

const int kNumOutputSamples = 10000;

const double framesPerCycle = 81.379; // target output period

int numInputSamples = kNumOutputSamples * sourceRate / sinkRate;

std::unique_ptr<float[]> inputBuffer = std::make_unique<float[]>(numInputSamples);

std::unique_ptr<float[]> outputBuffer = std::make_unique<float[]>(kNumOutputSamples);

// Generate a sine wave for input.

const double kPhaseIncrement = 2.0 * sinkRate / (framesPerCycle * sourceRate);

double phase = 0.0;

for (int i = 0; i < numInputSamples; i++) {

inputBuffer[i] = sin(phase * M_PI);

phase += kPhaseIncrement;

while (phase > 1.0) {

phase -= 2.0;

}

}

int sourceZeroCrossingCount = countZeroCrossingsWithHysteresis(inputBuffer.get(), numInputSamples);

// Use a MultiChannelResampler to convert from the sourceRate to the sinkRate.

std::unique_ptr<MultiChannelResampler> mcResampler;

mcResampler.reset(MultiChannelResampler::make(kChannelCount,

sourceRate,

sinkRate,

quality));

int inputFramesLeft = numInputSamples;

int numRead = 0;

float *input = inputBuffer.get(); // for iteration

float *output = outputBuffer.get();

while (inputFramesLeft > 0) {

if (mcResampler->isWriteNeeded()) {

mcResampler->writeNextFrame(input);

input++;

inputFramesLeft--;

} else {

mcResampler->readNextFrame(output);

output++;

numRead++;

}

}

// Flush out remaining frames from the flowgraph

while (!mcResampler->isWriteNeeded()) {

mcResampler->readNextFrame(output);

output++;

numRead++;

}

ASSERT_LE(numRead, kNumOutputSamples);

// Some frames are lost priming the FIR filter.

const int kMaxAlgorithmicFrameLoss = 5;

EXPECT_GT(numRead, kNumOutputSamples - kMaxAlgorithmicFrameLoss);

int sinkZeroCrossingCount = countZeroCrossingsWithHysteresis(outputBuffer.get(), numRead);

// The sine wave may be cut off partially. This may cause multiple crossing

// differences when upsampling.

const int kMaxZeroCrossingDelta = std::max(sinkRate / sourceRate / 2, 1);

EXPECT_LE(abs(sourceZeroCrossingCount - sinkZeroCrossingCount), kMaxZeroCrossingDelta);

// Detect glitches by looking for spikes in the second derivative.

output = outputBuffer.get();

float previousValue = output[0];

float previousSlope = output[1] - output[0];

for (int i = 0; i < numRead; i++) {

float slope = output[i] - previousValue;

float slopeDelta = fabs(slope - previousSlope);

// Skip a few samples because there are often some steep slope changes at the beginning.

if (i > 10) {

EXPECT_LT(slopeDelta, 0.1);

}

previousValue = output[i];

previousSlope = slope;

}

#if 0

// Save to disk for inspection.

FILE *fp = fopen( "/sdcard/Download/src_float_out.raw" , "wb" );

fwrite(outputBuffer.get(), sizeof(float), numRead, fp );

fclose(fp);

#endif

const int rates[] = {8000, 11025, 22050, 32000, 44100, 48000, 64000, 88200, 96000};

const MultiChannelResampler::Quality qualities[] =

{

MultiChannelResampler::Quality::Fastest,

MultiChannelResampler::Quality::Low,

MultiChannelResampler::Quality::Medium,

MultiChannelResampler::Quality::High,

MultiChannelResampler::Quality::Best

};

for (int srcRate : rates) {

for (int destRate : rates) {

for (auto quality : qualities) {

if (srcRate != destRate) {

checkResampler(srcRate, destRate, quality);

}

}

}

}