Merge changes I921c81db,If2a22882,Ide7e7642,I5593cd1a,I923e6043, ... (035dda9b) · Commits · e / os / android_frameworks_av

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)));