aaudio test: test stealing an exclusive stream
This test starts an exclusive stream.
Then a few seconds later it starts a second exclusive stream.
The first stream should get stolen and they should both end up
as SHARED streams.
See comment at start of test_steal_exclusive.cpp for more information.
Bug: 129846760
Test: this is a test
Test: adb shell test_steal_exclusive
Change-Id: Idff0c394ccee2310dd2d38e7715f823e50955e73
diff --git a/media/libaaudio/tests/Android.bp b/media/libaaudio/tests/Android.bp
index 73fd896..a6e5f70 100644
--- a/media/libaaudio/tests/Android.bp
+++ b/media/libaaudio/tests/Android.bp
@@ -226,3 +226,15 @@
"libutils",
],
}
+
+cc_test {
+ name: "test_steal_exclusive",
+ defaults: ["libaaudio_tests_defaults"],
+ srcs: ["test_steal_exclusive.cpp"],
+ shared_libs: [
+ "libaaudio",
+ "libbinder",
+ "libcutils",
+ "libutils",
+ ],
+}
diff --git a/media/libaaudio/tests/test_steal_exclusive.cpp b/media/libaaudio/tests/test_steal_exclusive.cpp
new file mode 100644
index 0000000..2a05910
--- /dev/null
+++ b/media/libaaudio/tests/test_steal_exclusive.cpp
@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2020 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.
+ */
+
+/**
+ * This test starts an exclusive stream.
+ * Then a few seconds later it starts a second exclusive stream.
+ * The first stream should get stolen and they should both end up
+ * as SHARED streams.
+ * The test will print PASS or FAIL.
+ *
+ * If you plug in a headset during the test then you can get them to both
+ * open at almost the same time. This can result in a race condition.
+ * Both streams may try to automatically reopen their streams in EXCLUSIVE mode.
+ * The first stream will have its EXCLUSIVE stream stolen by the second stream.
+ * It will usually get disconnected between its Open and Start calls.
+ * This can also occur in normal use. But is unlikely because the window is very narrow.
+ * In this case, where two streams are responding to the same disconnect event,
+ * it will usually happen.
+ *
+ * Because the stream has not started, this condition will not trigger an onError callback.
+ * But the stream will get an error returned from AAudioStream_requestStart().
+ * The test uses this result to trigger a retry in the onError callback.
+ * That is the best practice for any app restarting a stream.
+ *
+ * You should see that both streams are advancing after the disconnect.
+ *
+ * The headset can connect using a 3.5 mm jack, or USB-C or Bluetooth.
+ *
+ * This test can be used with INPUT by using the -i command line option.
+ * Before running the test you will need to enter "adb root" so that
+ * you can have permission to record.
+ * Also the headset needs to have a microphone.
+ * Then the test should behave essentially the same.
+ */
+
+#include <atomic>
+#include <stdio.h>
+#include <thread>
+#include <unistd.h>
+
+#include <aaudio/AAudio.h>
+
+#define DEFAULT_TIMEOUT_NANOS ((int64_t)1000000000)
+#define SOLO_DURATION_MSEC 2000
+#define DUET_DURATION_MSEC 8000
+#define SLEEP_DURATION_MSEC 500
+
+static const char * s_sharingModeToText(aaudio_sharing_mode_t mode) {
+ return (mode == AAUDIO_SHARING_MODE_EXCLUSIVE) ? "EXCLUSIVE"
+ : ((mode == AAUDIO_SHARING_MODE_SHARED) ? "SHARED"
+ : AAudio_convertResultToText(mode));
+}
+
+static void s_myErrorCallbackProc(
+ AAudioStream *stream,
+ void *userData,
+ aaudio_result_t error);
+
+struct AudioEngine {
+ AAudioStream *stream = nullptr;
+ std::thread *thread = nullptr;
+ aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT;
+
+ // These counters are read and written by the callback and the main thread.
+ std::atomic<int32_t> framesRead{};
+ std::atomic<int32_t> framesCalled{};
+ std::atomic<int32_t> callbackCount{};
+
+ void reset() {
+ framesRead.store(0);
+ framesCalled.store(0);
+ callbackCount.store(0);
+ }
+};
+
+// 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++;
+
+ engine->framesRead = (int32_t)AAudioStream_getFramesRead(stream);
+ engine->framesCalled += numFrames;
+ return AAUDIO_CALLBACK_RESULT_CONTINUE;
+}
+
+static aaudio_result_t s_OpenAudioStream(struct AudioEngine *engine,
+ aaudio_direction_t direction) {
+ AAudioStreamBuilder *builder = nullptr;
+ engine->direction = direction;
+
+ // Use an AAudioStreamBuilder to contain requested parameters.
+ aaudio_result_t result = AAudio_createStreamBuilder(&builder);
+ if (result != AAUDIO_OK) {
+ printf("AAudio_createStreamBuilder returned %s",
+ AAudio_convertResultToText(result));
+ return result;
+ }
+
+ // Request stream properties.
+ AAudioStreamBuilder_setFormat(builder, AAUDIO_FORMAT_PCM_FLOAT);
+ AAudioStreamBuilder_setPerformanceMode(builder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
+ AAudioStreamBuilder_setSharingMode(builder, AAUDIO_SHARING_MODE_EXCLUSIVE);
+ AAudioStreamBuilder_setDirection(builder, direction);
+ AAudioStreamBuilder_setDataCallback(builder, s_myDataCallbackProc, engine);
+ AAudioStreamBuilder_setErrorCallback(builder, s_myErrorCallbackProc, engine);
+
+ // Create an AAudioStream using the Builder.
+ result = AAudioStreamBuilder_openStream(builder, &engine->stream);
+ AAudioStreamBuilder_delete(builder);
+ builder = nullptr;
+ if (result != AAUDIO_OK) {
+ printf("AAudioStreamBuilder_openStream returned %s",
+ AAudio_convertResultToText(result));
+ }
+
+ // See see what kind of stream we actually opened.
+ int32_t deviceId = AAudioStream_getDeviceId(engine->stream);
+ aaudio_sharing_mode_t actualSharingMode = AAudioStream_getSharingMode(engine->stream);
+ printf("-------- opened: deviceId = %3d, actualSharingMode = %s\n",
+ deviceId,
+ s_sharingModeToText(actualSharingMode));
+
+ 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;
+ }
+ return result;
+}
+
+static void s_myRestartStreamProc(void *userData) {
+ printf("%s() - restart in separate thread\n", __func__);
+ AudioEngine *engine = (AudioEngine *) userData;
+ int retriesLeft = 1;
+ aaudio_result_t result;
+ do {
+ s_CloseAudioStream(engine);
+ s_OpenAudioStream(engine, engine->direction);
+ // It is possible for the stream to be disconnected, or stolen between the time
+ // it is opened and when it is started. If that happens then try again.
+ // If it was stolen then it should succeed the second time because there will already be
+ // a SHARED stream, which will not get stolen.
+ result = AAudioStream_requestStart(engine->stream);
+ printf("%s() - AAudioStream_requestStart() returns %s\n", __func__,
+ AAudio_convertResultToText(result));
+ } while (retriesLeft-- > 0 && result != AAUDIO_OK);
+}
+
+static void s_myErrorCallbackProc(
+ AAudioStream * /* stream */,
+ void *userData,
+ aaudio_result_t error) {
+ printf("%s() - error = %s\n", __func__, AAudio_convertResultToText(error));
+ // Handle error on a separate thread.
+ std::thread t(s_myRestartStreamProc, userData);
+ t.detach();
+}
+
+static void s_usage() {
+ printf("test_steal_exclusive [-i]\n");
+ printf(" -i direction INPUT, otherwise OUTPUT\n");
+}
+
+/**
+ * @return 0 is OK, -1 for error
+ */
+static int s_checkEnginePositions(AudioEngine *engine) {
+ if (engine->stream == nullptr) return 0; // race condition with onError procs!
+
+ 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 victim;
+ struct AudioEngine thief;
+ aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT;
+ aaudio_result_t result = AAUDIO_OK;
+ int errorCount = 0;
+
+ // 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 Stealing an EXCLUSIVE stream V1.0\n");
+ printf("\n");
+
+ for (int i = 1; i < argc; i++) {
+ const char *arg = argv[i];
+ if (arg[0] == '-') {
+ char option = arg[1];
+ switch (option) {
+ case 'i':
+ direction = AAUDIO_DIRECTION_INPUT;
+ break;
+ default:
+ s_usage();
+ exit(EXIT_FAILURE);
+ break;
+ }
+ } else {
+ s_usage();
+ exit(EXIT_FAILURE);
+ break;
+ }
+ }
+
+ result = s_OpenAudioStream(&victim, direction);
+ if (result != AAUDIO_OK) {
+ printf("s_OpenAudioStream victim returned %s\n",
+ AAudio_convertResultToText(result));
+ errorCount++;
+ }
+ victim.reset();
+
+ // Start stream.
+ result = AAudioStream_requestStart(victim.stream);
+ printf("AAudioStream_requestStart(VICTIM) returned %d >>>>>>>>>>>>>>>>>>>>>>\n", result);
+ if (result != AAUDIO_OK) {
+ errorCount++;
+ }
+
+ if (result == AAUDIO_OK) {
+ const int watchLoops = SOLO_DURATION_MSEC / SLEEP_DURATION_MSEC;
+ for (int i = watchLoops; i > 0; i--) {
+ errorCount += s_checkEnginePositions(&victim) ? 1 : 0;
+ usleep(SLEEP_DURATION_MSEC * 1000);
+ }
+ }
+
+ printf("Try to start the THIEF stream that may steal the VICTIM MMAP resource -----\n");
+ result = s_OpenAudioStream(&thief, direction);
+ if (result != AAUDIO_OK) {
+ printf("s_OpenAudioStream victim returned %s\n",
+ AAudio_convertResultToText(result));
+ errorCount++;
+ }
+ thief.reset();
+
+ // Start stream.
+ result = AAudioStream_requestStart(thief.stream);
+ printf("AAudioStream_requestStart(THIEF) returned %d >>>>>>>>>>>>>>>>>>>>>>\n", result);
+ if (result != AAUDIO_OK) {
+ errorCount++;
+ }
+ printf("You might enjoy plugging in a headset now to see what happens...\n");
+
+ if (result == AAUDIO_OK) {
+ const int watchLoops = DUET_DURATION_MSEC / SLEEP_DURATION_MSEC;
+ for (int i = watchLoops; i > 0; i--) {
+ printf("victim: ");
+ errorCount += s_checkEnginePositions(&victim) ? 1 : 0;
+ printf(" thief: ");
+ errorCount += s_checkEnginePositions(&thief) ? 1 : 0;
+ usleep(SLEEP_DURATION_MSEC * 1000);
+ }
+ }
+
+ // Check for PASS/FAIL
+ aaudio_sharing_mode_t victimSharingMode = AAudioStream_getSharingMode(victim.stream);
+ aaudio_sharing_mode_t thiefSharingMode = AAudioStream_getSharingMode(thief.stream);
+ printf("victimSharingMode = %s, thiefSharingMode = %s, - ",
+ s_sharingModeToText(victimSharingMode),
+ s_sharingModeToText(thiefSharingMode));
+ if ((victimSharingMode == AAUDIO_SHARING_MODE_SHARED)
+ && (thiefSharingMode == AAUDIO_SHARING_MODE_SHARED)) {
+ printf("Both modes are SHARED => PASS\n");
+ } else {
+ errorCount++;
+ printf("Both modes should be SHARED => FAIL!!\n");
+ }
+
+ const int64_t victimFramesRead = AAudioStream_getFramesRead(victim.stream);
+ const int64_t thiefFramesRead = AAudioStream_getFramesRead(thief.stream);
+ printf("victimFramesRead = %d, thiefFramesRead = %d, - ",
+ (int)victimFramesRead, (int)thiefFramesRead);
+ if (victimFramesRead > 0 && thiefFramesRead > 0) {
+ printf("Both streams are running => PASS\n");
+ } else {
+ errorCount++;
+ printf("Both streams should be running => FAIL!!\n");
+ }
+
+ result = AAudioStream_requestStop(victim.stream);
+ printf("AAudioStream_requestStop() returned %d <<<<<<<<<<<<<<<<<<<<<\n", result);
+ if (result != AAUDIO_OK) {
+ errorCount++;
+ }
+ result = AAudioStream_requestStop(thief.stream);
+ printf("AAudioStream_requestStop() returned %d <<<<<<<<<<<<<<<<<<<<<\n", result);
+ if (result != AAUDIO_OK) {
+ errorCount++;
+ }
+
+ s_CloseAudioStream(&victim);
+ s_CloseAudioStream(&thief);
+
+ printf("aaudio result = %d = %s\n", result, AAudio_convertResultToText(result));
+ printf("test %s\n", errorCount ? "FAILED" : "PASSED");
+
+ return errorCount ? EXIT_FAILURE : EXIT_SUCCESS;
+}