/*
* Copyright (C) 2015 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 "policy.h"
#include <utils/String8.h>
#include <utils/SortedVector.h>
#include <utils/RefBase.h>
#include <utils/Errors.h>
#include <system/audio.h>
#include <cutils/config_utils.h>
namespace android {
typedef SortedVector<uint32_t> SampleRateVector;
typedef SortedVector<audio_channel_mask_t> ChannelsVector;
typedef Vector<audio_format_t> FormatVector;
template <typename T>
bool operator == (const SortedVector<T> &left, const SortedVector<T> &right);
class AudioProfile : public virtual RefBase
{
public:
AudioProfile(audio_format_t format,
audio_channel_mask_t channelMasks,
uint32_t samplingRate) :
mName(String8("")),
mFormat(format)
{
mChannelMasks.add(channelMasks);
mSamplingRates.add(samplingRate);
}
AudioProfile(audio_format_t format,
const ChannelsVector &channelMasks,
const SampleRateVector &samplingRateCollection) :
mName(String8("")),
mFormat(format),
mChannelMasks(channelMasks),
mSamplingRates(samplingRateCollection)
{}
audio_format_t getFormat() const { return mFormat; }
void setChannels(const ChannelsVector &channelMasks)
{
if (mIsDynamicChannels) {
mChannelMasks = channelMasks;
}
}
const ChannelsVector &getChannels() const { return mChannelMasks; }
void setSampleRates(const SampleRateVector &sampleRates)
{
if (mIsDynamicRate) {
mSamplingRates = sampleRates;
}
}
const SampleRateVector &getSampleRates() const { return mSamplingRates; }
bool isValid() const { return hasValidFormat() && hasValidRates() && hasValidChannels(); }
void clear()
{
if (mIsDynamicChannels) {
mChannelMasks.clear();
}
if (mIsDynamicRate) {
mSamplingRates.clear();
}
}
inline bool supportsChannels(audio_channel_mask_t channels) const
{
return mChannelMasks.indexOf(channels) >= 0;
}
inline bool supportsRate(uint32_t rate) const
{
return mSamplingRates.indexOf(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,
audio_channel_mask_t &updatedChannelMask,
audio_port_type_t portType,
audio_port_role_t portRole) const;
status_t checkCompatibleSamplingRate(uint32_t samplingRate,
uint32_t &updatedSamplingRate) const;
bool hasValidFormat() const { return mFormat != AUDIO_FORMAT_DEFAULT; }
bool hasValidRates() const { return !mSamplingRates.isEmpty(); }
bool hasValidChannels() const { return !mChannelMasks.isEmpty(); }
void setDynamicChannels(bool dynamic) { mIsDynamicChannels = dynamic; }
bool isDynamicChannels() const { return mIsDynamicChannels; }
void setDynamicRate(bool dynamic) { mIsDynamicRate = dynamic; }
bool isDynamicRate() const { return mIsDynamicRate; }
void setDynamicFormat(bool dynamic) { mIsDynamicFormat = dynamic; }
bool isDynamicFormat() const { return mIsDynamicFormat; }
bool isDynamic() { return mIsDynamicFormat || mIsDynamicChannels || mIsDynamicRate; }
void dump(int fd, int spaces) const;
private:
String8 mName;
audio_format_t mFormat;
ChannelsVector mChannelMasks;
SampleRateVector mSamplingRates;
bool mIsDynamicFormat = false;
bool mIsDynamicChannels = false;
bool mIsDynamicRate = false;
};
class AudioProfileVector : public Vector<sp<AudioProfile> >
{
public:
ssize_t add(const sp<AudioProfile> &profile)
{
ssize_t index = Vector::add(profile);
// we sort from worst to best, so that AUDIO_FORMAT_DEFAULT is always the first entry.
// TODO: compareFormats could be a lambda to convert between pointer-to-format to format:
// [](const audio_format_t *format1, const audio_format_t *format2) {
// return compareFormats(*format1, *format2);
// }
sort(compareFormats);
return index;
}
// 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)
{
// Check valid profile to add:
if (!profileToAdd->hasValidFormat()) {
return -1;
}
if (!profileToAdd->hasValidChannels() && !profileToAdd->hasValidRates()) {
FormatVector formats;
formats.add(profileToAdd->getFormat());
setFormats(FormatVector(formats));
return 0;
}
if (!profileToAdd->hasValidChannels() && profileToAdd->hasValidRates()) {
setSampleRatesFor(profileToAdd->getSampleRates(), profileToAdd->getFormat());
return 0;
}
if (profileToAdd->hasValidChannels() && !profileToAdd->hasValidRates()) {
setChannelsFor(profileToAdd->getChannels(), profileToAdd->getFormat());
return 0;
}
// Go through the list of profile to avoid duplicates
for (size_t profileIndex = 0; profileIndex < size(); profileIndex++) {
const sp<AudioProfile> &profile = itemAt(profileIndex);
if (profile->isValid() && profile == profileToAdd) {
// Nothing to do
return profileIndex;
}
}
profileToAdd->setDynamicFormat(true); // set the format as dynamic to allow removal
return add(profileToAdd);
}
sp<AudioProfile> getFirstValidProfile() const
{
for (size_t i = 0; i < size(); i++) {
if (itemAt(i)->isValid()) {
return itemAt(i);
}
}
return 0;
}
bool hasValidProfile() const { return getFirstValidProfile() != 0; }
status_t checkExactProfile(uint32_t samplingRate, audio_channel_mask_t channelMask,
audio_format_t format) const;
status_t checkCompatibleProfile(uint32_t &samplingRate, audio_channel_mask_t &channelMask,
audio_format_t &format,
audio_port_type_t portType,
audio_port_role_t portRole) const;
FormatVector getSupportedFormats() const
{
FormatVector supportedFormats;
for (size_t i = 0; i < size(); i++) {
if (itemAt(i)->hasValidFormat()) {
supportedFormats.add(itemAt(i)->getFormat());
}
}
return supportedFormats;
}
bool hasDynamicProfile() const
{
for (size_t i = 0; i < size(); i++) {
if (itemAt(i)->isDynamic()) {
return true;
}
}
return false;
}
bool hasDynamicFormat() const
{
return getProfileFor(gDynamicFormat) != 0;
}
bool hasDynamicChannelsFor(audio_format_t format) const
{
for (size_t i = 0; i < size(); i++) {
sp<AudioProfile> profile = itemAt(i);
if (profile->getFormat() == format && profile->isDynamicChannels()) {
return true;
}
}
return false;
}
bool hasDynamicRateFor(audio_format_t format) const
{
for (size_t i = 0; i < size(); i++) {
sp<AudioProfile> profile = itemAt(i);
if (profile->getFormat() == format && profile->isDynamicRate()) {
return true;
}
}
return false;
}
// One audio profile will be added for each format supported by Audio HAL
void setFormats(const FormatVector &formats)
{
// Only allow to change the format of dynamic profile
sp<AudioProfile> dynamicFormatProfile = getProfileFor(gDynamicFormat);
if (dynamicFormatProfile == 0) {
return;
}
for (size_t i = 0; i < formats.size(); i++) {
sp<AudioProfile> profile = new AudioProfile(formats[i],
dynamicFormatProfile->getChannels(),
dynamicFormatProfile->getSampleRates());
profile->setDynamicFormat(true);
profile->setDynamicChannels(dynamicFormatProfile->isDynamicChannels());
profile->setDynamicRate(dynamicFormatProfile->isDynamicRate());
add(profile);
}
}
void clearProfiles()
{
for (size_t i = size(); i != 0; ) {
sp<AudioProfile> profile = itemAt(--i);
if (profile->isDynamicFormat() && profile->hasValidFormat()) {
removeAt(i);
continue;
}
profile->clear();
}
}
void dump(int fd, int spaces) const
{
const size_t SIZE = 256;
char buffer[SIZE];
snprintf(buffer, SIZE, "%*s- Profiles:\n", spaces, "");
write(fd, buffer, strlen(buffer));
for (size_t i = 0; i < size(); i++) {
snprintf(buffer, SIZE, "%*sProfile %zu:", spaces + 4, "", i);
write(fd, buffer, strlen(buffer));
itemAt(i)->dump(fd, spaces + 8);
}
}
private:
void setSampleRatesFor(const SampleRateVector &sampleRates, audio_format_t format)
{
for (size_t i = 0; i < size(); i++) {
sp<AudioProfile> profile = itemAt(i);
if (profile->getFormat() == format && profile->isDynamicRate()) {
if (profile->hasValidRates()) {
// Need to create a new profile with same format
sp<AudioProfile> profileToAdd = new AudioProfile(format, profile->getChannels(),
sampleRates);
profileToAdd->setDynamicFormat(true); // need to set to allow cleaning
add(profileToAdd);
} else {
profile->setSampleRates(sampleRates);
}
return;
}
}
}
void setChannelsFor(const ChannelsVector &channelMasks, audio_format_t format)
{
for (size_t i = 0; i < size(); i++) {
sp<AudioProfile> profile = itemAt(i);
if (profile->getFormat() == format && profile->isDynamicChannels()) {
if (profile->hasValidChannels()) {
// Need to create a new profile with same format
sp<AudioProfile> profileToAdd = new AudioProfile(format, channelMasks,
profile->getSampleRates());
profileToAdd->setDynamicFormat(true); // need to set to allow cleaning
add(profileToAdd);
} else {
profile->setChannels(channelMasks);
}
return;
}
}
}
sp<AudioProfile> getProfileFor(audio_format_t format) const
{
for (size_t i = 0; i < size(); i++) {
if (itemAt(i)->getFormat() == format) {
return itemAt(i);
}
}
return 0;
}
static int compareFormats(const sp<AudioProfile> *profile1, const sp<AudioProfile> *profile2);
};
bool operator == (const AudioProfile &left, const AudioProfile &right);
}; // namespace android