Merge changes I1d2263f0,Iaa2c8046,Idcf09587,I8bdcd0da,If80513b6, ... (3932ad83) · Commits · e / os / android_frameworks_av

media/libaudiofoundation/Android.bp

+14 −3

Original line number	Diff line number	Diff line
		@@ -2,6 +2,16 @@ cc_library_headers {
		name: "libaudiofoundation_headers",
		vendor_available: true,
		export_include_dirs: ["include"],
		header_libs: [
		"libaudio_system_headers",
		"libaudioclient_headers",
		"libmedia_headers",
		],
		export_header_lib_headers: [
		"libaudio_system_headers",
		"libaudioclient_headers",
		"libmedia_headers",
		],
		}

		cc_library_shared {
		@@ -9,6 +19,7 @@ cc_library_shared {
		vendor_available: true,

		srcs: [
		"AudioContainers.cpp",
		"AudioGain.cpp",
		"AudioPort.cpp",
		"AudioProfile.cpp",
		@@ -25,12 +36,12 @@ cc_library_shared {
		],

		header_libs: [
		"libaudio_system_headers",
		"libaudioclient_headers",
		"libaudiofoundation_headers",
		],

		export_header_lib_headers: ["libaudiofoundation_headers"],
		export_header_lib_headers: [
		"libaudiofoundation_headers",
		],

		cflags: [
		"-Werror",

media/libaudiofoundation/AudioContainers.cpp

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.
		*/

		#include <sstream>
		#include <string>

		#include <media/AudioContainers.h>

		namespace android {

		const DeviceTypeSet& getAudioDeviceOutAllSet() {
		static const DeviceTypeSet audioDeviceOutAllSet = DeviceTypeSet(
		std::begin(AUDIO_DEVICE_OUT_ALL_ARRAY),
		std::end(AUDIO_DEVICE_OUT_ALL_ARRAY));
		return audioDeviceOutAllSet;
		}

		const DeviceTypeSet& getAudioDeviceOutAllA2dpSet() {
		static const DeviceTypeSet audioDeviceOutAllA2dpSet = DeviceTypeSet(
		std::begin(AUDIO_DEVICE_OUT_ALL_A2DP_ARRAY),
		std::end(AUDIO_DEVICE_OUT_ALL_A2DP_ARRAY));
		return audioDeviceOutAllA2dpSet;
		}

		const DeviceTypeSet& getAudioDeviceOutAllScoSet() {
		static const DeviceTypeSet audioDeviceOutAllScoSet = DeviceTypeSet(
		std::begin(AUDIO_DEVICE_OUT_ALL_SCO_ARRAY),
		std::end(AUDIO_DEVICE_OUT_ALL_SCO_ARRAY));
		return audioDeviceOutAllScoSet;
		}

		const DeviceTypeSet& getAudioDeviceInAllSet() {
		static const DeviceTypeSet audioDeviceInAllSet = DeviceTypeSet(
		std::begin(AUDIO_DEVICE_IN_ALL_ARRAY),
		std::end(AUDIO_DEVICE_IN_ALL_ARRAY));
		return audioDeviceInAllSet;
		}

		bool deviceTypesToString(const DeviceTypeSet &deviceTypes, std::string &str) {
		bool ret = true;
		for (auto it = deviceTypes.begin(); it != deviceTypes.end();) {
		std::string deviceTypeStr;
		ret = audio_is_output_device(*it) ?
		OutputDeviceConverter::toString(*it, deviceTypeStr) :
		InputDeviceConverter::toString(*it, deviceTypeStr);
		if (!ret) {
		break;
		}
		str.append(deviceTypeStr);
		if (++it != deviceTypes.end()) {
		str.append(" , ");
		}
		}
		if (!ret) {
		str = "Unknown values";
		}
		return ret;
		}

		std::string dumpDeviceTypes(const DeviceTypeSet &deviceTypes) {
		std::string ret;
		for (auto it = deviceTypes.begin(); it != deviceTypes.end();) {
		std::stringstream ss;
		ss << "0x" << std::hex << (*it);
		ret.append(ss.str());
		if (++it != deviceTypes.end()) {
		ret.append(" , ");
		}
		}
		return ret;
		}

		} // namespace android

media/libaudiofoundation/AudioGain.cpp

+85 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,8 @@
		#define ALOGVV(a...) do { } while(0)
		#endif

		#include <algorithm>

		#include <android-base/stringprintf.h>
		#include <media/AudioGain.h>
		#include <utils/Log.h>
		@@ -111,4 +113,87 @@ void AudioGain::dump(std::string *dst, int spaces, int index) const
		dst->append(base::StringPrintf("%*s- max_ramp_ms: %d ms\n", spaces, "", mGain.max_ramp_ms));
		}

		bool AudioGain::equals(const sp<AudioGain>& other) const
		{
		return other != nullptr &&
		mUseInChannelMask == other->mUseInChannelMask &&
		mUseForVolume == other->mUseForVolume &&
		// Compare audio gain
		mGain.mode == other->mGain.mode &&
		mGain.channel_mask == other->mGain.channel_mask &&
		mGain.min_value == other->mGain.min_value &&
		mGain.max_value == other->mGain.max_value &&
		mGain.default_value == other->mGain.default_value &&
		mGain.step_value == other->mGain.step_value &&
		mGain.min_ramp_ms == other->mGain.min_ramp_ms &&
		mGain.max_ramp_ms == other->mGain.max_ramp_ms;
		}

		status_t AudioGain::writeToParcel(android::Parcel *parcel) const
		{
		status_t status = NO_ERROR;
		if ((status = parcel->writeInt32(mIndex)) != NO_ERROR) return status;
		if ((status = parcel->writeBool(mUseInChannelMask)) != NO_ERROR) return status;
		if ((status = parcel->writeBool(mUseForVolume)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.mode)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.channel_mask)) != NO_ERROR) return status;
		if ((status = parcel->writeInt32(mGain.min_value)) != NO_ERROR) return status;
		if ((status = parcel->writeInt32(mGain.max_value)) != NO_ERROR) return status;
		if ((status = parcel->writeInt32(mGain.default_value)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.step_value)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.min_ramp_ms)) != NO_ERROR) return status;
		status = parcel->writeUint32(mGain.max_ramp_ms);
		return status;
		}

		status_t AudioGain::readFromParcel(const android::Parcel *parcel)
		{
		status_t status = NO_ERROR;
		if ((status = parcel->readInt32(&mIndex)) != NO_ERROR) return status;
		if ((status = parcel->readBool(&mUseInChannelMask)) != NO_ERROR) return status;
		if ((status = parcel->readBool(&mUseForVolume)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.mode)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.channel_mask)) != NO_ERROR) return status;
		if ((status = parcel->readInt32(&mGain.min_value)) != NO_ERROR) return status;
		if ((status = parcel->readInt32(&mGain.max_value)) != NO_ERROR) return status;
		if ((status = parcel->readInt32(&mGain.default_value)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.step_value)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.min_ramp_ms)) != NO_ERROR) return status;
		status = parcel->readUint32(&mGain.max_ramp_ms);
		return status;
		}

		bool AudioGains::equals(const AudioGains &other) const
		{
		return std::equal(begin(), end(), other.begin(), other.end(),
		[](const sp<AudioGain>& left, const sp<AudioGain>& right) {
		return left->equals(right);
		});
		}

		status_t AudioGains::writeToParcel(android::Parcel *parcel) const {
		status_t status = NO_ERROR;
		if ((status = parcel->writeVectorSize(*this)) != NO_ERROR) return status;
		for (const auto &audioGain : *this) {
		if ((status = parcel->writeParcelable(*audioGain)) != NO_ERROR) {
		break;
		}
		}
		return status;
		}

		status_t AudioGains::readFromParcel(const android::Parcel *parcel) {
		status_t status = NO_ERROR;
		this->clear();
		if ((status = parcel->resizeOutVector(this)) != NO_ERROR) return status;
		for (size_t i = 0; i < this->size(); i++) {
		this->at(i) = new AudioGain(0, false);
		if ((status = parcel->readParcelable(this->at(i).get())) != NO_ERROR) {
		this->clear();
		break;
		}
		}
		return status;
		}

		} // namespace android

media/libaudiofoundation/AudioPort.cpp

+96 −0

Original line number	Diff line number	Diff line
		@@ -105,6 +105,46 @@ void AudioPort::log(const char* indent) const
		ALOGI("%s Port[nm:%s, type:%d, role:%d]", indent, mName.c_str(), mType, mRole);
		}

		bool AudioPort::equals(const sp<AudioPort> &other) const
		{
		return other != nullptr &&
		mGains.equals(other->getGains()) &&
		mName.compare(other->getName()) == 0 &&
		mType == other->getType() &&
		mRole == other->getRole() &&
		mProfiles.equals(other->getAudioProfiles());
		}

		status_t AudioPort::writeToParcel(Parcel *parcel) const
		{
		status_t status = NO_ERROR;
		if ((status = parcel->writeUtf8AsUtf16(mName)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mType)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mRole)) != NO_ERROR) return status;
		if ((status = parcel->writeParcelable(mProfiles)) != NO_ERROR) return status;
		if ((status = parcel->writeParcelable(mGains)) != NO_ERROR) return status;
		return status;
		}

		status_t AudioPort::readFromParcel(const Parcel *parcel)
		{
		status_t status = NO_ERROR;
		if ((status = parcel->readUtf8FromUtf16(&mName)) != NO_ERROR) return status;
		static_assert(sizeof(mType) == sizeof(uint32_t));
		if ((status = parcel->readUint32(reinterpret_cast<uint32_t*>(&mType))) != NO_ERROR) {
		return status;
		}
		static_assert(sizeof(mRole) == sizeof(uint32_t));
		if ((status = parcel->readUint32(reinterpret_cast<uint32_t*>(&mRole))) != NO_ERROR) {
		return status;
		}
		mProfiles.clear();
		if ((status = parcel->readParcelable(&mProfiles)) != NO_ERROR) return status;
		mGains.clear();
		if ((status = parcel->readParcelable(&mGains)) != NO_ERROR) return status;
		return status;
		}

		// --- AudioPortConfig class implementation

		status_t AudioPortConfig::applyAudioPortConfig(
		@@ -188,4 +228,60 @@ bool AudioPortConfig::hasGainController(bool canUseForVolume) const
		: audioport->getGains().size() > 0;
		}

		bool AudioPortConfig::equals(const sp<AudioPortConfig> &other) const
		{
		return other != nullptr &&
		mSamplingRate == other->getSamplingRate() &&
		mFormat == other->getFormat() &&
		mChannelMask == other->getChannelMask() &&
		// Compare audio gain config
		mGain.index == other->mGain.index &&
		mGain.mode == other->mGain.mode &&
		mGain.channel_mask == other->mGain.channel_mask &&
		std::equal(std::begin(mGain.values), std::end(mGain.values),
		std::begin(other->mGain.values)) &&
		mGain.ramp_duration_ms == other->mGain.ramp_duration_ms;
		}

		status_t AudioPortConfig::writeToParcel(Parcel *parcel) const
		{
		status_t status = NO_ERROR;
		if ((status = parcel->writeUint32(mSamplingRate)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mFormat)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mChannelMask)) != NO_ERROR) return status;
		if ((status = parcel->writeInt32(mId)) != NO_ERROR) return status;
		// Write mGain to parcel.
		if ((status = parcel->writeInt32(mGain.index)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.mode)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.channel_mask)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mGain.ramp_duration_ms)) != NO_ERROR) return status;
		std::vector<int> values(std::begin(mGain.values), std::end(mGain.values));
		if ((status = parcel->writeInt32Vector(values)) != NO_ERROR) return status;
		return status;
		}

		status_t AudioPortConfig::readFromParcel(const Parcel *parcel)
		{
		status_t status = NO_ERROR;
		if ((status = parcel->readUint32(&mSamplingRate)) != NO_ERROR) return status;
		static_assert(sizeof(mFormat) == sizeof(uint32_t));
		if ((status = parcel->readUint32(reinterpret_cast<uint32_t*>(&mFormat))) != NO_ERROR) {
		return status;
		}
		if ((status = parcel->readUint32(&mChannelMask)) != NO_ERROR) return status;
		if ((status = parcel->readInt32(&mId)) != NO_ERROR) return status;
		// Read mGain from parcel.
		if ((status = parcel->readInt32(&mGain.index)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.mode)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.channel_mask)) != NO_ERROR) return status;
		if ((status = parcel->readUint32(&mGain.ramp_duration_ms)) != NO_ERROR) return status;
		std::vector<int> values;
		if ((status = parcel->readInt32Vector(&values)) != NO_ERROR) return status;
		if (values.size() != std::size(mGain.values)) {
		return BAD_VALUE;
		}
		std::copy(values.begin(), values.end(), mGain.values);
		return status;
		}

		} // namespace android

media/libaudiofoundation/AudioProfile.cpp

+85 −0

Original line number	Diff line number	Diff line
		@@ -118,6 +118,56 @@ void AudioProfile::dump(std::string *dst, int spaces) const
		}
		}

		bool AudioProfile::equals(const sp<AudioProfile>& other) const
		{
		return other != nullptr &&
		mName.compare(other->mName) == 0 &&
		mFormat == other->getFormat() &&
		mChannelMasks == other->getChannels() &&
		mSamplingRates == other->getSampleRates() &&
		mIsDynamicFormat == other->isDynamicFormat() &&
		mIsDynamicChannels == other->isDynamicChannels() &&
		mIsDynamicRate == other->isDynamicRate();
		}

		status_t AudioProfile::writeToParcel(Parcel *parcel) const
		{
		status_t status = NO_ERROR;
		if ((status = parcel->writeUtf8AsUtf16(mName)) != NO_ERROR) return status;
		if ((status = parcel->writeUint32(mFormat)) != NO_ERROR) return status;
		std::vector<int> values(mChannelMasks.begin(), mChannelMasks.end());
		if ((status = parcel->writeInt32Vector(values)) != NO_ERROR) return status;
		values.clear();
		values.assign(mSamplingRates.begin(), mSamplingRates.end());
		if ((status = parcel->writeInt32Vector(values)) != NO_ERROR) return status;
		if ((status = parcel->writeBool(mIsDynamicFormat)) != NO_ERROR) return status;
		if ((status = parcel->writeBool(mIsDynamicChannels)) != NO_ERROR) return status;
		if ((status = parcel->writeBool(mIsDynamicRate)) != NO_ERROR) return status;
		return status;
		}

		status_t AudioProfile::readFromParcel(const Parcel *parcel)
		{
		status_t status = NO_ERROR;
		if ((status = parcel->readUtf8FromUtf16(&mName)) != NO_ERROR) return status;
		static_assert(sizeof(mFormat) == sizeof(uint32_t));
		if ((status = parcel->readUint32(reinterpret_cast<uint32_t*>(&mFormat))) != NO_ERROR) {
		return status;
		}
		std::vector<int> values;
		if ((status = parcel->readInt32Vector(&values)) != NO_ERROR) return status;
		mChannelMasks.clear();
		mChannelMasks.insert(values.begin(), values.end());
		values.clear();
		if ((status = parcel->readInt32Vector(&values)) != NO_ERROR) return status;
		mSamplingRates.clear();
		mSamplingRates.insert(values.begin(), values.end());
		if ((status = parcel->readBool(&mIsDynamicFormat)) != NO_ERROR) return status;
		if ((status = parcel->readBool(&mIsDynamicChannels)) != NO_ERROR) return status;
		if ((status = parcel->readBool(&mIsDynamicRate)) != NO_ERROR) return status;
		return status;
		}

		ssize_t AudioProfileVector::add(const sp<AudioProfile> &profile)
		{
		ssize_t index = size();
		@@ -219,4 +269,39 @@ void AudioProfileVector::dump(std::string *dst, int spaces) const
		}
		}

		status_t AudioProfileVector::writeToParcel(Parcel *parcel) const
		{
		status_t status = NO_ERROR;
		if ((status = parcel->writeVectorSize(*this)) != NO_ERROR) return status;
		for (const auto &audioProfile : *this) {
		if ((status = parcel->writeParcelable(*audioProfile)) != NO_ERROR) {
		break;
		}
		}
		return status;
		}

		status_t AudioProfileVector::readFromParcel(const Parcel *parcel)
		{
		status_t status = NO_ERROR;
		this->clear();
		if ((status = parcel->resizeOutVector(this)) != NO_ERROR) return status;
		for (size_t i = 0; i < this->size(); ++i) {
		this->at(i) = new AudioProfile(AUDIO_FORMAT_DEFAULT, AUDIO_CHANNEL_NONE, 0 /sampleRate/);
		if ((status = parcel->readParcelable(this->at(i).get())) != NO_ERROR) {
		this->clear();
		break;
		}
		}
		return status;
		}

		bool AudioProfileVector::equals(const AudioProfileVector& other) const
		{
		return std::equal(begin(), end(), other.begin(), other.end(),
		[](const sp<AudioProfile>& left, const sp<AudioProfile>& right) {
		return left->equals(right);
		});
		}

		} // namespace android