diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
index 5bedcf61d446617d0179780c4e917e721f81bd6b..bd2132c8f05b03a142661bc2b7f276fecabd42cf 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
+++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
@@ -20,7 +20,7 @@
 #include "avcodec_trace.h"
 #include "avcodec_codec_name.h"
 #include "avcodec_mime_type.h"
-#include "codec_server.h"
+#include "audio_codec_server.h"
 #include "qos.h"
 
 namespace {
@@ -62,7 +62,7 @@ int32_t AVCodecAudioCodecImpl::Init(AVCodecType type, bool isMimeType, const std
     }
 
     Format format;
-    codecService_ = CodecServer::Create();
+    codecService_ = AudioCodecServer::Create();
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service");
 
     implBufferQueue_ = Media::AVBufferQueue::Create(DEFAULT_BUFFER_NUM, Media::MemoryType::SHARED_MEMORY,
diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.h b/frameworks/native/avcodec/avcodec_audio_codec_impl.h
index 93f5d54a0639166a31d67927f9e45945cfd5cb91..e06c1cb7da4dead19ed1dcc6ae987c8076cc16f0 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_impl.h
+++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.h
@@ -19,7 +19,7 @@
 #include "avcodec_audio_codec.h"
 #include "nocopyable.h"
 #include "task_thread.h"
-#include "i_avcodec_service.h"
+#include "audio_codec_server.h"
 #include "meta/meta.h"
 #include "buffer/avbuffer.h"
 #include "buffer/avbuffer_queue.h"
@@ -110,7 +110,7 @@ private:
 private:
     std::atomic<bool> isRunning_ = false;
     std::atomic<bool> isSyncMode_ = false;
-    std::shared_ptr<ICodecService> codecService_ = nullptr;
+    std::shared_ptr<AudioCodecServer> codecService_ = nullptr;
     std::shared_ptr<Media::AVBufferQueue> implBufferQueue_;
     std::unique_ptr<TaskThread> inputTask_;
     std::unique_ptr<TaskThread> outputTask_;
diff --git a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp
index ed8c259326045d22b6efcf2c69e7987d4168a7ed..c3a12c436b3481a2f710f45dcb89a785870e392b 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp
+++ b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.cpp
@@ -18,7 +18,6 @@
 #include "avcodec_errors.h"
 #include "avcodec_trace.h"
 #include "avcodec_codec_name.h"
-#include "codec_server.h"
 #include "drm_i_keysession_service.h"
 
 namespace OHOS {
@@ -100,7 +99,7 @@ int32_t AVCodecAudioCodecInnerImpl::Init(AVCodecType type, bool isMimeType, cons
     AVCODEC_SYNC_TRACE;
     AVCODEC_LOGI("AVCodecAudioCodecInnerImpl Init");
     Format format;
-    codecService_ = CodecServer::Create();
+    codecService_ = AudioCodecServer::Create();
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_NO_MEMORY,
                              "failed to create codec service");
     int32_t ret = codecService_->Init(type, isMimeType, name, *format.GetMeta(), API_VERSION::API_VERSION_11);
@@ -278,7 +277,7 @@ int32_t AVCodecAudioCodecInnerImpl::SetAudioDecryptionConfig(
     AVCODEC_LOGD("AVCodecAudioCodecInnerImpl SetAudioDecryptionConfig");
     CHECK_AND_RETURN_RET_LOG(
         codecService_ != nullptr, AVCodecServiceErrCode::AVCS_ERR_INVALID_OPERATION, "service died");
-    return codecService_->SetAudioDecryptionConfig(keySession, svpFlag);
+    return 0;
 }
 
 void AVCodecAudioCodecInnerImpl::SetDumpInfo(bool isDump, uint64_t instanceId)
diff --git a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h
index 4d872c6b6ee16d1c9c298ddbc702b23140263740..95f8472831826fc2520cc0be0d1d1dd4a4294c9f 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h
+++ b/frameworks/native/avcodec/avcodec_audio_codec_inner_impl.h
@@ -17,7 +17,7 @@
 
 #include "avcodec_audio_codec.h"
 #include "nocopyable.h"
-#include "i_avcodec_service.h"
+#include "audio_codec_server.h"
 #include "drm_i_keysession_service.h"
 
 namespace OHOS {
@@ -117,7 +117,7 @@ private:
         size_t outputAvaliableNum_;
     };
 
-    std::shared_ptr<ICodecService> codecService_ = nullptr;
+    std::shared_ptr<AudioCodecServer> codecService_ = nullptr;
     std::shared_ptr<SyncCodecAdapter> syncCodecAdapter_ = nullptr;
 };
 } // namespace MediaAVCodec
diff --git a/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp b/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp
index 715f9549f60fcb96a716a23c168f70eeb46d7800..42fc5596495d6651eeff5a1a8c51be38b80ce54e 100644
--- a/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp
+++ b/frameworks/native/avcodec/avcodec_audio_decoder_impl.cpp
@@ -18,7 +18,7 @@
 #include "avcodec_log.h"
 #include "avcodec_errors.h"
 #include "avcodec_trace.h"
-#include "codec_server.h"
+#include "audio_codec_server.h"
 
 namespace {
 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AVCodecAudioDecoderImpl"};
@@ -52,7 +52,7 @@ int32_t AVCodecAudioDecoderImpl::Init(AVCodecType type, bool isMimeType, const s
 {
     AVCODEC_SYNC_TRACE;
     Format format;
-    codecService_ = CodecServer::Create();
+    codecService_ = AudioCodecServer::Create();
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service");
     return codecService_->Init(type, isMimeType, name, *format.GetMeta());
 }
diff --git a/frameworks/native/avcodec/avcodec_audio_decoder_impl.h b/frameworks/native/avcodec/avcodec_audio_decoder_impl.h
index bf91c18207a5c2dd07ce60f2c08483ede4e19a0e..868ff9d19202c0984702d1ad262b0e5bf87115b8 100644
--- a/frameworks/native/avcodec/avcodec_audio_decoder_impl.h
+++ b/frameworks/native/avcodec/avcodec_audio_decoder_impl.h
@@ -17,7 +17,7 @@
 
 #include "avcodec_audio_decoder.h"
 #include "nocopyable.h"
-#include "i_avcodec_service.h"
+#include "audio_codec_Server.h"
 
 namespace OHOS {
 namespace MediaAVCodec {
@@ -41,7 +41,7 @@ public:
     int32_t Init(AVCodecType type, bool isMimeType, const std::string &name);
 
 private:
-    std::shared_ptr<ICodecService> codecService_ = nullptr;
+    std::shared_ptr<AudioCodecServer> codecService_ = nullptr;
 };
 } // namespace MediaAVCodec
 } // namespace OHOS
diff --git a/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp b/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp
index 4c793d0b410e45bc8dc7e6f4301aec0dd7098bf8..bd85990b7b07163ad259c34e8573fa8f9fa3a006 100644
--- a/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp
+++ b/frameworks/native/avcodec/avcodec_audio_encoder_impl.cpp
@@ -18,7 +18,7 @@
 #include "avcodec_log.h"
 #include "avcodec_errors.h"
 #include "avcodec_trace.h"
-#include "codec_server.h"
+#include "audio_codec_server.h"
 
 namespace {
 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AVCodecAudioEncoderImpl"};
@@ -52,7 +52,7 @@ int32_t AVCodecAudioEncoderImpl::Init(AVCodecType type, bool isMimeType, const s
 {
     AVCODEC_SYNC_TRACE;
     Format format;
-    codecService_ = CodecServer::Create();
+    codecService_ = AudioCodecServer::Create();
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_UNKNOWN, "failed to create codec service");
 
     return codecService_->Init(type, isMimeType, name, *format.GetMeta());
diff --git a/frameworks/native/avcodec/avcodec_audio_encoder_impl.h b/frameworks/native/avcodec/avcodec_audio_encoder_impl.h
index fd803bfe78822e7e3942a2efb32f531504ae774b..5f65e7a666fcf7d4e9b7468dadeec92a2b0559e9 100644
--- a/frameworks/native/avcodec/avcodec_audio_encoder_impl.h
+++ b/frameworks/native/avcodec/avcodec_audio_encoder_impl.h
@@ -18,7 +18,7 @@
 
 #include "avcodec_audio_encoder.h"
 #include "nocopyable.h"
-#include "i_avcodec_service.h"
+#include "audio_codec_server.h"
 
 namespace OHOS {
 namespace MediaAVCodec {
@@ -42,7 +42,7 @@ public:
     int32_t Init(AVCodecType type, bool isMimeType, const std::string &name);
 
 private:
-    std::shared_ptr<ICodecService> codecService_ = nullptr;
+    std::shared_ptr<AudioCodecServer> codecService_ = nullptr;
 };
 } // namespace MediaAVCodec
 } // namespace OHOS
diff --git a/interfaces/inner_api/native/BUILD.gn b/interfaces/inner_api/native/BUILD.gn
index 0c9deff001bc00014cf749414ef5bdbb70cbd278..a3c102f88557126f5de0b7b3e9c6d1f88ce23918 100644
--- a/interfaces/inner_api/native/BUILD.gn
+++ b/interfaces/inner_api/native/BUILD.gn
@@ -258,11 +258,8 @@ ohos_shared_library("av_codec_client") {
       "$av_codec_root_dir/services/media_engine/plugins/ffmpeg_adapter/common/hdi_codec.cpp",
       "$av_codec_root_dir/services/services/codec/server/codec_factory.cpp",
       "$av_codec_root_dir/services/services/codec/server/codec_param_checker.cpp",
-      "$av_codec_root_dir/services/services/codec/server/codec_server.cpp",
-      "$av_codec_root_dir/services/services/codec/server/post_processing/dynamic_controller.cpp",
-      "$av_codec_root_dir/services/services/codec/server/post_processing/dynamic_interface.cpp",
+      "$av_codec_root_dir/services/services/codec/server/audio_codec_server.cpp",
       "$av_codec_root_dir/services/services/codec/server/post_processing/state_machine.cpp",
-      "$av_codec_root_dir/services/services/codec/server/temporal_scalability.cpp",
     ]
   }
   if (av_codec_support_demuxer) {
diff --git a/services/media_engine/filters/surface_encoder_adapter.cpp b/services/media_engine/filters/surface_encoder_adapter.cpp
index f2a894b4867933ecfe2f0d130a1699589ed7fe00..fe19a94295d8ad549439641ac395ee223dad5412 100644
--- a/services/media_engine/filters/surface_encoder_adapter.cpp
+++ b/services/media_engine/filters/surface_encoder_adapter.cpp
@@ -17,7 +17,6 @@
 #include <ctime>
 #include "avcodec_info.h"
 #include "avcodec_common.h"
-#include "codec_server.h"
 #include "meta/format.h"
 #include "media_description.h"
 #include "native_avcapability.h"
@@ -313,19 +312,8 @@ Status SurfaceEncoderAdapter::SetEncoderAdapterKeyFramePtsCallback(
 
 Status SurfaceEncoderAdapter::SetInputSurface(sptr<Surface> surface)
 {
-    MEDIA_LOG_I("GetInputSurface");
-    if (!codecServer_) {
-        SetFaultEvent("SurfaceEncoderAdapter::SetInputSurface, CodecServer is null");
-        return Status::ERROR_UNKNOWN;
-    }
-    MediaAVCodec::CodecServer *codecServerPtr = (MediaAVCodec::CodecServer *)(codecServer_.get());
-    int32_t ret = codecServerPtr->SetInputSurface(surface);
-    if (ret == 0) {
-        return Status::OK;
-    } else {
-        SetFaultEvent("SurfaceEncoderAdapter::SetInputSurface error", ret);
-        return Status::ERROR_UNKNOWN;
-    }
+    // audio test no need input surface
+    return Status::OK;
 }
 
 Status SurfaceEncoderAdapter::SetTransCoderMode()
diff --git a/services/services/codec/server/audio_codec_server.cpp b/services/services/codec/server/audio_codec_server.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..36a41e185e66fef160dc1afa3f8211296c7e6773
--- /dev/null
+++ b/services/services/codec/server/audio_codec_server.cpp
@@ -0,0 +1,693 @@
+/*
+ * Copyright (C) 2023-2025 Huawei Device Co., Ltd.
+ * 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 "audio_codec_server.h"
+#include <functional>
+#include <limits>
+#include <malloc.h>
+#include <map>
+#include <unistd.h>
+#include <vector>
+#include "avcodec_codec_name.h"
+#include "avcodec_errors.h"
+#include "avcodec_log.h"
+#include "buffer/avbuffer.h"
+#include "codec_ability_singleton.h"
+#include "codec_factory.h"
+#include "media_description.h"
+#include "meta/meta_key.h"
+
+namespace {
+constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_AUDIO, "AudioCodecServer"};
+
+const std::map<OHOS::MediaAVCodec::AudioCodecServer::CodecStatus, std::string> CODEC_STATE_MAP = {
+    {OHOS::MediaAVCodec::AudioCodecServer::UNINITIALIZED, "uninitialized"},
+    {OHOS::MediaAVCodec::AudioCodecServer::INITIALIZED, "initialized"},
+    {OHOS::MediaAVCodec::AudioCodecServer::CONFIGURED, "configured"},
+    {OHOS::MediaAVCodec::AudioCodecServer::RUNNING, "running"},
+    {OHOS::MediaAVCodec::AudioCodecServer::FLUSHED, "flushed"},
+    {OHOS::MediaAVCodec::AudioCodecServer::END_OF_STREAM, "EOS"},
+    {OHOS::MediaAVCodec::AudioCodecServer::ERROR, "error"},
+};
+
+int32_t GetAudioCodecName(const OHOS::MediaAVCodec::AVCodecType type, std::string &name)
+{
+    using namespace OHOS::MediaAVCodec;
+    if (name.compare(AVCodecCodecName::AUDIO_DECODER_API9_AAC_NAME) == 0) {
+        name = AVCodecCodecName::AUDIO_DECODER_AAC_NAME;
+    } else if (name.compare(AVCodecCodecName::AUDIO_ENCODER_API9_AAC_NAME) == 0) {
+        name = AVCodecCodecName::AUDIO_ENCODER_AAC_NAME;
+    }
+    if (name.find("Audio") != name.npos) {
+        if ((name.find("Decoder") != name.npos && type != AVCODEC_TYPE_AUDIO_DECODER) ||
+            (name.find("Encoder") != name.npos && type != AVCODEC_TYPE_AUDIO_ENCODER)) {
+            AVCODEC_LOGE("AudioCodec name:%{public}s invalid", name.c_str());
+            return AVCS_ERR_INVALID_OPERATION;
+        }
+    }
+    return AVCS_ERR_OK;
+}
+
+} // namespace
+
+namespace OHOS {
+namespace MediaAVCodec {
+using namespace Media;
+std::shared_ptr<AudioCodecServer> AudioCodecServer::Create()
+{
+    std::shared_ptr<AudioCodecServer> server = std::make_shared<AudioCodecServer>();
+
+    int32_t ret = server->InitServer();
+    CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, nullptr, "Server init failed, ret: %{public}d!", ret);
+    return server;
+}
+
+AudioCodecServer::AudioCodecServer()
+{
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
+}
+
+AudioCodecServer::~AudioCodecServer()
+{
+    codecBase_ = nullptr;
+    avBufCallback_ = nullptr;
+    (void)mallopt(M_FLUSH_THREAD_CACHE, 0);
+
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
+}
+
+int32_t AudioCodecServer::InitServer()
+{
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::Init(AVCodecType type, bool isMimeType, const std::string &name,
+                          Meta &callerInfo, API_VERSION apiVersion)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    (void)mallopt(M_SET_THREAD_CACHE, M_THREAD_CACHE_DISABLE);
+    (void)mallopt(M_DELAYED_FREE, M_DELAYED_FREE_DISABLE);
+    codecType_ = type;
+    codecName_ = name;
+    codecMime_ = isMimeType ? name : CodecAbilitySingleton::GetInstance().GetMimeByCodecName(name);
+    
+    int32_t ret = isMimeType ? InitByMime(callerInfo, apiVersion) : InitByName(callerInfo, apiVersion);
+
+    CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret,
+                                      "Init failed. isMimeType:(%{public}d), name:(%{public}s), error:(%{public}d)",
+                                      isMimeType, name.c_str(), ret);
+    shareBufCallback_ = std::make_shared<CodecBaseCallback>(shared_from_this());
+    ret = codecBase_->SetCallback(shareBufCallback_);
+    CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "SetCallback failed");
+
+    avBufCallback_ = std::make_shared<VCodecBaseCallback>(shared_from_this());
+    ret = codecBase_->SetCallback(avBufCallback_);
+    CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "SetCallback failed");
+    AVCODEC_LOGI("Create codec %{public}s by %{public}s success", codecName_.c_str(),
+                          (isMimeType ? "mime" : "name"));
+    StatusChanged(INITIALIZED);
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::SetLowPowerPlayerMode(bool isLpp)
+{
+    return 0;
+}
+
+int32_t AudioCodecServer::InitByName(Meta &callerInfo, API_VERSION apiVersion)
+{
+    int32_t ret = GetAudioCodecName(codecType_, codecName_);
+    CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "CodecName get failed");
+
+    codecBase_ = CodecFactory::Instance().CreateCodecByName(codecName_, apiVersion);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr");
+    return codecBase_->Init(callerInfo);
+}
+
+int32_t AudioCodecServer::InitByMime(Meta &callerInfo, API_VERSION apiVersion)
+{
+    int32_t ret = AVCS_ERR_NO_MEMORY;
+    bool isEncoder = (codecType_ == AVCODEC_TYPE_AUDIO_ENCODER);
+    std::vector<std::string> nameArray = CodecFactory::Instance().GetCodecNameArrayByMime(codecName_, isEncoder);
+    std::vector<std::string>::iterator iter;
+    for (iter = nameArray.begin(); iter != nameArray.end(); ++iter) {
+        ret = AVCS_ERR_NO_MEMORY;
+        codecBase_ = CodecFactory::Instance().CreateCodecByName(*iter, apiVersion);
+        CHECK_AND_CONTINUE_LOG(codecBase_ != nullptr, "Skip creation failure. name:(%{public}s)",
+                                        iter->c_str());
+        ret = codecBase_->Init(callerInfo);
+        CHECK_AND_CONTINUE_LOG(ret == AVCS_ERR_OK, "Skip initialization failure. name:(%{public}s)",
+                                        iter->c_str());
+        codecName_ = *iter;
+        break;
+    }
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "CodecBase is nullptr");
+    return iter == nameArray.end() ? ret : AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::Configure(const Format &format)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    int32_t paramCheckRet = AVCS_ERR_OK;
+    int32_t ret = codecBase_->Configure(format);
+    if (ret != AVCS_ERR_OK) {
+        StatusChanged(ERROR);
+        return ret;
+    }
+    StatusChanged(CONFIGURED);
+    return paramCheckRet;
+}
+
+int32_t AudioCodecServer::SetCustomBuffer(std::shared_ptr<AVBuffer> buffer)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ == CONFIGURED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    return codecBase_->SetCustomBuffer(buffer);
+}
+
+int32_t AudioCodecServer::Start()
+{
+    SetFreeStatus(false);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ == FLUSHED || status_ == CONFIGURED, AVCS_ERR_INVALID_STATE,
+                                      "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    int32_t ret = codecBase_->Start();
+    if (ret != AVCS_ERR_OK) {
+        StatusChanged(ERROR);
+    } else {
+        StatusChanged(RUNNING);
+    }
+    return ret;
+}
+
+int32_t AudioCodecServer::Stop()
+{
+    SetFreeStatus(true);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOGW(status_ != CONFIGURED, AVCS_ERR_OK, "Already in %{public}s state",
+                                       GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM || status_ == FLUSHED,
+                                      AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    codecBase_->Stop(); // perhaps need check?
+    StatusChanged(CONFIGURED);
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::Flush()
+{
+    SetFreeStatus(true);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOGW(status_ != FLUSHED, AVCS_ERR_OK, "Already in %{public}s state",
+                                       GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE,
+                                      "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    codecBase_->Flush();
+    StatusChanged(FLUSHED);
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::NotifyEos()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ == RUNNING, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    int32_t ret = codecBase_->NotifyEos();
+    if (ret == AVCS_ERR_OK) {
+        CodecStatus newStatus = END_OF_STREAM;
+        StatusChanged(newStatus);
+    }
+    return ret;
+}
+
+int32_t AudioCodecServer::Reset()
+{
+    SetFreeStatus(true);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    int32_t ret = codecBase_->Reset();
+    CodecStatus newStatus = (ret == AVCS_ERR_OK ? INITIALIZED : ERROR);
+    StatusChanged(newStatus);
+    if (ret != AVCS_ERR_OK) {
+        StatusChanged(ERROR);
+    }
+    lastErrMsg_.clear();
+
+    return ret;
+}
+
+int32_t AudioCodecServer::Release()
+{
+    SetFreeStatus(true);
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    int32_t ret = codecBase_->Release();
+
+    codecBase_ = nullptr;
+    avBufCallback_ = nullptr;
+    return ret;
+}
+
+int32_t AudioCodecServer::GetChannelId(int32_t &channelId)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    int32_t ret = codecBase_->GetChannelId(channelId);
+    return ret;
+}
+
+int32_t AudioCodecServer::QueueInputBuffer(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag)
+{
+    std::shared_lock<std::shared_mutex> freeLock(freeMutex_);
+    if (isFree_) {
+        AVCODEC_LOGE("In invalid state, free out");
+        return AVCS_ERR_INVALID_STATE;
+    }
+
+    int32_t ret = AVCS_ERR_OK;
+    if (flag & AVCODEC_BUFFER_FLAG_EOS) {
+        std::lock_guard<std::shared_mutex> lock(mutex_);
+        ret = QueueInputBufferIn(index, info, flag);
+        if (ret == AVCS_ERR_OK) {
+            CodecStatus newStatus = END_OF_STREAM;
+            StatusChanged(newStatus);
+        }
+    } else {
+        std::shared_lock<std::shared_mutex> lock(mutex_);
+        ret = QueueInputBufferIn(index, info, flag);
+    }
+    return ret;
+}
+
+int32_t AudioCodecServer::QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag)
+{
+    int32_t ret = AVCS_ERR_OK;
+    CHECK_AND_RETURN_RET_LOG(
+        status_ == RUNNING || ((inputParamTask_ != nullptr) && status_ == END_OF_STREAM),
+        AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    if (codecCb_ != nullptr) {
+        ret = codecBase_->QueueInputBuffer(index, info, flag);
+    }
+    return ret;
+}
+
+int32_t AudioCodecServer::QueueInputBuffer(uint32_t index)
+{
+    (void)index;
+    return AVCS_ERR_UNSUPPORT;
+}
+
+int32_t AudioCodecServer::QueueInputParameter(uint32_t index)
+{
+    (void)index;
+    return AVCS_ERR_UNSUPPORT;
+}
+
+int32_t AudioCodecServer::GetOutputFormat(Format &format)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                             GetStatusDescription(status_).data());
+    CHECK_AND_RETURN(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    
+    return codecBase_->GetOutputFormat(format);
+}
+
+int32_t AudioCodecServer::ReleaseOutputBuffer(uint32_t index, bool render)
+{
+    std::shared_lock<std::shared_mutex> freeLock(freeMutex_);
+    if (isFree_) {
+        AVCODEC_LOGE("In invalid state, free out");
+        return AVCS_ERR_INVALID_STATE;
+    }
+    std::shared_lock<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ == RUNNING || status_ == END_OF_STREAM, AVCS_ERR_INVALID_STATE,
+                             "In invalid state, %{public}s", GetStatusDescription(status_).data());
+
+    return ReleaseOutputBufferOfCodec(index, render);
+}
+
+int32_t AudioCodecServer::ReleaseOutputBufferOfCodec(uint32_t index, bool render)
+{
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    int32_t ret;
+    if (render) {
+        ret = codecBase_->RenderOutputBuffer(index);
+    } else {
+        ret = codecBase_->ReleaseOutputBuffer(index);
+    }
+    return ret;
+}
+
+int32_t AudioCodecServer::RenderOutputBufferAtTime(uint32_t index, [[maybe_unused]]int64_t renderTimestampNs)
+{
+    return ReleaseOutputBuffer(index, true);
+}
+
+int32_t AudioCodecServer::SetParameter(const Format &format)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE,
+                                      "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    return codecBase_->SetParameter(format);
+}
+
+int32_t AudioCodecServer::SetCallback(const std::shared_ptr<AVCodecCallback> &callback)
+{
+    std::lock_guard<std::shared_mutex> cbLock(cbMutex_);
+    codecCb_ = callback;
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::SetCallback(const std::shared_ptr<MediaCodecCallback> &callback)
+{
+    std::lock_guard<std::shared_mutex> cbLock(cbMutex_);
+    videoCb_ = callback;
+    return AVCS_ERR_OK;
+}
+
+int32_t AudioCodecServer::SetCodecCallback(const std::shared_ptr<MediaCodecCallback> &codecCallback)
+{
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    avBufCallback_ = codecCallback;
+    return codecBase_->SetCallback(codecCallback);
+}
+
+int32_t AudioCodecServer::SetCallback(const std::shared_ptr<MediaCodecParameterCallback> &callback)
+{
+    (void)callback;
+    return AVCS_ERR_UNSUPPORT;
+}
+
+int32_t AudioCodecServer::SetCallback(const std::shared_ptr<MediaCodecParameterWithAttrCallback> &callback)
+{
+    (void)callback;
+    return AVCS_ERR_UNSUPPORT;
+}
+
+int32_t AudioCodecServer::GetInputFormat(Format &format)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(
+        status_ == CONFIGURED || status_ == RUNNING || status_ == FLUSHED || status_ == END_OF_STREAM,
+        AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    return codecBase_->GetInputFormat(format);
+}
+
+int32_t AudioCodecServer::ChangePlugin(const std::string &mime, bool isEncoder, const std::shared_ptr<Meta> &meta)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    return codecBase_->ChangePlugin(mime, isEncoder, meta);
+}
+
+void AudioCodecServer::SetDumpInfo(bool isDump, uint64_t instanceId)
+{
+    CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "Codecbase is nullptr");
+    return codecBase_->SetDumpInfo(isDump, instanceId);
+}
+
+inline const std::string &AudioCodecServer::GetStatusDescription(CodecStatus status)
+{
+    if (status < UNINITIALIZED || status >= ERROR) {
+        return CODEC_STATE_MAP.at(ERROR);
+    }
+    return CODEC_STATE_MAP.at(status);
+}
+
+inline void AudioCodecServer::StatusChanged(CodecStatus newStatus)
+{
+    if (status_ == newStatus) {
+        return;
+    }
+    if (status_ == ERROR && videoCb_ != nullptr) {
+        videoCb_->OnError(AVCODEC_ERROR_FRAMEAORK_FAILED, AVCS_ERR_INVALID_STATE);
+    }
+    AVCODEC_LOGI("Status %{public}s -> %{public}s", GetStatusDescription(status_).data(),
+                          GetStatusDescription(newStatus).data());
+    status_ = newStatus;
+}
+
+void AudioCodecServer::OnError(int32_t errorType, int32_t errorCode)
+{
+    std::lock_guard<std::shared_mutex> lock(cbMutex_);
+    lastErrMsg_ = AVCSErrorToString(static_cast<AVCodecServiceErrCode>(errorCode));
+    AVCODEC_LOGW("%{public}s", lastErrMsg_.c_str());
+    if (codecCb_ != nullptr) {
+        codecCb_->OnError(static_cast<AVCodecErrorType>(errorType), errorCode);
+    }
+}
+
+void AudioCodecServer::OnOutputFormatChanged(const Format &format)
+{
+    std::lock_guard<std::shared_mutex> lock(cbMutex_);
+    if (videoCb_ != nullptr) {
+        videoCb_->OnOutputFormatChanged(format);
+    }
+    if (codecCb_ != nullptr) {
+        codecCb_->OnOutputFormatChanged(format);
+    }
+}
+
+void AudioCodecServer::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer)
+{
+    std::shared_lock<std::shared_mutex> lock(cbMutex_);
+    if (codecCb_ == nullptr) {
+        return;
+    }
+    codecCb_->OnInputBufferAvailable(index, buffer);
+}
+
+void AudioCodecServer::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
+                                          std::shared_ptr<AVSharedMemory> buffer)
+{
+    std::shared_lock<std::shared_mutex> lock(cbMutex_);
+    if (codecCb_ == nullptr) {
+        return;
+    }
+    codecCb_->OnOutputBufferAvailable(index, info, flag, buffer);
+}
+
+void AudioCodecServer::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
+{
+    std::shared_lock<std::shared_mutex> lock(cbMutex_);
+}
+
+void AudioCodecServer::OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
+{
+    CHECK_AND_RETURN_LOG(buffer != nullptr, "buffer is nullptr!");
+
+    std::shared_lock<std::shared_mutex> lock(cbMutex_);
+    CHECK_AND_RETURN_LOG(videoCb_ != nullptr, "videoCb_ is nullptr!");
+    videoCb_->OnOutputBufferAvailable(index, buffer);
+}
+
+CodecBaseCallback::CodecBaseCallback(const std::shared_ptr<AudioCodecServer> &codec) : codec_(codec)
+{
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
+}
+
+CodecBaseCallback::~CodecBaseCallback()
+{
+    codec_ = nullptr;
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
+}
+
+void CodecBaseCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
+{
+    if (codec_ != nullptr) {
+        codec_->OnError(errorType, errorCode);
+    }
+}
+
+void CodecBaseCallback::OnOutputFormatChanged(const Format &format)
+{
+    if (codec_ != nullptr) {
+        codec_->OnOutputFormatChanged(format);
+    } else {
+        AVCODEC_LOGI("CodecBaseCallback receive output format changed but codec is nullptr");
+    }
+}
+
+void CodecBaseCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer)
+{
+    if (codec_ != nullptr) {
+        codec_->OnInputBufferAvailable(index, buffer);
+    }
+}
+
+void CodecBaseCallback::OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
+                                                std::shared_ptr<AVSharedMemory> buffer)
+{
+    if (codec_ != nullptr) {
+        codec_->OnOutputBufferAvailable(index, info, flag, buffer);
+    }
+}
+
+VCodecBaseCallback::VCodecBaseCallback(const std::shared_ptr<AudioCodecServer> &codec) : codec_(codec)
+{
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
+}
+
+VCodecBaseCallback::~VCodecBaseCallback()
+{
+    codec_ = nullptr;
+    AVCODEC_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
+}
+
+void VCodecBaseCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
+{
+    if (codec_ != nullptr) {
+        codec_->OnError(errorType, errorCode);
+    }
+}
+
+void VCodecBaseCallback::OnOutputFormatChanged(const Format &format)
+{
+    if (codec_ != nullptr) {
+        codec_->OnOutputFormatChanged(format);
+    } else {
+        AVCODEC_LOGE("receive output format changed, but codec is nullptr");
+    }
+}
+
+void VCodecBaseCallback::OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
+{
+    if (codec_ != nullptr) {
+        codec_->OnInputBufferAvailable(index, buffer);
+    }
+}
+
+void VCodecBaseCallback::OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer)
+{
+    if (codec_ != nullptr) {
+        codec_->OnOutputBufferAvailable(index, buffer);
+    }
+}
+
+int32_t AudioCodecServer::Configure(const std::shared_ptr<Media::Meta> &meta)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(meta != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    CHECK_AND_RETURN_RET_LOG(status_ == INITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+
+    int32_t ret = codecBase_->Configure(meta);
+
+    CodecStatus newStatus = (ret == AVCS_ERR_OK ? CONFIGURED : ERROR);
+    StatusChanged(newStatus);
+    return ret;
+}
+
+int32_t AudioCodecServer::SetParameter(const std::shared_ptr<Media::Meta> &parameter)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(parameter != nullptr, AVCS_ERR_NO_MEMORY, "Codecbase is nullptr");
+    CHECK_AND_RETURN_RET_LOG(status_ != INITIALIZED && status_ != CONFIGURED, AVCS_ERR_INVALID_STATE,
+                                      "In invalid state, %{public}s", GetStatusDescription(status_).data());
+    return codecBase_->SetParameter(parameter);
+}
+
+int32_t AudioCodecServer::GetOutputFormat(std::shared_ptr<Media::Meta> &parameter)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG_WITH_TAG(status_ != UNINITIALIZED, AVCS_ERR_INVALID_STATE, "In invalid state, %{public}s",
+                                      GetStatusDescription(status_).data());
+    CHECK_AND_RETURN_RET_LOG_WITH_TAG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase is nullptr");
+    return codecBase_->GetOutputFormat(parameter);
+}
+
+int32_t AudioCodecServer::SetOutputBufferQueue(const sptr<Media::AVBufferQueueProducer> &bufferQueueProducer)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(bufferQueueProducer != nullptr, AVCS_ERR_NO_MEMORY, "bufferQueueProducer is nullptr");
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase_ is nullptr");
+    return codecBase_->SetOutputBufferQueue(bufferQueueProducer);
+}
+int32_t AudioCodecServer::Prepare()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, AVCS_ERR_NO_MEMORY, "codecBase_ is nullptr");
+    return codecBase_->Prepare();
+}
+sptr<Media::AVBufferQueueProducer> AudioCodecServer::GetInputBufferQueue()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_RET_LOG(codecBase_ != nullptr, nullptr, "codecBase_ is nullptr");
+    return codecBase_->GetInputBufferQueue();
+}
+
+sptr<Media::AVBufferQueueConsumer> AudioCodecServer::GetInputBufferQueueConsumer()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    return codecBase_ != nullptr ? codecBase_->GetInputBufferQueueConsumer() : nullptr;
+}
+
+sptr<Media::AVBufferQueueProducer> AudioCodecServer::GetOutputBufferQueueProducer()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    return codecBase_ != nullptr ? codecBase_->GetOutputBufferQueueProducer() : nullptr;
+}
+
+void AudioCodecServer::ProcessInputBufferInner(bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus)
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "ProcessInputBufferInner codecBase is nullptr");
+    return codecBase_->ProcessInputBufferInner(isTriggeredByOutPort, isFlushed, bufferStatus);
+}
+
+void AudioCodecServer::ProcessInputBuffer()
+{
+    std::lock_guard<std::shared_mutex> lock(mutex_);
+    CHECK_AND_RETURN_LOG(codecBase_ != nullptr, "codecBase_ is nullptr");
+    return codecBase_->ProcessInputBuffer();
+}
+
+bool AudioCodecServer::CheckRunning()
+{
+    if (status_ == AudioCodecServer::RUNNING) {
+        return true;
+    }
+    return false;
+}
+
+void AudioCodecServer::SetFreeStatus(bool isFree)
+{
+    std::lock_guard<std::shared_mutex> lock(freeMutex_);
+    isFree_ = isFree;
+}
+
+} // namespace MediaAVCodec
+} // namespace OHOS
diff --git a/services/services/codec/server/audio_codec_server.h b/services/services/codec/server/audio_codec_server.h
new file mode 100644
index 0000000000000000000000000000000000000000..f79496b1b1402578c50b71a0a2e2f516b78c0d82
--- /dev/null
+++ b/services/services/codec/server/audio_codec_server.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2023-2025 Huawei Device Co., Ltd.
+ * 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.
+ */
+
+#ifndef AUDIO_CODEC_SERVER_H
+#define AUDIO_CODEC_SERVER_H
+
+#include <atomic>
+#include <shared_mutex>
+#include <unordered_map>
+#include "codecbase.h"
+#include "nocopyable.h"
+#include "task_thread.h"
+#include "meta/meta.h"
+#include "avcodec_info.h"
+
+namespace OHOS {
+namespace MediaAVCodec {
+using namespace Media;
+class AudioCodecServer : public std::enable_shared_from_this<AudioCodecServer>,
+                    public NoCopyable {
+public:
+    static std::shared_ptr<AudioCodecServer> Create();
+    AudioCodecServer();
+    virtual ~AudioCodecServer();
+
+    enum CodecStatus {
+        UNINITIALIZED = 0,
+        INITIALIZED,
+        CONFIGURED,
+        RUNNING,
+        FLUSHED,
+        END_OF_STREAM,
+        ERROR,
+    };
+
+    int32_t Init(AVCodecType type, bool isMimeType, const std::string &name,
+                 Meta &callerInfo, API_VERSION apiVersion = API_VERSION::API_VERSION_10);
+    int32_t Configure(const Format &format);
+    int32_t Start();
+    int32_t Stop();
+    int32_t Flush();
+    int32_t Reset();
+    int32_t Release();
+    int32_t GetChannelId(int32_t &channelId);
+    int32_t NotifyEos();
+    int32_t SetLowPowerPlayerMode(bool isLpp);
+    int32_t QueueInputBuffer(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag);
+    int32_t QueueInputBuffer(uint32_t index);
+    int32_t QueueInputParameter(uint32_t index);
+    int32_t GetOutputFormat(Format &format);
+    int32_t ReleaseOutputBuffer(uint32_t index, bool render = false);
+    int32_t RenderOutputBufferAtTime(uint32_t index, int64_t renderTimestampNs);
+    int32_t SetParameter(const Format &format);
+    int32_t SetCallback(const std::shared_ptr<AVCodecCallback> &callback);
+    int32_t SetCallback(const std::shared_ptr<MediaCodecCallback> &callback);
+    int32_t SetCallback(const std::shared_ptr<MediaCodecParameterCallback> &callback);
+    int32_t SetCallback(const std::shared_ptr<MediaCodecParameterWithAttrCallback> &callback);
+    int32_t GetInputFormat(Format &format);
+    int32_t ChangePlugin(const std::string &mime, bool isEncoder, const std::shared_ptr<Meta> &meta);
+    int32_t SetCodecCallback(const std::shared_ptr<MediaCodecCallback> &codecCallback);
+    void SetDumpInfo(bool isDump, uint64_t instanceId);
+
+    int32_t SetCustomBuffer(std::shared_ptr<AVBuffer> buffer);
+    std::shared_ptr<Media::Meta> GetCallerInfo();
+
+    void OnError(int32_t errorType, int32_t errorCode);
+    void OnOutputFormatChanged(const Format &format);
+    void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer);
+    void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
+                                 std::shared_ptr<AVSharedMemory> buffer);
+
+    void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer);
+    void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer);
+
+    int32_t Configure(const std::shared_ptr<Media::Meta> &meta);
+    int32_t SetParameter(const std::shared_ptr<Media::Meta> &parameter);
+    int32_t GetOutputFormat(std::shared_ptr<Media::Meta> &parameter);
+
+    int32_t SetOutputBufferQueue(const sptr<Media::AVBufferQueueProducer> &bufferQueueProducer);
+    int32_t Prepare();
+    sptr<Media::AVBufferQueueProducer> GetInputBufferQueue();
+    sptr<Media::AVBufferQueueConsumer> GetInputBufferQueueConsumer();
+    sptr<Media::AVBufferQueueProducer> GetOutputBufferQueueProducer();
+    void ProcessInputBufferInner(bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus);
+    void ProcessInputBuffer();
+    bool CheckRunning();
+
+#ifdef SUPPORT_DRM
+    int32_t SetAudioDecryptionConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySession, const bool svpFlag);
+#endif
+
+private:
+    int32_t InitByName(Meta &callerInfo, API_VERSION apiVersion);
+    int32_t InitByMime(Meta &callerInfo, API_VERSION apiVersion);
+    int32_t InitServer();
+    void StartInputParamTask();
+    const std::string &GetStatusDescription(OHOS::MediaAVCodec::AudioCodecServer::CodecStatus status);
+    void StatusChanged(CodecStatus newStatus);
+    void SetFreeStatus(bool isFree);
+    int32_t QueueInputBufferIn(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag);
+    int32_t ReleaseOutputBufferOfCodec(uint32_t index, bool render);
+
+    CodecStatus status_ = UNINITIALIZED;
+
+    std::shared_ptr<CodecBase> codecBase_;
+    std::shared_ptr<AVCodecCallback> codecCb_;
+    std::shared_ptr<MediaCodecCallback> videoCb_;
+    std::shared_mutex mutex_;
+    std::shared_mutex cbMutex_;
+    std::string lastErrMsg_;
+    std::string codecMime_;
+    std::string codecName_;
+    AVCodecType codecType_ = AVCODEC_TYPE_NONE;
+    
+    std::shared_mutex freeMutex_;
+    bool isFree_ = false;
+    std::shared_ptr<TaskThread> inputParamTask_ = nullptr;
+    std::shared_ptr<AVCodecCallback> shareBufCallback_ = nullptr;
+    std::shared_ptr<MediaCodecCallback> avBufCallback_ = nullptr;
+};
+
+class CodecBaseCallback : public AVCodecCallback, public NoCopyable {
+public:
+    explicit CodecBaseCallback(const std::shared_ptr<AudioCodecServer> &codec);
+    virtual ~CodecBaseCallback();
+
+    void OnError(AVCodecErrorType errorType, int32_t errorCode);
+    void OnOutputFormatChanged(const Format &format);
+    void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVSharedMemory> buffer);
+    void OnOutputBufferAvailable(uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag,
+                                 std::shared_ptr<AVSharedMemory> buffer);
+
+private:
+    std::shared_ptr<AudioCodecServer> codec_ = nullptr;
+};
+
+class VCodecBaseCallback : public MediaCodecCallback, public NoCopyable {
+public:
+    explicit VCodecBaseCallback(const std::shared_ptr<AudioCodecServer> &codec);
+    virtual ~VCodecBaseCallback();
+
+    void OnError(AVCodecErrorType errorType, int32_t errorCode);
+    void OnOutputFormatChanged(const Format &format);
+    void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer);
+    void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer);
+
+private:
+    std::shared_ptr<AudioCodecServer> codec_ = nullptr;
+};
+} // namespace MediaAVCodec
+} // namespace OHOS
+#endif // CODEC_SERVER_H
\ No newline at end of file
diff --git a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp
index 493fb9c2be50f88c616f05707cd9adf8094f18f0..75908024d80eec4a3ed0da6d76181d0dd3c87736 100644
--- a/test/unittest/audio_test/audio_codec_inner_unit_test.cpp
+++ b/test/unittest/audio_test/audio_codec_inner_unit_test.cpp
@@ -3,7 +3,7 @@
 #define private public
 #include "avcodec_audio_codec_inner_impl.h"
 #undef private
-#include "i_avcodec_service.h"
+#include "audio_codec_server.h"
 #include "avcodec_log.h"
 #include "avcodec_errors.h"
 #include "avcodec_trace.h"
@@ -19,60 +19,57 @@ constexpr int32_t DEFAULT_BUFFER_SIZE = 4;
 namespace OHOS {
 namespace Media {
 
-class MockCodecService : public ICodecService {
+class MockCodecService : public AudioCodecServer {
 public:
     MOCK_METHOD(int32_t, Init,
-        (AVCodecType type, bool isMimeType, const std::string &name, Meta &callerInfo, API_VERSION apiVersion),
-        (override));
-    MOCK_METHOD(int32_t, Configure, (const Format &format), (override));
-    MOCK_METHOD(int32_t, SetCustomBuffer, (std::shared_ptr<AVBuffer> buffer), (override));
-    MOCK_METHOD(int32_t, Start, (), (override));
-    MOCK_METHOD(int32_t, Stop, (), (override));
-    MOCK_METHOD(int32_t, Flush, (), (override));
-    MOCK_METHOD(int32_t, Reset, (), (override));
-    MOCK_METHOD(int32_t, Release, (), (override));
-    MOCK_METHOD(int32_t, NotifyEos, (), (override));
-    MOCK_METHOD(sptr<Surface>, CreateInputSurface, (), (override));
-    MOCK_METHOD(int32_t, SetOutputSurface, (sptr<Surface> surface), (override));
+        (AVCodecType type, bool isMimeType, const std::string &name, Meta &callerInfo, API_VERSION apiVersion));
+    MOCK_METHOD(int32_t, Configure, (const Format &format));
+    MOCK_METHOD(int32_t, SetCustomBuffer, (std::shared_ptr<AVBuffer> buffer));
+    MOCK_METHOD(int32_t, Start, ());
+    MOCK_METHOD(int32_t, Stop, ());
+    MOCK_METHOD(int32_t, Flush, ());
+    MOCK_METHOD(int32_t, Reset, ());
+    MOCK_METHOD(int32_t, Release, ());
+    MOCK_METHOD(int32_t, NotifyEos, ());
+    MOCK_METHOD(sptr<Surface>, CreateInputSurface, ());
+    MOCK_METHOD(int32_t, SetOutputSurface, (sptr<Surface> surface));
     MOCK_METHOD(
-        int32_t, QueueInputBuffer, (uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag), (override));
-    MOCK_METHOD(int32_t, QueueInputBuffer, (uint32_t index), (override));
-    MOCK_METHOD(int32_t, QueueInputParameter, (uint32_t index), (override));
-    MOCK_METHOD(int32_t, GetOutputFormat, (Format & format), (override));
-    MOCK_METHOD(int32_t, ReleaseOutputBuffer, (uint32_t index, bool render), (override));
-    MOCK_METHOD(int32_t, RenderOutputBufferAtTime, (uint32_t index, int64_t renderTimestampNs), (override));
-    MOCK_METHOD(int32_t, SetParameter, (const Format &format), (override));
-    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<AVCodecCallback> &callback), (override));
-    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<MediaCodecCallback> &callback), (override));
-    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<MediaCodecParameterCallback> &callback), (override));
+        int32_t, QueueInputBuffer, (uint32_t index, AVCodecBufferInfo info, AVCodecBufferFlag flag));
+    MOCK_METHOD(int32_t, QueueInputBuffer, (uint32_t index));
+    MOCK_METHOD(int32_t, QueueInputParameter, (uint32_t index));
+    MOCK_METHOD(int32_t, GetOutputFormat, (Format & format));
+    MOCK_METHOD(int32_t, ReleaseOutputBuffer, (uint32_t index, bool render));
+    MOCK_METHOD(int32_t, RenderOutputBufferAtTime, (uint32_t index, int64_t renderTimestampNs));
+    MOCK_METHOD(int32_t, SetParameter, (const Format &format));
+    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<AVCodecCallback> &callback));
+    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<MediaCodecCallback> &callback));
+    MOCK_METHOD(int32_t, SetCallback, (const std::shared_ptr<MediaCodecParameterCallback> &callback));
     MOCK_METHOD(
-        int32_t, SetCallback, (const std::shared_ptr<MediaCodecParameterWithAttrCallback> &callback), (override));
-    MOCK_METHOD(int32_t, ChangePlugin, (const std::string &mime, bool isEncoder, const std::shared_ptr<Meta> &meta),
-        (override));
-    MOCK_METHOD(int32_t, SetCodecCallback, (const std::shared_ptr<MediaCodecCallback> &codecCallback), (override));
-    MOCK_METHOD(void, SetDumpInfo, (bool isDump, uint64_t instanceId), (override));
-    MOCK_METHOD(int32_t, GetInputFormat, (Format & format), (override));
+        int32_t, SetCallback, (const std::shared_ptr<MediaCodecParameterWithAttrCallback> &callback));
+    MOCK_METHOD(int32_t, ChangePlugin, (const std::string &mime, bool isEncoder, const std::shared_ptr<Meta> &meta));
+    MOCK_METHOD(int32_t, SetCodecCallback, (const std::shared_ptr<MediaCodecCallback> &codecCallback));
+    MOCK_METHOD(void, SetDumpInfo, (bool isDump, uint64_t instanceId));
+    MOCK_METHOD(int32_t, GetInputFormat, (Format & format));
     MOCK_METHOD(int32_t, SetDecryptConfig,
-        (const sptr<DrmStandard::IMediaKeySessionService> &keySession, const bool svpFlag), (override));
-    MOCK_METHOD(int32_t, CreateCodecByName, (const std::string &name), (override));
-    MOCK_METHOD(int32_t, Configure, (const std::shared_ptr<Meta> &meta), (override));
-    MOCK_METHOD(int32_t, SetParameter, (const std::shared_ptr<Meta> &parameter), (override));
-    MOCK_METHOD(int32_t, GetOutputFormat, (std::shared_ptr<Meta> & parameter), (override));
-    MOCK_METHOD(int32_t, SetOutputBufferQueue, (const sptr<AVBufferQueueProducer> &bufferQueueProducer), (override));
-    MOCK_METHOD(int32_t, Prepare, (), (override));
-    MOCK_METHOD(sptr<AVBufferQueueProducer>, GetInputBufferQueue, (), (override));
-    MOCK_METHOD(void, ProcessInputBuffer, (), (override));
-    MOCK_METHOD(bool, CheckRunning, (), (override));
+        (const sptr<DrmStandard::IMediaKeySessionService> &keySession, const bool svpFlag));
+    MOCK_METHOD(int32_t, CreateCodecByName, (const std::string &name));
+    MOCK_METHOD(int32_t, Configure, (const std::shared_ptr<Meta> &meta));
+    MOCK_METHOD(int32_t, SetParameter, (const std::shared_ptr<Meta> &parameter));
+    MOCK_METHOD(int32_t, GetOutputFormat, (std::shared_ptr<Meta> & parameter));
+    MOCK_METHOD(int32_t, SetOutputBufferQueue, (const sptr<AVBufferQueueProducer> &bufferQueueProducer));
+    MOCK_METHOD(int32_t, Prepare, ());
+    MOCK_METHOD(sptr<AVBufferQueueProducer>, GetInputBufferQueue, ());
+    MOCK_METHOD(void, ProcessInputBuffer, ());
+    MOCK_METHOD(bool, CheckRunning, ());
     MOCK_METHOD(int32_t, SetAudioDecryptionConfig,
-        (const sptr<DrmStandard::IMediaKeySessionService> &keySession, const bool svpFlag), (override));
-    MOCK_METHOD(sptr<AVBufferQueueConsumer>, GetInputBufferQueueConsumer, (), (override));
-    MOCK_METHOD(sptr<AVBufferQueueProducer>, GetOutputBufferQueueProducer, (), (override));
+        (const sptr<DrmStandard::IMediaKeySessionService> &keySession, const bool svpFlag));
+    MOCK_METHOD(sptr<AVBufferQueueConsumer>, GetInputBufferQueueConsumer, ());
+    MOCK_METHOD(sptr<AVBufferQueueProducer>, GetOutputBufferQueueProducer, ());
     MOCK_METHOD(
-        void, ProcessInputBufferInner, (bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus), (override));
+        void, ProcessInputBufferInner, (bool isTriggeredByOutPort, bool isFlushed, uint32_t &bufferStatus));
 
     MOCK_METHOD(int32_t, GetChannelId, (int32_t & channelId));
     MOCK_METHOD(int32_t, SetLowPowerPlayerMode, (bool isLpp));
-    MOCK_METHOD(int32_t, NotifyMemoryExchange, (const bool exchangeFlag), (override));
 };
 
 class AudioCodecInnerTest : public ::testing::Test {