tests/tests/nativemedia/aaudio/jni/test_aaudio.cpp - platform/cts - Git at Google

 /*
  * Copyright 2016 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.
  */

 #define LOG_NDEBUG 0
 #define LOG_TAG "AAudioTest"

 #include <memory>
 #include <tuple>

 #include <unistd.h>

 #include <aaudio/AAudio.h>
 #include <android/log.h>
 #include <gtest/gtest.h>

 #include "test_aaudio.h"
 #include "utils.h"

 using StreamTestParams = std::tuple<aaudio_sharing_mode_t, aaudio_performance_mode_t>;
 enum {
     PARAM_SHARING_MODE = 0,
     PARAM_PERF_MODE
 };

 static std::string getTestName(const ::testing::TestParamInfo<StreamTestParams>& info) {
     return std::string() + sharingModeToString(std::get<PARAM_SHARING_MODE>(info.param)) +
             "__" + performanceModeToString(std::get<PARAM_PERF_MODE>(info.param));
 }

 template<typename T>
 class AAudioStreamTest : public ::testing::TestWithParam<StreamTestParams> {
   protected:
     AAudioStreamBuilder* builder() const { return mHelper->builder(); }
     AAudioStream* stream() const { return mHelper->stream(); }
     const StreamBuilderHelper::Parameters& actual() const { return mHelper->actual(); }
     int32_t framesPerBurst() const { return mHelper->framesPerBurst(); }

     std::unique_ptr<T> mHelper;
     bool mSetupSuccesful = false;
     std::unique_ptr<int16_t[]> mData;
 };


 class AAudioInputStreamTest : public AAudioStreamTest<InputStreamBuilderHelper> {
   protected:
     void SetUp() override;

     int32_t mFramesPerRead;
 };

 void AAudioInputStreamTest::SetUp() {
     mSetupSuccesful = false;
     if (!deviceSupportsFeature(FEATURE_RECORDING)) return;
     mHelper.reset(new InputStreamBuilderHelper(
                     std::get<PARAM_SHARING_MODE>(GetParam()),
                     std::get<PARAM_PERF_MODE>(GetParam())));
     mHelper->initBuilder();
     mHelper->createAndVerifyStream(&mSetupSuccesful);
     if (!mSetupSuccesful) return;

     mFramesPerRead = framesPerBurst();
     const int32_t framesPerMsec = actual().sampleRate / MILLIS_PER_SECOND;
     // Some DMA might use very short bursts of 16 frames. We don't need to read such small
     // buffers. But it helps to use a multiple of the burst size for predictable scheduling.
     while (mFramesPerRead < framesPerMsec) {
         mFramesPerRead *= 2;
     }
     mData.reset(new int16_t[mFramesPerRead * actual().channelCount]);
 }

 TEST_P(AAudioInputStreamTest, testReading) {
     if (!mSetupSuccesful) return;

     const int32_t framesToRecord = actual().sampleRate;  // 1 second
     EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
     EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
     mHelper->startStream();
     // See b/62090113. For legacy path, the device is only known after
     // the stream has been started.
     ASSERT_NE(AAUDIO_UNSPECIFIED, AAudioStream_getDeviceId(stream()));
     for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
         aaudio_result_t result = AAudioStream_read(
                 stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
                 DEFAULT_READ_TIMEOUT);
         ASSERT_GT(result, 0);
         framesLeft -= result;
     }
     mHelper->stopStream();
     EXPECT_GE(AAudioStream_getFramesRead(stream()), framesToRecord);
     EXPECT_GE(AAudioStream_getFramesWritten(stream()), framesToRecord);
     EXPECT_GE(AAudioStream_getXRunCount(stream()), 0);
 }

 TEST_P(AAudioInputStreamTest, testStartReadStop) {
     if (!mSetupSuccesful) return;

     // Use 1/8 second as start-stops take a lot more time than just recording.
     const int32_t framesToRecord = actual().sampleRate / 8;
     EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
     EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
     for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
         mHelper->startStream();
         aaudio_result_t result = AAudioStream_read(
                 stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
                 DEFAULT_READ_TIMEOUT);
         ASSERT_GT(result, 0);
         framesLeft -= result;
         mHelper->stopStream();
     }
     EXPECT_GE(AAudioStream_getFramesRead(stream()), framesToRecord);
     EXPECT_GE(AAudioStream_getFramesWritten(stream()), framesToRecord);
 }

 TEST_P(AAudioInputStreamTest, testReadCounterFreezeAfterStop) {
     if (!mSetupSuccesful) return;

     const int32_t framesToRecord = actual().sampleRate / 10;  // 1/10 second
     EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
     EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
     mHelper->startStream();
     for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
         aaudio_result_t result = AAudioStream_read(
                 stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
                 DEFAULT_READ_TIMEOUT);
         ASSERT_GT(result, 0);
         framesLeft -= result;
     }
     mHelper->stopStream();
     const int32_t framesReadAtStop = AAudioStream_getFramesRead(stream());
     const int32_t framesWrittenAtStop = AAudioStream_getFramesWritten(stream());
     ASSERT_EQ(0, TEMP_FAILURE_RETRY(usleep(100 * MICROS_PER_MILLISECOND)));
     EXPECT_EQ(framesReadAtStop, AAudioStream_getFramesRead(stream()));
     EXPECT_EQ(framesWrittenAtStop, AAudioStream_getFramesWritten(stream()));
 }

 TEST_P(AAudioInputStreamTest, testPauseAndFlushNotSupported) {
     if (!mSetupSuccesful) return;
     mHelper->startStream();
     EXPECT_EQ(AAUDIO_ERROR_UNIMPLEMENTED, AAudioStream_requestPause(stream()));
     EXPECT_EQ(AAUDIO_ERROR_UNIMPLEMENTED, AAudioStream_requestFlush(stream()));
     mHelper->stopStream();
 }

 INSTANTIATE_TEST_CASE_P(SPM, AAudioInputStreamTest,
         ::testing::Values(
                 std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_NONE),
                 // Recording in POWER_SAVING mode isn't supported, b/62291775.
                 std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
                 std::make_tuple(AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_NONE),
                 std::make_tuple(
                         AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_POWER_SAVING),
                 std::make_tuple(
                         AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY)),
         &getTestName);


 class AAudioOutputStreamTest : public AAudioStreamTest<OutputStreamBuilderHelper> {
   protected:
     void SetUp() override;
 };

 void AAudioOutputStreamTest::SetUp() {
     mSetupSuccesful = false;
     if (!deviceSupportsFeature(FEATURE_PLAYBACK)) return;
     mHelper.reset(new OutputStreamBuilderHelper(
                     std::get<PARAM_SHARING_MODE>(GetParam()),
                     std::get<PARAM_PERF_MODE>(GetParam())));
     mHelper->initBuilder();

     mHelper->createAndVerifyStream(&mSetupSuccesful);
     if (!mSetupSuccesful) return;

     // Allocate a buffer for the audio data.
     // TODO handle possibility of other data formats
     size_t dataSizeSamples = framesPerBurst() * actual().channelCount;
     mData.reset(new int16_t[dataSizeSamples]);
     memset(&mData[0], 0, dataSizeSamples);
 }

 TEST_P(AAudioOutputStreamTest, testWriting) {
     if (!mSetupSuccesful) return;

     // Prime the buffer.
     int32_t framesWritten = 0;
     int64_t framesTotal = 0;
     int64_t timeoutNanos = 0;
     do {
         framesWritten = AAudioStream_write(
                 stream(), &mData[0], framesPerBurst(), timeoutNanos);
         // There should be some room for priming the buffer.
         framesTotal += framesWritten;
         ASSERT_GE(framesWritten, 0);
         ASSERT_LE(framesWritten, framesPerBurst());
     } while (framesWritten > 0);
     ASSERT_TRUE(framesTotal > 0);

     int writeLoops = 0;
     int64_t aaudioFramesRead = 0;
     int64_t aaudioFramesReadPrev = 0;
     int64_t aaudioFramesReadFinal = 0;
     int64_t aaudioFramesWritten = 0;
     // Start/write/pause more than once to see if it fails after the first time.
     // Write some data and measure the rate to see if the timing is OK.
     for (int numLoops = 0; numLoops < 2; numLoops++) {
         mHelper->startStream();
         // See b/62090113. For legacy path, the device is only known after
         // the stream has been started.
         ASSERT_NE(AAUDIO_UNSPECIFIED, AAudioStream_getDeviceId(stream()));

         // Write some data while we are running. Read counter should be advancing.
         writeLoops = 1 * actual().sampleRate / framesPerBurst(); // 1 second
         ASSERT_LT(2, writeLoops); // detect absurdly high framesPerBurst
         timeoutNanos = 100 * (NANOS_PER_SECOND * framesPerBurst() /
                 actual().sampleRate); // N bursts
         framesWritten = 1;
         aaudioFramesRead = AAudioStream_getFramesRead(stream());
         aaudioFramesReadPrev = aaudioFramesRead;
         int64_t beginTime = getNanoseconds(CLOCK_MONOTONIC);
         do {
             framesWritten = AAudioStream_write(
                     stream(), &mData[0], framesPerBurst(), timeoutNanos);
             EXPECT_EQ(framesPerBurst(), framesWritten);

             framesTotal += framesWritten;
             aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
             EXPECT_EQ(framesTotal, aaudioFramesWritten);

             // Try to get a more accurate measure of the sample rate.
             if (beginTime == 0) {
                 aaudioFramesRead = AAudioStream_getFramesRead(stream());
                 if (aaudioFramesRead > aaudioFramesReadPrev) { // is read pointer advancing
                     beginTime = getNanoseconds(CLOCK_MONOTONIC);
                     aaudioFramesReadPrev = aaudioFramesRead;
                 }
             }
         } while (framesWritten > 0 && writeLoops-- > 0);

         aaudioFramesReadFinal = AAudioStream_getFramesRead(stream());
         ASSERT_GT(aaudioFramesReadFinal, 0);
         EXPECT_GT(aaudioFramesReadFinal, aaudioFramesReadPrev);


         // TODO why is AudioTrack path so inaccurate?
         /* See b/38268547, there is no way to specify that MMAP mode needs to be used,
            even EXCLUSIVE mode may fall back to legacy
         const int64_t endTime = getNanoseconds(CLOCK_MONOTONIC);
         const double rateTolerance = 200.0; // arbitrary tolerance for sample rate
         if (std::get<PARAM_SHARING_MODE>(GetParam()) != AAUDIO_SHARING_MODE_SHARED) {
             // Calculate approximate sample rate and compare with stream rate.
             double seconds = (endTime - beginTime) / (double) NANOS_PER_SECOND;
             double measuredRate = (aaudioFramesReadFinal - aaudioFramesReadPrev) / seconds;
             ASSERT_NEAR(actual().sampleRate, measuredRate, rateTolerance);
         }
         */

         mHelper->pauseStream();
     }
     EXPECT_GE(AAudioStream_getXRunCount(stream()), 0);

     // Make sure the read counter is not advancing when we are paused.
     aaudioFramesRead = AAudioStream_getFramesRead(stream());
     ASSERT_GE(aaudioFramesRead, aaudioFramesReadFinal); // monotonic increase
     // Currently not possible to enforce for AAudio over AudioTrack (b/33354715).
     // ASSERT_EQ(0, TEMP_FAILURE_RETRY(usleep(100 * MICROS_PER_MILLISECOND)));
     // EXPECT_EQ(aaudioFramesRead, AAudioStream_getFramesRead(stream()));

     // ------------------- TEST FLUSH -----------------
     // Prime the buffer.
     timeoutNanos = 0;
     writeLoops = 1000;
     do {
         framesWritten = AAudioStream_write(
                 stream(), &mData[0], framesPerBurst(), timeoutNanos);
         framesTotal += framesWritten;
     } while (framesWritten > 0 && writeLoops-- > 0);
     EXPECT_EQ(0, framesWritten);

     mHelper->flushStream();

     // After a flush, the read counter should be caught up with the write counter.
     aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
     EXPECT_EQ(framesTotal, aaudioFramesWritten);
     aaudioFramesRead = AAudioStream_getFramesRead(stream());
     EXPECT_EQ(aaudioFramesWritten, aaudioFramesRead);

     sleep(1); // FIXME - The write returns 0 if we remove this sleep! Why?

     // The buffer should be empty after a flush so we should be able to write.
     framesWritten = AAudioStream_write(stream(), &mData[0], framesPerBurst(), timeoutNanos);
     // There should be some room for priming the buffer.
     ASSERT_GT(framesWritten, 0);
     ASSERT_LE(framesWritten, framesPerBurst());
 }

 // Make sure the read and write frame counters do not diverge by more than the
 // capacity of the buffer.
 TEST_P(AAudioOutputStreamTest, testWriteStopWrite) {
     if (!mSetupSuccesful) return;

     int32_t framesWritten = 0;
     int64_t framesTotal = 0;
     int64_t timeoutNanos = 0;
     int32_t writeLoops = 0;
     int64_t aaudioFramesRead = 0;
     int64_t aaudioFramesWritten = 0;
     int32_t frameCapacity = AAudioStream_getBufferCapacityInFrames(stream());

     // Start/write/stop more than once to see if it fails after the first time.
     for (int numLoops = 0; numLoops < 2; numLoops++) {
         mHelper->startStream();

         // Write some data while we are running. Read counter should be advancing.
         writeLoops = 1 * actual().sampleRate / framesPerBurst(); // 1 second
         ASSERT_LT(2, writeLoops); // detect absurdly high framesPerBurst

         // Calculate a reasonable timeout value.
         const int32_t timeoutBursts = 20;
         timeoutNanos = timeoutBursts * (NANOS_PER_SECOND * framesPerBurst() /
                               actual().sampleRate);
         // Account for cold start latency.
         timeoutNanos = std::max(timeoutNanos, 400 * NANOS_PER_MILLISECOND);

         do {
             framesWritten = AAudioStream_write(
                     stream(), &mData[0], framesPerBurst(), timeoutNanos);
             EXPECT_EQ(framesPerBurst(), framesWritten);
             framesTotal += framesWritten;

             aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
             EXPECT_EQ(framesTotal, aaudioFramesWritten);
             aaudioFramesRead = AAudioStream_getFramesRead(stream());

             // How many frames are sitting in the buffer?
             int32_t writtenButNotRead = (int32_t)(aaudioFramesWritten - aaudioFramesRead);
             ASSERT_LE(writtenButNotRead, frameCapacity);
             // It is legal for writtenButNotRead to be negative because
             // MMAP HW can underrun the FIFO.
         } while (framesWritten > 0 && writeLoops-- > 0);

         mHelper->stopStream();
     }
 }

 // Note that the test for EXCLUSIVE sharing mode may fail gracefully if
 // this mode isn't supported by the platform.
 INSTANTIATE_TEST_CASE_P(SPM, AAudioOutputStreamTest,
         ::testing::Values(
                 std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_NONE),
                 std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
                 std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_POWER_SAVING),

                 std::make_tuple(AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_NONE),
                 std::make_tuple(
                         AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
                 std::make_tuple(
                         AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_POWER_SAVING)),
         &getTestName);
	/*
	* Copyright 2016 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.
	*/

	#define LOG_NDEBUG 0
	#define LOG_TAG "AAudioTest"

	#include <memory>
	#include <tuple>

	#include <unistd.h>

	#include <aaudio/AAudio.h>
	#include <android/log.h>
	#include <gtest/gtest.h>

	#include "test_aaudio.h"
	#include "utils.h"

	using StreamTestParams = std::tuple<aaudio_sharing_mode_t, aaudio_performance_mode_t>;
	enum {
	PARAM_SHARING_MODE = 0,
	PARAM_PERF_MODE
	};

	static std::string getTestName(const ::testing::TestParamInfo<StreamTestParams>& info) {
	return std::string() + sharingModeToString(std::get<PARAM_SHARING_MODE>(info.param)) +
	"__" + performanceModeToString(std::get<PARAM_PERF_MODE>(info.param));
	}

	template<typename T>
	class AAudioStreamTest : public ::testing::TestWithParam<StreamTestParams> {
	protected:
	AAudioStreamBuilder* builder() const { return mHelper->builder(); }
	AAudioStream* stream() const { return mHelper->stream(); }
	const StreamBuilderHelper::Parameters& actual() const { return mHelper->actual(); }
	int32_t framesPerBurst() const { return mHelper->framesPerBurst(); }

	std::unique_ptr<T> mHelper;
	bool mSetupSuccesful = false;
	std::unique_ptr<int16_t[]> mData;
	};


	class AAudioInputStreamTest : public AAudioStreamTest<InputStreamBuilderHelper> {
	protected:
	void SetUp() override;

	int32_t mFramesPerRead;
	};

	void AAudioInputStreamTest::SetUp() {
	mSetupSuccesful = false;
	if (!deviceSupportsFeature(FEATURE_RECORDING)) return;
	mHelper.reset(new InputStreamBuilderHelper(
	std::get<PARAM_SHARING_MODE>(GetParam()),
	std::get<PARAM_PERF_MODE>(GetParam())));
	mHelper->initBuilder();
	mHelper->createAndVerifyStream(&mSetupSuccesful);
	if (!mSetupSuccesful) return;

	mFramesPerRead = framesPerBurst();
	const int32_t framesPerMsec = actual().sampleRate / MILLIS_PER_SECOND;
	// Some DMA might use very short bursts of 16 frames. We don't need to read such small
	// buffers. But it helps to use a multiple of the burst size for predictable scheduling.
	while (mFramesPerRead < framesPerMsec) {
	mFramesPerRead *= 2;
	}
	mData.reset(new int16_t[mFramesPerRead * actual().channelCount]);
	}

	TEST_P(AAudioInputStreamTest, testReading) {
	if (!mSetupSuccesful) return;

	const int32_t framesToRecord = actual().sampleRate; // 1 second
	EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
	EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
	mHelper->startStream();
	// See b/62090113. For legacy path, the device is only known after
	// the stream has been started.
	ASSERT_NE(AAUDIO_UNSPECIFIED, AAudioStream_getDeviceId(stream()));
	for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
	aaudio_result_t result = AAudioStream_read(
	stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
	DEFAULT_READ_TIMEOUT);
	ASSERT_GT(result, 0);
	framesLeft -= result;
	}
	mHelper->stopStream();
	EXPECT_GE(AAudioStream_getFramesRead(stream()), framesToRecord);
	EXPECT_GE(AAudioStream_getFramesWritten(stream()), framesToRecord);
	EXPECT_GE(AAudioStream_getXRunCount(stream()), 0);
	}

	TEST_P(AAudioInputStreamTest, testStartReadStop) {
	if (!mSetupSuccesful) return;

	// Use 1/8 second as start-stops take a lot more time than just recording.
	const int32_t framesToRecord = actual().sampleRate / 8;
	EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
	EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
	for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
	mHelper->startStream();
	aaudio_result_t result = AAudioStream_read(
	stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
	DEFAULT_READ_TIMEOUT);
	ASSERT_GT(result, 0);
	framesLeft -= result;
	mHelper->stopStream();
	}
	EXPECT_GE(AAudioStream_getFramesRead(stream()), framesToRecord);
	EXPECT_GE(AAudioStream_getFramesWritten(stream()), framesToRecord);
	}

	TEST_P(AAudioInputStreamTest, testReadCounterFreezeAfterStop) {
	if (!mSetupSuccesful) return;

	const int32_t framesToRecord = actual().sampleRate / 10; // 1/10 second
	EXPECT_EQ(0, AAudioStream_getFramesRead(stream()));
	EXPECT_EQ(0, AAudioStream_getFramesWritten(stream()));
	mHelper->startStream();
	for (int32_t framesLeft = framesToRecord; framesLeft > 0; ) {
	aaudio_result_t result = AAudioStream_read(
	stream(), &mData[0], std::min(framesToRecord, mFramesPerRead),
	DEFAULT_READ_TIMEOUT);
	ASSERT_GT(result, 0);
	framesLeft -= result;
	}
	mHelper->stopStream();
	const int32_t framesReadAtStop = AAudioStream_getFramesRead(stream());
	const int32_t framesWrittenAtStop = AAudioStream_getFramesWritten(stream());
	ASSERT_EQ(0, TEMP_FAILURE_RETRY(usleep(100 * MICROS_PER_MILLISECOND)));
	EXPECT_EQ(framesReadAtStop, AAudioStream_getFramesRead(stream()));
	EXPECT_EQ(framesWrittenAtStop, AAudioStream_getFramesWritten(stream()));
	}

	TEST_P(AAudioInputStreamTest, testPauseAndFlushNotSupported) {
	if (!mSetupSuccesful) return;
	mHelper->startStream();
	EXPECT_EQ(AAUDIO_ERROR_UNIMPLEMENTED, AAudioStream_requestPause(stream()));
	EXPECT_EQ(AAUDIO_ERROR_UNIMPLEMENTED, AAudioStream_requestFlush(stream()));
	mHelper->stopStream();
	}

	INSTANTIATE_TEST_CASE_P(SPM, AAudioInputStreamTest,
	::testing::Values(
	std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_NONE),
	// Recording in POWER_SAVING mode isn't supported, b/62291775.
	std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
	std::make_tuple(AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_NONE),
	std::make_tuple(
	AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_POWER_SAVING),
	std::make_tuple(
	AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY)),
	&getTestName);


	class AAudioOutputStreamTest : public AAudioStreamTest<OutputStreamBuilderHelper> {
	protected:
	void SetUp() override;
	};

	void AAudioOutputStreamTest::SetUp() {
	mSetupSuccesful = false;
	if (!deviceSupportsFeature(FEATURE_PLAYBACK)) return;
	mHelper.reset(new OutputStreamBuilderHelper(
	std::get<PARAM_SHARING_MODE>(GetParam()),
	std::get<PARAM_PERF_MODE>(GetParam())));
	mHelper->initBuilder();

	mHelper->createAndVerifyStream(&mSetupSuccesful);
	if (!mSetupSuccesful) return;

	// Allocate a buffer for the audio data.
	// TODO handle possibility of other data formats
	size_t dataSizeSamples = framesPerBurst() * actual().channelCount;
	mData.reset(new int16_t[dataSizeSamples]);
	memset(&mData[0], 0, dataSizeSamples);
	}

	TEST_P(AAudioOutputStreamTest, testWriting) {
	if (!mSetupSuccesful) return;

	// Prime the buffer.
	int32_t framesWritten = 0;
	int64_t framesTotal = 0;
	int64_t timeoutNanos = 0;
	do {
	framesWritten = AAudioStream_write(
	stream(), &mData[0], framesPerBurst(), timeoutNanos);
	// There should be some room for priming the buffer.
	framesTotal += framesWritten;
	ASSERT_GE(framesWritten, 0);
	ASSERT_LE(framesWritten, framesPerBurst());
	} while (framesWritten > 0);
	ASSERT_TRUE(framesTotal > 0);

	int writeLoops = 0;
	int64_t aaudioFramesRead = 0;
	int64_t aaudioFramesReadPrev = 0;
	int64_t aaudioFramesReadFinal = 0;
	int64_t aaudioFramesWritten = 0;
	// Start/write/pause more than once to see if it fails after the first time.
	// Write some data and measure the rate to see if the timing is OK.
	for (int numLoops = 0; numLoops < 2; numLoops++) {
	mHelper->startStream();
	// See b/62090113. For legacy path, the device is only known after
	// the stream has been started.
	ASSERT_NE(AAUDIO_UNSPECIFIED, AAudioStream_getDeviceId(stream()));

	// Write some data while we are running. Read counter should be advancing.
	writeLoops = 1 * actual().sampleRate / framesPerBurst(); // 1 second
	ASSERT_LT(2, writeLoops); // detect absurdly high framesPerBurst
	timeoutNanos = 100 * (NANOS_PER_SECOND * framesPerBurst() /
	actual().sampleRate); // N bursts
	framesWritten = 1;
	aaudioFramesRead = AAudioStream_getFramesRead(stream());
	aaudioFramesReadPrev = aaudioFramesRead;
	int64_t beginTime = getNanoseconds(CLOCK_MONOTONIC);
	do {
	framesWritten = AAudioStream_write(
	stream(), &mData[0], framesPerBurst(), timeoutNanos);
	EXPECT_EQ(framesPerBurst(), framesWritten);

	framesTotal += framesWritten;
	aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
	EXPECT_EQ(framesTotal, aaudioFramesWritten);

	// Try to get a more accurate measure of the sample rate.
	if (beginTime == 0) {
	aaudioFramesRead = AAudioStream_getFramesRead(stream());
	if (aaudioFramesRead > aaudioFramesReadPrev) { // is read pointer advancing
	beginTime = getNanoseconds(CLOCK_MONOTONIC);
	aaudioFramesReadPrev = aaudioFramesRead;
	}
	}
	} while (framesWritten > 0 && writeLoops-- > 0);

	aaudioFramesReadFinal = AAudioStream_getFramesRead(stream());
	ASSERT_GT(aaudioFramesReadFinal, 0);
	EXPECT_GT(aaudioFramesReadFinal, aaudioFramesReadPrev);


	// TODO why is AudioTrack path so inaccurate?
	/* See b/38268547, there is no way to specify that MMAP mode needs to be used,
	even EXCLUSIVE mode may fall back to legacy
	const int64_t endTime = getNanoseconds(CLOCK_MONOTONIC);
	const double rateTolerance = 200.0; // arbitrary tolerance for sample rate
	if (std::get<PARAM_SHARING_MODE>(GetParam()) != AAUDIO_SHARING_MODE_SHARED) {
	// Calculate approximate sample rate and compare with stream rate.
	double seconds = (endTime - beginTime) / (double) NANOS_PER_SECOND;
	double measuredRate = (aaudioFramesReadFinal - aaudioFramesReadPrev) / seconds;
	ASSERT_NEAR(actual().sampleRate, measuredRate, rateTolerance);
	}
	*/

	mHelper->pauseStream();
	}
	EXPECT_GE(AAudioStream_getXRunCount(stream()), 0);

	// Make sure the read counter is not advancing when we are paused.
	aaudioFramesRead = AAudioStream_getFramesRead(stream());
	ASSERT_GE(aaudioFramesRead, aaudioFramesReadFinal); // monotonic increase
	// Currently not possible to enforce for AAudio over AudioTrack (b/33354715).
	// ASSERT_EQ(0, TEMP_FAILURE_RETRY(usleep(100 * MICROS_PER_MILLISECOND)));
	// EXPECT_EQ(aaudioFramesRead, AAudioStream_getFramesRead(stream()));

	// ------------------- TEST FLUSH -----------------
	// Prime the buffer.
	timeoutNanos = 0;
	writeLoops = 1000;
	do {
	framesWritten = AAudioStream_write(
	stream(), &mData[0], framesPerBurst(), timeoutNanos);
	framesTotal += framesWritten;
	} while (framesWritten > 0 && writeLoops-- > 0);
	EXPECT_EQ(0, framesWritten);

	mHelper->flushStream();

	// After a flush, the read counter should be caught up with the write counter.
	aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
	EXPECT_EQ(framesTotal, aaudioFramesWritten);
	aaudioFramesRead = AAudioStream_getFramesRead(stream());
	EXPECT_EQ(aaudioFramesWritten, aaudioFramesRead);

	sleep(1); // FIXME - The write returns 0 if we remove this sleep! Why?

	// The buffer should be empty after a flush so we should be able to write.
	framesWritten = AAudioStream_write(stream(), &mData[0], framesPerBurst(), timeoutNanos);
	// There should be some room for priming the buffer.
	ASSERT_GT(framesWritten, 0);
	ASSERT_LE(framesWritten, framesPerBurst());
	}

	// Make sure the read and write frame counters do not diverge by more than the
	// capacity of the buffer.
	TEST_P(AAudioOutputStreamTest, testWriteStopWrite) {
	if (!mSetupSuccesful) return;

	int32_t framesWritten = 0;
	int64_t framesTotal = 0;
	int64_t timeoutNanos = 0;
	int32_t writeLoops = 0;
	int64_t aaudioFramesRead = 0;
	int64_t aaudioFramesWritten = 0;
	int32_t frameCapacity = AAudioStream_getBufferCapacityInFrames(stream());

	// Start/write/stop more than once to see if it fails after the first time.
	for (int numLoops = 0; numLoops < 2; numLoops++) {
	mHelper->startStream();

	// Write some data while we are running. Read counter should be advancing.
	writeLoops = 1 * actual().sampleRate / framesPerBurst(); // 1 second
	ASSERT_LT(2, writeLoops); // detect absurdly high framesPerBurst

	// Calculate a reasonable timeout value.
	const int32_t timeoutBursts = 20;
	timeoutNanos = timeoutBursts * (NANOS_PER_SECOND * framesPerBurst() /
	actual().sampleRate);
	// Account for cold start latency.
	timeoutNanos = std::max(timeoutNanos, 400 * NANOS_PER_MILLISECOND);

	do {
	framesWritten = AAudioStream_write(
	stream(), &mData[0], framesPerBurst(), timeoutNanos);
	EXPECT_EQ(framesPerBurst(), framesWritten);
	framesTotal += framesWritten;

	aaudioFramesWritten = AAudioStream_getFramesWritten(stream());
	EXPECT_EQ(framesTotal, aaudioFramesWritten);
	aaudioFramesRead = AAudioStream_getFramesRead(stream());

	// How many frames are sitting in the buffer?
	int32_t writtenButNotRead = (int32_t)(aaudioFramesWritten - aaudioFramesRead);
	ASSERT_LE(writtenButNotRead, frameCapacity);
	// It is legal for writtenButNotRead to be negative because
	// MMAP HW can underrun the FIFO.
	} while (framesWritten > 0 && writeLoops-- > 0);

	mHelper->stopStream();
	}
	}

	// Note that the test for EXCLUSIVE sharing mode may fail gracefully if
	// this mode isn't supported by the platform.
	INSTANTIATE_TEST_CASE_P(SPM, AAudioOutputStreamTest,
	::testing::Values(
	std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_NONE),
	std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
	std::make_tuple(AAUDIO_SHARING_MODE_SHARED, AAUDIO_PERFORMANCE_MODE_POWER_SAVING),

	std::make_tuple(AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_NONE),
	std::make_tuple(
	AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY),
	std::make_tuple(
	AAUDIO_SHARING_MODE_EXCLUSIVE, AAUDIO_PERFORMANCE_MODE_POWER_SAVING)),
	&getTestName);