Merge "Use standard containers for audio stuff in audio framework" (5dd8c0fd) · Commits · e / os / android_frameworks_av

media/libaudiofoundation/include/media/AudioContainers.h

0 → 100644

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

		#pragma once

		#include <set>
		#include <vector>

		#include <system/audio.h>

		namespace android {

		using ChannelMaskSet = std::set<audio_channel_mask_t>;
		using FormatSet = std::set<audio_format_t>;
		using SampleRateSet = std::set<uint32_t>;

		using FormatVector = std::vector<audio_format_t>;

		static inline ChannelMaskSet asInMask(const ChannelMaskSet& channelMasks) {
		ChannelMaskSet inMaskSet;
		for (const auto &channel : channelMasks) {
		if (audio_channel_mask_out_to_in(channel) != AUDIO_CHANNEL_INVALID) {
		inMaskSet.insert(audio_channel_mask_out_to_in(channel));
		}
		}
		return inMaskSet;
		}

		static inline ChannelMaskSet asOutMask(const ChannelMaskSet& channelMasks) {
		ChannelMaskSet outMaskSet;
		for (const auto &channel : channelMasks) {
		if (audio_channel_mask_in_to_out(channel) != AUDIO_CHANNEL_INVALID) {
		outMaskSet.insert(audio_channel_mask_in_to_out(channel));
		}
		}
		return outMaskSet;
		}

		} // namespace android
		No newline at end of file

media/libmedia/include/media/TypeConverter.h

+11 −17

Original line number	Diff line number	Diff line
		@@ -17,10 +17,11 @@
		#ifndef ANDROID_TYPE_CONVERTER_H_
		#define ANDROID_TYPE_CONVERTER_H_

		#include <set>
		#include <string>
		#include <string.h>

		#include <vector>

		#include <system/audio.h>
		#include <utils/Log.h>
		#include <utils/Vector.h>
		@@ -42,37 +43,37 @@ struct DefaultTraits
		}
		};
		template <typename T>
		struct VectorTraits
		struct SortedVectorTraits
		{
		typedef T Type;
		typedef Vector<Type> Collection;
		typedef SortedVector<Type> Collection;
		static void add(Collection &collection, Type value)
		{
		collection.add(value);
		}
		};
		template <typename T>
		struct SortedVectorTraits
		struct SetTraits
		{
		typedef T Type;
		typedef SortedVector<Type> Collection;
		typedef std::set<Type> Collection;
		static void add(Collection &collection, Type value)
		{
		collection.add(value);
		collection.insert(value);
		}
		};

		using SampleRateTraits = SortedVectorTraits<uint32_t>;
		using SampleRateTraits = SetTraits<uint32_t>;
		using DeviceTraits = DefaultTraits<audio_devices_t>;
		struct OutputDeviceTraits : public DeviceTraits {};
		struct InputDeviceTraits : public DeviceTraits {};
		using ChannelTraits = SortedVectorTraits<audio_channel_mask_t>;
		using ChannelTraits = SetTraits<audio_channel_mask_t>;
		struct OutputChannelTraits : public ChannelTraits {};
		struct InputChannelTraits : public ChannelTraits {};
		struct ChannelIndexTraits : public ChannelTraits {};
		using InputFlagTraits = DefaultTraits<audio_input_flags_t>;
		using OutputFlagTraits = DefaultTraits<audio_output_flags_t>;
		using FormatTraits = VectorTraits<audio_format_t>;
		using FormatTraits = DefaultTraits<audio_format_t>;
		using GainModeTraits = DefaultTraits<audio_gain_mode_t>;
		using StreamTraits = DefaultTraits<audio_stream_type_t>;
		using AudioModeTraits = DefaultTraits<audio_mode_t>;
		@@ -259,6 +260,7 @@ template <typename T, std::enable_if_t<std::is_same<T, audio_content_type_t>::va
		\|\| std::is_same<T, audio_source_t>::value
		\|\| std::is_same<T, audio_stream_type_t>::value
		\|\| std::is_same<T, audio_usage_t>::value
		\|\| std::is_same<T, audio_format_t>::value
		, int> = 0>
		static inline std::string toString(const T& value)
		{
		@@ -291,14 +293,6 @@ static inline std::string toString(const audio_devices_t& devices)
		return result;
		}

		// TODO: Remove when FormatTraits uses DefaultTraits.
		static inline std::string toString(const audio_format_t& format)
		{
		std::string result;
		return TypeConverter<VectorTraits<audio_format_t>>::toString(format, result)
		? result : std::to_string(static_cast<int>(format));
		}

		static inline std::string toString(const audio_attributes_t& attributes)
		{
		std::ostringstream result;

services/audiopolicy/common/managerdefinitions/include/AudioPort.h

+5 −4

Original line number	Diff line number	Diff line
		@@ -143,8 +143,9 @@ public:
		AudioGains mGains; // gain controllers

		private:
		void pickChannelMask(audio_channel_mask_t &channelMask, const ChannelsVector &channelMasks) const;
		void pickSamplingRate(uint32_t &rate,const SampleRateVector &samplingRates) const;
		void pickChannelMask(audio_channel_mask_t &channelMask,
		const ChannelMaskSet &channelMasks) const;
		void pickSamplingRate(uint32_t &rate, const SampleRateSet &samplingRates) const;

		sp<HwModule> mModule; // audio HW module exposing this I/O stream
		String8 mName;

services/audiopolicy/common/managerdefinitions/include/AudioProfile.h

+19 −58

Original line number	Diff line number	Diff line
		@@ -16,55 +16,15 @@

		#pragma once

		#include <vector>

		#include <media/AudioContainers.h>
		#include <system/audio.h>
		#include <utils/RefBase.h>
		#include <utils/SortedVector.h>
		#include <utils/String8.h>

		#include "policy.h"

		namespace android {

		typedef SortedVector<uint32_t> SampleRateVector;
		typedef Vector<audio_format_t> FormatVector;

		template <typename T>
		bool operator== (const SortedVector<T> &left, const SortedVector<T> &right)
		{
		if (left.size() != right.size()) {
		return false;
		}
		for (size_t index = 0; index < right.size(); index++) {
		if (left[index] != right[index]) {
		return false;
		}
		}
		return true;
		}

		template <typename T>
		bool operator!= (const SortedVector<T> &left, const SortedVector<T> &right)
		{
		return !(left == right);
		}

		class ChannelsVector : public SortedVector<audio_channel_mask_t>
		{
		public:
		ChannelsVector() = default;
		ChannelsVector(const ChannelsVector&) = default;
		ChannelsVector(const SortedVector<audio_channel_mask_t>& sv) :
		SortedVector<audio_channel_mask_t>(sv) {}
		ChannelsVector& operator=(const ChannelsVector&) = default;

		// Applies audio_channel_mask_out_to_in to all elements and returns the result.
		ChannelsVector asInMask() const;
		// Applies audio_channel_mask_in_to_out to all elements and returns the result.
		ChannelsVector asOutMask() const;
		};

		class AudioProfile : public virtual RefBase
		{
		public:
		@@ -72,22 +32,22 @@ public:

		AudioProfile(audio_format_t format, audio_channel_mask_t channelMasks, uint32_t samplingRate);
		AudioProfile(audio_format_t format,
		const ChannelsVector &channelMasks,
		const SampleRateVector &samplingRateCollection);
		const ChannelMaskSet &channelMasks,
		const SampleRateSet &samplingRateCollection);

		audio_format_t getFormat() const { return mFormat; }
		const ChannelsVector &getChannels() const { return mChannelMasks; }
		const SampleRateVector &getSampleRates() const { return mSamplingRates; }
		void setChannels(const ChannelsVector &channelMasks);
		void setSampleRates(const SampleRateVector &sampleRates);
		const ChannelMaskSet &getChannels() const { return mChannelMasks; }
		const SampleRateSet &getSampleRates() const { return mSamplingRates; }
		void setChannels(const ChannelMaskSet &channelMasks);
		void setSampleRates(const SampleRateSet &sampleRates);

		void clear();
		bool isValid() const { return hasValidFormat() && hasValidRates() && hasValidChannels(); }
		bool supportsChannels(audio_channel_mask_t channels) const
		{
		return mChannelMasks.indexOf(channels) >= 0;
		return mChannelMasks.count(channels) != 0;
		}
		bool supportsRate(uint32_t rate) const { return mSamplingRates.indexOf(rate) >= 0; }
		bool supportsRate(uint32_t rate) const { return mSamplingRates.count(rate) != 0; }

		status_t checkExact(uint32_t rate, audio_channel_mask_t channels, audio_format_t format) const;
		status_t checkCompatibleChannelMask(audio_channel_mask_t channelMask,
		@@ -98,8 +58,8 @@ public:
		uint32_t &updatedSamplingRate) const;

		bool hasValidFormat() const { return mFormat != AUDIO_FORMAT_DEFAULT; }
		bool hasValidRates() const { return !mSamplingRates.isEmpty(); }
		bool hasValidChannels() const { return !mChannelMasks.isEmpty(); }
		bool hasValidRates() const { return !mSamplingRates.empty(); }
		bool hasValidChannels() const { return !mChannelMasks.empty(); }

		void setDynamicChannels(bool dynamic) { mIsDynamicChannels = dynamic; }
		bool isDynamicChannels() const { return mIsDynamicChannels; }
		@@ -117,8 +77,8 @@ public:
		private:
		String8 mName;
		audio_format_t mFormat;
		ChannelsVector mChannelMasks;
		SampleRateVector mSamplingRates;
		ChannelMaskSet mChannelMasks;
		SampleRateSet mSamplingRates;

		bool mIsDynamicFormat = false;
		bool mIsDynamicChannels = false;
		@@ -126,13 +86,16 @@ private:
		};


		class AudioProfileVector : public Vector<sp<AudioProfile> >
		class AudioProfileVector : public std::vector<sp<AudioProfile> >
		{
		public:
		ssize_t add(const sp<AudioProfile> &profile);
		// This API is intended to be used by the policy manager once retrieving capabilities
		// for a profile with dynamic format, rate and channels attributes
		ssize_t addProfileFromHal(const sp<AudioProfile> &profileToAdd);
		void appendProfiles(const AudioProfileVector& audioProfiles) {
		insert(end(), audioProfiles.begin(), audioProfiles.end());
		}

		status_t checkExactProfile(uint32_t samplingRate, audio_channel_mask_t channelMask,
		audio_format_t format) const;
		@@ -169,10 +132,8 @@ public:

		private:
		sp<AudioProfile> getProfileFor(audio_format_t format) const;
		void setSampleRatesFor(const SampleRateVector &sampleRates, audio_format_t format);
		void setChannelsFor(const ChannelsVector &channelMasks, audio_format_t format);

		static int compareFormats(const sp<AudioProfile> profile1, const sp<AudioProfile> profile2);
		void setSampleRatesFor(const SampleRateSet &sampleRates, audio_format_t format);
		void setChannelsFor(const ChannelMaskSet &channelMasks, audio_format_t format);
		};

		bool operator == (const AudioProfile &left, const AudioProfile &right);

services/audiopolicy/common/managerdefinitions/src/AudioPort.cpp

+30 −48

Original line number	Diff line number	Diff line
		@@ -64,30 +64,19 @@ void AudioPort::toAudioPort(struct audio_port *port) const
		{
		// TODO: update this function once audio_port structure reflects the new profile definition.
		// For compatibility reason: flatening the AudioProfile into audio_port structure.
		SortedVector<audio_format_t> flatenedFormats;
		SampleRateVector flatenedRates;
		ChannelsVector flatenedChannels;
		FormatSet flatenedFormats;
		SampleRateSet flatenedRates;
		ChannelMaskSet flatenedChannels;
		for (const auto& profile : mProfiles) {
		if (profile->isValid()) {
		audio_format_t formatToExport = profile->getFormat();
		const SampleRateVector &ratesToExport = profile->getSampleRates();
		const ChannelsVector &channelsToExport = profile->getChannels();
		const SampleRateSet &ratesToExport = profile->getSampleRates();
		const ChannelMaskSet &channelsToExport = profile->getChannels();

		flatenedFormats.insert(formatToExport);
		flatenedRates.insert(ratesToExport.begin(), ratesToExport.end());
		flatenedChannels.insert(channelsToExport.begin(), channelsToExport.end());

		if (flatenedFormats.indexOf(formatToExport) < 0) {
		flatenedFormats.add(formatToExport);
		}
		for (size_t rateIndex = 0; rateIndex < ratesToExport.size(); rateIndex++) {
		uint32_t rate = ratesToExport[rateIndex];
		if (flatenedRates.indexOf(rate) < 0) {
		flatenedRates.add(rate);
		}
		}
		for (size_t chanIndex = 0; chanIndex < channelsToExport.size(); chanIndex++) {
		audio_channel_mask_t channels = channelsToExport[chanIndex];
		if (flatenedChannels.indexOf(channels) < 0) {
		flatenedChannels.add(channels);
		}
		}
		if (flatenedRates.size() > AUDIO_PORT_MAX_SAMPLING_RATES \|\|
		flatenedChannels.size() > AUDIO_PORT_MAX_CHANNEL_MASKS \|\|
		flatenedFormats.size() > AUDIO_PORT_MAX_FORMATS) {
		@@ -102,23 +91,16 @@ void AudioPort::toAudioPort(struct audio_port *port) const
		port->num_sample_rates = flatenedRates.size();
		port->num_channel_masks = flatenedChannels.size();
		port->num_formats = flatenedFormats.size();
		for (size_t i = 0; i < flatenedRates.size(); i++) {
		port->sample_rates[i] = flatenedRates[i];
		}
		for (size_t i = 0; i < flatenedChannels.size(); i++) {
		port->channel_masks[i] = flatenedChannels[i];
		}
		for (size_t i = 0; i < flatenedFormats.size(); i++) {
		port->formats[i] = flatenedFormats[i];
		}
		std::copy(flatenedRates.begin(), flatenedRates.end(), port->sample_rates);
		std::copy(flatenedChannels.begin(), flatenedChannels.end(), port->channel_masks);
		std::copy(flatenedFormats.begin(), flatenedFormats.end(), port->formats);

		ALOGV("AudioPort::toAudioPort() num gains %zu", mGains.size());

		uint32_t i;
		for (i = 0; i < mGains.size() && i < AUDIO_PORT_MAX_GAINS; i++) {
		port->num_gains = std::min(mGains.size(), (size_t) AUDIO_PORT_MAX_GAINS);
		for (size_t i = 0; i < port->num_gains; i++) {
		port->gains[i] = mGains[i]->getGain();
		}
		port->num_gains = i;
		}

		void AudioPort::importAudioPort(const sp<AudioPort>& port, bool force __unused)
		@@ -162,7 +144,7 @@ status_t AudioPort::checkExactAudioProfile(const struct audio_port_config *confi
		return status;
		}

		void AudioPort::pickSamplingRate(uint32_t &pickedRate,const SampleRateVector &samplingRates) const
		void AudioPort::pickSamplingRate(uint32_t &pickedRate,const SampleRateSet &samplingRates) const
		{
		pickedRate = 0;
		// For direct outputs, pick minimum sampling rate: this helps ensuring that the
		@@ -170,9 +152,9 @@ void AudioPort::pickSamplingRate(uint32_t &pickedRate,const SampleRateVector &sa
		// sink
		if (isDirectOutput()) {
		uint32_t samplingRate = UINT_MAX;
		for (size_t i = 0; i < samplingRates.size(); i ++) {
		if ((samplingRates[i] < samplingRate) && (samplingRates[i] > 0)) {
		samplingRate = samplingRates[i];
		for (const auto rate : samplingRates) {
		if ((rate < samplingRate) && (rate > 0)) {
		samplingRate = rate;
		}
		}
		pickedRate = (samplingRate == UINT_MAX) ? 0 : samplingRate;
		@@ -188,16 +170,16 @@ void AudioPort::pickSamplingRate(uint32_t &pickedRate,const SampleRateVector &sa
		// TODO: should mSamplingRates[] be ordered in terms of our preference
		// and we return the first (and hence most preferred) match? This is of concern if
		// we want to choose 96kHz over 192kHz for USB driver stability or resource constraints.
		for (size_t i = 0; i < samplingRates.size(); i ++) {
		if ((samplingRates[i] > pickedRate) && (samplingRates[i] <= maxRate)) {
		pickedRate = samplingRates[i];
		for (const auto rate : samplingRates) {
		if ((rate > pickedRate) && (rate <= maxRate)) {
		pickedRate = rate;
		}
		}
		}
		}

		void AudioPort::pickChannelMask(audio_channel_mask_t &pickedChannelMask,
		const ChannelsVector &channelMasks) const
		const ChannelMaskSet &channelMasks) const
		{
		pickedChannelMask = AUDIO_CHANNEL_NONE;
		// For direct outputs, pick minimum channel count: this helps ensuring that the
		@@ -205,15 +187,15 @@ void AudioPort::pickChannelMask(audio_channel_mask_t &pickedChannelMask,
		// sink
		if (isDirectOutput()) {
		uint32_t channelCount = UINT_MAX;
		for (size_t i = 0; i < channelMasks.size(); i ++) {
		for (const auto channelMask : channelMasks) {
		uint32_t cnlCount;
		if (useInputChannelMask()) {
		cnlCount = audio_channel_count_from_in_mask(channelMasks[i]);
		cnlCount = audio_channel_count_from_in_mask(channelMask);
		} else {
		cnlCount = audio_channel_count_from_out_mask(channelMasks[i]);
		cnlCount = audio_channel_count_from_out_mask(channelMask);
		}
		if ((cnlCount < channelCount) && (cnlCount > 0)) {
		pickedChannelMask = channelMasks[i];
		pickedChannelMask = channelMask;
		channelCount = cnlCount;
		}
		}
		@@ -226,15 +208,15 @@ void AudioPort::pickChannelMask(audio_channel_mask_t &pickedChannelMask,
		if (mType != AUDIO_PORT_TYPE_MIX) {
		maxCount = UINT_MAX;
		}
		for (size_t i = 0; i < channelMasks.size(); i ++) {
		for (const auto channelMask : channelMasks) {
		uint32_t cnlCount;
		if (useInputChannelMask()) {
		cnlCount = audio_channel_count_from_in_mask(channelMasks[i]);
		cnlCount = audio_channel_count_from_in_mask(channelMask);
		} else {
		cnlCount = audio_channel_count_from_out_mask(channelMasks[i]);
		cnlCount = audio_channel_count_from_out_mask(channelMask);
		}
		if ((cnlCount > channelCount) && (cnlCount <= maxCount)) {
		pickedChannelMask = channelMasks[i];
		pickedChannelMask = channelMask;
		channelCount = cnlCount;
		}
		}