media/libaaudio/tests/test_attributes.cpp - LeafOS-Project/android_frameworks_av - Gitiles

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

 // Test AAudio attributes such as Usage, ContentType and InputPreset.

 // TODO Many of these tests are duplicates of CTS tests in
 // "test_aaudio_attributes.cpp". That other file is more current.
 // So these tests could be deleted.

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

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

 constexpr int64_t kNanosPerSecond = 1000000000;
 constexpr int kNumFrames = 256;
 constexpr int kChannelCount = 2;

 constexpr int32_t DONT_SET = -1000;

 static void checkAttributes(aaudio_performance_mode_t perfMode,
                             aaudio_usage_t usage,
                             aaudio_content_type_t contentType,
                             aaudio_input_preset_t preset = DONT_SET,
                             aaudio_allowed_capture_policy_t capturePolicy = DONT_SET,
                             int privacyMode = DONT_SET,
                             aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT) {

     std::unique_ptr<float[]> buffer(new float[kNumFrames * kChannelCount]);

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

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

     // Request stream properties.
     AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, perfMode);
     AAudioStreamBuilder_setDirection(aaudioBuilder, direction);

     // Set the attribute in the builder.
     if (usage != DONT_SET) {
         AAudioStreamBuilder_setUsage(aaudioBuilder, usage);
     }
     if (contentType != DONT_SET) {
         AAudioStreamBuilder_setContentType(aaudioBuilder, contentType);
     }
     if (preset != DONT_SET) {
         AAudioStreamBuilder_setInputPreset(aaudioBuilder, preset);
     }
     if (capturePolicy != DONT_SET) {
         AAudioStreamBuilder_setAllowedCapturePolicy(aaudioBuilder, capturePolicy);
     }
     if (privacyMode != DONT_SET) {
         AAudioStreamBuilder_setPrivacySensitive(aaudioBuilder, (bool)privacyMode);
     }

     // Create an AAudioStream using the Builder.
     ASSERT_EQ(AAUDIO_OK, AAudioStreamBuilder_openStream(aaudioBuilder, &aaudioStream));
     AAudioStreamBuilder_delete(aaudioBuilder);

     // Make sure we get the same attributes back from the stream.
     aaudio_usage_t expectedUsage =
             (usage == DONT_SET || usage == AAUDIO_UNSPECIFIED)
             ? AAUDIO_USAGE_MEDIA // default
             : usage;
     EXPECT_EQ(expectedUsage, AAudioStream_getUsage(aaudioStream));

     aaudio_content_type_t expectedContentType =
             (contentType == DONT_SET || contentType == AAUDIO_UNSPECIFIED)
             ? AAUDIO_CONTENT_TYPE_MUSIC // default
             : contentType;
     EXPECT_EQ(expectedContentType, AAudioStream_getContentType(aaudioStream));

     aaudio_input_preset_t expectedPreset =
             (preset == DONT_SET || preset == AAUDIO_UNSPECIFIED)
             ? AAUDIO_INPUT_PRESET_VOICE_RECOGNITION // default
             : preset;
     EXPECT_EQ(expectedPreset, AAudioStream_getInputPreset(aaudioStream));

     aaudio_allowed_capture_policy_t expectedCapturePolicy =
             (capturePolicy == DONT_SET || capturePolicy == AAUDIO_UNSPECIFIED)
             ? AAUDIO_ALLOW_CAPTURE_BY_ALL // default
             : capturePolicy;
     EXPECT_EQ(expectedCapturePolicy, AAudioStream_getAllowedCapturePolicy(aaudioStream));

     bool expectedPrivacyMode =
             (privacyMode == DONT_SET) ?
                 ((preset == AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION
                     || preset == AAUDIO_INPUT_PRESET_CAMCORDER) ? true : false) :
                 privacyMode;
     EXPECT_EQ(expectedPrivacyMode, AAudioStream_isPrivacySensitive(aaudioStream));

     EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStart(aaudioStream));

     if (direction == AAUDIO_DIRECTION_INPUT) {
         EXPECT_EQ(kNumFrames,
                   AAudioStream_read(aaudioStream, buffer.get(), kNumFrames, kNanosPerSecond));
     } else {
         EXPECT_EQ(kNumFrames,
                   AAudioStream_write(aaudioStream, buffer.get(), kNumFrames, kNanosPerSecond));
     }

     EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStop(aaudioStream));

     EXPECT_EQ(AAUDIO_OK, AAudioStream_close(aaudioStream));
 }

 static const aaudio_usage_t sUsages[] = {
     DONT_SET,
     AAUDIO_UNSPECIFIED,
     AAUDIO_USAGE_MEDIA,
     AAUDIO_USAGE_VOICE_COMMUNICATION,
     AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING,
     AAUDIO_USAGE_ALARM,
     AAUDIO_USAGE_NOTIFICATION,
     AAUDIO_USAGE_NOTIFICATION_RINGTONE,
     AAUDIO_USAGE_NOTIFICATION_EVENT,
     AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY,
     AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
     AAUDIO_USAGE_ASSISTANCE_SONIFICATION,
     AAUDIO_USAGE_GAME,
     AAUDIO_USAGE_ASSISTANT,
     // Note that the AAUDIO_SYSTEM_USAGE_* values requires special permission.
 };

 static const aaudio_content_type_t sContentypes[] = {
     DONT_SET,
     AAUDIO_UNSPECIFIED,
     AAUDIO_CONTENT_TYPE_SPEECH,
     AAUDIO_CONTENT_TYPE_MUSIC,
     AAUDIO_CONTENT_TYPE_MOVIE,
     AAUDIO_CONTENT_TYPE_SONIFICATION
 };

 static const aaudio_input_preset_t sInputPresets[] = {
     DONT_SET,
     AAUDIO_UNSPECIFIED,
     AAUDIO_INPUT_PRESET_GENERIC,
     AAUDIO_INPUT_PRESET_CAMCORDER,
     AAUDIO_INPUT_PRESET_VOICE_RECOGNITION,
     AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION,
     AAUDIO_INPUT_PRESET_UNPROCESSED,
     AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE,
 };

 static const aaudio_input_preset_t sAllowCapturePolicies[] = {
     DONT_SET,
     AAUDIO_UNSPECIFIED,
     AAUDIO_ALLOW_CAPTURE_BY_ALL,
     AAUDIO_ALLOW_CAPTURE_BY_SYSTEM,
     AAUDIO_ALLOW_CAPTURE_BY_NONE,
 };

 static const int sPrivacyModes[] = {
     DONT_SET,
     false,
     true,
 };

 static void checkAttributesUsage(aaudio_performance_mode_t perfMode) {
     for (aaudio_usage_t usage : sUsages) {
         checkAttributes(perfMode, usage, DONT_SET);
     }
 }

 static void checkAttributesContentType(aaudio_performance_mode_t perfMode) {
     for (aaudio_content_type_t contentType : sContentypes) {
         checkAttributes(perfMode, DONT_SET, contentType);
     }
 }

 static void checkAttributesInputPreset(aaudio_performance_mode_t perfMode) {
     for (aaudio_input_preset_t inputPreset : sInputPresets) {
         checkAttributes(perfMode,
                         DONT_SET,
                         DONT_SET,
                         inputPreset,
                         DONT_SET,
                         DONT_SET,
                         AAUDIO_DIRECTION_INPUT);
     }
 }

 static void checkAttributesAllowedCapturePolicy(aaudio_performance_mode_t perfMode) {
     for (aaudio_allowed_capture_policy_t policy : sAllowCapturePolicies) {
         checkAttributes(perfMode,
                         DONT_SET,
                         DONT_SET,
                         DONT_SET,
                         policy,
                         AAUDIO_DIRECTION_INPUT);
     }
 }

 static void checkAttributesPrivacySensitive(aaudio_performance_mode_t perfMode) {
     for (int privacyMode : sPrivacyModes) {
         checkAttributes(perfMode,
                         DONT_SET,
                         DONT_SET,
                         DONT_SET,
                         DONT_SET,
                         privacyMode,
                         AAUDIO_DIRECTION_INPUT);
     }
 }

 TEST(test_attributes, aaudio_usage_perfnone) {
     checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_NONE);
 }

 TEST(test_attributes, aaudio_content_type_perfnone) {
     checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_NONE);
 }

 TEST(test_attributes, aaudio_input_preset_perfnone) {
     checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_NONE);
 }

 TEST(test_attributes, aaudio_allowed_capture_policy_perfnone) {
     checkAttributesAllowedCapturePolicy(AAUDIO_PERFORMANCE_MODE_NONE);
 }

 TEST(test_attributes, aaudio_usage_lowlat) {
     checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 }

 TEST(test_attributes, aaudio_content_type_lowlat) {
     checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 }

 TEST(test_attributes, aaudio_input_preset_lowlat) {
     checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 }

 TEST(test_attributes, aaudio_allowed_capture_policy_lowlat) {
     checkAttributesAllowedCapturePolicy(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 }

 TEST(test_attributes, aaudio_allowed_privacy_sensitive_lowlat) {
     checkAttributesPrivacySensitive(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
 }
	/*
	* 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.
	*/

	// Test AAudio attributes such as Usage, ContentType and InputPreset.

	// TODO Many of these tests are duplicates of CTS tests in
	// "test_aaudio_attributes.cpp". That other file is more current.
	// So these tests could be deleted.

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

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

	constexpr int64_t kNanosPerSecond = 1000000000;
	constexpr int kNumFrames = 256;
	constexpr int kChannelCount = 2;

	constexpr int32_t DONT_SET = -1000;

	static void checkAttributes(aaudio_performance_mode_t perfMode,
	aaudio_usage_t usage,
	aaudio_content_type_t contentType,
	aaudio_input_preset_t preset = DONT_SET,
	aaudio_allowed_capture_policy_t capturePolicy = DONT_SET,
	int privacyMode = DONT_SET,
	aaudio_direction_t direction = AAUDIO_DIRECTION_OUTPUT) {

	std::unique_ptr<float[]> buffer(new float[kNumFrames * kChannelCount]);

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

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

	// Request stream properties.
	AAudioStreamBuilder_setPerformanceMode(aaudioBuilder, perfMode);
	AAudioStreamBuilder_setDirection(aaudioBuilder, direction);

	// Set the attribute in the builder.
	if (usage != DONT_SET) {
	AAudioStreamBuilder_setUsage(aaudioBuilder, usage);
	}
	if (contentType != DONT_SET) {
	AAudioStreamBuilder_setContentType(aaudioBuilder, contentType);
	}
	if (preset != DONT_SET) {
	AAudioStreamBuilder_setInputPreset(aaudioBuilder, preset);
	}
	if (capturePolicy != DONT_SET) {
	AAudioStreamBuilder_setAllowedCapturePolicy(aaudioBuilder, capturePolicy);
	}
	if (privacyMode != DONT_SET) {
	AAudioStreamBuilder_setPrivacySensitive(aaudioBuilder, (bool)privacyMode);
	}

	// Create an AAudioStream using the Builder.
	ASSERT_EQ(AAUDIO_OK, AAudioStreamBuilder_openStream(aaudioBuilder, &aaudioStream));
	AAudioStreamBuilder_delete(aaudioBuilder);

	// Make sure we get the same attributes back from the stream.
	aaudio_usage_t expectedUsage =
	(usage == DONT_SET \|\| usage == AAUDIO_UNSPECIFIED)
	? AAUDIO_USAGE_MEDIA // default
	: usage;
	EXPECT_EQ(expectedUsage, AAudioStream_getUsage(aaudioStream));

	aaudio_content_type_t expectedContentType =
	(contentType == DONT_SET \|\| contentType == AAUDIO_UNSPECIFIED)
	? AAUDIO_CONTENT_TYPE_MUSIC // default
	: contentType;
	EXPECT_EQ(expectedContentType, AAudioStream_getContentType(aaudioStream));

	aaudio_input_preset_t expectedPreset =
	(preset == DONT_SET \|\| preset == AAUDIO_UNSPECIFIED)
	? AAUDIO_INPUT_PRESET_VOICE_RECOGNITION // default
	: preset;
	EXPECT_EQ(expectedPreset, AAudioStream_getInputPreset(aaudioStream));

	aaudio_allowed_capture_policy_t expectedCapturePolicy =
	(capturePolicy == DONT_SET \|\| capturePolicy == AAUDIO_UNSPECIFIED)
	? AAUDIO_ALLOW_CAPTURE_BY_ALL // default
	: capturePolicy;
	EXPECT_EQ(expectedCapturePolicy, AAudioStream_getAllowedCapturePolicy(aaudioStream));

	bool expectedPrivacyMode =
	(privacyMode == DONT_SET) ?
	((preset == AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION
	\|\| preset == AAUDIO_INPUT_PRESET_CAMCORDER) ? true : false) :
	privacyMode;
	EXPECT_EQ(expectedPrivacyMode, AAudioStream_isPrivacySensitive(aaudioStream));

	EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStart(aaudioStream));

	if (direction == AAUDIO_DIRECTION_INPUT) {
	EXPECT_EQ(kNumFrames,
	AAudioStream_read(aaudioStream, buffer.get(), kNumFrames, kNanosPerSecond));
	} else {
	EXPECT_EQ(kNumFrames,
	AAudioStream_write(aaudioStream, buffer.get(), kNumFrames, kNanosPerSecond));
	}

	EXPECT_EQ(AAUDIO_OK, AAudioStream_requestStop(aaudioStream));

	EXPECT_EQ(AAUDIO_OK, AAudioStream_close(aaudioStream));
	}

	static const aaudio_usage_t sUsages[] = {
	DONT_SET,
	AAUDIO_UNSPECIFIED,
	AAUDIO_USAGE_MEDIA,
	AAUDIO_USAGE_VOICE_COMMUNICATION,
	AAUDIO_USAGE_VOICE_COMMUNICATION_SIGNALLING,
	AAUDIO_USAGE_ALARM,
	AAUDIO_USAGE_NOTIFICATION,
	AAUDIO_USAGE_NOTIFICATION_RINGTONE,
	AAUDIO_USAGE_NOTIFICATION_EVENT,
	AAUDIO_USAGE_ASSISTANCE_ACCESSIBILITY,
	AAUDIO_USAGE_ASSISTANCE_NAVIGATION_GUIDANCE,
	AAUDIO_USAGE_ASSISTANCE_SONIFICATION,
	AAUDIO_USAGE_GAME,
	AAUDIO_USAGE_ASSISTANT,
	// Note that the AAUDIO_SYSTEM_USAGE_* values requires special permission.
	};

	static const aaudio_content_type_t sContentypes[] = {
	DONT_SET,
	AAUDIO_UNSPECIFIED,
	AAUDIO_CONTENT_TYPE_SPEECH,
	AAUDIO_CONTENT_TYPE_MUSIC,
	AAUDIO_CONTENT_TYPE_MOVIE,
	AAUDIO_CONTENT_TYPE_SONIFICATION
	};

	static const aaudio_input_preset_t sInputPresets[] = {
	DONT_SET,
	AAUDIO_UNSPECIFIED,
	AAUDIO_INPUT_PRESET_GENERIC,
	AAUDIO_INPUT_PRESET_CAMCORDER,
	AAUDIO_INPUT_PRESET_VOICE_RECOGNITION,
	AAUDIO_INPUT_PRESET_VOICE_COMMUNICATION,
	AAUDIO_INPUT_PRESET_UNPROCESSED,
	AAUDIO_INPUT_PRESET_VOICE_PERFORMANCE,
	};

	static const aaudio_input_preset_t sAllowCapturePolicies[] = {
	DONT_SET,
	AAUDIO_UNSPECIFIED,
	AAUDIO_ALLOW_CAPTURE_BY_ALL,
	AAUDIO_ALLOW_CAPTURE_BY_SYSTEM,
	AAUDIO_ALLOW_CAPTURE_BY_NONE,
	};

	static const int sPrivacyModes[] = {
	DONT_SET,
	false,
	true,
	};

	static void checkAttributesUsage(aaudio_performance_mode_t perfMode) {
	for (aaudio_usage_t usage : sUsages) {
	checkAttributes(perfMode, usage, DONT_SET);
	}
	}

	static void checkAttributesContentType(aaudio_performance_mode_t perfMode) {
	for (aaudio_content_type_t contentType : sContentypes) {
	checkAttributes(perfMode, DONT_SET, contentType);
	}
	}

	static void checkAttributesInputPreset(aaudio_performance_mode_t perfMode) {
	for (aaudio_input_preset_t inputPreset : sInputPresets) {
	checkAttributes(perfMode,
	DONT_SET,
	DONT_SET,
	inputPreset,
	DONT_SET,
	DONT_SET,
	AAUDIO_DIRECTION_INPUT);
	}
	}

	static void checkAttributesAllowedCapturePolicy(aaudio_performance_mode_t perfMode) {
	for (aaudio_allowed_capture_policy_t policy : sAllowCapturePolicies) {
	checkAttributes(perfMode,
	DONT_SET,
	DONT_SET,
	DONT_SET,
	policy,
	AAUDIO_DIRECTION_INPUT);
	}
	}

	static void checkAttributesPrivacySensitive(aaudio_performance_mode_t perfMode) {
	for (int privacyMode : sPrivacyModes) {
	checkAttributes(perfMode,
	DONT_SET,
	DONT_SET,
	DONT_SET,
	DONT_SET,
	privacyMode,
	AAUDIO_DIRECTION_INPUT);
	}
	}

	TEST(test_attributes, aaudio_usage_perfnone) {
	checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_NONE);
	}

	TEST(test_attributes, aaudio_content_type_perfnone) {
	checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_NONE);
	}

	TEST(test_attributes, aaudio_input_preset_perfnone) {
	checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_NONE);
	}

	TEST(test_attributes, aaudio_allowed_capture_policy_perfnone) {
	checkAttributesAllowedCapturePolicy(AAUDIO_PERFORMANCE_MODE_NONE);
	}

	TEST(test_attributes, aaudio_usage_lowlat) {
	checkAttributesUsage(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
	}

	TEST(test_attributes, aaudio_content_type_lowlat) {
	checkAttributesContentType(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
	}

	TEST(test_attributes, aaudio_input_preset_lowlat) {
	checkAttributesInputPreset(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
	}

	TEST(test_attributes, aaudio_allowed_capture_policy_lowlat) {
	checkAttributesAllowedCapturePolicy(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
	}

	TEST(test_attributes, aaudio_allowed_privacy_sensitive_lowlat) {
	checkAttributesPrivacySensitive(AAUDIO_PERFORMANCE_MODE_LOW_LATENCY);
	}