378 lines
15 KiB
C++
378 lines
15 KiB
C++
/*
|
|
* Copyright (C) 2022 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 <algorithm>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <iterator>
|
|
#include <memory>
|
|
#define LOG_TAG "EffectsFactoryHalAidl"
|
|
//#define LOG_NDEBUG 0
|
|
|
|
#include <error/expected_utils.h>
|
|
#include <aidl/android/media/audio/common/AudioStreamType.h>
|
|
#include <android/binder_manager.h>
|
|
#include <media/AidlConversionCppNdk.h>
|
|
#include <media/AidlConversionEffect.h>
|
|
#include <system/audio.h>
|
|
#include <utils/Log.h>
|
|
|
|
#include "EffectBufferHalAidl.h"
|
|
#include "EffectHalAidl.h"
|
|
#include "EffectProxy.h"
|
|
#include "EffectsFactoryHalAidl.h"
|
|
|
|
using ::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid;
|
|
using ::aidl::android::aidl_utils::statusTFromBinderStatus;
|
|
using ::aidl::android::hardware::audio::effect::Descriptor;
|
|
using ::aidl::android::hardware::audio::effect::IFactory;
|
|
using ::aidl::android::hardware::audio::effect::Processing;
|
|
using ::aidl::android::media::audio::common::AudioSource;
|
|
using ::aidl::android::media::audio::common::AudioStreamType;
|
|
using ::aidl::android::media::audio::common::AudioUuid;
|
|
using ::android::base::unexpected;
|
|
using ::android::detail::AudioHalVersionInfo;
|
|
|
|
namespace android {
|
|
namespace effect {
|
|
|
|
EffectsFactoryHalAidl::EffectsFactoryHalAidl(std::shared_ptr<IFactory> effectsFactory)
|
|
: mFactory(effectsFactory),
|
|
mHalVersion(AudioHalVersionInfo(
|
|
AudioHalVersionInfo::Type::AIDL,
|
|
[this]() {
|
|
int32_t majorVersion = 0;
|
|
return (mFactory && mFactory->getInterfaceVersion(&majorVersion).isOk())
|
|
? majorVersion
|
|
: 0;
|
|
}())),
|
|
mHalDescList([this]() {
|
|
std::vector<Descriptor> list;
|
|
if (mFactory) {
|
|
mFactory->queryEffects(std::nullopt, std::nullopt, std::nullopt, &list).isOk();
|
|
}
|
|
return list;
|
|
}()),
|
|
mUuidProxyMap([this]() {
|
|
std::map<AudioUuid, std::shared_ptr<EffectProxy>> proxyMap;
|
|
for (const auto& desc : mHalDescList) {
|
|
// create EffectProxy
|
|
if (desc.common.id.proxy.has_value()) {
|
|
const auto& uuid = desc.common.id.proxy.value();
|
|
if (0 == proxyMap.count(uuid)) {
|
|
proxyMap.insert({uuid, ndk::SharedRefBase::make<EffectProxy>(desc.common.id,
|
|
mFactory)});
|
|
}
|
|
proxyMap[uuid]->addSubEffect(desc);
|
|
ALOGI("%s addSubEffect %s", __func__, desc.common.toString().c_str());
|
|
}
|
|
}
|
|
return proxyMap;
|
|
}()),
|
|
mProxyDescList([this]() {
|
|
std::vector<Descriptor> list;
|
|
for (const auto& proxy : mUuidProxyMap) {
|
|
if (Descriptor desc; proxy.second && proxy.second->getDescriptor(&desc).isOk()) {
|
|
list.emplace_back(std::move(desc));
|
|
}
|
|
}
|
|
return list;
|
|
}()),
|
|
mNonProxyDescList([this]() {
|
|
std::vector<Descriptor> list;
|
|
std::copy_if(mHalDescList.begin(), mHalDescList.end(), std::back_inserter(list),
|
|
[](const Descriptor& desc) { return !desc.common.id.proxy.has_value(); });
|
|
return list;
|
|
}()),
|
|
mEffectCount(mNonProxyDescList.size() + mProxyDescList.size()),
|
|
mAidlProcessings([this]() -> std::vector<Processing> {
|
|
std::vector<Processing> processings;
|
|
if (!mFactory || !mFactory->queryProcessing(std::nullopt, &processings).isOk()) {
|
|
ALOGE("%s queryProcessing failed", __func__);
|
|
}
|
|
return processings;
|
|
}()) {
|
|
ALOG_ASSERT(mFactory != nullptr, "Provided IEffectsFactory service is NULL");
|
|
ALOGI("%s with %zu nonProxyEffects and %zu proxyEffects", __func__, mNonProxyDescList.size(),
|
|
mProxyDescList.size());
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::queryNumberEffects(uint32_t *pNumEffects) {
|
|
if (pNumEffects == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
*pNumEffects = mEffectCount;
|
|
ALOGI("%s %d", __func__, *pNumEffects);
|
|
return OK;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::getDescriptor(uint32_t index, effect_descriptor_t* pDescriptor) {
|
|
if (pDescriptor == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
if (index >= mEffectCount) {
|
|
ALOGE("%s index %d exceed max number %zu", __func__, index, mEffectCount);
|
|
return INVALID_OPERATION;
|
|
}
|
|
|
|
if (index >= mNonProxyDescList.size()) {
|
|
*pDescriptor =
|
|
VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_Descriptor_effect_descriptor(
|
|
mProxyDescList.at(index - mNonProxyDescList.size())));
|
|
} else {
|
|
*pDescriptor =
|
|
VALUE_OR_RETURN_STATUS(::aidl::android::aidl2legacy_Descriptor_effect_descriptor(
|
|
mNonProxyDescList.at(index)));
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::getDescriptor(const effect_uuid_t* halUuid,
|
|
effect_descriptor_t* pDescriptor) {
|
|
if (halUuid == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
AudioUuid uuid =
|
|
VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halUuid));
|
|
return getHalDescriptorWithImplUuid(uuid, pDescriptor);
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::getDescriptors(const effect_uuid_t* halType,
|
|
std::vector<effect_descriptor_t>* descriptors) {
|
|
if (halType == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
AudioUuid type =
|
|
VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*halType));
|
|
return getHalDescriptorWithTypeUuid(type, descriptors);
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::createEffect(const effect_uuid_t* uuid, int32_t sessionId,
|
|
int32_t ioId, int32_t deviceId __unused,
|
|
sp<EffectHalInterface>* effect) {
|
|
if (uuid == nullptr || effect == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
if (sessionId == AUDIO_SESSION_DEVICE && ioId == AUDIO_IO_HANDLE_NONE) {
|
|
return INVALID_OPERATION;
|
|
}
|
|
ALOGI("%s session %d ioId %d", __func__, sessionId, ioId);
|
|
|
|
AudioUuid aidlUuid =
|
|
VALUE_OR_RETURN_STATUS(::aidl::android::legacy2aidl_audio_uuid_t_AudioUuid(*uuid));
|
|
std::shared_ptr<IEffect> aidlEffect;
|
|
// Use EffectProxy interface instead of IFactory to create
|
|
const bool isProxy = isProxyEffect(aidlUuid);
|
|
if (isProxy) {
|
|
aidlEffect = mUuidProxyMap.at(aidlUuid);
|
|
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(mUuidProxyMap.at(aidlUuid)->create()));
|
|
} else {
|
|
RETURN_STATUS_IF_ERROR(
|
|
statusTFromBinderStatus(mFactory->createEffect(aidlUuid, &aidlEffect)));
|
|
}
|
|
if (aidlEffect == nullptr) {
|
|
ALOGE("%s failed to create effect with UUID: %s", __func__, aidlUuid.toString().c_str());
|
|
return NAME_NOT_FOUND;
|
|
}
|
|
Descriptor desc;
|
|
RETURN_STATUS_IF_ERROR(statusTFromBinderStatus(aidlEffect->getDescriptor(&desc)));
|
|
|
|
uint64_t effectId;
|
|
{
|
|
std::lock_guard lg(mLock);
|
|
effectId = ++mEffectIdCounter;
|
|
}
|
|
|
|
*effect =
|
|
sp<EffectHalAidl>::make(mFactory, aidlEffect, effectId, sessionId, ioId, desc, isProxy);
|
|
return OK;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::dumpEffects(int fd) {
|
|
status_t ret = OK;
|
|
// record the error ret and continue dump as many effects as possible
|
|
for (const auto& proxy : mUuidProxyMap) {
|
|
if (proxy.second) {
|
|
if (status_t temp = proxy.second->dump(fd, nullptr, 0); temp != OK) {
|
|
ret = temp;
|
|
}
|
|
}
|
|
}
|
|
RETURN_STATUS_IF_ERROR(mFactory->dump(fd, nullptr, 0));
|
|
return ret;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::allocateBuffer(size_t size, sp<EffectBufferHalInterface>* buffer) {
|
|
ALOGI("%s size %zu buffer %p", __func__, size, buffer);
|
|
return EffectBufferHalAidl::allocate(size, buffer);
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::mirrorBuffer(void* external, size_t size,
|
|
sp<EffectBufferHalInterface>* buffer) {
|
|
ALOGI("%s extern %p size %zu buffer %p", __func__, external, size, buffer);
|
|
return EffectBufferHalAidl::mirror(external, size, buffer);
|
|
}
|
|
|
|
AudioHalVersionInfo EffectsFactoryHalAidl::getHalVersion() const {
|
|
return mHalVersion;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::getHalDescriptorWithImplUuid(const AudioUuid& uuid,
|
|
effect_descriptor_t* pDescriptor) {
|
|
if (pDescriptor == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
const auto& list = isProxyEffect(uuid) ? mProxyDescList : mNonProxyDescList;
|
|
auto matchIt = std::find_if(list.begin(), list.end(),
|
|
[&](const auto& desc) { return desc.common.id.uuid == uuid; });
|
|
if (matchIt == list.end()) {
|
|
ALOGE("%s UUID not found in HAL and proxy list %s", __func__, uuid.toString().c_str());
|
|
return BAD_VALUE;
|
|
}
|
|
ALOGI("%s UUID impl found %s", __func__, uuid.toString().c_str());
|
|
|
|
*pDescriptor = VALUE_OR_RETURN_STATUS(
|
|
::aidl::android::aidl2legacy_Descriptor_effect_descriptor(*matchIt));
|
|
return OK;
|
|
}
|
|
|
|
status_t EffectsFactoryHalAidl::getHalDescriptorWithTypeUuid(
|
|
const AudioUuid& type, std::vector<effect_descriptor_t>* descriptors) {
|
|
if (descriptors == nullptr) {
|
|
return BAD_VALUE;
|
|
}
|
|
|
|
std::vector<Descriptor> result;
|
|
std::copy_if(mNonProxyDescList.begin(), mNonProxyDescList.end(), std::back_inserter(result),
|
|
[&](auto& desc) { return desc.common.id.type == type; });
|
|
std::copy_if(mProxyDescList.begin(), mProxyDescList.end(), std::back_inserter(result),
|
|
[&](auto& desc) { return desc.common.id.type == type; });
|
|
if (result.empty()) {
|
|
ALOGW("%s UUID type not found in HAL and proxy list %s", __func__, type.toString().c_str());
|
|
return BAD_VALUE;
|
|
}
|
|
ALOGI("%s UUID type found %zu \n %s", __func__, result.size(), type.toString().c_str());
|
|
|
|
*descriptors = VALUE_OR_RETURN_STATUS(
|
|
aidl::android::convertContainer<std::vector<effect_descriptor_t>>(
|
|
result, ::aidl::android::aidl2legacy_Descriptor_effect_descriptor));
|
|
return OK;
|
|
}
|
|
|
|
bool EffectsFactoryHalAidl::isProxyEffect(const AudioUuid& uuid) const {
|
|
return 0 != mUuidProxyMap.count(uuid);
|
|
}
|
|
|
|
std::shared_ptr<const effectsConfig::Processings> EffectsFactoryHalAidl::getProcessings() const {
|
|
|
|
auto getConfigEffectWithDescriptor =
|
|
[](const auto& desc) -> std::shared_ptr<const effectsConfig::Effect> {
|
|
effectsConfig::Effect effect = {.name = desc.common.name, .isProxy = false};
|
|
if (const auto uuid =
|
|
::aidl::android::aidl2legacy_AudioUuid_audio_uuid_t(desc.common.id.uuid);
|
|
uuid.ok()) {
|
|
static_cast<effectsConfig::EffectImpl>(effect).uuid = uuid.value();
|
|
return std::make_shared<const effectsConfig::Effect>(effect);
|
|
} else {
|
|
return nullptr;
|
|
}
|
|
};
|
|
|
|
auto getConfigProcessingWithAidlProcessing =
|
|
[&](const auto& aidlProcess, std::vector<effectsConfig::InputStream>& preprocess,
|
|
std::vector<effectsConfig::OutputStream>& postprocess) {
|
|
if (aidlProcess.type.getTag() == Processing::Type::streamType) {
|
|
AudioStreamType aidlType =
|
|
aidlProcess.type.template get<Processing::Type::streamType>();
|
|
const auto type =
|
|
::aidl::android::aidl2legacy_AudioStreamType_audio_stream_type_t(
|
|
aidlType);
|
|
if (!type.ok()) {
|
|
return;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;
|
|
std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),
|
|
std::back_inserter(effects), getConfigEffectWithDescriptor);
|
|
effectsConfig::OutputStream stream = {.type = type.value(),
|
|
.effects = std::move(effects)};
|
|
postprocess.emplace_back(stream);
|
|
} else if (aidlProcess.type.getTag() == Processing::Type::source) {
|
|
AudioSource aidlType =
|
|
aidlProcess.type.template get<Processing::Type::source>();
|
|
const auto type =
|
|
::aidl::android::aidl2legacy_AudioSource_audio_source_t(aidlType);
|
|
if (!type.ok()) {
|
|
return;
|
|
}
|
|
|
|
std::vector<std::shared_ptr<const effectsConfig::Effect>> effects;
|
|
std::transform(aidlProcess.ids.begin(), aidlProcess.ids.end(),
|
|
std::back_inserter(effects), getConfigEffectWithDescriptor);
|
|
effectsConfig::InputStream stream = {.type = type.value(),
|
|
.effects = std::move(effects)};
|
|
preprocess.emplace_back(stream);
|
|
}
|
|
};
|
|
|
|
static std::shared_ptr<const effectsConfig::Processings> processings(
|
|
[&]() -> std::shared_ptr<const effectsConfig::Processings> {
|
|
std::vector<effectsConfig::InputStream> preprocess;
|
|
std::vector<effectsConfig::OutputStream> postprocess;
|
|
for (const auto& processing : mAidlProcessings) {
|
|
getConfigProcessingWithAidlProcessing(processing, preprocess, postprocess);
|
|
}
|
|
|
|
if (0 == preprocess.size() && 0 == postprocess.size()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return std::make_shared<const effectsConfig::Processings>(
|
|
effectsConfig::Processings({.preprocess = std::move(preprocess),
|
|
.postprocess = std::move(postprocess)}));
|
|
}());
|
|
|
|
return processings;
|
|
}
|
|
|
|
// Return 0 for AIDL, as the AIDL interface is not aware of the configuration file.
|
|
::android::error::Result<size_t> EffectsFactoryHalAidl::getSkippedElements() const {
|
|
return 0;
|
|
}
|
|
|
|
} // namespace effect
|
|
|
|
// When a shared library is built from a static library, even explicit
|
|
// exports from a static library are optimized out unless actually used by
|
|
// the shared library. See EffectsFactoryHalEntry.cpp.
|
|
extern "C" void* createIEffectsFactoryImpl() {
|
|
auto serviceName = std::string(IFactory::descriptor) + "/default";
|
|
auto service = IFactory::fromBinder(
|
|
ndk::SpAIBinder(AServiceManager_waitForService(serviceName.c_str())));
|
|
if (!service) {
|
|
ALOGE("%s binder service %s not exist", __func__, serviceName.c_str());
|
|
return nullptr;
|
|
}
|
|
return new effect::EffectsFactoryHalAidl(service);
|
|
}
|
|
|
|
} // namespace android
|