/*
* Copyright (C) 2016 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.
*/
// Play an impulse and then record it.
// Measure the round trip latency.
#include <assert.h>
#include <cctype>
#include <math.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <aaudio/AAudio.h>
#define INPUT_PEAK_THRESHOLD 0.1f
#define SILENCE_FRAMES 10000
#define SAMPLE_RATE 48000
#define NUM_SECONDS 7
#define FILENAME "/data/oboe_input.raw"
#define NANOS_PER_MICROSECOND ((int64_t)1000)
#define NANOS_PER_MILLISECOND (NANOS_PER_MICROSECOND * 1000)
#define MILLIS_PER_SECOND 1000
#define NANOS_PER_SECOND (NANOS_PER_MILLISECOND * MILLIS_PER_SECOND)
class AudioRecorder
{
public:
AudioRecorder() {
}
~AudioRecorder() {
delete[] mData;
}
void allocate(int maxFrames) {
delete[] mData;
mData = new float[maxFrames];
mMaxFrames = maxFrames;
}
void record(int16_t *inputData, int inputChannelCount, int numFrames) {
// stop at end of buffer
if ((mFrameCounter + numFrames) > mMaxFrames) {
numFrames = mMaxFrames - mFrameCounter;
}
for (int i = 0; i < numFrames; i++) {
mData[mFrameCounter++] = inputData[i * inputChannelCount] * (1.0f / 32768);
}
}
void record(float *inputData, int inputChannelCount, int numFrames) {
// stop at end of buffer
if ((mFrameCounter + numFrames) > mMaxFrames) {
numFrames = mMaxFrames - mFrameCounter;
}
for (int i = 0; i < numFrames; i++) {
mData[mFrameCounter++] = inputData[i * inputChannelCount];
}
}
int save(const char *fileName) {
FILE *fid = fopen(fileName, "wb");
if (fid == NULL) {
return errno;
}
int written = fwrite(mData, sizeof(float), mFrameCounter, fid);
fclose(fid);
return written;
}
private:
float *mData = NULL;
int32_t mFrameCounter = 0;
int32_t mMaxFrames = 0;
};
// ====================================================================================
// ========================= Loopback Processor =======================================
// ====================================================================================
class LoopbackProcessor {
public:
// Calculate mean and standard deviation.
double calculateAverageLatency(double *deviation) {
if (mLatencyCount <= 0) {
return -1.0;
}
double sum = 0.0;
for (int i = 0; i < mLatencyCount; i++) {
sum += mLatencyArray[i];
}
double average = sum / mLatencyCount;
sum = 0.0;
for (int i = 0; i < mLatencyCount; i++) {
double error = average - mLatencyArray[i];
sum += error * error; // squared
}
*deviation = sqrt(sum / mLatencyCount);
return average;
}
float getMaxAmplitude() const { return mMaxAmplitude; }
int getMeasurementCount() const { return mLatencyCount; }
float getAverageAmplitude() const { return mAmplitudeTotal / mAmplitudeCount; }
// TODO Convert this to a feedback circuit and then use auto-correlation to measure the period.
void process(float *inputData, int inputChannelCount,
float *outputData, int outputChannelCount,
int numFrames) {
(void) outputChannelCount;
// Measure peak and average amplitude.
for (int i = 0; i < numFrames; i++) {
float sample = inputData[i * inputChannelCount];
if (sample > mMaxAmplitude) {
mMaxAmplitude = sample;
}
if (sample < 0) {
sample = 0 - sample;
}
mAmplitudeTotal += sample;
mAmplitudeCount++;
}
// Clear output.
memset(outputData, 0, numFrames * outputChannelCount * sizeof(float));
// Wait a while between hearing the pulse and starting a new one.
if (mState == STATE_SILENT) {
mCounter += numFrames;
if (mCounter > SILENCE_FRAMES) {
//printf("LoopbackProcessor send impulse, burst #%d\n", mBurstCounter);
// copy impulse
for (float sample : mImpulse) {
*outputData = sample;
outputData += outputChannelCount;
}
mState = STATE_LISTENING;
mCounter = 0;
}
}
// Start listening as soon as we send the impulse.
if (mState == STATE_LISTENING) {
for (int i = 0; i < numFrames; i++) {
float sample = inputData[i * inputChannelCount];
if (sample >= INPUT_PEAK_THRESHOLD) {
mLatencyArray[mLatencyCount++] = mCounter;
if (mLatencyCount >= MAX_LATENCY_VALUES) {
mState = STATE_DONE;
} else {
mState = STATE_SILENT;
}
mCounter = 0;
break;
} else {
mCounter++;
}
}
}
}
void echo(float *inputData, int inputChannelCount,
float *outputData, int outputChannelCount,
int numFrames) {
int channelsValid = (inputChannelCount < outputChannelCount)
? inputChannelCount : outputChannelCount;
for (int i = 0; i < numFrames; i++) {
int ic;
for (ic = 0; ic < channelsValid; ic++) {
outputData[ic] = inputData[ic];
}
for (ic = 0; ic < outputChannelCount; ic++) {
outputData[ic] = 0;
}
inputData += inputChannelCount;
outputData += outputChannelCount;
}
}
private:
enum {
STATE_SILENT,
STATE_LISTENING,
STATE_DONE
};
enum {
MAX_LATENCY_VALUES = 64
};
int mState = STATE_SILENT;
int32_t mCounter = 0;
int32_t mLatencyArray[MAX_LATENCY_VALUES];
int32_t mLatencyCount = 0;
float mMaxAmplitude = 0;
float mAmplitudeTotal = 0;
int32_t mAmplitudeCount = 0;
static const float mImpulse[5];
};
const float LoopbackProcessor::mImpulse[5] = {0.5f, 0.9f, 0.0f, -0.9f, -0.5f};
// TODO make this a class that manages its own buffer allocation
struct LoopbackData {
AAudioStream *inputStream = nullptr;
int32_t inputFramesMaximum = 0;
int16_t *inputData = nullptr;
float *conversionBuffer = nullptr;
int32_t actualInputChannelCount = 0;
int32_t actualOutputChannelCount = 0;
int32_t inputBuffersToDiscard = 10;
aaudio_result_t inputError;
LoopbackProcessor loopbackProcessor;
AudioRecorder audioRecorder;
};
static void convertPcm16ToFloat(const int16_t *source,
float *destination,
int32_t numSamples) {
const float scaler = 1.0f / 32768.0f;
for (int i = 0; i < numSamples; i++) {
destination[i] = source[i] * scaler;
}
}
// ====================================================================================
// ========================= CALLBACK =================================================
// ====================================================================================
// Callback function that fills the audio output buffer.
static aaudio_data_callback_result_t MyDataCallbackProc(
AAudioStream *outputStream,
void *userData,
void *audioData,
int32_t numFrames
) {
(void) outputStream;
LoopbackData *myData = (LoopbackData *) userData;
float *outputData = (float *) audioData;
// Read audio data from the input stream.
int32_t framesRead;
if (numFrames > myData->inputFramesMaximum) {
myData->inputError = AAUDIO_ERROR_OUT_OF_RANGE;
return AAUDIO_CALLBACK_RESULT_STOP;
}
if (myData->inputBuffersToDiscard > 0) {
// Drain the input.
do {
framesRead = AAudioStream_read(myData->inputStream, myData->inputData,
numFrames, 0);
if (framesRead < 0) {
myData->inputError = framesRead;
} else if (framesRead > 0) {
myData->inputBuffersToDiscard--;
}
} while(framesRead > 0);
} else {
framesRead = AAudioStream_read(myData->inputStream, myData->inputData,
numFrames, 0);
if (framesRead < 0) {
myData->inputError = framesRead;
} else if (framesRead > 0) {
// Process valid input data.
myData->audioRecorder.record(myData->inputData,
myData->actualInputChannelCount,
framesRead);
int32_t numSamples = framesRead * myData->actualInputChannelCount;
convertPcm16ToFloat(myData->inputData, myData->conversionBuffer, numSamples);
myData->loopbackProcessor.process(myData->conversionBuffer,
myData->actualInputChannelCount,
outputData,
myData->actualOutputChannelCount,
framesRead);
}
}
return AAUDIO_CALLBACK_RESULT_CONTINUE;
}
static void usage() {
printf("loopback: -b{burstsPerBuffer} -p{outputPerfMode} -P{inputPerfMode}\n");
printf(" -b{burstsPerBuffer} for example 2 for double buffered\n");
printf(" -p{outputPerfMode} set output AAUDIO_PERFORMANCE_MODE*\n");
printf(" -P{inputPerfMode} set input AAUDIO_PERFORMANCE_MODE*\n");
printf(" n for _NONE\n");
printf(" l for _LATENCY\n");
printf(" p for _POWER_SAVING;\n");
printf("For example: loopback -b2 -pl -Pn\n");
}
static aaudio_performance_mode_t parsePerformanceMode(char c) {
aaudio_performance_mode_t mode = AAUDIO_PERFORMANCE_MODE_NONE;
c = tolower(c);
switch (c) {
case 'n':
mode = AAUDIO_PERFORMANCE_MODE_NONE;
break;
case 'l':
mode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
break;
case 'p':
mode = AAUDIO_PERFORMANCE_MODE_POWER_SAVING;
break;
default:
printf("ERROR invalue performance mode %c\n", c);
break;
}
return mode;
}
// ====================================================================================
// TODO break up this large main() function into smaller functions
int main(int argc, const char **argv)
{
aaudio_result_t result = AAUDIO_OK;
LoopbackData loopbackData;
AAudioStream *outputStream = nullptr;
const int requestedInputChannelCount = 1;
const int requestedOutputChannelCount = AAUDIO_UNSPECIFIED;
const int requestedSampleRate = SAMPLE_RATE;
int actualSampleRate = 0;
const aaudio_format_t requestedInputFormat = AAUDIO_FORMAT_PCM_I16;
const aaudio_format_t requestedOutputFormat = AAUDIO_FORMAT_PCM_FLOAT;
aaudio_format_t actualInputFormat;
aaudio_format_t actualOutputFormat;
const aaudio_sharing_mode_t requestedSharingMode = AAUDIO_SHARING_MODE_EXCLUSIVE;
//const aaudio_sharing_mode_t requestedSharingMode = AAUDIO_SHARING_MODE_SHARED;
aaudio_sharing_mode_t actualSharingMode;
AAudioStreamBuilder *builder = nullptr;
aaudio_stream_state_t state = AAUDIO_STREAM_STATE_UNINITIALIZED;
int32_t framesPerBurst = 0;
float *outputData = NULL;
double deviation;
double latency;
aaudio_performance_mode_t outputPerformanceLevel = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
aaudio_performance_mode_t inputPerformanceLevel = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
int32_t burstsPerBuffer = 1; // single buffered
for (int i = 1; i < argc; i++) {
const char *arg = argv[i];
if (arg[0] == '-') {
char option = arg[1];
switch (option) {
case 'b':
burstsPerBuffer = atoi(&arg[2]);
break;
case 'p':
outputPerformanceLevel = parsePerformanceMode(arg[2]);
break;
case 'P':
inputPerformanceLevel = parsePerformanceMode(arg[2]);
break;
default:
usage();
break;
}
} else {
break;
}
}
loopbackData.audioRecorder.allocate(NUM_SECONDS * SAMPLE_RATE);
// Make printf print immediately so that debug info is not stuck
// in a buffer if we hang or crash.
setvbuf(stdout, NULL, _IONBF, (size_t) 0);
printf("%s - Audio loopback using AAudio\n", argv[0]);
// Use an AAudioStreamBuilder to contain requested parameters.
result = AAudio_createStreamBuilder(&builder);
if (result < 0) {
goto finish;
}
// Request common stream properties.
AAudioStreamBuilder_setSampleRate(builder, requestedSampleRate);
AAudioStreamBuilder_setFormat(builder, requestedInputFormat);
AAudioStreamBuilder_setSharingMode(builder, requestedSharingMode);
// Open the input stream.
AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_INPUT);
AAudioStreamBuilder_setPerformanceMode(builder, inputPerformanceLevel);
AAudioStreamBuilder_setChannelCount(builder, requestedInputChannelCount);
result = AAudioStreamBuilder_openStream(builder, &loopbackData.inputStream);
printf("AAudioStreamBuilder_openStream(input) returned %d = %s\n",
result, AAudio_convertResultToText(result));
if (result < 0) {
goto finish;
}
// Create an output stream using the Builder.
AAudioStreamBuilder_setDirection(builder, AAUDIO_DIRECTION_OUTPUT);
AAudioStreamBuilder_setFormat(builder, requestedOutputFormat);
AAudioStreamBuilder_setPerformanceMode(builder, outputPerformanceLevel);
AAudioStreamBuilder_setChannelCount(builder, requestedOutputChannelCount);
AAudioStreamBuilder_setDataCallback(builder, MyDataCallbackProc, &loopbackData);
result = AAudioStreamBuilder_openStream(builder, &outputStream);
printf("AAudioStreamBuilder_openStream(output) returned %d = %s\n",
result, AAudio_convertResultToText(result));
if (result != AAUDIO_OK) {
goto finish;
}
printf("Stream INPUT ---------------------\n");
loopbackData.actualInputChannelCount = AAudioStream_getChannelCount(loopbackData.inputStream);
printf(" channelCount: requested = %d, actual = %d\n", requestedInputChannelCount,
loopbackData.actualInputChannelCount);
printf(" framesPerBurst = %d\n", AAudioStream_getFramesPerBurst(loopbackData.inputStream));
actualInputFormat = AAudioStream_getFormat(loopbackData.inputStream);
printf(" dataFormat: requested = %d, actual = %d\n", requestedInputFormat, actualInputFormat);
assert(actualInputFormat == AAUDIO_FORMAT_PCM_I16);
printf("Stream OUTPUT ---------------------\n");
// Check to see what kind of stream we actually got.
actualSampleRate = AAudioStream_getSampleRate(outputStream);
printf(" sampleRate: requested = %d, actual = %d\n", requestedSampleRate, actualSampleRate);
loopbackData.actualOutputChannelCount = AAudioStream_getChannelCount(outputStream);
printf(" channelCount: requested = %d, actual = %d\n", requestedOutputChannelCount,
loopbackData.actualOutputChannelCount);
actualSharingMode = AAudioStream_getSharingMode(outputStream);
printf(" sharingMode: requested = %d, actual = %d\n", requestedSharingMode, actualSharingMode);
// This is the number of frames that are read in one chunk by a DMA controller
// or a DSP or a mixer.
framesPerBurst = AAudioStream_getFramesPerBurst(outputStream);
printf(" framesPerBurst = %d\n", framesPerBurst);
printf(" bufferCapacity = %d\n", AAudioStream_getBufferCapacityInFrames(outputStream));
actualOutputFormat = AAudioStream_getFormat(outputStream);
printf(" dataFormat: requested = %d, actual = %d\n", requestedOutputFormat, actualOutputFormat);
assert(actualOutputFormat == AAUDIO_FORMAT_PCM_FLOAT);
// Allocate a buffer for the audio data.
loopbackData.inputFramesMaximum = 32 * framesPerBurst;
loopbackData.inputData = new int16_t[loopbackData.inputFramesMaximum * loopbackData.actualInputChannelCount];
loopbackData.conversionBuffer = new float[loopbackData.inputFramesMaximum *
loopbackData.actualInputChannelCount];
result = AAudioStream_setBufferSizeInFrames(outputStream, burstsPerBuffer * framesPerBurst);
if (result < 0) { // may be positive buffer size
fprintf(stderr, "ERROR - AAudioStream_setBufferSize() returned %d\n", result);
goto finish;
}
printf("AAudioStream_setBufferSize() actual = %d\n",result);
// Start output first so input stream runs low.
result = AAudioStream_requestStart(outputStream);
if (result != AAUDIO_OK) {
fprintf(stderr, "ERROR - AAudioStream_requestStart(output) returned %d = %s\n",
result, AAudio_convertResultToText(result));
goto finish;
}
result = AAudioStream_requestStart(loopbackData.inputStream);
if (result != AAUDIO_OK) {
fprintf(stderr, "ERROR - AAudioStream_requestStart(input) returned %d = %s\n",
result, AAudio_convertResultToText(result));
goto finish;
}
printf("------- sleep while the callback runs --------------\n");
fflush(stdout);
sleep(NUM_SECONDS);
printf("input error = %d = %s\n",
loopbackData.inputError, AAudio_convertResultToText(loopbackData.inputError));
printf("AAudioStream_getXRunCount %d\n", AAudioStream_getXRunCount(outputStream));
printf("framesRead = %d\n", (int) AAudioStream_getFramesRead(outputStream));
printf("framesWritten = %d\n", (int) AAudioStream_getFramesWritten(outputStream));
latency = loopbackData.loopbackProcessor.calculateAverageLatency(&deviation);
printf("measured peak = %8.5f\n", loopbackData.loopbackProcessor.getMaxAmplitude());
printf("threshold = %8.5f\n", INPUT_PEAK_THRESHOLD);
printf("measured average = %8.5f\n", loopbackData.loopbackProcessor.getAverageAmplitude());
printf("# latency measurements = %d\n", loopbackData.loopbackProcessor.getMeasurementCount());
printf("measured latency = %8.2f +/- %4.5f frames\n", latency, deviation);
printf("measured latency = %8.2f msec <===== !!\n", (1000.0 * latency / actualSampleRate));
{
int written = loopbackData.audioRecorder.save(FILENAME);
printf("wrote %d samples to %s\n", written, FILENAME);
}
finish:
AAudioStream_close(outputStream);
AAudioStream_close(loopbackData.inputStream);
delete[] loopbackData.conversionBuffer;
delete[] loopbackData.inputData;
delete[] outputData;
AAudioStreamBuilder_delete(builder);
printf("exiting - AAudio result = %d = %s\n", result, AAudio_convertResultToText(result));
return (result != AAUDIO_OK) ? EXIT_FAILURE : EXIT_SUCCESS;
}