Extract threading logic to EffectThread and other changes

iscle · iscle · commit 4c430372b53d · 2025-04-02T02:43:03.000+02:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -161,6 +161,8 @@ set(FILES
         src/shim.cpp
 
         # Main
+        src/aidl/EffectThread.cpp
+
         src/viper/ViPER.cpp
         src/ViPER4Android.cpp
         src/ViperContext.cpp
diff --git a/src/aidl/EffectThread.cpp b/src/aidl/EffectThread.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2022 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 <cstddef>
+#include <memory>
+
+#define LOG_TAG "AHAL_EffectThread"
+#include <log/log.h>
+#include <pthread.h>
+#include <sys/resource.h>
+
+#include "EffectThread.h"
+#include "EffectTypes.h"
+
+namespace aidl::android::hardware::audio::effect {
+
+    EffectThread::~EffectThread() {
+        destroyThread();
+    }
+
+    RetCode EffectThread::createThread(const std::string& name, int priority) {
+        if (mThread.joinable()) {
+            ALOGW("%s %s thread already created, no-op", mName.c_str(), __func__);
+            return RetCode::SUCCESS;
+        }
+
+        mName = name;
+        mPriority = priority;
+        {
+            std::lock_guard lg(mThreadMutex);
+            mStop = true;
+            mExit = false;
+        }
+
+        mThread = std::thread(&EffectThread::threadLoop, this);
+        ALOGV("%s %s priority %d done", mName.c_str(), __func__, mPriority);
+        return RetCode::SUCCESS;
+    }
+
+    RetCode EffectThread::destroyThread() {
+        {
+            std::lock_guard lg(mThreadMutex);
+            mStop = mExit = true;
+        }
+
+        mCv.notify_one();
+        if (mThread.joinable()) {
+            mThread.join();
+        }
+
+        ALOGV("%s", mName.c_str());
+        return RetCode::SUCCESS;
+    }
+
+    RetCode EffectThread::startThread() {
+        {
+            std::lock_guard lg(mThreadMutex);
+            if (mDraining) {
+                mDraining = false;
+            } else {
+                mStop = false;
+            }
+            mCv.notify_one();
+        }
+
+        ALOGV("%s", mName.c_str());
+        return RetCode::SUCCESS;
+    }
+
+    RetCode EffectThread::stopThread() {
+        {
+            std::lock_guard lg(mThreadMutex);
+            mStop = true;
+            mCv.notify_one();
+        }
+
+        ALOGV("%s", mName.c_str());
+        return RetCode::SUCCESS;
+    }
+
+    RetCode EffectThread::startDraining() {
+        std::lock_guard lg(mThreadMutex);
+        mDraining = true;
+        mCv.notify_one();
+
+        ALOGV("%s", mName.c_str());
+        return RetCode::SUCCESS;
+    }
+
+    RetCode EffectThread::finishDraining() {
+        std::lock_guard lg(mThreadMutex);
+        mDraining = false;
+        mStop = true;
+        mCv.notify_one();
+
+        ALOGV("%s", mName.c_str());
+        return RetCode::SUCCESS;
+    }
+
+    void EffectThread::threadLoop() {
+        pthread_setname_np(pthread_self(), mName.substr(0, kMaxTaskNameLen - 1).c_str());
+        setpriority(PRIO_PROCESS, 0, mPriority);
+        while (true) {
+            {
+                std::unique_lock l(mThreadMutex);
+                ::android::base::ScopedLockAssertion lock_assertion(mThreadMutex);
+                mCv.wait(l, [&]() REQUIRES(mThreadMutex) { return mExit || !mStop; });
+                if (mExit) {
+                    ALOGV("%s threadLoop EXIT!", mName.c_str());
+                    return;
+                }
+            }
+            process();
+        }
+    }
+
+}  // namespace aidl::android::hardware::audio::effect
diff --git a/src/aidl/EffectThread.h b/src/aidl/EffectThread.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+#pragma once
+#include <atomic>
+#include <memory>
+#include <string>
+#include <thread>
+
+#include <android-base/thread_annotations.h>
+#include <fmq/EventFlag.h>
+#include <system/thread_defs.h>
+
+//#include "EffectContext.h"
+#include "EffectTypes.h"
+
+namespace aidl::android::hardware::audio::effect {
+
+    class EffectThread {
+    public:
+        virtual ~EffectThread();
+
+        // called by effect implementation
+        RetCode createThread(const std::string& name, int priority = ANDROID_PRIORITY_URGENT_AUDIO);
+        RetCode destroyThread();
+        RetCode startThread();
+        RetCode stopThread();
+        RetCode startDraining();
+        RetCode finishDraining();
+
+        // Will call process() in a loop if the thread is running.
+        void threadLoop();
+
+        /**
+         * process() call effectProcessImpl() for effect data processing, it is necessary for the
+         * processing to be called under Effect thread mutex mThreadMutex, to avoid the effect state
+         * change before/during data processing, and keep the thread and effect state consistent.
+         */
+        virtual void process() = 0;
+
+    protected:
+        bool mDraining GUARDED_BY(mThreadMutex) = false;
+
+    private:
+        static constexpr int kMaxTaskNameLen = 15;
+
+        std::mutex mThreadMutex;
+        std::condition_variable mCv;
+        bool mStop GUARDED_BY(mThreadMutex) = true;
+        bool mExit GUARDED_BY(mThreadMutex) = false;
+
+        std::thread mThread;
+        int mPriority;
+        std::string mName;
+    };
+}  // namespace aidl::android::hardware::audio::effect
diff --git a/src/aidl/EffectTypes.h b/src/aidl/EffectTypes.h
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2022 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.
+ */
+
+#pragma once
+#include <string>
+
+#include <aidl/android/hardware/audio/effect/BnEffect.h>
+#include <aidl/android/hardware/audio/effect/Range.h>
+#include <android-base/logging.h>
+//#include <system/audio_effects/aidl_effects_utils.h>
+
+typedef binder_exception_t (*EffectCreateFunctor)(
+        const ::aidl::android::media::audio::common::AudioUuid*,
+        std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect>*);
+typedef binder_exception_t (*EffectDestroyFunctor)(
+        const std::shared_ptr<::aidl::android::hardware::audio::effect::IEffect>&);
+typedef binder_exception_t (*EffectQueryFunctor)(
+        const ::aidl::android::media::audio::common::AudioUuid*,
+        ::aidl::android::hardware::audio::effect::Descriptor*);
+
+struct effect_dl_interface_s {
+    EffectCreateFunctor createEffectFunc;
+    EffectDestroyFunctor destroyEffectFunc;
+    EffectQueryFunctor queryEffectFunc;
+};
+
+namespace aidl::android::hardware::audio::effect {
+
+    enum class RetCode {
+        SUCCESS,
+        ERROR_ILLEGAL_PARAMETER, /* Illegal parameter */
+        ERROR_THREAD,            /* Effect thread error */
+        ERROR_NULL_POINTER,      /* NULL pointer */
+        ERROR_ALIGNMENT_ERROR,   /* Memory alignment error */
+        ERROR_BLOCK_SIZE_EXCEED, /* Maximum block size exceeded */
+        ERROR_EFFECT_LIB_ERROR,  /* Effect implementation library error */
+        ERROR_EVENT_FLAG_ERROR   /* Error with effect event flags */
+    };
+
+    static const int INVALID_AUDIO_SESSION_ID = -1;
+
+    inline std::ostream& operator<<(std::ostream& out, const RetCode& code) {
+        switch (code) {
+            case RetCode::SUCCESS:
+                return out << "SUCCESS";
+            case RetCode::ERROR_ILLEGAL_PARAMETER:
+                return out << "ERROR_ILLEGAL_PARAMETER";
+            case RetCode::ERROR_THREAD:
+                return out << "ERROR_THREAD";
+            case RetCode::ERROR_NULL_POINTER:
+                return out << "ERROR_NULL_POINTER";
+            case RetCode::ERROR_ALIGNMENT_ERROR:
+                return out << "ERROR_ALIGNMENT_ERROR";
+            case RetCode::ERROR_BLOCK_SIZE_EXCEED:
+                return out << "ERROR_BLOCK_SIZE_EXCEED";
+            case RetCode::ERROR_EFFECT_LIB_ERROR:
+                return out << "ERROR_EFFECT_LIB_ERROR";
+            case RetCode::ERROR_EVENT_FLAG_ERROR:
+                return out << "ERROR_EVENT_FLAG_ERROR";
+        }
+
+        return out << "EnumError: " << code;
+    }
+
+#define RETURN_IF_ASTATUS_NOT_OK(status, message)                                               \
+    do {                                                                                        \
+        const ::ndk::ScopedAStatus curr_status = (status);                                      \
+        if (!curr_status.isOk()) {                                                              \
+            LOG(ERROR) << __func__ << ": line" << __LINE__                                      \
+                       << " return with status: " << curr_status.getDescription() << (message); \
+            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(                            \
+                    curr_status.getExceptionCode(), (message));                                 \
+        }                                                                                       \
+    } while (0)
+
+#define RETURN_IF(expr, exception, message)                                                  \
+    do {                                                                                     \
+        if (expr) {                                                                          \
+            LOG(ERROR) << __func__ << ": line" << __LINE__ << " return with expr " << #expr; \
+            return ndk::ScopedAStatus::fromExceptionCodeWithMessage((exception), (message)); \
+        }                                                                                    \
+    } while (0)
+
+#define RETURN_OK_IF(expr)                                                                  \
+    do {                                                                                    \
+        if (expr) {                                                                         \
+            LOG(INFO) << __func__ << ": line" << __LINE__ << " return with expr " << #expr; \
+            return ndk::ScopedAStatus::ok();                                                \
+        }                                                                                   \
+    } while (0)
+
+#define RETURN_VALUE_IF(expr, ret, log)                                                       \
+    do {                                                                                      \
+        if (expr) {                                                                           \
+            LOG(ERROR) << __func__ << ": line" << __LINE__ << " return with expr \"" << #expr \
+                       << "\":" << (log);                                                     \
+            return ret;                                                                       \
+        }                                                                                     \
+    } while (0)
+
+#define RETURN_IF_BINDER_EXCEPTION(functor)                                \
+    {                                                                      \
+        binder_exception_t exception = functor;                            \
+        if (EX_NONE != exception) {                                        \
+            LOG(ERROR) << #functor << ": failed with error " << exception; \
+            return ndk::ScopedAStatus::fromExceptionCode(exception);       \
+        }                                                                  \
+    }
+
+/**
+ * Make a Range::$EffectType$Range.
+ * T: The $EffectType$, Visualizer for example.
+ * Tag: The union tag name in $EffectType$ definition, latencyMs for example.
+ * l: The value of Range::$EffectType$Range.min.
+ * r: The value of Range::$EffectType$Range.max.
+ */
+#define MAKE_RANGE(T, Tag, l, r) \
+    { .min = T::make<T::Tag>(l), .max = T::make<T::Tag>(r) }
+
+}  // namespace aidl::android::hardware::audio::effect
diff --git a/src/shim.cpp b/src/shim.cpp
@@ -1,19 +1,20 @@
 #include <string>
+#include <log/log.h>
 
 namespace android::hardware::details {
     void check(bool exp) {
-
+        ALOGE_IF(!exp, "Check failed");
     }
 
     void check(bool exp, const char* message) {
-
+        ALOGE_IF(!exp, "%s", message);
     }
 
     void logError(const std::string &message) {
-
+        ALOGE("%s", message.c_str());
     }
 
     void errorWriteLog(int tag, const char* info) {
-
+        ALOGE("%d: %s", tag, info);
     }
 } // namespace android::hardware::details
diff --git a/src/viper_aidl.cpp b/src/viper_aidl.cpp
diff --git a/src/viper_aidl.h b/src/viper_aidl.h

Original file line number	Diff line number	Diff line change
`@@ -1,19 +1,20 @@`
`1`	`1`	`#include <string>`
	`2`	`+#include <log/log.h>`
`2`	`3`
`3`	`4`	`namespace android::hardware::details {`
`4`	`5`	`void check(bool exp) {`
`5`		`-`
	`6`	`+ ALOGE_IF(!exp, "Check failed");`
`6`	`7`	`}`
`7`	`8`
`8`	`9`	`void check(bool exp, const char* message) {`
`9`		`-`
	`10`	`+ ALOGE_IF(!exp, "%s", message);`
`10`	`11`	`}`
`11`	`12`
`12`	`13`	`void logError(const std::string &message) {`
`13`		`-`
	`14`	`+ ALOGE("%s", message.c_str());`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`void errorWriteLog(int tag, const char* info) {`
`17`		`-`
	`18`	`+ ALOGE("%d: %s", tag, info);`
`18`	`19`	`}`
`19`	`20`	`} // namespace android::hardware::details`