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

Commit 82cb0363 authored by Kevin Rocard's avatar Kevin Rocard
Browse files

Audio V4: Fix issues in the legacy wrapper raised by clang-format 



This patch only contains cosmetic reformatting imposed by clang-format.

Bug: 38184704
Test: compile
Change-Id: I57545f2b8de1e982028ef4794328741d91682e0c
Signed-off-by: default avatarKevin Rocard <krocard@google.com>
parent cb9827c0

audio/2.0/default/Conversions.cpp

+19 −25
Original line number Diff line number Diff line
@@ -31,31 +31,25 @@ std::string deviceAddressToHal(const DeviceAddress& address) { 
    uint32_t halDevice = static_cast<uint32_t>(address.device);

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

    if (isInput) halDevice &= ~AUDIO_DEVICE_BIT_IN;

    if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0)

            || (isInput && (halDevice & AUDIO_DEVICE_IN_BLUETOOTH_A2DP) != 0)) {

        snprintf(halAddress, sizeof(halAddress),

                "%02X:%02X:%02X:%02X:%02X:%02X",

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

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

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

            || (isInput && (halDevice & AUDIO_DEVICE_IN_IP) != 0)) {

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

            || (isInput && (halDevice & AUDIO_DEVICE_IN_ALL_USB) != 0)) {

        snprintf(halAddress, sizeof(halAddress),

                "card=%d;device=%d",

                address.address.alsa.card, address.address.alsa.device);

    } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_BUS) != 0)

            || (isInput && (halDevice & AUDIO_DEVICE_IN_BUS) != 0)) {

        snprintf(halAddress, sizeof(halAddress),

                "%s", address.busAddress.c_str());

    } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_REMOTE_SUBMIX)) != 0

            || (isInput && (halDevice & AUDIO_DEVICE_IN_REMOTE_SUBMIX) != 0)) {

        snprintf(halAddress, sizeof(halAddress),

                "%s", address.rSubmixAddress.c_str());

    } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_IP) != 0) ||

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

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

               (isInput && (halDevice & AUDIO_DEVICE_IN_ALL_USB) != 0)) {

        snprintf(halAddress, sizeof(halAddress), "card=%d;device=%d", address.address.alsa.card,

                 address.address.alsa.device);

    } else if ((!isInput && (halDevice & AUDIO_DEVICE_OUT_BUS) != 0) ||

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

        snprintf(halAddress, sizeof(halAddress), "%s", address.busAddress.c_str());

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

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

        snprintf(halAddress, sizeof(halAddress), "%s", address.rSubmixAddress.c_str());

    }

    return halAddress;

}

audio/2.0/default/Device.cpp

+52 −79
Original line number Diff line number Diff line
@@ -17,9 +17,9 @@ 
#define LOG_TAG "DeviceHAL"

//#define LOG_NDEBUG 0



#include <algorithm>

#include <memory.h>

#include <string.h>

#include <algorithm>



#include <android/log.h>
@@ -38,14 +38,11 @@ namespace audio { 
namespace V2_0 {

namespace implementation {



Device::Device(audio_hw_device_t* device)

        : mDevice(device) {

}

Device::Device(audio_hw_device_t* device) : mDevice(device) {}



Device::~Device() {

    int status = audio_hw_device_close(mDevice);

    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice,

             strerror(-status));

    ALOGW_IF(status, "Error closing audio hw device %p: %s", mDevice, strerror(-status));

    mDevice = nullptr;

}
@@ -98,16 +95,14 @@ Return<Result> Device::setMasterVolume(float volume) { 
        ALOGW("Can not set a master volume (%f) outside [0,1]", volume);

        return Result::INVALID_ARGUMENTS;

    }

    return analyzeStatus("set_master_volume",

                         mDevice->set_master_volume(mDevice, volume));

    return analyzeStatus("set_master_volume", mDevice->set_master_volume(mDevice, volume));

}



Return<void> Device::getMasterVolume(getMasterVolume_cb _hidl_cb) {

    Result retval(Result::NOT_SUPPORTED);

    float volume = 0;

    if (mDevice->get_master_volume != NULL) {

        retval = analyzeStatus("get_master_volume",

                               mDevice->get_master_volume(mDevice, &volume));

        retval = analyzeStatus("get_master_volume", mDevice->get_master_volume(mDevice, &volume));

    }

    _hidl_cb(retval, volume);

    return Void();
@@ -119,8 +114,7 @@ Return<Result> Device::setMicMute(bool mute) { 


Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) {

    bool mute = false;

    Result retval =

        analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));

    Result retval = analyzeStatus("get_mic_mute", mDevice->get_mic_mute(mDevice, &mute));

    _hidl_cb(retval, mute);

    return Void();

}
@@ -128,8 +122,7 @@ Return<void> Device::getMicMute(getMicMute_cb _hidl_cb) { 
Return<Result> Device::setMasterMute(bool mute) {

    Result retval(Result::NOT_SUPPORTED);

    if (mDevice->set_master_mute != NULL) {

        retval = analyzeStatus("set_master_mute",

                               mDevice->set_master_mute(mDevice, mute));

        retval = analyzeStatus("set_master_mute", mDevice->set_master_mute(mDevice, mute));

    }

    return retval;

}
@@ -138,15 +131,13 @@ Return<void> Device::getMasterMute(getMasterMute_cb _hidl_cb) { 
    Result retval(Result::NOT_SUPPORTED);

    bool mute = false;

    if (mDevice->get_master_mute != NULL) {

        retval = analyzeStatus("get_master_mute",

                               mDevice->get_master_mute(mDevice, &mute));

        retval = analyzeStatus("get_master_mute", mDevice->get_master_mute(mDevice, &mute));

    }

    _hidl_cb(retval, mute);

    return Void();

}



Return<void> Device::getInputBufferSize(const AudioConfig& config,

                                        getInputBufferSize_cb _hidl_cb) {

Return<void> Device::getInputBufferSize(const AudioConfig& config, getInputBufferSize_cb _hidl_cb) {

    audio_config_t halConfig;

    HidlUtils::audioConfigToHal(config, &halConfig);

    size_t halBufferSize = mDevice->get_input_buffer_size(mDevice, &halConfig);
@@ -160,10 +151,8 @@ Return<void> Device::getInputBufferSize(const AudioConfig& config, 
    return Void();

}



Return<void> Device::openOutputStream(int32_t ioHandle,

                                      const DeviceAddress& device,

                                      const AudioConfig& config,

                                      AudioOutputFlag flags,

Return<void> Device::openOutputStream(int32_t ioHandle, const DeviceAddress& device,

                                      const AudioConfig& config, AudioOutputFlag flags,

                                      openOutputStream_cb _hidl_cb) {

    audio_config_t halConfig;

    HidlUtils::audioConfigToHal(config, &halConfig);
@@ -172,13 +161,12 @@ Return<void> Device::openOutputStream(int32_t ioHandle, 
        "open_output_stream handle: %d devices: %x flags: %#x "

        "srate: %d format %#x channels %x address %s",

        ioHandle, static_cast<audio_devices_t>(device.device),

        static_cast<audio_output_flags_t>(flags), halConfig.sample_rate,

        halConfig.format, halConfig.channel_mask,

        deviceAddressToHal(device).c_str());

    int status = mDevice->open_output_stream(

        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),

        static_cast<audio_output_flags_t>(flags), &halConfig, &halStream,

        deviceAddressToHal(device).c_str());

        static_cast<audio_output_flags_t>(flags), halConfig.sample_rate, halConfig.format,

        halConfig.channel_mask, deviceAddressToHal(device).c_str());

    int status =

        mDevice->open_output_stream(mDevice, ioHandle, static_cast<audio_devices_t>(device.device),

                                    static_cast<audio_output_flags_t>(flags), &halConfig,

                                    &halStream, deviceAddressToHal(device).c_str());

    ALOGV("open_output_stream status %d stream %p", status, halStream);

    sp<IStreamOut> streamOut;

    if (status == OK) {
@@ -186,16 +174,13 @@ Return<void> Device::openOutputStream(int32_t ioHandle, 
    }

    AudioConfig suggestedConfig;

    HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);

    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut,

             suggestedConfig);

    _hidl_cb(analyzeStatus("open_output_stream", status), streamOut, suggestedConfig);

    return Void();

}



Return<void> Device::openInputStream(int32_t ioHandle,

                                     const DeviceAddress& device,

                                     const AudioConfig& config,

                                     AudioInputFlag flags, AudioSource source,

                                     openInputStream_cb _hidl_cb) {

Return<void> Device::openInputStream(int32_t ioHandle, const DeviceAddress& device,

                                     const AudioConfig& config, AudioInputFlag flags,

                                     AudioSource source, openInputStream_cb _hidl_cb) {

    audio_config_t halConfig;

    HidlUtils::audioConfigToHal(config, &halConfig);

    audio_stream_in_t* halStream;
@@ -203,14 +188,12 @@ Return<void> Device::openInputStream(int32_t ioHandle, 
        "open_input_stream handle: %d devices: %x flags: %#x "

        "srate: %d format %#x channels %x address %s source %d",

        ioHandle, static_cast<audio_devices_t>(device.device),

        static_cast<audio_input_flags_t>(flags), halConfig.sample_rate,

        halConfig.format, halConfig.channel_mask,

        deviceAddressToHal(device).c_str(),

        static_cast<audio_input_flags_t>(flags), halConfig.sample_rate, halConfig.format,

        halConfig.channel_mask, deviceAddressToHal(device).c_str(),

        static_cast<audio_source_t>(source));

    int status = mDevice->open_input_stream(

        mDevice, ioHandle, static_cast<audio_devices_t>(device.device),

        &halConfig, &halStream, static_cast<audio_input_flags_t>(flags),

        deviceAddressToHal(device).c_str(),

        mDevice, ioHandle, static_cast<audio_devices_t>(device.device), &halConfig, &halStream,

        static_cast<audio_input_flags_t>(flags), deviceAddressToHal(device).c_str(),

        static_cast<audio_source_t>(source));

    ALOGV("open_input_stream status %d stream %p", status, halStream);

    sp<IStreamIn> streamIn;
@@ -219,8 +202,7 @@ Return<void> Device::openInputStream(int32_t ioHandle, 
    }

    AudioConfig suggestedConfig;

    HidlUtils::audioConfigFromHal(halConfig, &suggestedConfig);

    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn,

             suggestedConfig);

    _hidl_cb(analyzeStatus("open_input_stream", status), streamIn, suggestedConfig);

    return Void();

}
@@ -234,13 +216,10 @@ Return<void> Device::createAudioPatch(const hidl_vec<AudioPortConfig>& sources, 
    Result retval(Result::NOT_SUPPORTED);

    AudioPatchHandle patch = 0;

    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {

        std::unique_ptr<audio_port_config[]> halSources(

            HidlUtils::audioPortConfigsToHal(sources));

        std::unique_ptr<audio_port_config[]> halSinks(

            HidlUtils::audioPortConfigsToHal(sinks));

        std::unique_ptr<audio_port_config[]> halSources(HidlUtils::audioPortConfigsToHal(sources));

        std::unique_ptr<audio_port_config[]> halSinks(HidlUtils::audioPortConfigsToHal(sinks));

        audio_patch_handle_t halPatch = AUDIO_PATCH_HANDLE_NONE;

        retval = analyzeStatus(

            "create_audio_patch",

        retval = analyzeStatus("create_audio_patch",

                               mDevice->create_audio_patch(mDevice, sources.size(), &halSources[0],

                                                           sinks.size(), &halSinks[0], &halPatch));

        if (retval == Result::OK) {
@@ -255,18 +234,15 @@ Return<Result> Device::releaseAudioPatch(int32_t patch) { 
    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {

        return analyzeStatus(

            "release_audio_patch",

            mDevice->release_audio_patch(

                mDevice, static_cast<audio_patch_handle_t>(patch)));

            mDevice->release_audio_patch(mDevice, static_cast<audio_patch_handle_t>(patch)));

    }

    return Result::NOT_SUPPORTED;

}



Return<void> Device::getAudioPort(const AudioPort& port,

                                  getAudioPort_cb _hidl_cb) {

Return<void> Device::getAudioPort(const AudioPort& port, getAudioPort_cb _hidl_cb) {

    audio_port halPort;

    HidlUtils::audioPortToHal(port, &halPort);

    Result retval = analyzeStatus("get_audio_port",

                                  mDevice->get_audio_port(mDevice, &halPort));

    Result retval = analyzeStatus("get_audio_port", mDevice->get_audio_port(mDevice, &halPort));

    AudioPort resultPort = port;

    if (retval == Result::OK) {

        HidlUtils::audioPortFromHal(halPort, &resultPort);
@@ -279,8 +255,7 @@ Return<Result> Device::setAudioPortConfig(const AudioPortConfig& config) { 
    if (version() >= AUDIO_DEVICE_API_VERSION_3_0) {

        struct audio_port_config halPortConfig;

        HidlUtils::audioPortConfigToHal(config, &halPortConfig);

        return analyzeStatus(

            "set_audio_port_config",

        return analyzeStatus("set_audio_port_config",

                             mDevice->set_audio_port_config(mDevice, &halPortConfig));

    }

    return Result::NOT_SUPPORTED;
@@ -296,14 +271,12 @@ Return<Result> Device::setScreenState(bool turnedOn) { 
    return setParam(AudioParameter::keyScreenState, turnedOn);

}



Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys,

                                   getParameters_cb _hidl_cb) {

Return<void> Device::getParameters(const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb) {

    getParametersImpl(keys, _hidl_cb);

    return Void();

}



Return<Result> Device::setParameters(

    const hidl_vec<ParameterValue>& parameters) {

Return<Result> Device::setParameters(const hidl_vec<ParameterValue>& parameters) {

    return setParametersImpl(parameters);

}

audio/2.0/default/Device.h

+31 −39
Original line number Diff line number Diff line
@@ -19,8 +19,8 @@ 


#include <memory>



#include <media/AudioParameter.h>

#include <hardware/audio.h>

#include <media/AudioParameter.h>



#include <android/hardware/audio/2.0/IDevice.h>

#include <hidl/Status.h>
@@ -66,24 +66,16 @@ struct Device : public IDevice, public ParametersUtil { 
    Return<void> getMicMute(getMicMute_cb _hidl_cb) override;

    Return<Result> setMasterMute(bool mute) override;

    Return<void> getMasterMute(getMasterMute_cb _hidl_cb) override;

    Return<void> getInputBufferSize(

            const AudioConfig& config, getInputBufferSize_cb _hidl_cb)  override;

    Return<void> openOutputStream(

            int32_t ioHandle,

            const DeviceAddress& device,

            const AudioConfig& config,

            AudioOutputFlag flags,

    Return<void> getInputBufferSize(const AudioConfig& config,

                                    getInputBufferSize_cb _hidl_cb) override;

    Return<void> openOutputStream(int32_t ioHandle, const DeviceAddress& device,

                                  const AudioConfig& config, AudioOutputFlag flags,

                                  openOutputStream_cb _hidl_cb) override;

    Return<void> openInputStream(

            int32_t ioHandle,

            const DeviceAddress& device,

            const AudioConfig& config,

            AudioInputFlag flags,

            AudioSource source,

            openInputStream_cb _hidl_cb)  override;

    Return<void> openInputStream(int32_t ioHandle, const DeviceAddress& device,

                                 const AudioConfig& config, AudioInputFlag flags,

                                 AudioSource source, openInputStream_cb _hidl_cb) override;

    Return<bool> supportsAudioPatches() override;

    Return<void> createAudioPatch(

            const hidl_vec<AudioPortConfig>& sources,

    Return<void> createAudioPatch(const hidl_vec<AudioPortConfig>& sources,

                                  const hidl_vec<AudioPortConfig>& sinks,

                                  createAudioPatch_cb _hidl_cb) override;

    Return<Result> releaseAudioPatch(int32_t patch) override;
@@ -91,8 +83,8 @@ struct Device : public IDevice, public ParametersUtil { 
    Return<Result> setAudioPortConfig(const AudioPortConfig& config) override;

    Return<AudioHwSync> getHwAvSync() override;

    Return<Result> setScreenState(bool turnedOn) override;

    Return<void> getParameters(

            const hidl_vec<hidl_string>& keys, getParameters_cb _hidl_cb)  override;

    Return<void> getParameters(const hidl_vec<hidl_string>& keys,

                               getParameters_cb _hidl_cb) override;

    Return<Result> setParameters(const hidl_vec<ParameterValue>& parameters) override;

    Return<void> debugDump(const hidl_handle& fd) override;

audio/2.0/default/DevicesFactory.cpp

+19 −16
Original line number Diff line number Diff line
@@ -33,31 +33,35 @@ namespace implementation { 
// static

const char* DevicesFactory::deviceToString(IDevicesFactory::Device device) {

    switch (device) {

        case IDevicesFactory::Device::PRIMARY: return AUDIO_HARDWARE_MODULE_ID_PRIMARY;

        case IDevicesFactory::Device::A2DP: return AUDIO_HARDWARE_MODULE_ID_A2DP;

        case IDevicesFactory::Device::USB: return AUDIO_HARDWARE_MODULE_ID_USB;

        case IDevicesFactory::Device::R_SUBMIX: return AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX;

        case IDevicesFactory::Device::STUB: return AUDIO_HARDWARE_MODULE_ID_STUB;

        case IDevicesFactory::Device::PRIMARY:

            return AUDIO_HARDWARE_MODULE_ID_PRIMARY;

        case IDevicesFactory::Device::A2DP:

            return AUDIO_HARDWARE_MODULE_ID_A2DP;

        case IDevicesFactory::Device::USB:

            return AUDIO_HARDWARE_MODULE_ID_USB;

        case IDevicesFactory::Device::R_SUBMIX:

            return AUDIO_HARDWARE_MODULE_ID_REMOTE_SUBMIX;

        case IDevicesFactory::Device::STUB:

            return AUDIO_HARDWARE_MODULE_ID_STUB;

    }

    return nullptr;

}



// static

int DevicesFactory::loadAudioInterface(const char *if_name, audio_hw_device_t **dev)

{

int DevicesFactory::loadAudioInterface(const char* if_name, audio_hw_device_t** dev) {

    const hw_module_t* mod;

    int rc;



    rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod);

    if (rc) {

        ALOGE("%s couldn't load audio hw module %s.%s (%s)", __func__,

                AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));

        ALOGE("%s couldn't load audio hw module %s.%s (%s)", __func__, AUDIO_HARDWARE_MODULE_ID,

              if_name, strerror(-rc));

        goto out;

    }

    rc = audio_hw_device_open(mod, dev);

    if (rc) {

        ALOGE("%s couldn't open audio hw device in %s.%s (%s)", __func__,

                AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));

        ALOGE("%s couldn't open audio hw device in %s.%s (%s)", __func__, AUDIO_HARDWARE_MODULE_ID,

              if_name, strerror(-rc));

        goto out;

    }

    if ((*dev)->common.version < AUDIO_DEVICE_API_VERSION_MIN) {
@@ -85,8 +89,7 @@ Return<void> DevicesFactory::openDevice(IDevicesFactory::Device device, openDevi 
            if (device == IDevicesFactory::Device::PRIMARY) {

                result = new PrimaryDevice(halDevice);

            } else {

                result = new ::android::hardware::audio::V2_0::implementation::

                    Device(halDevice);

                result = new ::android::hardware::audio::V2_0::implementation::Device(halDevice);

            }

            retval = Result::OK;

        } else if (halStatus == -EINVAL) {

audio/2.0/default/DevicesFactory.h

+3 −4
Original line number Diff line number Diff line
@@ -45,7 +45,6 @@ struct DevicesFactory : public IDevicesFactory { 
   private:

    static const char* deviceToString(IDevicesFactory::Device device);

    static int loadAudioInterface(const char* if_name, audio_hw_device_t** dev);



};



extern "C" IDevicesFactory* HIDL_FETCH_IDevicesFactory(const char* name);