aaudio: monkey test random activity (86938671) · Commits · e / os / android_frameworks_av

media/libaaudio/tests/Android.bp

+13 −0

Original line number	Diff line number	Diff line
		@@ -111,3 +111,16 @@ cc_test {
		"libutils",
		],
		}

		cc_test {
		name: "test_aaudio_monkey",
		defaults: ["libaaudio_tests_defaults"],
		srcs: ["test_aaudio_monkey.cpp"],
		header_libs: ["libaaudio_example_utils"],
		shared_libs: [
		"libaaudio",
		"libbinder",
		"libcutils",
		"libutils",
		],
		}

media/libaaudio/tests/test_aaudio_monkey.cpp

0 → 100644

+307 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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.
		*/

		// Try to trigger bugs by playing randomly on multiple streams.

		#include <stdio.h>
		#include <stdlib.h>
		#include <vector>

		#include <aaudio/AAudio.h>
		#include "AAudioArgsParser.h"
		#include "AAudioExampleUtils.h"
		#include "AAudioSimplePlayer.h"
		#include "SineGenerator.h"

		#define DEFAULT_TIMEOUT_NANOS (1 * NANOS_PER_SECOND)

		#define NUM_LOOPS 1000
		#define MAX_MICROS_DELAY (2 * 1000 * 1000)

		// TODO Consider adding an input stream.
		#define PROB_START (0.20)
		#define PROB_PAUSE (PROB_START + 0.10)
		#define PROB_FLUSH (PROB_PAUSE + 0.10)
		#define PROB_STOP (PROB_FLUSH + 0.10)
		#define PROB_CLOSE (PROB_STOP + 0.10)
		static_assert(PROB_CLOSE < 0.9, "Probability sum too high.");

		aaudio_data_callback_result_t AAudioMonkeyDataCallback(
		AAudioStream *stream,
		void *userData,
		void *audioData,
		int32_t numFrames);

		void AAudioMonkeyErrorCallbackProc(
		AAudioStream *stream __unused,
		void *userData __unused,
		aaudio_result_t error) {
		printf("Error Callback, error: %d\n",(int)error);
		}

		// This function is not thread safe. Only use this from a single thread.
		double nextRandomDouble() {
		return drand48();
		}

		class AAudioMonkey : public AAudioSimplePlayer {
		public:

		AAudioMonkey(int index, AAudioArgsParser *argParser)
		: mArgParser(argParser)
		, mIndex(index) {}

		aaudio_result_t open() {
		printf("Monkey # %d ---------------------------------------------- OPEN\n", mIndex);
		double offset = mIndex * 50;
		mSine1.setup(440.0, 48000);
		mSine1.setSweep(300.0 + offset, 600.0 + offset, 5.0);
		mSine2.setup(660.0, 48000);
		mSine2.setSweep(350.0 + offset, 900.0 + offset, 7.0);

		aaudio_result_t result = AAudioSimplePlayer::open(*mArgParser,
		AAudioMonkeyDataCallback,
		AAudioMonkeyErrorCallbackProc,
		this);
		if (result != AAUDIO_OK) {
		printf("ERROR - player.open() returned %d\n", result);
		}

		mArgParser->compareWithStream(getStream());
		return result;
		}

		bool isOpen() {
		return (getStream() != nullptr);

		}
		/**
		*
		* @return true if stream passes tests
		*/
		bool validate() {
		if (!isOpen()) return true; // closed is OK

		// update and query stream state
		aaudio_stream_state_t state = AAUDIO_STREAM_STATE_UNKNOWN;
		aaudio_result_t result = AAudioStream_waitForStateChange(getStream(),
		AAUDIO_STREAM_STATE_UNKNOWN, &state, 0);
		if (result != AAUDIO_OK) {
		printf("ERROR - AAudioStream_waitForStateChange returned %d\n", result);
		return false;
		}

		int64_t framesRead = AAudioStream_getFramesRead(getStream());
		int64_t framesWritten = AAudioStream_getFramesWritten(getStream());
		int32_t xRuns = AAudioStream_getXRunCount(getStream());
		// Print status
		printf("%30s, framesWritten = %8lld, framesRead = %8lld, xRuns = %d\n",
		AAudio_convertStreamStateToText(state),
		(unsigned long long) framesWritten,
		(unsigned long long) framesRead,
		xRuns);

		if (framesWritten < framesRead) {
		printf("WARNING - UNDERFLOW - diff = %d !!!!!!!!!!!!\n",
		(int) (framesWritten - framesRead));
		}
		return true;
		}

		aaudio_result_t invoke() {
		aaudio_result_t result = AAUDIO_OK;
		if (!isOpen()) {
		result = open();
		if (result != AAUDIO_OK) return result;
		}

		if (!validate()) {
		return -1;
		}

		double dice = nextRandomDouble();
		// Select an action based on a weighted probability.
		if (dice < PROB_START) {
		printf("start\n");
		result = AAudioStream_requestStart(getStream());
		} else if (dice < PROB_PAUSE) {
		printf("pause\n");
		result = AAudioStream_requestPause(getStream());
		} else if (dice < PROB_FLUSH) {
		printf("flush\n");
		result = AAudioStream_requestFlush(getStream());
		} else if (dice < PROB_STOP) {
		printf("stop\n");
		result = AAudioStream_requestStop(getStream());
		} else if (dice < PROB_CLOSE) {
		printf("close\n");
		result = close();
		} else {
		printf("do nothing\n");
		}

		if (result == AAUDIO_ERROR_INVALID_STATE) {
		printf(" got AAUDIO_ERROR_INVALID_STATE - expected from a monkey\n");
		result = AAUDIO_OK;
		}
		if (result == AAUDIO_OK && isOpen()) {
		if (!validate()) {
		result = -1;
		}
		}
		return result;
		}

		aaudio_data_callback_result_t renderAudio(
		AAudioStream *stream,
		void *audioData,
		int32_t numFrames) {

		int32_t samplesPerFrame = AAudioStream_getChannelCount(stream);
		// This code only plays on the first one or two channels.
		// TODO Support arbitrary number of channels.
		switch (AAudioStream_getFormat(stream)) {
		case AAUDIO_FORMAT_PCM_I16: {
		int16_t audioBuffer = (int16_t ) audioData;
		// Render sine waves as shorts to first channel.
		mSine1.render(&audioBuffer[0], samplesPerFrame, numFrames);
		// Render sine waves to second channel if there is one.
		if (samplesPerFrame > 1) {
		mSine2.render(&audioBuffer[1], samplesPerFrame, numFrames);
		}
		}
		break;
		case AAUDIO_FORMAT_PCM_FLOAT: {
		float audioBuffer = (float ) audioData;
		// Render sine waves as floats to first channel.
		mSine1.render(&audioBuffer[0], samplesPerFrame, numFrames);
		// Render sine waves to second channel if there is one.
		if (samplesPerFrame > 1) {
		mSine2.render(&audioBuffer[1], samplesPerFrame, numFrames);
		}
		}
		break;
		default:
		return AAUDIO_CALLBACK_RESULT_STOP;
		}
		return AAUDIO_CALLBACK_RESULT_CONTINUE;
		}

		private:
		const AAudioArgsParser *mArgParser;
		const int mIndex;
		SineGenerator mSine1;
		SineGenerator mSine2;
		};

		// Callback function that fills the audio output buffer.
		aaudio_data_callback_result_t AAudioMonkeyDataCallback(
		AAudioStream *stream,
		void *userData,
		void *audioData,
		int32_t numFrames
		) {
		// should not happen but just in case...
		if (userData == nullptr) {
		printf("ERROR - AAudioMonkeyDataCallback needs userData\n");
		return AAUDIO_CALLBACK_RESULT_STOP;
		}
		AAudioMonkey monkey = (AAudioMonkey ) userData;
		return monkey->renderAudio(stream, audioData, numFrames);
		}


		static void usage() {
		AAudioArgsParser::usage();
		printf(" -i{seed} Initial random seed\n");
		printf(" -t{count} number of monkeys in the Troop\n");
		}

		int main(int argc, const char **argv) {
		AAudioArgsParser argParser;
		std::vector<AAudioMonkey> monkeys;
		aaudio_result_t result;
		int numMonkeys = 1;

		// Make printf print immediately so that debug info is not stuck
		// in a buffer if we hang or crash.
		setvbuf(stdout, nullptr, _IONBF, (size_t) 0);

		printf("%s - Monkeys\n", argv[0]);

		long int seed = (long int)getNanoseconds(); // different every time by default

		for (int i = 1; i < argc; i++) {
		const char *arg = argv[i];
		if (argParser.parseArg(arg)) {
		// Handle options that are not handled by the ArgParser
		if (arg[0] == '-') {
		char option = arg[1];
		switch (option) {
		case 'i':
		seed = atol(&arg[2]);
		break;
		case 't':
		numMonkeys = atoi(&arg[2]);
		break;
		default:
		usage();
		exit(EXIT_FAILURE);
		break;
		}
		} else {
		usage();
		exit(EXIT_FAILURE);
		break;
		}
		}
		}

		srand48(seed);
		printf("seed = %ld, nextRandomDouble() = %f\n", seed, nextRandomDouble());

		for (int m = 0; m < numMonkeys; m++) {
		monkeys.emplace_back(m, &argParser);
		}

		for (int i = 0; i < NUM_LOOPS; i++) {
		// pick a random monkey and invoke it
		double dice = nextRandomDouble();
		int monkeyIndex = floor(dice * numMonkeys);
		printf("----------- Monkey #%d\n", monkeyIndex);
		result = monkeys[monkeyIndex].invoke();
		if (result != AAUDIO_OK) {
		goto error;
		}

		// sleep some random time
		dice = nextRandomDouble();
		dice = dice * dice * dice; // skew towards smaller delays
		int micros = (int) (dice * MAX_MICROS_DELAY);
		usleep(micros);

		// TODO consider making this multi-threaded, one thread per monkey, to catch more bugs
		}

		printf("PASS\n");
		return EXIT_SUCCESS;

		error:
		printf("FAIL - AAudio result = %d = %s\n", result, AAudio_convertResultToText(result));
		usleep(1000 * 1000); // give me time to stop the logcat
		return EXIT_FAILURE;
		}