diff --git a/audio/aidl/default/equalizer/Android.bp b/audio/aidl/default/equalizer/Android.bp
index 2a2ddbc..69d7450 100644
--- a/audio/aidl/default/equalizer/Android.bp
+++ b/audio/aidl/default/equalizer/Android.bp
@@ -24,15 +24,9 @@
 }
 
 cc_library_shared {
-    name: "libequalizer",
-    vendor: true,
-    shared_libs: [
-        "libaudioaidlcommon",
-        "libbase",
-        "android.hardware.common-V2-ndk",
-    ],
+    name: "libequalizersw",
     defaults: [
-        "aidlaudioservice_defaults",
+        "aidlaudioeffectservice_defaults",
         "latest_android_media_audio_common_types_ndk_shared",
         "latest_android_hardware_audio_effect_ndk_shared",
     ],
@@ -40,12 +34,6 @@
         "Equalizer.cpp",
         ":effectCommonFile",
     ],
-    cflags: [
-        "-Wall",
-        "-Wextra",
-        "-Werror",
-        "-Wthread-safety",
-    ],
     visibility: [
         "//hardware/interfaces/audio/aidl/default",
     ],
diff --git a/audio/aidl/default/equalizer/Equalizer.cpp b/audio/aidl/default/equalizer/Equalizer.cpp
index 43fa206..0e07d39 100644
--- a/audio/aidl/default/equalizer/Equalizer.cpp
+++ b/audio/aidl/default/equalizer/Equalizer.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include <cstddef>
 #define LOG_TAG "AHAL_EqualizerSw"
 #include <Utils.h>
 #include <algorithm>
@@ -24,11 +25,18 @@
 
 #include "equalizer-impl/EqualizerSw.h"
 
-using android::hardware::audio::common::getFrameSizeInBytes;
+using aidl::android::hardware::audio::effect::EqualizerSw;
+using aidl::android::hardware::audio::effect::EqualizerSwImplUUID;
+using aidl::android::hardware::audio::effect::IEffect;
+using aidl::android::hardware::audio::effect::State;
+using aidl::android::media::audio::common::AudioUuid;
 
-namespace aidl::android::hardware::audio::effect {
-
-extern "C" binder_exception_t createEffect(std::shared_ptr<IEffect>* instanceSpp) {
+extern "C" binder_exception_t createEffect(const AudioUuid* in_impl_uuid,
+                                           std::shared_ptr<IEffect>* instanceSpp) {
+    if (!in_impl_uuid || *in_impl_uuid != EqualizerSwImplUUID) {
+        LOG(ERROR) << __func__ << "uuid not supported";
+        return EX_ILLEGAL_ARGUMENT;
+    }
     if (instanceSpp) {
         *instanceSpp = ndk::SharedRefBase::make<EqualizerSw>();
         LOG(DEBUG) << __func__ << " instance " << instanceSpp->get() << " created";
@@ -51,212 +59,39 @@
     return EX_NONE;
 }
 
-ndk::ScopedAStatus EqualizerSw::open(const Parameter::Common& common,
-                                     const Parameter::Specific& specific,
-                                     OpenEffectReturn* _aidl_return) {
-    LOG(DEBUG) << __func__;
-    if (mState != State::INIT) {
-        LOG(WARNING) << __func__ << " eq already open";
-        return ndk::ScopedAStatus::ok();
-    }
-
-    // Set essential parameters before create worker thread.
-    setCommonParameter(common);
-    setSpecificParameter(specific);
-
-    LOG(DEBUG) << " common: " << common.toString() << " specific " << specific.toString();
-
-    auto& input = common.input;
-    auto& output = common.output;
-    size_t inputFrameSize = getFrameSizeInBytes(input.base.format, input.base.channelMask);
-    size_t outputFrameSize = getFrameSizeInBytes(output.base.format, output.base.channelMask);
-    mContext = std::make_shared<EqualizerSwContext>(1, input.frameCount * inputFrameSize,
-                                                    output.frameCount * outputFrameSize);
-    if (!mContext) {
-        LOG(ERROR) << __func__ << " created EqualizerSwContext failed";
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_UNSUPPORTED_OPERATION,
-                                                                "FailedToCreateFmq");
-    }
-    setContext(mContext);
-
-    // create the worker thread
-    if (RetCode::SUCCESS != createThread(LOG_TAG)) {
-        LOG(ERROR) << __func__ << " created worker thread failed";
-        mContext.reset();
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_UNSUPPORTED_OPERATION,
-                                                                "FailedToCreateWorker");
-    }
-
-    _aidl_return->statusMQ = mContext->getStatusFmq()->dupeDesc();
-    _aidl_return->inputDataMQ = mContext->getInputDataFmq()->dupeDesc();
-    _aidl_return->outputDataMQ = mContext->getOutputDataFmq()->dupeDesc();
-    mState = State::IDLE;
-    return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus EqualizerSw::close() {
-    if (mState == State::INIT) {
-        LOG(WARNING) << __func__ << " instance already closed";
-        return ndk::ScopedAStatus::ok();
-    } else if (mState == State::PROCESSING) {
-        LOG(ERROR) << __func__ << " instance still processing";
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
-                                                                "EqInstanceProcessing");
-    }
-
-    // stop the worker thread
-    mState = State::INIT;
-    destroyThread();
-    mContext.reset();
-
-    LOG(DEBUG) << __func__;
-    return ndk::ScopedAStatus::ok();
-}
+namespace aidl::android::hardware::audio::effect {
 
 ndk::ScopedAStatus EqualizerSw::getDescriptor(Descriptor* _aidl_return) {
-    LOG(DEBUG) << __func__ << mDesc.toString();
-    *_aidl_return = mDesc;
+    LOG(DEBUG) << __func__ << kDesc.toString();
+    *_aidl_return = kDesc;
     return ndk::ScopedAStatus::ok();
 }
 
-ndk::ScopedAStatus EqualizerSw::command(CommandId in_commandId) {
-    LOG(DEBUG) << __func__ << ": receive command:" << toString(in_commandId);
-    if (mState == State::INIT) {
-        LOG(ERROR) << __func__ << ": instance not open yet";
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
-                                                                "CommandStateError");
-    }
-    switch (in_commandId) {
-        case CommandId::START:
-            // start processing.
-            mState = State::PROCESSING;
-            startThread();
-            LOG(DEBUG) << __func__ << " state: " << toString(mState);
-            return ndk::ScopedAStatus::ok();
-        case CommandId::STOP:
-            // stop processing.
-            mState = State::IDLE;
-            stopThread();
-            LOG(DEBUG) << __func__ << " state: " << toString(mState);
-            return ndk::ScopedAStatus::ok();
-        case CommandId::RESET:
-            // TODO: reset buffer status.
-            mState = State::IDLE;
-            stopThread();
-            LOG(DEBUG) << __func__ << " state: " << toString(mState);
-            return ndk::ScopedAStatus::ok();
-        default:
-            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                    "CommandIdNotSupported");
-    }
-    return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus EqualizerSw::setParameter(const Parameter& in_param) {
-    if (mState == State::INIT) {
-        LOG(ERROR) << __func__ << ": instance not open yet";
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE, "StateError");
-    }
-    LOG(DEBUG) << __func__ << " with: " << in_param.toString();
-    auto tag = in_param.getTag();
-    switch (tag) {
-        case Parameter::common: {
-            return setCommonParameter(in_param.get<Parameter::common>());
-        }
-        case Parameter::specific: {
-            return setSpecificParameter(in_param.get<Parameter::specific>());
-        }
-        default:
-            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                    "ParameterNotSupported");
-    }
-}
-
-ndk::ScopedAStatus EqualizerSw::getParameter(const Parameter::Id& in_paramId,
-                                             Parameter* _aidl_return) {
-    LOG(DEBUG) << __func__ << in_paramId.toString();
-    auto tag = in_paramId.getTag();
-    switch (tag) {
-        case Parameter::Id::commonTag: {
-            _aidl_return->set<Parameter::common>(mCommonParam);
-            LOG(DEBUG) << __func__ << " get: " << _aidl_return->toString();
-            return ndk::ScopedAStatus::ok();
-        }
-        case Parameter::Id::specificId: {
-            auto& id = in_paramId.get<Parameter::Id::specificId>();
-            Parameter::Specific specific;
-            ndk::ScopedAStatus status = getSpecificParameter(id, &specific);
-            if (!status.isOk()) {
-                LOG(ERROR) << __func__
-                           << " getSpecificParameter error: " << status.getDescription();
-                return status;
-            }
-            _aidl_return->set<Parameter::specific>(specific);
-            LOG(DEBUG) << __func__ << _aidl_return->toString();
-            return ndk::ScopedAStatus::ok();
-        }
-        case Parameter::Id::vendorTag: {
-            LOG(DEBUG) << __func__ << " noop for vendor tag now";
-            return ndk::ScopedAStatus::ok();
-        }
-    }
-    LOG(ERROR) << " unsupported tag: " << toString(tag);
-    return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                            "Parameter:IdNotSupported");
-}
-
-ndk::ScopedAStatus EqualizerSw::getState(State* _aidl_return) {
-    *_aidl_return = mState;
-    return ndk::ScopedAStatus::ok();
-}
-
-/// Private methods.
-ndk::ScopedAStatus EqualizerSw::setCommonParameter(const Parameter::Common& common) {
-    mCommonParam = common;
-    LOG(DEBUG) << __func__ << " set: " << mCommonParam.toString();
-    return ndk::ScopedAStatus::ok();
-}
-
-ndk::ScopedAStatus EqualizerSw::setSpecificParameter(const Parameter::Specific& specific) {
-    if (Parameter::Specific::equalizer != specific.getTag()) {
-        LOG(ERROR) << " unsupported effect: " << specific.toString();
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                "EffectNotSupported");
-    }
+ndk::ScopedAStatus EqualizerSw::setParameterSpecific(const Parameter::Specific& specific) {
+    RETURN_IF(Parameter::Specific::equalizer != specific.getTag(), EX_ILLEGAL_ARGUMENT,
+              "EffectNotSupported");
+    std::lock_guard lg(mMutex);
+    RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
 
     auto& eqParam = specific.get<Parameter::Specific::equalizer>();
     auto tag = eqParam.getTag();
     switch (tag) {
-        case Equalizer::bandLevels: {
-            auto& bandLevels = eqParam.get<Equalizer::bandLevels>();
-            const auto& [minItem, maxItem] = std::minmax_element(
-                    bandLevels.begin(), bandLevels.end(),
-                    [](const auto& a, const auto& b) { return a.index < b.index; });
-            if (bandLevels.size() >= NUM_OF_BANDS || minItem->index < 0 ||
-                maxItem->index >= NUM_OF_BANDS) {
-                LOG(ERROR) << " bandLevels " << bandLevels.size() << "minIndex " << minItem->index
-                           << "maxIndex " << maxItem->index << " illegal ";
-                return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                        "ExceedMaxBandNum");
-            }
-            mBandLevels = bandLevels;
-            return ndk::ScopedAStatus::ok();
-        }
         case Equalizer::preset: {
-            int preset = eqParam.get<Equalizer::preset>();
-            if (preset < 0 || preset >= NUM_OF_PRESETS) {
-                LOG(ERROR) << " preset: " << preset << " invalid";
-                return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                        "ExceedMaxBandNum");
-            }
-            mPreset = preset;
-            LOG(DEBUG) << __func__ << " preset set to " << mPreset;
+            RETURN_IF(mContext->setEqPreset(eqParam.get<Equalizer::preset>()) != RetCode::SUCCESS,
+                      EX_ILLEGAL_ARGUMENT, "setBandLevelsFailed");
             return ndk::ScopedAStatus::ok();
         }
-        case Equalizer::vendor: {
-            LOG(DEBUG) << __func__ << " noop for vendor tag now";
+        case Equalizer::bandLevels: {
+            RETURN_IF(mContext->setEqBandLevels(eqParam.get<Equalizer::bandLevels>()) !=
+                              RetCode::SUCCESS,
+                      EX_ILLEGAL_ARGUMENT, "setBandLevelsFailed");
             return ndk::ScopedAStatus::ok();
         }
+        default: {
+            LOG(ERROR) << __func__ << " unsupported tag: " << toString(tag);
+            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
+                                                                    "EqTagNotSupported");
+        }
     }
 
     LOG(ERROR) << __func__ << " unsupported eq param tag: " << toString(tag);
@@ -264,59 +99,72 @@
                                                             "ParamNotSupported");
 }
 
-ndk::ScopedAStatus EqualizerSw::getSpecificParameter(Parameter::Specific::Id id,
+ndk::ScopedAStatus EqualizerSw::getParameterSpecific(const Parameter::Id& id,
                                                      Parameter::Specific* specific) {
-    Equalizer eqParam;
     auto tag = id.getTag();
-    if (tag != Parameter::Specific::Id::equalizerTag) {
-        LOG(ERROR) << " invalid tag: " << toString(tag);
-        return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                                "UnsupportedTag");
+    RETURN_IF(Parameter::Id::equalizerTag != tag, EX_ILLEGAL_ARGUMENT, "wrongIdTag");
+    auto eqId = id.get<Parameter::Id::equalizerTag>();
+    auto eqIdTag = eqId.getTag();
+    switch (eqIdTag) {
+        case Equalizer::Id::commonTag:
+            return getParameterEqualizer(eqId.get<Equalizer::Id::commonTag>(), specific);
+        default:
+            LOG(ERROR) << __func__ << " tag " << toString(eqIdTag) << " not supported";
+            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
+                                                                    "EqualizerTagNotSupported");
     }
-    auto eqTag = id.get<Parameter::Specific::Id::equalizerTag>();
-    switch (eqTag) {
+}
+
+ndk::ScopedAStatus EqualizerSw::getParameterEqualizer(const Equalizer::Tag& tag,
+                                                      Parameter::Specific* specific) {
+    std::lock_guard lg(mMutex);
+    RETURN_IF(!mContext, EX_NULL_POINTER, "nullContext");
+
+    Equalizer eqParam;
+    switch (tag) {
         case Equalizer::bandLevels: {
-            eqParam.set<Equalizer::bandLevels>(mBandLevels);
-            specific->set<Parameter::Specific::equalizer>(eqParam);
-            return ndk::ScopedAStatus::ok();
+            eqParam.set<Equalizer::bandLevels>(mContext->getEqBandLevels());
+            break;
         }
         case Equalizer::preset: {
-            eqParam.set<Equalizer::preset>(mPreset);
-            LOG(DEBUG) << __func__ << " preset " << mPreset;
-            specific->set<Parameter::Specific::equalizer>(eqParam);
-            return ndk::ScopedAStatus::ok();
+            eqParam.set<Equalizer::preset>(mContext->getEqPreset());
+            break;
         }
-        case Equalizer::vendor: {
-            LOG(DEBUG) << __func__ << " noop for vendor tag now";
-            return ndk::ScopedAStatus::ok();
+        default: {
+            LOG(ERROR) << __func__ << " not handled tag: " << toString(tag);
+            return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
+                                                                    "unsupportedTag");
         }
     }
-    LOG(ERROR) << __func__ << " unsupported eq param: " << toString(eqTag);
-    return ndk::ScopedAStatus::fromExceptionCodeWithMessage(EX_ILLEGAL_ARGUMENT,
-                                                            "ParamNotSupported");
+
+    specific->set<Parameter::Specific::equalizer>(eqParam);
+    return ndk::ScopedAStatus::ok();
 }
 
-void EqualizerSw::cleanUp() {
-    if (State::PROCESSING == mState) {
-        command(CommandId::STOP);
+std::shared_ptr<EffectContext> EqualizerSw::createContext(const Parameter::Common& common) {
+    if (mContext) {
+        LOG(DEBUG) << __func__ << " context already exist";
+        return mContext;
     }
-    if (State::INIT != mState) {
-        close();
-    }
+    mContext = std::make_shared<EqualizerSwContext>(1 /* statusFmqDepth */, common);
+    return mContext;
 }
 
-IEffect::Status EqualizerSw::status(binder_status_t status, size_t consumed, size_t produced) {
-    IEffect::Status ret;
-    ret.status = status;
-    ret.fmqByteConsumed = consumed;
-    ret.fmqByteProduced = produced;
-    return ret;
+RetCode EqualizerSw::releaseContext() {
+    if (mContext) {
+        mContext.reset();
+    }
+    return RetCode::SUCCESS;
 }
 
 // Processing method running in EffectWorker thread.
-IEffect::Status EqualizerSw::effectProcessImpl() {
+IEffect::Status EqualizerSw::effectProcessImpl(float* in, float* out, int process) {
     // TODO: get data buffer and process.
-    return status(STATUS_OK, mContext->availableToRead(), mContext->availableToWrite());
+    LOG(DEBUG) << __func__ << " in " << in << " out " << out << " process " << process;
+    for (int i = 0; i < process; i++) {
+        *out++ = *in++;
+    }
+    return {STATUS_OK, process, process};
 }
 
 }  // namespace aidl::android::hardware::audio::effect