Merge changes Ida15546f,I1b099e23 into oc-dev (8f4b21a0) · Commits · e / os / android_frameworks_av

media/libaaudio/include/aaudio/AAudio.h

+17 −14

Original line number	Diff line number	Diff line
		@@ -209,14 +209,13 @@ AAUDIO_API void AAudioStreamBuilder_setDeviceId(AAudioStreamBuilder* builder,
		/**
		* Request a sample rate in Hertz.
		*
		* The stream may be opened with a different sample rate.
		* So the application should query for the actual rate after the stream is opened.
		*
		* Technically, this should be called the "frame rate" or "frames per second",
		* because it refers to the number of complete frames transferred per second.
		* But it is traditionally called "sample rate". So we use that term.
		*
		* The default, if you do not call this function, is AAUDIO_UNSPECIFIED.
		* An optimal value will then be chosen when the stream is opened.
		* After opening a stream with an unspecified value, the application must
		* query for the actual value, which may vary by device.
		*
		* If an exact value is specified then an opened stream will use that value.
		* If a stream cannot be opened with the specified value then the open will fail.
		*
		* @param builder reference provided by AAudio_createStreamBuilder()
		* @param sampleRate frames per second. Common rates include 44100 and 48000 Hz.
		@@ -227,12 +226,13 @@ AAUDIO_API void AAudioStreamBuilder_setSampleRate(AAudioStreamBuilder* builder,
		/**
		* Request a number of channels for the stream.
		*
		* The stream may be opened with a different value.
		* So the application should query for the actual value after the stream is opened.
		*
		* The default, if you do not call this function, is AAUDIO_UNSPECIFIED.
		* An optimal value will then be chosen when the stream is opened.
		* After opening a stream with an unspecified value, the application must
		* query for the actual value, which may vary by device.
		*
		* Note, this quantity is sometimes referred to as "samples per frame".
		* If an exact value is specified then an opened stream will use that value.
		* If a stream cannot be opened with the specified value then the open will fail.
		*
		* @param builder reference provided by AAudio_createStreamBuilder()
		* @param channelCount Number of channels desired.
		@@ -252,12 +252,15 @@ AAUDIO_API void AAudioStreamBuilder_setSamplesPerFrame(AAudioStreamBuilder* buil
		* Request a sample data format, for example AAUDIO_FORMAT_PCM_I16.
		*
		* The default, if you do not call this function, is AAUDIO_UNSPECIFIED.
		* An optimal value will then be chosen when the stream is opened.
		* After opening a stream with an unspecified value, the application must
		* query for the actual value, which may vary by device.
		*
		* The stream may be opened with a different value.
		* So the application should query for the actual value after the stream is opened.
		* If an exact value is specified then an opened stream will use that value.
		* If a stream cannot be opened with the specified value then the open will fail.
		*
		* @param builder reference provided by AAudio_createStreamBuilder()
		* @param format Most common formats are AAUDIO_FORMAT_PCM_FLOAT and AAUDIO_FORMAT_PCM_I16.
		* @param format common formats are AAUDIO_FORMAT_PCM_FLOAT and AAUDIO_FORMAT_PCM_I16.
		*/
		AAUDIO_API void AAudioStreamBuilder_setFormat(AAudioStreamBuilder* builder,
		aaudio_audio_format_t format);

media/libaaudio/tests/Android.mk

+12 −0

Original line number	Diff line number	Diff line
		@@ -47,3 +47,15 @@ LOCAL_SHARED_LIBRARIES := libaudioclient libaudioutils libbinder \
		LOCAL_STATIC_LIBRARIES := libaaudio
		LOCAL_MODULE := test_linear_ramp
		include $(BUILD_NATIVE_TEST)

		include $(CLEAR_VARS)
		LOCAL_C_INCLUDES := \
		$(call include-path-for, audio-utils) \
		frameworks/av/media/libaaudio/include \
		frameworks/av/media/libaaudio/src
		LOCAL_SRC_FILES:= test_open_params.cpp
		LOCAL_SHARED_LIBRARIES := libaudioclient libaudioutils libbinder \
		libcutils liblog libmedia libutils
		LOCAL_STATIC_LIBRARIES := libaaudio
		LOCAL_MODULE := test_open_params
		include $(BUILD_NATIVE_TEST)

media/libaaudio/tests/test_open_params.cpp

0 → 100644

+157 −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.
		*/

		// Play sine waves using AAudio.

		#include <stdio.h>
		//#include <stdlib.h>
		//#include <math.h>

		#include <android-base/macros.h>
		#include <aaudio/AAudio.h>

		#include <gtest/gtest.h>

		static const char *getSharingModeText(aaudio_sharing_mode_t mode) {
		const char *modeText = "unknown";
		switch (mode) {
		case AAUDIO_SHARING_MODE_EXCLUSIVE:
		modeText = "EXCLUSIVE";
		break;
		case AAUDIO_SHARING_MODE_SHARED:
		modeText = "SHARED";
		break;
		default:
		break;
		}
		return modeText;
		}

		// Callback function that fills the audio output buffer.
		aaudio_data_callback_result_t MyDataCallbackProc(
		AAudioStream *stream,
		void *userData,
		void *audioData,
		int32_t numFrames
		) {
		(void) stream;
		(void) userData;
		(void) audioData;
		(void) numFrames;
		return AAUDIO_CALLBACK_RESULT_CONTINUE;
		}

		static void testOpenOptions(aaudio_direction_t direction,
		int32_t channelCount,
		int32_t sampleRate,
		aaudio_audio_format_t format) {

		aaudio_result_t result = AAUDIO_OK;

		int32_t bufferCapacity;
		int32_t framesPerBurst = 0;

		int32_t actualChannelCount = 0;
		int32_t actualSampleRate = 0;
		aaudio_audio_format_t actualDataFormat = AAUDIO_FORMAT_UNSPECIFIED;
		aaudio_sharing_mode_t actualSharingMode = AAUDIO_SHARING_MODE_SHARED;
		aaudio_direction_t actualDirection;

		AAudioStreamBuilder *aaudioBuilder = nullptr;
		AAudioStream *aaudioStream = nullptr;

		printf("TestOpen: dir = %d, chans = %3d, rate = %6d format = %d\n",
		direction, channelCount, sampleRate, format);

		// Use an AAudioStreamBuilder to contain requested parameters.
		ASSERT_EQ(AAUDIO_OK, AAudio_createStreamBuilder(&aaudioBuilder));

		// Request stream properties.
		AAudioStreamBuilder_setDirection(aaudioBuilder, direction);
		AAudioStreamBuilder_setSampleRate(aaudioBuilder, sampleRate);
		AAudioStreamBuilder_setChannelCount(aaudioBuilder, channelCount);
		AAudioStreamBuilder_setFormat(aaudioBuilder, format);
		AAudioStreamBuilder_setDataCallback(aaudioBuilder, MyDataCallbackProc, nullptr);

		//AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, AAUDIO_PERFORMANCE_MODE_NONE);
		AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
		//AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, AAUDIO_PERFORMANCE_MODE_POWER_SAVING);

		// Create an AAudioStream using the Builder.
		result = AAudioStreamBuilder_openStream(aaudioBuilder, &aaudioStream);
		if (result != AAUDIO_OK) {
		printf("Stream not opened! That may be OK.\n");
		goto finish;
		}

		// Check to see what kind of stream we actually got.
		actualSampleRate = AAudioStream_getSampleRate(aaudioStream);
		actualChannelCount = AAudioStream_getChannelCount(aaudioStream);
		actualDataFormat = AAudioStream_getFormat(aaudioStream);
		actualDirection = AAudioStream_getDirection(aaudioStream);

		printf(" dir = %d, chans = %3d, rate = %6d format = %d\n",
		direction, actualChannelCount, actualSampleRate, actualDataFormat);

		// If we ask for something specific then we should get that.
		if (channelCount != AAUDIO_UNSPECIFIED) {
		EXPECT_EQ(channelCount, actualChannelCount);
		}
		if (sampleRate != AAUDIO_UNSPECIFIED) {
		EXPECT_EQ(sampleRate, actualSampleRate);
		}
		if (format != AAUDIO_FORMAT_UNSPECIFIED) {
		EXPECT_EQ(format, actualDataFormat);
		}
		EXPECT_EQ(direction, actualDirection);

		// This is the number of frames that are read in one chunk by a DMA controller
		// or a DSP or a mixer.
		framesPerBurst = AAudioStream_getFramesPerBurst(aaudioStream);
		bufferCapacity = AAudioStream_getBufferCapacityInFrames(aaudioStream);
		printf(" bufferCapacity = %d, remainder = %d\n",
		bufferCapacity, bufferCapacity % framesPerBurst);

		finish:
		AAudioStream_close(aaudioStream);
		AAudioStreamBuilder_delete(aaudioBuilder);
		printf(" result = %d = %s\n", result, AAudio_convertResultToText(result));
		}

		//void foo() { // for tricking the Android Studio formatter
		TEST(test_open_params, aaudio_open_all) {
		aaudio_direction_t directions[] = {AAUDIO_DIRECTION_OUTPUT, AAUDIO_DIRECTION_INPUT};
		aaudio_audio_format_t formats[] = {AAUDIO_FORMAT_UNSPECIFIED, AAUDIO_FORMAT_PCM_I16, AAUDIO_FORMAT_PCM_FLOAT};
		int32_t rates[] = {AAUDIO_UNSPECIFIED, 22050, 32000, 44100, 48000, 88200, 96000, 37913, 59132};

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

		for (uint dirIndex = 0;dirIndex < arraysize(directions); dirIndex++) {
		aaudio_direction_t direction = directions[dirIndex];
		for (int32_t channelCount = 0; channelCount <= 8; channelCount++) {
		testOpenOptions(direction, channelCount,
		AAUDIO_UNSPECIFIED, AAUDIO_FORMAT_UNSPECIFIED);
		}
		for (uint i = 0; i < arraysize(rates); i++) {
		testOpenOptions(direction, AAUDIO_UNSPECIFIED, rates[i], AAUDIO_FORMAT_UNSPECIFIED);
		}
		for (uint i = 0; i < arraysize(formats); i++) {
		testOpenOptions(direction, AAUDIO_UNSPECIFIED, AAUDIO_UNSPECIFIED, formats[i]);
		}
		}
		}