hardware_interfaces/audio/core/all-versions/default/Conversions.cpp

/*
 * Copyright (C) 2018 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 "core/default/Conversions.h"

#include <stdio.h>

#include <log/log.h>
#include <media/AudioContainers.h>

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

std::string deviceAddressToHal(const DeviceAddress& address) {
    // HAL assumes that the address is NUL-terminated.
    char halAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
    memset(halAddress, 0, sizeof(halAddress));
    uint32_t halDevice = static_cast<uint32_t>(address.device);
    if (getAudioDeviceOutAllA2dpSet().count(halDevice) > 0 ||
        halDevice == AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
        snprintf(halAddress, sizeof(halAddress), "%02X:%02X:%02X:%02X:%02X:%02X",
                 address.address.mac[0], address.address.mac[1], address.address.mac[2],
                 address.address.mac[3], address.address.mac[4], address.address.mac[5]);
    } else if (halDevice == AUDIO_DEVICE_OUT_IP || halDevice == AUDIO_DEVICE_IN_IP) {
        snprintf(halAddress, sizeof(halAddress), "%d.%d.%d.%d", address.address.ipv4[0],
                 address.address.ipv4[1], address.address.ipv4[2], address.address.ipv4[3]);
    } else if (getAudioDeviceOutAllUsbSet().count(halDevice) > 0 ||
               getAudioDeviceInAllUsbSet().count(halDevice) > 0) {
        snprintf(halAddress, sizeof(halAddress), "card=%d;device=%d", address.address.alsa.card,
                 address.address.alsa.device);
    } else if (halDevice == AUDIO_DEVICE_OUT_BUS || halDevice == AUDIO_DEVICE_IN_BUS) {
        snprintf(halAddress, sizeof(halAddress), "%s", address.busAddress.c_str());
    } else if (halDevice == AUDIO_DEVICE_OUT_REMOTE_SUBMIX ||
               halDevice == AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
        snprintf(halAddress, sizeof(halAddress), "%s", address.rSubmixAddress.c_str());
    }
    return halAddress;
}

#if MAJOR_VERSION >= 4
status_t deviceAddressFromHal(audio_devices_t device, const char* halAddress,
                              DeviceAddress* address) {
    if (address == nullptr) {
        return BAD_VALUE;
    }
    address->device = AudioDevice(device);
    if (halAddress == nullptr || strnlen(halAddress, AUDIO_DEVICE_MAX_ADDRESS_LEN) == 0) {
        return OK;
    }

    if (getAudioDeviceOutAllA2dpSet().count(device) > 0 ||
        device == AUDIO_DEVICE_IN_BLUETOOTH_A2DP) {
        int status =
            sscanf(halAddress, "%hhX:%hhX:%hhX:%hhX:%hhX:%hhX", &address->address.mac[0],
                   &address->address.mac[1], &address->address.mac[2], &address->address.mac[3],
                   &address->address.mac[4], &address->address.mac[5]);
        return status == 6 ? OK : BAD_VALUE;
    } else if (device == AUDIO_DEVICE_OUT_IP || device == AUDIO_DEVICE_IN_IP) {
        int status =
            sscanf(halAddress, "%hhu.%hhu.%hhu.%hhu", &address->address.ipv4[0],
                   &address->address.ipv4[1], &address->address.ipv4[2], &address->address.ipv4[3]);
        return status == 4 ? OK : BAD_VALUE;
    } else if (getAudioDeviceOutAllUsbSet().count(device) > 0 ||
               getAudioDeviceInAllUsbSet().count(device) > 0) {
        int status = sscanf(halAddress, "card=%d;device=%d", &address->address.alsa.card,
                            &address->address.alsa.device);
        return status == 2 ? OK : BAD_VALUE;
    } else if (device == AUDIO_DEVICE_OUT_BUS || device == AUDIO_DEVICE_IN_BUS) {
        address->busAddress = halAddress;
        return OK;
    } else if (device == AUDIO_DEVICE_OUT_REMOTE_SUBMIX ||
               device == AUDIO_DEVICE_IN_REMOTE_SUBMIX) {
        address->rSubmixAddress = halAddress;
        return OK;
    }
    address->busAddress = halAddress;
    return OK;
}

AudioMicrophoneChannelMapping halToChannelMapping(audio_microphone_channel_mapping_t mapping) {
    switch (mapping) {
        case AUDIO_MICROPHONE_CHANNEL_MAPPING_UNUSED:
            return AudioMicrophoneChannelMapping::UNUSED;
        case AUDIO_MICROPHONE_CHANNEL_MAPPING_DIRECT:
            return AudioMicrophoneChannelMapping::DIRECT;
        case AUDIO_MICROPHONE_CHANNEL_MAPPING_PROCESSED:
            return AudioMicrophoneChannelMapping::PROCESSED;
        default:
            ALOGE("Invalid channel mapping type: %d", mapping);
            return AudioMicrophoneChannelMapping::UNUSED;
    }
}

AudioMicrophoneLocation halToLocation(audio_microphone_location_t location) {
    switch (location) {
        default:
        case AUDIO_MICROPHONE_LOCATION_UNKNOWN:
            return AudioMicrophoneLocation::UNKNOWN;
        case AUDIO_MICROPHONE_LOCATION_MAINBODY:
            return AudioMicrophoneLocation::MAINBODY;
        case AUDIO_MICROPHONE_LOCATION_MAINBODY_MOVABLE:
            return AudioMicrophoneLocation::MAINBODY_MOVABLE;
        case AUDIO_MICROPHONE_LOCATION_PERIPHERAL:
            return AudioMicrophoneLocation::PERIPHERAL;
    }
}

AudioMicrophoneDirectionality halToDirectionality(audio_microphone_directionality_t dir) {
    switch (dir) {
        default:
        case AUDIO_MICROPHONE_DIRECTIONALITY_UNKNOWN:
            return AudioMicrophoneDirectionality::UNKNOWN;
        case AUDIO_MICROPHONE_DIRECTIONALITY_OMNI:
            return AudioMicrophoneDirectionality::OMNI;
        case AUDIO_MICROPHONE_DIRECTIONALITY_BI_DIRECTIONAL:
            return AudioMicrophoneDirectionality::BI_DIRECTIONAL;
        case AUDIO_MICROPHONE_DIRECTIONALITY_CARDIOID:
            return AudioMicrophoneDirectionality::CARDIOID;
        case AUDIO_MICROPHONE_DIRECTIONALITY_HYPER_CARDIOID:
            return AudioMicrophoneDirectionality::HYPER_CARDIOID;
        case AUDIO_MICROPHONE_DIRECTIONALITY_SUPER_CARDIOID:
            return AudioMicrophoneDirectionality::SUPER_CARDIOID;
    }
}

bool halToMicrophoneCharacteristics(MicrophoneInfo* pDst,
                                    const struct audio_microphone_characteristic_t& src) {
    bool status = false;
    if (pDst != NULL) {
        pDst->deviceId = src.device_id;

        if (deviceAddressFromHal(src.device, src.address, &pDst->deviceAddress) != OK) {
            return false;
        }
        pDst->channelMapping.resize(AUDIO_CHANNEL_COUNT_MAX);
        for (size_t ch = 0; ch < pDst->channelMapping.size(); ch++) {
            pDst->channelMapping[ch] = halToChannelMapping(src.channel_mapping[ch]);
        }
        pDst->location = halToLocation(src.location);
        pDst->group = (AudioMicrophoneGroup)src.group;
        pDst->indexInTheGroup = (uint32_t)src.index_in_the_group;
        pDst->sensitivity = src.sensitivity;
        pDst->maxSpl = src.max_spl;
        pDst->minSpl = src.min_spl;
        pDst->directionality = halToDirectionality(src.directionality);
        pDst->frequencyResponse.resize(src.num_frequency_responses);
        for (size_t k = 0; k < src.num_frequency_responses; k++) {
            pDst->frequencyResponse[k].frequency = src.frequency_responses[0][k];
            pDst->frequencyResponse[k].level = src.frequency_responses[1][k];
        }
        pDst->position.x = src.geometric_location.x;
        pDst->position.y = src.geometric_location.y;
        pDst->position.z = src.geometric_location.z;

        pDst->orientation.x = src.orientation.x;
        pDst->orientation.y = src.orientation.y;
        pDst->orientation.z = src.orientation.z;

        status = true;
    }
    return status;
}
#endif

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