Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ab5c4f07 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Support query microphones information." into pi-dev

parents d83bad7d 1b09e269

audio/core/all-versions/default/include/core/all-versions/default/Conversions.h

+5 −0
Original line number Diff line number Diff line
@@ -30,6 +30,11 @@ using ::android::hardware::audio::AUDIO_HAL_VERSION::DeviceAddress; 


std::string deviceAddressToHal(const DeviceAddress& address);



#ifdef AUDIO_HAL_VERSION_4_0

bool halToMicrophoneCharacteristics(MicrophoneInfo* pDst,

                                    const struct audio_microphone_characteristic_t& src);

#endif



}  // namespace implementation

}  // namespace AUDIO_HAL_VERSION

}  // namespace audio

audio/core/all-versions/default/include/core/all-versions/default/Conversions.impl.h

+128 −0
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ namespace audio { 
namespace AUDIO_HAL_VERSION {

namespace implementation {



using ::android::hardware::audio::common::AUDIO_HAL_VERSION::AudioDevice;



std::string deviceAddressToHal(const DeviceAddress& address) {

    // HAL assumes that the address is NUL-terminated.

    char halAddress[AUDIO_DEVICE_MAX_ADDRESS_LEN];
@@ -54,6 +56,132 @@ std::string deviceAddressToHal(const DeviceAddress& address) { 
    return halAddress;

}



#ifdef AUDIO_HAL_VERSION_4_0

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;

    }



    const bool isInput = (device & AUDIO_DEVICE_BIT_IN) != 0;

    if (isInput) device &= ~AUDIO_DEVICE_BIT_IN;

    if ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_A2DP) != 0) ||

        (isInput && (device & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {

        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 ((!isInput && (device & AUDIO_DEVICE_OUT_IP) != 0) ||

               (isInput && (device & AUDIO_DEVICE_IN_IP) != 0)) {

        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 ((!isInput && (device & AUDIO_DEVICE_OUT_ALL_USB)) != 0 ||

               (isInput && (device & AUDIO_DEVICE_IN_ALL_USB)) != 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 ((!isInput && (device & AUDIO_DEVICE_OUT_BUS) != 0) ||

               (isInput && (device & AUDIO_DEVICE_IN_BUS) != 0)) {

        address->busAddress = halAddress;

        return OK;

    } else if ((!isInput && (device & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0 ||

               (isInput && (device & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {

        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;

    }

}



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 AUDIO_HAL_VERSION

}  // namespace audio

audio/core/all-versions/default/include/core/all-versions/default/Device.impl.h

+14 −2
Original line number Diff line number Diff line
@@ -332,8 +332,20 @@ Return<void> Device::debug(const hidl_handle& fd, const hidl_vec<hidl_string>& / 


#ifdef AUDIO_HAL_VERSION_4_0

Return<void> Device::getMicrophones(getMicrophones_cb _hidl_cb) {

    // TODO return device microphones

    _hidl_cb(Result::NOT_SUPPORTED, {});

    Result retval = Result::NOT_SUPPORTED;

    size_t actual_mics = AUDIO_MICROPHONE_MAX_COUNT;

    audio_microphone_characteristic_t mic_array[AUDIO_MICROPHONE_MAX_COUNT];



    hidl_vec<MicrophoneInfo> microphones;

    if (mDevice->get_microphones != NULL &&

        mDevice->get_microphones(mDevice, &mic_array[0], &actual_mics) == 0) {

        microphones.resize(actual_mics);

        for (size_t i = 0; i < actual_mics; ++i) {

            halToMicrophoneCharacteristics(&microphones[i], mic_array[i]);

        }

        retval = Result::OK;

    }

    _hidl_cb(retval, microphones);

    return Void();

}

audio/core/all-versions/default/include/core/all-versions/default/StreamIn.impl.h

+17 −1
Original line number Diff line number Diff line
@@ -26,6 +26,8 @@ 


using ::android::hardware::audio::AUDIO_HAL_VERSION::MessageQueueFlagBits;

using ::android::hardware::audio::all_versions::implementation::isGainNormalized;

#include "Conversions.h"

#include "Util.h"



namespace android {

namespace hardware {
@@ -454,7 +456,21 @@ Return<void> StreamIn::updateSinkMetadata(const SinkMetadata& /*sinkMetadata*/) 
}



Return<void> StreamIn::getActiveMicrophones(getActiveMicrophones_cb _hidl_cb) {

    _hidl_cb(Result::NOT_SUPPORTED, {});  // TODO: retrieve from legacy

    Result retval = Result::NOT_SUPPORTED;

    size_t actual_mics = AUDIO_MICROPHONE_MAX_COUNT;

    audio_microphone_characteristic_t mic_array[AUDIO_MICROPHONE_MAX_COUNT];



    hidl_vec<MicrophoneInfo> microphones;

    if (mStream->get_active_microphones != NULL &&

        mStream->get_active_microphones(mStream, &mic_array[0], &actual_mics) == 0) {

        microphones.resize(actual_mics);

        for (size_t i = 0; i < actual_mics; ++i) {

            halToMicrophoneCharacteristics(&microphones[i], mic_array[i]);

        }

        retval = Result::OK;

    }



    _hidl_cb(retval, microphones);

    return Void();

}

#endif