hardware_interfaces/audio/effect/all-versions/default/util/EffectUtils.cpp

/*
 * Copyright (C) 2021 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 <memory.h>

#define LOG_TAG "EffectUtils"
#include <log/log.h>

#include <HidlUtils.h>
#include <UuidUtils.h>
#include <common/all-versions/VersionUtils.h>

#include "util/EffectUtils.h"

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(*(a)))

using ::android::hardware::audio::common::CPP_VERSION::implementation::HidlUtils;
using ::android::hardware::audio::common::CPP_VERSION::implementation::UuidUtils;
using ::android::hardware::audio::common::utils::EnumBitfield;

namespace android {
namespace hardware {
namespace audio {
namespace effect {
namespace CPP_VERSION {
namespace implementation {

using namespace ::android::hardware::audio::common::CPP_VERSION;

#define CONVERT_CHECKED(expr, result)                   \
    if (status_t status = (expr); status != NO_ERROR) { \
        result = status;                                \
    }

#if MAJOR_VERSION <= 6

status_t EffectUtils::effectBufferConfigFromHal(const buffer_config_t& halConfig, bool /*isInput*/,
                                                EffectBufferConfig* config) {
    config->buffer.id = 0;
    config->buffer.frameCount = 0;
    config->samplingRateHz = halConfig.samplingRate;
    config->channels = EnumBitfield<AudioChannelMask>(halConfig.channels);
    config->format = AudioFormat(halConfig.format);
    config->accessMode = EffectBufferAccess(halConfig.accessMode);
    config->mask = EnumBitfield<EffectConfigParameters>(halConfig.mask);
    return NO_ERROR;
}

status_t EffectUtils::effectBufferConfigToHal(const EffectBufferConfig& config,
                                              buffer_config_t* halConfig) {
    // Note: setting the buffers directly is considered obsolete. They need to be set
    // using 'setProcessBuffers'.
    halConfig->buffer.frameCount = 0;
    halConfig->buffer.raw = nullptr;
    halConfig->samplingRate = config.samplingRateHz;
    halConfig->channels = static_cast<uint32_t>(config.channels);
    // Note: The framework code does not use BP.
    halConfig->bufferProvider.cookie = nullptr;
    halConfig->bufferProvider.getBuffer = nullptr;
    halConfig->bufferProvider.releaseBuffer = nullptr;
    halConfig->format = static_cast<uint8_t>(config.format);
    halConfig->accessMode = static_cast<uint8_t>(config.accessMode);
    halConfig->mask = static_cast<uint8_t>(config.mask);
    return NO_ERROR;
}

#else

status_t EffectUtils::effectBufferConfigFromHal(const buffer_config_t& halConfig, bool isInput,
                                                EffectBufferConfig* config) {
    status_t result = NO_ERROR;
    config->buffer.unspecified();
    audio_config_base_t halConfigBase = {halConfig.samplingRate,
                                         static_cast<audio_channel_mask_t>(halConfig.channels),
                                         static_cast<audio_format_t>(halConfig.format)};
    CONVERT_CHECKED(HidlUtils::audioConfigBaseOptionalFromHal(
                            halConfigBase, isInput, halConfig.mask & EFFECT_CONFIG_FORMAT,
                            halConfig.mask & EFFECT_CONFIG_SMP_RATE,
                            halConfig.mask & EFFECT_CONFIG_CHANNELS, &config->base),
                    result);
    if (halConfig.mask & EFFECT_CONFIG_ACC_MODE) {
        config->accessMode.value(EffectBufferAccess(halConfig.accessMode));
    }
    return result;
}

status_t EffectUtils::effectBufferConfigToHal(const EffectBufferConfig& config,
                                              buffer_config_t* halConfig) {
    status_t result = NO_ERROR;
    // Note: setting the buffers directly is considered obsolete. They need to be set
    // using 'setProcessBuffers'.
    halConfig->buffer.frameCount = 0;
    halConfig->buffer.raw = nullptr;
    audio_config_base_t halConfigBase = AUDIO_CONFIG_BASE_INITIALIZER;
    bool formatSpecified = false, sRateSpecified = false, channelMaskSpecified = false;
    CONVERT_CHECKED(
            HidlUtils::audioConfigBaseOptionalToHal(config.base, &halConfigBase, &formatSpecified,
                                                    &sRateSpecified, &channelMaskSpecified),
            result);
    halConfig->mask = 0;
    if (sRateSpecified) {
        halConfig->mask |= EFFECT_CONFIG_SMP_RATE;
        halConfig->samplingRate = halConfigBase.sample_rate;
    }
    if (channelMaskSpecified) {
        halConfig->mask |= EFFECT_CONFIG_CHANNELS;
        halConfig->channels = halConfigBase.channel_mask;
    }
    if (formatSpecified) {
        halConfig->mask |= EFFECT_CONFIG_FORMAT;
        halConfig->format = halConfigBase.format;
    }
    // Note: The framework code does not use BP.
    halConfig->bufferProvider.cookie = nullptr;
    halConfig->bufferProvider.getBuffer = nullptr;
    halConfig->bufferProvider.releaseBuffer = nullptr;
    if (config.accessMode.getDiscriminator() ==
        EffectBufferConfig::OptionalAccessMode::hidl_discriminator::value) {
        halConfig->mask |= EFFECT_CONFIG_ACC_MODE;
        halConfig->accessMode = static_cast<uint8_t>(config.accessMode.value());
    }
    return result;
}

#endif  // MAJOR_VERSION >= 6

status_t EffectUtils::effectConfigFromHal(const effect_config_t& halConfig, bool isInput,
                                          EffectConfig* config) {
    status_t result = NO_ERROR;
    CONVERT_CHECKED(effectBufferConfigFromHal(halConfig.inputCfg, isInput, &config->inputCfg),
                    result);
    CONVERT_CHECKED(effectBufferConfigFromHal(halConfig.outputCfg, isInput, &config->outputCfg),
                    result);
    return result;
}

status_t EffectUtils::effectConfigToHal(const EffectConfig& config, effect_config_t* halConfig) {
    status_t result = NO_ERROR;
    CONVERT_CHECKED(effectBufferConfigToHal(config.inputCfg, &halConfig->inputCfg), result);
    CONVERT_CHECKED(effectBufferConfigToHal(config.outputCfg, &halConfig->outputCfg), result);
    return result;
}

status_t EffectUtils::effectDescriptorFromHal(const effect_descriptor_t& halDescriptor,
                                              EffectDescriptor* descriptor) {
    UuidUtils::uuidFromHal(halDescriptor.type, &descriptor->type);
    UuidUtils::uuidFromHal(halDescriptor.uuid, &descriptor->uuid);
    descriptor->flags = EnumBitfield<EffectFlags>(halDescriptor.flags);
    descriptor->cpuLoad = halDescriptor.cpuLoad;
    descriptor->memoryUsage = halDescriptor.memoryUsage;
#if MAJOR_VERSION <= 6
    memcpy(descriptor->name.data(), halDescriptor.name, descriptor->name.size());
    memcpy(descriptor->implementor.data(), halDescriptor.implementor,
           descriptor->implementor.size());
#else
    descriptor->name = hidl_string(halDescriptor.name, ARRAY_SIZE(halDescriptor.name));
    descriptor->implementor =
            hidl_string(halDescriptor.implementor, ARRAY_SIZE(halDescriptor.implementor));
#endif
    return NO_ERROR;
}

status_t EffectUtils::effectDescriptorToHal(const EffectDescriptor& descriptor,
                                            effect_descriptor_t* halDescriptor) {
    status_t result = NO_ERROR;
    UuidUtils::uuidToHal(descriptor.type, &halDescriptor->type);
    UuidUtils::uuidToHal(descriptor.uuid, &halDescriptor->uuid);
    halDescriptor->flags = static_cast<uint32_t>(descriptor.flags);
    halDescriptor->cpuLoad = descriptor.cpuLoad;
    halDescriptor->memoryUsage = descriptor.memoryUsage;
#if MAJOR_VERSION <= 6
    memcpy(halDescriptor->name, descriptor.name.data(), descriptor.name.size());
    memcpy(halDescriptor->implementor, descriptor.implementor.data(),
           descriptor.implementor.size());
#else
    // According to 'dumpEffectDescriptor' 'name' and 'implementor' must be NUL-terminated.
    size_t nameSize = descriptor.name.size();
    if (nameSize >= ARRAY_SIZE(halDescriptor->name)) {
        ALOGE("effect name is too long: %zu (%zu max)", nameSize,
              ARRAY_SIZE(halDescriptor->name) - 1);
        nameSize = ARRAY_SIZE(halDescriptor->name) - 1;
        result = BAD_VALUE;
    }
    strncpy(halDescriptor->name, descriptor.name.c_str(), nameSize);
    halDescriptor->name[nameSize] = '\0';
    size_t implementorSize = descriptor.implementor.size();
    if (implementorSize >= ARRAY_SIZE(halDescriptor->implementor)) {
        ALOGE("effect implementor is too long: %zu (%zu max)", implementorSize,
              ARRAY_SIZE(halDescriptor->implementor) - 1);
        implementorSize = ARRAY_SIZE(halDescriptor->implementor) - 1;
        result = BAD_VALUE;
    }
    strncpy(halDescriptor->implementor, descriptor.implementor.c_str(), implementorSize);
    halDescriptor->implementor[implementorSize] = '\0';
#endif
    return result;
}

}  // namespace implementation
}  // namespace CPP_VERSION
}  // namespace effect
}  // namespace audio
}  // namespace hardware
}  // namespace android