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

Commit f56ce78b authored by Mikhail Naganov's avatar Mikhail Naganov
Browse files

libaudiohal: Implement stream opening 

Implement DeviceHalAidl::open{Input|Output}Stream,
DeviceHalAidl::{create|release}AudioPatch,
StreamHalAidl::getAudioProperties.

Bug: 205884982
Test: boot cuttlefish with AIDL enabled
Change-Id: I535c302dd791d4c002883ac73efc71ad0f39a83f
parent 1b3d28ec

media/libaudiohal/impl/DeviceHalAidl.cpp

+525 −33

File changed.

Preview size limit exceeded, changes collapsed.

media/libaudiohal/impl/DeviceHalAidl.h

+72 −8
Original line number Diff line number Diff line
@@ -16,8 +16,12 @@ 


#pragma once



#include <aidl/android/hardware/audio/core/sounddose/BpSoundDose.h>

#include <map>

#include <set>

#include <vector>



#include <aidl/android/hardware/audio/core/BpModule.h>

#include <aidl/android/hardware/audio/core/sounddose/BpSoundDose.h>

#include <media/audiohal/DeviceHalInterface.h>

#include <media/audiohal/EffectHalInterface.h>
@@ -123,17 +127,77 @@ class DeviceHalAidl : public DeviceHalInterface, public ConversionHelperAidl { 


  private:

    friend class sp<DeviceHalAidl>;

    using Patches = std::map<int32_t /*patch ID*/,

            ::aidl::android::hardware::audio::core::AudioPatch>;

    using PortConfigs = std::map<int32_t /*port config ID*/,

            ::aidl::android::media::audio::common::AudioPortConfig>;

    using Ports = std::map<int32_t /*port ID*/, ::aidl::android::media::audio::common::AudioPort>;

    class Cleanups;



    // Must not be constructed directly by clients.

    DeviceHalAidl(

            const std::string& instance,

            const std::shared_ptr<::aidl::android::hardware::audio::core::IModule>& module)

            : ConversionHelperAidl("DeviceHalAidl"), mInstance(instance), mModule(module) {}



    ~DeviceHalAidl() override = default;



    status_t createPortConfig(

            const ::aidl::android::media::audio::common::AudioPortConfig& requestedPortConfig,

            ::aidl::android::media::audio::common::AudioPortConfig* appliedPortConfig);

    status_t findOrCreatePatch(

        const std::set<int32_t>& sourcePortConfigIds,

        const std::set<int32_t>& sinkPortConfigIds,

        ::aidl::android::hardware::audio::core::AudioPatch* patch, bool* created);

    status_t findOrCreatePatch(

        const ::aidl::android::hardware::audio::core::AudioPatch& requestedPatch,

        ::aidl::android::hardware::audio::core::AudioPatch* patch, bool* created);

    status_t findOrCreatePortConfig(

            const ::aidl::android::media::audio::common::AudioDevice& device,

            ::aidl::android::media::audio::common::AudioPortConfig* portConfig,

            bool* created);

    status_t findOrCreatePortConfig(

            const ::aidl::android::media::audio::common::AudioConfig& config,

            const ::aidl::android::media::audio::common::AudioIoFlags& flags,

            int32_t ioHandle,

            ::aidl::android::media::audio::common::AudioPortConfig* portConfig, bool* created);

    status_t findOrCreatePortConfig(

        const ::aidl::android::media::audio::common::AudioPortConfig& requestedPortConfig,

        ::aidl::android::media::audio::common::AudioPortConfig* portConfig, bool* created);

    Patches::iterator findPatch(const std::set<int32_t>& sourcePortConfigIds,

            const std::set<int32_t>& sinkPortConfigIds);

    Ports::iterator findPort(const ::aidl::android::media::audio::common::AudioDevice& device);

    Ports::iterator findPort(

            const ::aidl::android::media::audio::common::AudioConfig& config,

            const ::aidl::android::media::audio::common::AudioIoFlags& flags);

    PortConfigs::iterator findPortConfig(

            const ::aidl::android::media::audio::common::AudioDevice& device);

    PortConfigs::iterator findPortConfig(

            const ::aidl::android::media::audio::common::AudioConfig& config,

            const ::aidl::android::media::audio::common::AudioIoFlags& flags,

            int32_t ioHandle);

    // Currently unused but may be useful for implementing setAudioPortConfig

    // PortConfigs::iterator findPortConfig(

    //         const ::aidl::android::media::audio::common::AudioPortConfig& portConfig);

    status_t prepareToOpenStream(

        int32_t aidlHandle,

        const ::aidl::android::media::audio::common::AudioDevice& aidlDevice,

        const ::aidl::android::media::audio::common::AudioIoFlags& aidlFlags,

        struct audio_config* config,

        Cleanups* cleanups,

        ::aidl::android::media::audio::common::AudioConfig* aidlConfig,

        ::aidl::android::media::audio::common::AudioPortConfig* mixPortConfig);

    void resetPatch(int32_t patchId);

    void resetPortConfig(int32_t portConfigId);



    const std::string mInstance;

    const std::shared_ptr<::aidl::android::hardware::audio::core::IModule> mModule;

    std::shared_ptr<::aidl::android::hardware::audio::core::sounddose::ISoundDose>

        mSoundDose = nullptr;



    // Can not be constructed directly by clients.

    explicit DeviceHalAidl(

            const std::shared_ptr<::aidl::android::hardware::audio::core::IModule>& module)

            : ConversionHelperAidl("DeviceHalAidl"), mModule(module) {}



    ~DeviceHalAidl() override = default;

    Ports mPorts;

    PortConfigs mPortConfigs;

    Patches mPatches;

    std::map<audio_patch_handle_t, int32_t /* patch ID */> mFwkHandles;

};



} // namespace android

media/libaudiohal/impl/DevicesFactoryHalAidl.cpp

+1 −1
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ status_t DevicesFactoryHalAidl::openDevice(const char *name, sp<DeviceHalInterfa 
    }

    // If the service is a nullptr, the device will not be really functional,

    // but will not crash either.

    *device = sp<DeviceHalAidl>::make(service);

    *device = sp<DeviceHalAidl>::make(name, service);

    return OK;

}

media/libaudiohal/impl/StreamHalAidl.cpp

+75 −37
Original line number Diff line number Diff line
@@ -46,10 +46,11 @@ std::shared_ptr<IStreamCommon> StreamHalAidl::getStreamCommon(const std::shared_ 
}



StreamHalAidl::StreamHalAidl(

        std::string_view className, bool isInput, const StreamDescriptor& descriptor,

        const std::shared_ptr<IStreamCommon>& stream)

        std::string_view className, bool isInput, const audio_config& config,

        const StreamDescriptor& descriptor, const std::shared_ptr<IStreamCommon>& stream)

        : ConversionHelperAidl(className),

          mIsInput(isInput),

          mConfig(configToBase(config)),

          mFrameSizeBytes(descriptor.frameSizeBytes),

          mBufferSizeFrames(descriptor.bufferSizeFrames),

          mCommandMQ(new CommandMQ(descriptor.command)),
@@ -76,7 +77,7 @@ status_t StreamHalAidl::getBufferSize(size_t *size) { 
    if (size == nullptr) {

        return BAD_VALUE;

    }

    if (mFrameSizeBytes == 0 || mBufferSizeFrames == 0) {

    if (mFrameSizeBytes == 0 || mBufferSizeFrames == 0 || !mStream) {

        return NO_INIT;

    }

    *size = mFrameSizeBytes * mBufferSizeFrames;
@@ -87,13 +88,8 @@ status_t StreamHalAidl::getAudioProperties(audio_config_base_t *configBase) { 
    if (configBase == nullptr) {

        return BAD_VALUE;

    }

    TIME_CHECK();

    *configBase = AUDIO_CONFIG_BASE_INITIALIZER;

    configBase->sample_rate = 48000;

    configBase->format = AUDIO_FORMAT_PCM_24_BIT_PACKED;

    configBase->channel_mask = mIsInput ? AUDIO_CHANNEL_IN_STEREO : AUDIO_CHANNEL_OUT_STEREO;

    // if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    if (!mStream) return NO_INIT;

    *configBase = mConfig;

    return OK;

}
@@ -116,7 +112,7 @@ status_t StreamHalAidl::getFrameSize(size_t *size) { 
    if (size == nullptr) {

        return BAD_VALUE;

    }

    if (mFrameSizeBytes == 0) {

    if (mFrameSizeBytes == 0 || !mStream) {

        return NO_INIT;

    }

    *size = mFrameSizeBytes;
@@ -140,6 +136,9 @@ status_t StreamHalAidl::removeEffect(sp<EffectHalInterface> effect __unused) { 
status_t StreamHalAidl::standby() {

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    if (mState == StreamDescriptor::State::STANDBY) {

        return OK;

    }

    ALOGE("%s not implemented yet", __func__);

    return OK;

}
@@ -180,7 +179,7 @@ status_t StreamHalAidl::getMmapPosition(struct audio_mmap_position *position __u 
}



status_t StreamHalAidl::setHalThreadPriority(int priority __unused) {

    mHalThreadPriority = priority;

    // Obsolete, must be done by the HAL module.

    return OK;

}
@@ -192,13 +191,9 @@ status_t StreamHalAidl::getHalPid(pid_t *pid __unused) { 
}



bool StreamHalAidl::requestHalThreadPriority(pid_t threadPid __unused, pid_t threadId __unused) {

    if (mHalThreadPriority == HAL_THREAD_PRIORITY_DEFAULT) {

    // Obsolete, must be done by the HAL module.

    return true;

}

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamHalAidl::legacyCreateAudioPatch(const struct audio_port_config& port __unused,

                                               std::optional<audio_source_t> source __unused,
@@ -244,8 +239,10 @@ class StreamCallback : public ::aidl::android::hardware::audio::core::BnStreamCa 
}  // namespace



StreamOutHalAidl::StreamOutHalAidl(

        const audio_config& config,

        const StreamDescriptor& descriptor, const std::shared_ptr<IStreamOut>& stream)

        : StreamHalAidl("StreamOutHalAidl", false /*isInput*/, descriptor, getStreamCommon(stream)),

        : StreamHalAidl("StreamOutHalAidl", false /*isInput*/, config,

                descriptor, getStreamCommon(stream)),

          mStream(stream) {}



status_t StreamOutHalAidl::getLatency(uint32_t *latency) {
@@ -360,34 +357,55 @@ status_t StreamOutHalAidl::updateSourceMetadata( 
}



status_t StreamOutHalAidl::getDualMonoMode(audio_dual_mono_mode_t* mode __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::setDualMonoMode(audio_dual_mono_mode_t mode __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::getAudioDescriptionMixLevel(float* leveldB __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::setAudioDescriptionMixLevel(float leveldB __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::getPlaybackRateParameters(

        audio_playback_rate_t* playbackRate __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::setPlaybackRateParameters(

        const audio_playback_rate_t& playbackRate __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamOutHalAidl::setEventCallback(

        const sp<StreamOutHalInterfaceEventCallback>& callback __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



namespace {
@@ -401,17 +419,26 @@ struct StreamOutEventCallback { 
}  // namespace



status_t StreamOutHalAidl::setLatencyMode(audio_latency_mode_t mode __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

};



status_t StreamOutHalAidl::getRecommendedLatencyModes(

        std::vector<audio_latency_mode_t> *modes __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

};



status_t StreamOutHalAidl::setLatencyModeCallback(

        const sp<StreamOutHalInterfaceLatencyModeCallback>& callback __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

};



void StreamOutHalAidl::onWriteReady() {
@@ -458,8 +485,10 @@ status_t StreamOutHalAidl::exit() { 
}



StreamInHalAidl::StreamInHalAidl(

        const audio_config& config,

        const StreamDescriptor& descriptor, const std::shared_ptr<IStreamIn>& stream)

        : StreamHalAidl("StreamInHalAidl", true /*isInput*/, descriptor, getStreamCommon(stream)),

        : StreamHalAidl("StreamInHalAidl", true /*isInput*/, config,

                descriptor, getStreamCommon(stream)),

          mStream(stream) {}



status_t StreamInHalAidl::setGain(float gain __unused) {
@@ -494,24 +523,33 @@ status_t StreamInHalAidl::getCapturePosition(int64_t *frames __unused, int64_t * 


status_t StreamInHalAidl::getActiveMicrophones(

        std::vector<media::MicrophoneInfo> *microphones __unused) {

    if (mStream == 0) return NO_INIT;

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamInHalAidl::updateSinkMetadata(

        const StreamInHalInterface::SinkMetadata& sinkMetadata  __unused) {

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamInHalAidl::setPreferredMicrophoneDirection(

            audio_microphone_direction_t direction __unused) {

    if (mStream == 0) return NO_INIT;

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



status_t StreamInHalAidl::setPreferredMicrophoneFieldDimension(float zoom __unused) {

    if (mStream == 0) return NO_INIT;

    return INVALID_OPERATION;

    TIME_CHECK();

    if (!mStream) return NO_INIT;

    ALOGE("%s not implemented yet", __func__);

    return OK;

}



} // namespace android

media/libaudiohal/impl/StreamHalAidl.h

+13 −2
Original line number Diff line number Diff line
@@ -101,6 +101,7 @@ class StreamHalAidl : public virtual StreamHalInterface, public ConversionHelper 
    // Subclasses can not be constructed directly by clients.

    StreamHalAidl(std::string_view className,

            bool isInput,

            const audio_config& config,

            const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor,

            const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamCommon>& stream);
@@ -111,6 +112,7 @@ class StreamHalAidl : public virtual StreamHalInterface, public ConversionHelper 
    bool requestHalThreadPriority(pid_t threadPid, pid_t threadId);



    const bool mIsInput;

    const audio_config_base_t mConfig;

    const size_t mFrameSizeBytes;

    const size_t mBufferSizeFrames;

    const std::unique_ptr<CommandMQ> mCommandMQ;
@@ -118,8 +120,17 @@ class StreamHalAidl : public virtual StreamHalInterface, public ConversionHelper 
    const std::unique_ptr<DataMQ> mDataMQ;

    // mStreamPowerLog is used for audio signal power logging.

    StreamPowerLog mStreamPowerLog;

    ::aidl::android::hardware::audio::core::StreamDescriptor::State mState =

              ::aidl::android::hardware::audio::core::StreamDescriptor::State::STANDBY;



  private:

    static audio_config_base_t configToBase(const audio_config& config) {

        audio_config_base_t result = AUDIO_CONFIG_BASE_INITIALIZER;

        result.sample_rate = config.sample_rate;

        result.channel_mask = config.channel_mask;

        result.format = config.format;

        return result;

    }

    static std::unique_ptr<DataMQ> maybeCreateDataMQ(

            const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor) {

        using Tag = ::aidl::android::hardware::audio::core::StreamDescriptor::AudioBuffer::Tag;
@@ -129,9 +140,7 @@ class StreamHalAidl : public virtual StreamHalInterface, public ConversionHelper 
        return nullptr;

    }



    const int HAL_THREAD_PRIORITY_DEFAULT = -1;

    const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamCommon> mStream;

    int mHalThreadPriority = HAL_THREAD_PRIORITY_DEFAULT;

};



class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl {
@@ -230,6 +239,7 @@ class StreamOutHalAidl : public StreamOutHalInterface, public StreamHalAidl { 


    // Can not be constructed directly by clients.

    StreamOutHalAidl(

            const audio_config& config,

            const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor,

            const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamOut>& stream);
@@ -271,6 +281,7 @@ class StreamInHalAidl : public StreamInHalInterface, public StreamHalAidl { 


    // Can not be constructed directly by clients.

    StreamInHalAidl(

            const audio_config& config,

            const ::aidl::android::hardware::audio::core::StreamDescriptor& descriptor,

            const std::shared_ptr<::aidl::android::hardware::audio::core::IStreamIn>& stream);