blob: 13e4a20be4832147f6a88668825daf50439e86b2 [file] [log] [blame]
/*
* Copyright 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Test FlowGraph
*
* This file also tests a few different conversion techniques because
* sometimes that have caused compiler bugs.
*/
#include <iostream>
#include <gtest/gtest.h>
#include "flowgraph/resampler/MultiChannelResampler.h"
using namespace RESAMPLER_OUTER_NAMESPACE::resampler;
// Measure zero crossings.
static int32_t countZeroCrossingsWithHysteresis(float *input, int32_t numSamples) {
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;
}
static constexpr int kChannelCount = 1;
/**
* Convert a sine wave and then look for glitches.
* Glitches have a high value in the second derivative.
*/
static void checkResampler(int32_t sourceRate, int32_t sinkRate,
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);
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
}
TEST(test_resampler, resampler_scan_all) {
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);
}
}
}
}
}
TEST(test_resampler, resampler_8000_11025_best) {
checkResampler(8000, 11025, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_8000_48000_best) {
checkResampler(8000, 48000, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_8000_44100_best) {
checkResampler(8000, 44100, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_11025_24000_best) {
checkResampler(11025, 24000, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_11025_48000_fastest) {
checkResampler(11025, 48000, MultiChannelResampler::Quality::Fastest);
}
TEST(test_resampler, resampler_11025_48000_low) {
checkResampler(11025, 48000, MultiChannelResampler::Quality::Low);
}
TEST(test_resampler, resampler_11025_48000_medium) {
checkResampler(11025, 48000, MultiChannelResampler::Quality::Medium);
}
TEST(test_resampler, resampler_11025_48000_high) {
checkResampler(11025, 48000, MultiChannelResampler::Quality::High);
}
TEST(test_resampler, resampler_11025_48000_best) {
checkResampler(11025, 48000, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_11025_44100_best) {
checkResampler(11025, 44100, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_11025_88200_best) {
checkResampler(11025, 88200, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_16000_48000_best) {
checkResampler(16000, 48000, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_44100_48000_low) {
checkResampler(44100, 48000, MultiChannelResampler::Quality::Low);
}
TEST(test_resampler, resampler_44100_48000_best) {
checkResampler(44100, 48000, MultiChannelResampler::Quality::Best);
}
// Look for glitches when downsampling.
TEST(test_resampler, resampler_48000_11025_best) {
checkResampler(48000, 11025, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_48000_44100_best) {
checkResampler(48000, 44100, MultiChannelResampler::Quality::Best);
}
TEST(test_resampler, resampler_44100_11025_best) {
checkResampler(44100, 11025, MultiChannelResampler::Quality::Best);
}