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

Commit 1db5a61a authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge changes I97fd41f8,Iab3c970b am: 98319e92 

Original change: https://android-review.googlesource.com/c/platform/hardware/interfaces/+/2381017



Change-Id: I615f96e0df393282b12f24a8fceb8e4c6839e749
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 8047dfe2 98319e92

audio/aidl/default/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -69,6 +69,7 @@ cc_library_static { 
        "Module.cpp",

        "SoundDose.cpp",

        "Stream.cpp",

        "StreamStub.cpp",

        "Telephony.cpp",

    ],

    generated_sources: [

audio/aidl/default/Module.cpp

+15 −10
Original line number Diff line number Diff line
@@ -28,6 +28,7 @@ 
#include "core-impl/Bluetooth.h"

#include "core-impl/Module.h"

#include "core-impl/SoundDose.h"

#include "core-impl/StreamStub.h"

#include "core-impl/Telephony.h"

#include "core-impl/utils.h"
@@ -102,9 +103,10 @@ void Module::cleanUpPatch(int32_t patchId) { 
    erase_all_values(mPatches, std::set<int32_t>{patchId});

}



ndk::ScopedAStatus Module::createStreamContext(int32_t in_portConfigId, int64_t in_bufferSizeFrames,

ndk::ScopedAStatus Module::createStreamContext(

        int32_t in_portConfigId, int64_t in_bufferSizeFrames,

        std::shared_ptr<IStreamCallback> asyncCallback,

                                               StreamContext* out_context) {

        std::shared_ptr<IStreamOutEventCallback> outEventCallback, StreamContext* out_context) {

    if (in_bufferSizeFrames <= 0) {

        LOG(ERROR) << __func__ << ": non-positive buffer size " << in_bufferSizeFrames;

        return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
@@ -147,7 +149,7 @@ ndk::ScopedAStatus Module::createStreamContext(int32_t in_portConfigId, int64_t 
                std::make_unique<StreamContext::ReplyMQ>(1, true /*configureEventFlagWord*/),

                portConfigIt->format.value(), portConfigIt->channelMask.value(),

                std::make_unique<StreamContext::DataMQ>(frameSize * in_bufferSizeFrames),

                asyncCallback, params);

                asyncCallback, outEventCallback, params);

        if (temp.isValid()) {

            *out_context = std::move(temp);

        } else {
@@ -545,13 +547,14 @@ ndk::ScopedAStatus Module::openInputStream(const OpenInputStreamArguments& in_ar 
    }

    StreamContext context;

    if (auto status = createStreamContext(in_args.portConfigId, in_args.bufferSizeFrames, nullptr,

                                          &context);

                                          nullptr, &context);

        !status.isOk()) {

        return status;

    }

    context.fillDescriptor(&_aidl_return->desc);

    std::shared_ptr<StreamIn> stream;

    if (auto status = StreamIn::createInstance(in_args.sinkMetadata, std::move(context),

    // TODO: Add a mapping from module instance names to a corresponding 'createInstance'.

    if (auto status = StreamInStub::createInstance(in_args.sinkMetadata, std::move(context),

                                                   mConfig->microphones, &stream);

        !status.isOk()) {

        return status;
@@ -598,13 +601,15 @@ ndk::ScopedAStatus Module::openOutputStream(const OpenOutputStreamArguments& in_ 
    }

    StreamContext context;

    if (auto status = createStreamContext(in_args.portConfigId, in_args.bufferSizeFrames,

                                          isNonBlocking ? in_args.callback : nullptr, &context);

                                          isNonBlocking ? in_args.callback : nullptr,

                                          in_args.eventCallback, &context);

        !status.isOk()) {

        return status;

    }

    context.fillDescriptor(&_aidl_return->desc);

    std::shared_ptr<StreamOut> stream;

    if (auto status = StreamOut::createInstance(in_args.sourceMetadata, std::move(context),

    // TODO: Add a mapping from module instance names to a corresponding 'createInstance'.

    if (auto status = StreamOutStub::createInstance(in_args.sourceMetadata, std::move(context),

                                                    in_args.offloadInfo, &stream);

        !status.isOk()) {

        return status;

audio/aidl/default/Stream.cpp

+153 −108

File changed.

Preview size limit exceeded, changes collapsed.

audio/aidl/default/StreamStub.cpp

0 → 100644
+125 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2023 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.

 */



#define LOG_TAG "AHAL_Stream"

#include <android-base/logging.h>



#include "core-impl/Module.h"

#include "core-impl/StreamStub.h"



using aidl::android::hardware::audio::common::SinkMetadata;

using aidl::android::hardware::audio::common::SourceMetadata;

using aidl::android::media::audio::common::AudioOffloadInfo;



namespace aidl::android::hardware::audio::core {



DriverStub::DriverStub(const StreamContext& context, bool isInput)

    : mFrameSizeBytes(context.getFrameSize()), mIsInput(isInput) {}



::android::status_t DriverStub::init() {

    usleep(1000);

    return ::android::OK;

}



::android::status_t DriverStub::drain(StreamDescriptor::DrainMode) {

    usleep(1000);

    return ::android::OK;

}



::android::status_t DriverStub::flush() {

    usleep(1000);

    return ::android::OK;

}



::android::status_t DriverStub::pause() {

    usleep(1000);

    return ::android::OK;

}



::android::status_t DriverStub::transfer(void* buffer, size_t frameCount, size_t* actualFrameCount,

                                         int32_t* latencyMs) {

    usleep(3000);

    if (mIsInput) {

        uint8_t* byteBuffer = static_cast<uint8_t*>(buffer);

        for (size_t i = 0; i < frameCount * mFrameSizeBytes; ++i) {

            byteBuffer[i] = std::rand() % 255;

        }

    }

    *actualFrameCount = frameCount;

    *latencyMs = Module::kLatencyMs;

    return ::android::OK;

}



::android::status_t DriverStub::standby() {

    usleep(1000);

    return ::android::OK;

}



// static

ndk::ScopedAStatus StreamInStub::createInstance(const SinkMetadata& sinkMetadata,

                                                StreamContext&& context,

                                                const std::vector<MicrophoneInfo>& microphones,

                                                std::shared_ptr<StreamIn>* result) {

    std::shared_ptr<StreamIn> stream =

            ndk::SharedRefBase::make<StreamInStub>(sinkMetadata, std::move(context), microphones);

    if (auto status = initInstance(stream); !status.isOk()) {

        return status;

    }

    *result = std::move(stream);

    return ndk::ScopedAStatus::ok();

}



StreamInStub::StreamInStub(const SinkMetadata& sinkMetadata, StreamContext&& context,

                           const std::vector<MicrophoneInfo>& microphones)

    : StreamIn(

              sinkMetadata, std::move(context),

              [](const StreamContext& ctx) -> DriverInterface* {

                  return new DriverStub(ctx, true /*isInput*/);

              },

              [](const StreamContext& ctx, DriverInterface* driver) -> StreamWorkerInterface* {

                  // The default worker implementation is used.

                  return new StreamInWorker(ctx, driver);

              },

              microphones) {}



// static

ndk::ScopedAStatus StreamOutStub::createInstance(const SourceMetadata& sourceMetadata,

                                                 StreamContext&& context,

                                                 const std::optional<AudioOffloadInfo>& offloadInfo,

                                                 std::shared_ptr<StreamOut>* result) {

    std::shared_ptr<StreamOut> stream = ndk::SharedRefBase::make<StreamOutStub>(

            sourceMetadata, std::move(context), offloadInfo);

    if (auto status = initInstance(stream); !status.isOk()) {

        return status;

    }

    *result = std::move(stream);

    return ndk::ScopedAStatus::ok();

}



StreamOutStub::StreamOutStub(const SourceMetadata& sourceMetadata, StreamContext&& context,

                             const std::optional<AudioOffloadInfo>& offloadInfo)

    : StreamOut(

              sourceMetadata, std::move(context),

              [](const StreamContext& ctx) -> DriverInterface* {

                  return new DriverStub(ctx, false /*isInput*/);

              },

              [](const StreamContext& ctx, DriverInterface* driver) -> StreamWorkerInterface* {

                  // The default worker implementation is used.

                  return new StreamOutWorker(ctx, driver);

              },

              offloadInfo) {}



}  // namespace aidl::android::hardware::audio::core

audio/aidl/default/include/core-impl/Module.h

+1 −0
Original line number Diff line number Diff line
@@ -115,6 +115,7 @@ class Module : public BnModule { 
    ndk::ScopedAStatus createStreamContext(

            int32_t in_portConfigId, int64_t in_bufferSizeFrames,

            std::shared_ptr<IStreamCallback> asyncCallback,

            std::shared_ptr<IStreamOutEventCallback> outEventCallback,

            ::aidl::android::hardware::audio::core::StreamContext* out_context);

    std::vector<::aidl::android::media::audio::common::AudioDevice> findConnectedDevices(

            int32_t portConfigId);