media/libaaudio/tests/test_return_stop.cpp - third_party/android/platform/frameworks/av - Git at Google

 /*
  * Copyright (C) 2018 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.
  */

 /**
  * Return stop from the callback.
  * Expect the callback to cease.
  * Check the logcat for bad behavior.
  */

 #include <stdio.h>
 #include <thread>
 #include <unistd.h>

 #include <aaudio/AAudio.h>

 #define DEFAULT_TIMEOUT_NANOS  ((int64_t)1000000000)
 #define STOP_AT_MSEC          1000
 #define LOOP_DURATION_MSEC    4000
 #define SLEEP_DURATION_MSEC    200

 static void s_myErrorCallbackProc(
         AAudioStream *stream,
         void *userData,
         aaudio_result_t error);

 struct AudioEngine {
     AAudioStreamBuilder *builder = nullptr;
     AAudioStream        *stream = nullptr;
     std::thread         *thread = nullptr;
     int32_t              stopAtFrame = 0;
     bool                 stopped = false;
     // These counters are read and written by the callback and the main thread.
     std::atomic<int32_t> framesRead{};
     std::atomic<int32_t> startingFramesRead{};
     std::atomic<int32_t> framesCalled{};
     std::atomic<int32_t> callbackCount{};
     std::atomic<int32_t> callbackCountAfterStop{};

     void reset() {
         framesRead.store(0);
         startingFramesRead.store(0);
         framesCalled.store(0);
         callbackCount.store(0);
         callbackCountAfterStop.store(0);
         stopped = false;
     }
 };

 // Callback function that fills the audio output buffer.
 static aaudio_data_callback_result_t s_myDataCallbackProc(
         AAudioStream *stream,
         void *userData,
         void *audioData,
         int32_t numFrames
 ) {
     (void) audioData;
     (void) numFrames;
     AudioEngine *engine = (struct AudioEngine *)userData;
     engine->callbackCount++;
     if (engine->stopped) {
         engine->callbackCountAfterStop++;
     }

     engine->framesRead = (int32_t)AAudioStream_getFramesRead(stream);
     if (engine->startingFramesRead == 0) {
         engine->startingFramesRead.store(engine->framesRead.load());
     }
     engine->framesCalled += numFrames;
     if (engine->framesCalled >= engine->stopAtFrame) {
         engine->stopped = true;
         return AAUDIO_CALLBACK_RESULT_STOP;
     } else {
         return AAUDIO_CALLBACK_RESULT_CONTINUE;
     }
 }

 static aaudio_result_t s_OpenAudioStream(struct AudioEngine *engine,
                                          aaudio_direction_t direction,
                                          aaudio_sharing_mode_t sharingMode,
                                          aaudio_performance_mode_t perfMode) {
     // Use an AAudioStreamBuilder to contain requested parameters.
     aaudio_result_t result = AAudio_createStreamBuilder(&engine->builder);
     if (result != AAUDIO_OK) {
         printf("AAudio_createStreamBuilder returned %s",
                AAudio_convertResultToText(result));
         return result;
     }

     // Request stream properties.
     AAudioStreamBuilder_setFormat(engine->builder, AAUDIO_FORMAT_PCM_FLOAT);
     AAudioStreamBuilder_setPerformanceMode(engine->builder, perfMode);
     AAudioStreamBuilder_setSharingMode(engine->builder, sharingMode);
     AAudioStreamBuilder_setDirection(engine->builder, direction);
     AAudioStreamBuilder_setDataCallback(engine->builder, s_myDataCallbackProc, engine);
     AAudioStreamBuilder_setErrorCallback(engine->builder, s_myErrorCallbackProc, engine);

     // Create an AAudioStream using the Builder.
     result = AAudioStreamBuilder_openStream(engine->builder, &engine->stream);
     if (result != AAUDIO_OK) {
         printf("AAudioStreamBuilder_openStream returned %s",
                AAudio_convertResultToText(result));
         return result;
     }

     return result;
 }

 static aaudio_result_t s_CloseAudioStream(struct AudioEngine *engine) {
     aaudio_result_t result = AAUDIO_OK;
     if (engine->stream != nullptr) {
         result = AAudioStream_close(engine->stream);
         if (result != AAUDIO_OK) {
             printf("AAudioStream_close returned %s\n",
                    AAudio_convertResultToText(result));
         }
         engine->stream = nullptr;
     }
     AAudioStreamBuilder_delete(engine->builder);
     engine->builder = nullptr;
     return result;
 }

 static void s_myErrorCallbackProc(
         AAudioStream *stream __unused,
         void *userData __unused,
         aaudio_result_t error) {
     printf("%s() - error = %d\n", __func__, error);
 }

 static void s_usage() {
     printf("test_return_stop [-i] [-x] [-n] [-c]\n");
     printf("     -i direction INPUT, otherwise OUTPUT\n");
     printf("     -x sharing mode EXCLUSIVE, otherwise SHARED\n");
     printf("     -n performance mode NONE, otherwise LOW_LATENCY\n");
     printf("     -c always return CONTINUE from callback, not STOP\n");
 }

 /**
  * @return 0 is OK, -1 for error
  */
 static int s_checkEnginePositions(AudioEngine *engine) {
     const int64_t framesRead = AAudioStream_getFramesRead(engine->stream);
     const int64_t framesWritten = AAudioStream_getFramesWritten(engine->stream);
     const int32_t delta = (int32_t)(framesWritten - framesRead);
     printf("playing framesRead = %7d, framesWritten = %7d"
            ", delta = %4d, framesCalled = %6d, callbackCount = %4d\n",
            (int32_t) framesRead,
            (int32_t) framesWritten,
            delta,
            engine->framesCalled.load(),
            engine->callbackCount.load()
     );
     if (delta > AAudioStream_getBufferCapacityInFrames(engine->stream)) {
         printf("ERROR - delta > capacity\n");
         return -1;
     }
     return 0;
 }

 int main(int argc, char **argv) {
     (void) argc;
     (void) argv;
     struct AudioEngine engine;
     aaudio_sharing_mode_t sharingMode = AAUDIO_SHARING_MODE_SHARED;
     aaudio_performance_mode_t perfMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
     aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT;
     aaudio_result_t result = AAUDIO_OK;
     bool alwaysContinue = false;
     int errorCount = 0;
     int callbackResult = EXIT_SUCCESS;

     // 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("Test Return Stop V1.0\n");
     printf("Wait for a few seconds.\n");
     printf("You should see callbackCount and framesRead stop advancing\n");
     printf("when callbackCount reaches %d msec\n", STOP_AT_MSEC);
     printf("\n");

     for (int i = 1; i < argc; i++) {
         const char *arg = argv[i];
         if (arg[0] == '-') {
             char option = arg[1];
             switch (option) {
                 case 'c':
                     alwaysContinue = true;
                     break;
                 case 'i':
                     direction = AAUDIO_DIRECTION_INPUT;
                     break;
                 case 'n':
                     perfMode = AAUDIO_PERFORMANCE_MODE_NONE;
                     break;
                 case 'x':
                     sharingMode = AAUDIO_SHARING_MODE_EXCLUSIVE;
                     break;
                 default:
                     s_usage();
                     exit(EXIT_FAILURE);
                     break;
             }
         } else {
             s_usage();
             exit(EXIT_FAILURE);
             break;
         }
     }

     result = s_OpenAudioStream(&engine, direction, sharingMode, perfMode);
     if (result != AAUDIO_OK) {
         printf("s_OpenAudioStream returned %s\n",
                AAudio_convertResultToText(result));
         errorCount++;
     }

     int32_t framesPerBurst = AAudioStream_getFramesPerBurst(engine.stream);
     // Use double buffered stream.
     const int32_t bufferSize = AAudioStream_setBufferSizeInFrames(engine.stream, 2 * framesPerBurst);
     if (bufferSize < 0) {
         printf("AAudioStream_setBufferSizeInFrames returned %s\n",
                AAudio_convertResultToText(bufferSize));
         errorCount++;
     }

     // Check to see what kind of stream we actually got.
     int32_t deviceId = AAudioStream_getDeviceId(engine.stream);
     aaudio_performance_mode_t actualPerfMode = AAudioStream_getPerformanceMode(engine.stream);
     printf("-------- opened: deviceId = %3d, framesPerBurst = %3d, perfMode = %d\n",
            deviceId, framesPerBurst, actualPerfMode);

     // Calculate how many callbacks needed.
     if (alwaysContinue) {
         engine.stopAtFrame = INT32_MAX;
     } else {
         int32_t sampleRate = AAudioStream_getSampleRate(engine.stream);
         engine.stopAtFrame = STOP_AT_MSEC * sampleRate / 1000;
     }

     for (int loops = 0; loops < 2 && result == AAUDIO_OK; loops++) {
         engine.reset();

         // Start stream.
         result = AAudioStream_requestStart(engine.stream);
         printf("AAudioStream_requestStart() returned %d >>>>>>>>>>>>>>>>>>>>>>\n", result);
         if (result != AAUDIO_OK) {
             errorCount++;
             break;
         }

         if (result == AAUDIO_OK) {
             const int watchLoops = LOOP_DURATION_MSEC / SLEEP_DURATION_MSEC;
             for (int i = watchLoops; i > 0; i--) {
                 errorCount += s_checkEnginePositions(&engine) ? 1 : 0;
                 usleep(SLEEP_DURATION_MSEC * 1000);
             }
         }

         if (engine.stopAtFrame != INT32_MAX) {
             callbackResult = (engine.callbackCountAfterStop == 0) ? EXIT_SUCCESS
                                                                   : EXIT_FAILURE;
             if (callbackResult) {
                 printf("ERROR - Callback count after STOP = %d\n",
                        engine.callbackCountAfterStop.load());
                 errorCount++;
             }
         }

         if (engine.startingFramesRead.load() == engine.framesRead.load()) {
             printf("ERROR - framesRead did not advance across callbacks\n");
             errorCount++;
         }

         result = AAudioStream_requestStop(engine.stream);
         printf("AAudioStream_requestStop() returned %d <<<<<<<<<<<<<<<<<<<<<\n", result);
         if (result != AAUDIO_OK) {
             errorCount++;
         }
         usleep(SLEEP_DURATION_MSEC * 1000);
         errorCount += s_checkEnginePositions(&engine) ? 1 : 0;
     }

     s_CloseAudioStream(&engine);

     printf("aaudio result = %d = %s\n", result, AAudio_convertResultToText(result));
     printf("test %s\n", errorCount ? "FAILED" : "PASSED");

     return errorCount ? EXIT_FAILURE : EXIT_SUCCESS;
 }
	/*
	* Copyright (C) 2018 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.
	*/

	/**
	* Return stop from the callback.
	* Expect the callback to cease.
	* Check the logcat for bad behavior.
	*/

	#include <stdio.h>
	#include <thread>
	#include <unistd.h>

	#include <aaudio/AAudio.h>

	#define DEFAULT_TIMEOUT_NANOS ((int64_t)1000000000)
	#define STOP_AT_MSEC 1000
	#define LOOP_DURATION_MSEC 4000
	#define SLEEP_DURATION_MSEC 200

	static void s_myErrorCallbackProc(
	AAudioStream *stream,
	void *userData,
	aaudio_result_t error);

	struct AudioEngine {
	AAudioStreamBuilder *builder = nullptr;
	AAudioStream *stream = nullptr;
	std::thread *thread = nullptr;
	int32_t stopAtFrame = 0;
	bool stopped = false;
	// These counters are read and written by the callback and the main thread.
	std::atomic<int32_t> framesRead{};
	std::atomic<int32_t> startingFramesRead{};
	std::atomic<int32_t> framesCalled{};
	std::atomic<int32_t> callbackCount{};
	std::atomic<int32_t> callbackCountAfterStop{};

	void reset() {
	framesRead.store(0);
	startingFramesRead.store(0);
	framesCalled.store(0);
	callbackCount.store(0);
	callbackCountAfterStop.store(0);
	stopped = false;
	}
	};

	// Callback function that fills the audio output buffer.
	static aaudio_data_callback_result_t s_myDataCallbackProc(
	AAudioStream *stream,
	void *userData,
	void *audioData,
	int32_t numFrames
	) {
	(void) audioData;
	(void) numFrames;
	AudioEngine engine = (struct AudioEngine )userData;
	engine->callbackCount++;
	if (engine->stopped) {
	engine->callbackCountAfterStop++;
	}

	engine->framesRead = (int32_t)AAudioStream_getFramesRead(stream);
	if (engine->startingFramesRead == 0) {
	engine->startingFramesRead.store(engine->framesRead.load());
	}
	engine->framesCalled += numFrames;
	if (engine->framesCalled >= engine->stopAtFrame) {
	engine->stopped = true;
	return AAUDIO_CALLBACK_RESULT_STOP;
	} else {
	return AAUDIO_CALLBACK_RESULT_CONTINUE;
	}
	}

	static aaudio_result_t s_OpenAudioStream(struct AudioEngine *engine,
	aaudio_direction_t direction,
	aaudio_sharing_mode_t sharingMode,
	aaudio_performance_mode_t perfMode) {
	// Use an AAudioStreamBuilder to contain requested parameters.
	aaudio_result_t result = AAudio_createStreamBuilder(&engine->builder);
	if (result != AAUDIO_OK) {
	printf("AAudio_createStreamBuilder returned %s",
	AAudio_convertResultToText(result));
	return result;
	}

	// Request stream properties.
	AAudioStreamBuilder_setFormat(engine->builder, AAUDIO_FORMAT_PCM_FLOAT);
	AAudioStreamBuilder_setPerformanceMode(engine->builder, perfMode);
	AAudioStreamBuilder_setSharingMode(engine->builder, sharingMode);
	AAudioStreamBuilder_setDirection(engine->builder, direction);
	AAudioStreamBuilder_setDataCallback(engine->builder, s_myDataCallbackProc, engine);
	AAudioStreamBuilder_setErrorCallback(engine->builder, s_myErrorCallbackProc, engine);

	// Create an AAudioStream using the Builder.
	result = AAudioStreamBuilder_openStream(engine->builder, &engine->stream);
	if (result != AAUDIO_OK) {
	printf("AAudioStreamBuilder_openStream returned %s",
	AAudio_convertResultToText(result));
	return result;
	}

	return result;
	}

	static aaudio_result_t s_CloseAudioStream(struct AudioEngine *engine) {
	aaudio_result_t result = AAUDIO_OK;
	if (engine->stream != nullptr) {
	result = AAudioStream_close(engine->stream);
	if (result != AAUDIO_OK) {
	printf("AAudioStream_close returned %s\n",
	AAudio_convertResultToText(result));
	}
	engine->stream = nullptr;
	}
	AAudioStreamBuilder_delete(engine->builder);
	engine->builder = nullptr;
	return result;
	}

	static void s_myErrorCallbackProc(
	AAudioStream *stream __unused,
	void *userData __unused,
	aaudio_result_t error) {
	printf("%s() - error = %d\n", __func__, error);
	}

	static void s_usage() {
	printf("test_return_stop [-i] [-x] [-n] [-c]\n");
	printf(" -i direction INPUT, otherwise OUTPUT\n");
	printf(" -x sharing mode EXCLUSIVE, otherwise SHARED\n");
	printf(" -n performance mode NONE, otherwise LOW_LATENCY\n");
	printf(" -c always return CONTINUE from callback, not STOP\n");
	}

	/**
	* @return 0 is OK, -1 for error
	*/
	static int s_checkEnginePositions(AudioEngine *engine) {
	const int64_t framesRead = AAudioStream_getFramesRead(engine->stream);
	const int64_t framesWritten = AAudioStream_getFramesWritten(engine->stream);
	const int32_t delta = (int32_t)(framesWritten - framesRead);
	printf("playing framesRead = %7d, framesWritten = %7d"
	", delta = %4d, framesCalled = %6d, callbackCount = %4d\n",
	(int32_t) framesRead,
	(int32_t) framesWritten,
	delta,
	engine->framesCalled.load(),
	engine->callbackCount.load()
	);
	if (delta > AAudioStream_getBufferCapacityInFrames(engine->stream)) {
	printf("ERROR - delta > capacity\n");
	return -1;
	}
	return 0;
	}

	int main(int argc, char **argv) {
	(void) argc;
	(void) argv;
	struct AudioEngine engine;
	aaudio_sharing_mode_t sharingMode = AAUDIO_SHARING_MODE_SHARED;
	aaudio_performance_mode_t perfMode = AAUDIO_PERFORMANCE_MODE_LOW_LATENCY;
	aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT;
	aaudio_result_t result = AAUDIO_OK;
	bool alwaysContinue = false;
	int errorCount = 0;
	int callbackResult = EXIT_SUCCESS;

	// 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("Test Return Stop V1.0\n");
	printf("Wait for a few seconds.\n");
	printf("You should see callbackCount and framesRead stop advancing\n");
	printf("when callbackCount reaches %d msec\n", STOP_AT_MSEC);
	printf("\n");

	for (int i = 1; i < argc; i++) {
	const char *arg = argv[i];
	if (arg[0] == '-') {
	char option = arg[1];
	switch (option) {
	case 'c':
	alwaysContinue = true;
	break;
	case 'i':
	direction = AAUDIO_DIRECTION_INPUT;
	break;
	case 'n':
	perfMode = AAUDIO_PERFORMANCE_MODE_NONE;
	break;
	case 'x':
	sharingMode = AAUDIO_SHARING_MODE_EXCLUSIVE;
	break;
	default:
	s_usage();
	exit(EXIT_FAILURE);
	break;
	}
	} else {
	s_usage();
	exit(EXIT_FAILURE);
	break;
	}
	}

	result = s_OpenAudioStream(&engine, direction, sharingMode, perfMode);
	if (result != AAUDIO_OK) {
	printf("s_OpenAudioStream returned %s\n",
	AAudio_convertResultToText(result));
	errorCount++;
	}

	int32_t framesPerBurst = AAudioStream_getFramesPerBurst(engine.stream);
	// Use double buffered stream.
	const int32_t bufferSize = AAudioStream_setBufferSizeInFrames(engine.stream, 2 * framesPerBurst);
	if (bufferSize < 0) {
	printf("AAudioStream_setBufferSizeInFrames returned %s\n",
	AAudio_convertResultToText(bufferSize));
	errorCount++;
	}

	// Check to see what kind of stream we actually got.
	int32_t deviceId = AAudioStream_getDeviceId(engine.stream);
	aaudio_performance_mode_t actualPerfMode = AAudioStream_getPerformanceMode(engine.stream);
	printf("-------- opened: deviceId = %3d, framesPerBurst = %3d, perfMode = %d\n",
	deviceId, framesPerBurst, actualPerfMode);

	// Calculate how many callbacks needed.
	if (alwaysContinue) {
	engine.stopAtFrame = INT32_MAX;
	} else {
	int32_t sampleRate = AAudioStream_getSampleRate(engine.stream);
	engine.stopAtFrame = STOP_AT_MSEC * sampleRate / 1000;
	}

	for (int loops = 0; loops < 2 && result == AAUDIO_OK; loops++) {
	engine.reset();

	// Start stream.
	result = AAudioStream_requestStart(engine.stream);
	printf("AAudioStream_requestStart() returned %d >>>>>>>>>>>>>>>>>>>>>>\n", result);
	if (result != AAUDIO_OK) {
	errorCount++;
	break;
	}

	if (result == AAUDIO_OK) {
	const int watchLoops = LOOP_DURATION_MSEC / SLEEP_DURATION_MSEC;
	for (int i = watchLoops; i > 0; i--) {
	errorCount += s_checkEnginePositions(&engine) ? 1 : 0;
	usleep(SLEEP_DURATION_MSEC * 1000);
	}
	}

	if (engine.stopAtFrame != INT32_MAX) {
	callbackResult = (engine.callbackCountAfterStop == 0) ? EXIT_SUCCESS
	: EXIT_FAILURE;
	if (callbackResult) {
	printf("ERROR - Callback count after STOP = %d\n",
	engine.callbackCountAfterStop.load());
	errorCount++;
	}
	}

	if (engine.startingFramesRead.load() == engine.framesRead.load()) {
	printf("ERROR - framesRead did not advance across callbacks\n");
	errorCount++;
	}

	result = AAudioStream_requestStop(engine.stream);
	printf("AAudioStream_requestStop() returned %d <<<<<<<<<<<<<<<<<<<<<\n", result);
	if (result != AAUDIO_OK) {
	errorCount++;
	}
	usleep(SLEEP_DURATION_MSEC * 1000);
	errorCount += s_checkEnginePositions(&engine) ? 1 : 0;
	}

	s_CloseAudioStream(&engine);

	printf("aaudio result = %d = %s\n", result, AAudio_convertResultToText(result));
	printf("test %s\n", errorCount ? "FAILED" : "PASSED");

	return errorCount ? EXIT_FAILURE : EXIT_SUCCESS;
	}