Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 18697362 authored by Phil Burk's avatar Phil Burk Committed by Gerrit Code Review
Browse files

Merge changes I921c81db,If2a22882,Ide7e7642,I5593cd1a,I923e6043, ... 

* changes:
  aaudio_loopback: rectify and low pass filter
  aaudio examples: make tests portable to O
  aaudio test: fix looping multiple times using -l
  aaudio_loopback: improve tolerance to noise
  aaudio: add callback size options to examples
  aaudio_loopback: do not set buffer capacity by default
parents 19a18612 73c0d52c

media/libaaudio/examples/input_monitor/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ cc_test { 
    cflags: ["-Wall", "-Werror"],

    shared_libs: ["libaaudio"],

    header_libs: ["libaaudio_example_utils"],

    pack_relocations: false,

}



cc_test {
@@ -14,4 +15,5 @@ cc_test { 
    cflags: ["-Wall", "-Werror"],

    shared_libs: ["libaaudio"],

    header_libs: ["libaaudio_example_utils"],

    pack_relocations: false,

}

media/libaaudio/examples/loopback/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -9,4 +9,5 @@ cc_test { 
        "libaudioutils",

        ],

    header_libs: ["libaaudio_example_utils"],

    pack_relocations: false,

}

media/libaaudio/examples/loopback/src/LoopbackAnalyzer.h

+440 −229

File changed.

Preview size limit exceeded, changes collapsed.

media/libaaudio/examples/loopback/src/loopback.cpp

+57 −51
Original line number Diff line number Diff line
@@ -35,15 +35,17 @@ 
#include "AAudioExampleUtils.h"

#include "LoopbackAnalyzer.h"



// V0.4.00 = rectify and low-pass filter the echos, use auto-correlation on entire echo

#define APP_VERSION             "0.4.00"



// Tag for machine readable results as property = value pairs

#define RESULT_TAG              "RESULT: "

#define NUM_SECONDS             5

#define PERIOD_MILLIS           1000

#define NUM_INPUT_CHANNELS      1

#define FILENAME_ALL            "/data/loopback_all.wav"

#define FILENAME_ECHOS          "/data/loopback_echos.wav"

#define APP_VERSION             "0.2.04"

#define FILENAME_PROCESSED      "/data/loopback_processed.wav"



constexpr int kLogPeriodMillis       = 1000;

constexpr int kNumInputChannels      = 1;

constexpr int kNumCallbacksToDrain   = 20;

constexpr int kNumCallbacksToDiscard = 20;
@@ -174,7 +176,8 @@ static aaudio_data_callback_result_t MyDataCallbackProc( 
        int64_t inputFramesWritten = AAudioStream_getFramesWritten(myData->inputStream);

        int64_t inputFramesRead = AAudioStream_getFramesRead(myData->inputStream);

        int64_t framesAvailable = inputFramesWritten - inputFramesRead;

        actualFramesRead = readFormattedData(myData, numFrames);



        actualFramesRead = readFormattedData(myData, numFrames); // READ

        if (actualFramesRead < 0) {

            result = AAUDIO_CALLBACK_RESULT_STOP;

        } else {
@@ -194,6 +197,7 @@ static aaudio_data_callback_result_t MyDataCallbackProc( 
                }

                myData->insufficientReadCount++;

                myData->insufficientReadFrames += numFrames - actualFramesRead; // deficit

                // printf("Error insufficientReadCount = %d\n",(int)myData->insufficientReadCount);

            }



            int32_t numSamples = actualFramesRead * myData->actualInputChannelCount;
@@ -336,9 +340,9 @@ int main(int argc, const char **argv) 


    aaudio_result_t       result = AAUDIO_OK;

    aaudio_sharing_mode_t requestedInputSharingMode  = AAUDIO_SHARING_MODE_SHARED;

    int                   requestedInputChannelCount = NUM_INPUT_CHANNELS;

    int                   requestedInputChannelCount = kNumInputChannels;

    aaudio_format_t       requestedInputFormat       = AAUDIO_FORMAT_UNSPECIFIED;

    int32_t               requestedInputCapacity     = -1;

    int32_t               requestedInputCapacity     = AAUDIO_UNSPECIFIED;

    aaudio_performance_mode_t inputPerformanceLevel  = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;



    int32_t               outputFramesPerBurst = 0;
@@ -356,6 +360,9 @@ int main(int argc, const char **argv) 


    printf("%s - Audio loopback using AAudio V" APP_VERSION "\n", argv[0]);



    // Use LOW_LATENCY as the default to match input default.

    argParser.setPerformanceMode(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);



    for (int i = 1; i < argc; i++) {

        const char *arg = argv[i];

        if (argParser.parseArg(arg)) {
@@ -404,7 +411,7 @@ int main(int argc, const char **argv) 
    }



    int32_t requestedDuration = argParser.getDurationSeconds();

    int32_t requestedDurationMillis = requestedDuration * MILLIS_PER_SECOND;

    int32_t requestedDurationMillis = requestedDuration * kMillisPerSecond;

    int32_t timeMillis = 0;

    int32_t recordingDuration = std::min(60 * 5, requestedDuration);
@@ -421,9 +428,11 @@ int main(int argc, const char **argv) 


            loopbackData.loopbackProcessor = &loopbackData.echoAnalyzer;

            int read = loopbackData.loopbackProcessor->load(FILENAME_ECHOS);

            printf("main() read %d mono samples from %s on Android device\n", read, FILENAME_ECHOS);

            printf("main() read %d mono samples from %s on Android device, rate = %d\n",

                   read, FILENAME_ECHOS,

                   loopbackData.loopbackProcessor->getSampleRate());

            loopbackData.loopbackProcessor->report();

            return 0;

            goto report_result;

        }

            break;

        default:
@@ -459,15 +468,10 @@ int main(int argc, const char **argv) 
    argParser.setPerformanceMode(inputPerformanceLevel);

    argParser.setChannelCount(requestedInputChannelCount);

    argParser.setSharingMode(requestedInputSharingMode);



    // Make sure the input buffer has plenty of capacity.

    // Extra capacity on input should not increase latency if we keep it drained.

    int32_t inputBufferCapacity = requestedInputCapacity;

    if (inputBufferCapacity < 0) {

        int32_t outputBufferCapacity = AAudioStream_getBufferCapacityInFrames(outputStream);

        inputBufferCapacity = 2 * outputBufferCapacity;

    if (requestedInputCapacity != AAUDIO_UNSPECIFIED) {

        printf("Warning! If you set input capacity then maybe no FAST track on Legacy path!\n");

    }

    argParser.setBufferCapacity(inputBufferCapacity);

    argParser.setBufferCapacity(requestedInputCapacity);



    result = recorder.open(argParser);

    if (result != AAUDIO_OK) {
@@ -517,15 +521,11 @@ int main(int argc, const char **argv) 
    // Start OUTPUT first so INPUT does not overflow.

    result = player.start();

    if (result != AAUDIO_OK) {

        printf("ERROR - AAudioStream_requestStart(output) returned %d = %s\n",

               result, AAudio_convertResultToText(result));

        goto finish;

    }



    result = recorder.start();

    if (result != AAUDIO_OK) {

        printf("ERROR - AAudioStream_requestStart(input) returned %d = %s\n",

               result, AAudio_convertResultToText(result));

        goto finish;

    }
@@ -568,7 +568,7 @@ int main(int argc, const char **argv) 
                   AAudioStream_getXRunCount(outputStream)

            );

        }

        int32_t periodMillis = (timeMillis < 2000) ? PERIOD_MILLIS / 4 : PERIOD_MILLIS;

        int32_t periodMillis = (timeMillis < 2000) ? kLogPeriodMillis / 4 : kLogPeriodMillis;

        usleep(periodMillis * 1000);

        timeMillis += periodMillis;

    }
@@ -590,15 +590,22 @@ int main(int argc, const char **argv) 
    printf("input error = %d = %s\n",

           loopbackData.inputError, AAudio_convertResultToText(loopbackData.inputError));



    written = loopbackData.loopbackProcessor->save(FILENAME_ECHOS);

    if (written > 0) {

        printf("main() wrote %8d mono samples to \"%s\" on Android device\n",

               written, FILENAME_ECHOS);

    }



    written = loopbackData.audioRecording.save(FILENAME_ALL);

    if (written > 0) {

        printf("main() wrote %8d mono samples to \"%s\" on Android device\n",

               written, FILENAME_ALL);

    }



    if (loopbackData.inputError == AAUDIO_OK) {

        if (testMode == TEST_SINE_MAGNITUDE) {

            printAudioGraph(loopbackData.audioRecording, 200);

        }

        // Print again so we don't have to scroll past waveform.

        printf("OUTPUT Stream ----------------------------------------\n");

        argParser.compareWithStream(outputStream);

        printf("INPUT  Stream ----------------------------------------\n");

        argParser.compareWithStream(inputStream);



        loopbackData.loopbackProcessor->report();

    }
@@ -606,22 +613,28 @@ int main(int argc, const char **argv) 
    {

        int32_t framesRead = AAudioStream_getFramesRead(inputStream);

        int32_t framesWritten = AAudioStream_getFramesWritten(inputStream);

        const int64_t framesAvailable = framesWritten - framesRead;

        printf("Callback Results ---------------------------------------- INPUT\n");

        printf("  input overruns   = %d\n", AAudioStream_getXRunCount(inputStream));

        printf("  input overruns   = %8d\n", AAudioStream_getXRunCount(inputStream));

        printf("  framesWritten    = %8d\n", framesWritten);

        printf("  framesRead       = %8d\n", framesRead);

        printf("  myFramesRead     = %8d\n", (int) loopbackData.framesReadTotal);

        printf("  written - read   = %8d\n", (int) (framesWritten - framesRead));

        printf("  written - read   = %8d\n", (int) framesAvailable);

        printf("  insufficient #   = %8d\n", (int) loopbackData.insufficientReadCount);

        if (loopbackData.insufficientReadCount > 0) {

            printf("  insufficient frames = %8d\n", (int) loopbackData.insufficientReadFrames);

            printf("  insuffic. frames = %8d\n", (int) loopbackData.insufficientReadFrames);

        }

        int32_t actualInputCapacity = AAudioStream_getBufferCapacityInFrames(inputStream);

        if (framesAvailable > 2 * actualInputCapacity) {

            printf("  WARNING: written - read > 2*capacity !\n");

        }

    }



    {

        int32_t framesRead = AAudioStream_getFramesRead(outputStream);

        int32_t framesWritten = AAudioStream_getFramesWritten(outputStream);

        printf("Callback Results ---------------------------------------- OUTPUT\n");

        printf("  output underruns = %d\n", AAudioStream_getXRunCount(outputStream));

        printf("  output underruns = %8d\n", AAudioStream_getXRunCount(outputStream));

        printf("  myFramesWritten  = %8d\n", (int) loopbackData.framesWrittenTotal);

        printf("  framesWritten    = %8d\n", framesWritten);

        printf("  framesRead       = %8d\n", framesRead);
@@ -629,22 +642,6 @@ int main(int argc, const char **argv) 
        printf("  max numFrames    = %8d\n", (int) loopbackData.maxNumFrames);

    }



    written = loopbackData.loopbackProcessor->save(FILENAME_ECHOS);

    if (written > 0) {

        printf("main() wrote %8d mono samples to \"%s\" on Android device\n",

               written, FILENAME_ECHOS);

    }



    written = loopbackData.audioRecording.save(FILENAME_ALL);

    if (written > 0) {

        printf("main() wrote %8d mono samples to \"%s\" on Android device\n",

               written, FILENAME_ALL);

    }



    if (loopbackData.loopbackProcessor->getResult() < 0) {

        printf("ERROR: LOOPBACK PROCESSING FAILED. Maybe because the volume was too low.\n");

        result = loopbackData.loopbackProcessor->getResult();

    }

    if (loopbackData.insufficientReadCount > 3) {

        printf("ERROR: LOOPBACK PROCESSING FAILED. insufficientReadCount too high\n");

        result = AAUDIO_ERROR_UNAVAILABLE;
@@ -656,14 +653,23 @@ finish: 
    delete[] loopbackData.inputFloatData;

    delete[] loopbackData.inputShortData;



report_result:

    written = loopbackData.loopbackProcessor->save(FILENAME_PROCESSED);

    if (written > 0) {

        printf("main() wrote %8d processed samples to \"%s\" on Android device\n",

               written, FILENAME_PROCESSED);

    }



    if (loopbackData.loopbackProcessor->getResult() < 0) {

        result = loopbackData.loopbackProcessor->getResult();

    }

    printf(RESULT_TAG "result = %d \n", result); // machine readable

    printf("result is %s\n", AAudio_convertResultToText(result)); // human readable

    if (result != AAUDIO_OK) {

        printf("FAILURE\n");

        printf("TEST FAILED\n");

        return EXIT_FAILURE;

    } else {

        printf("SUCCESS\n");

        printf("TEST PASSED\n");

        return EXIT_SUCCESS;

    }

}

media/libaaudio/examples/utils/AAudioArgsParser.h

+21 −3
Original line number Diff line number Diff line
@@ -130,10 +130,12 @@ public: 
    }



    int32_t getBufferCapacity() const {

        printf("%s() returns %d\n", __func__, mBufferCapacity);

        return mBufferCapacity;

    }



    void setBufferCapacity(int32_t frames) {

        printf("%s(%d)\n", __func__, frames);

        mBufferCapacity = frames;

    }
@@ -185,18 +187,26 @@ public: 
        mNumberOfBursts = numBursts;

    }



    int32_t getFramesPerCallback() const {

        return mFramesPerCallback;

    }

    void setFramesPerCallback(int32_t size) {

        mFramesPerCallback = size;

    }



    /**

     * Apply these parameters to a stream builder.

     * @param builder

     */

    void applyParameters(AAudioStreamBuilder *builder) const {

        AAudioStreamBuilder_setBufferCapacityInFrames(builder, getBufferCapacity());

        AAudioStreamBuilder_setChannelCount(builder, mChannelCount);

        AAudioStreamBuilder_setDeviceId(builder, mDeviceId);

        AAudioStreamBuilder_setFormat(builder, mFormat);

        AAudioStreamBuilder_setFramesPerDataCallback(builder, mFramesPerCallback);

        AAudioStreamBuilder_setPerformanceMode(builder, mPerformanceMode);

        AAudioStreamBuilder_setSampleRate(builder, mSampleRate);

        AAudioStreamBuilder_setBufferCapacityInFrames(builder, mBufferCapacity);

        AAudioStreamBuilder_setDeviceId(builder, mDeviceId);

        AAudioStreamBuilder_setSharingMode(builder, mSharingMode);

        AAudioStreamBuilder_setPerformanceMode(builder, mPerformanceMode);



        // Call P functions if supported.

        loadFutureFunctions();
@@ -232,6 +242,7 @@ private: 
    aaudio_input_preset_t      mInputPreset     = AAUDIO_UNSPECIFIED;



    int32_t                    mNumberOfBursts  = AAUDIO_UNSPECIFIED;

    int32_t                    mFramesPerCallback = AAUDIO_UNSPECIFIED;

};



class AAudioArgsParser : public AAudioParameters {
@@ -297,6 +308,9 @@ public: 
                case 'y':

                    setContentType(atoi(&arg[2]));

                    break;

                case 'z':

                    setFramesPerCallback(atoi(&arg[2]));

                    break;

                default:

                    unrecognized = true;

                    break;
@@ -350,6 +364,7 @@ public: 
        printf("      -u{usage} eg. 14 for AAUDIO_USAGE_GAME\n");

        printf("      -x to use EXCLUSIVE mode\n");

        printf("      -y{contentType} eg. 1 for AAUDIO_CONTENT_TYPE_SPEECH\n");

        printf("      -z{callbackSize} or block size, in frames, default = 0\n");

    }



    static aaudio_performance_mode_t parsePerformanceMode(char c) {
@@ -406,6 +421,9 @@ public: 
        printf("  Capacity:     requested = %d, actual = %d\n", getBufferCapacity(),

               AAudioStream_getBufferCapacityInFrames(stream));



        printf("  CallbackSize: requested = %d, actual = %d\n", getFramesPerCallback(),

               AAudioStream_getFramesPerDataCallback(stream));



        printf("  SharingMode:  requested = %s, actual = %s\n",

               getSharingModeText(getSharingMode()),

               getSharingModeText(AAudioStream_getSharingMode(stream)));