diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
index e230b6b44244a32e4e03a7a3e91688482ce0f929..bf6dd1ca046e2a3038b94aae94659beccfcbd2f6 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
+++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.cpp
@@ -77,7 +77,7 @@ int32_t AVCodecAudioCodecImpl::Configure(const Format &format)
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
     auto meta = const_cast<Format &>(format).GetMeta();
-
+    inputBufferSize_ = 0;
     return codecService_->Configure(meta);
 }
 
@@ -100,6 +100,7 @@ int32_t AVCodecAudioCodecImpl::Prepare()
     implConsumer_->SetBufferAvailableListener(comsumerListener);
 
     outputTask_->RegisterHandler([this] { ConsumerOutputBuffer(); });
+    inputTask_->RegisterHandler([this] { ProduceInputBuffer(); });
     return AVCS_ERR_OK;
 }
 
@@ -113,7 +114,6 @@ int32_t AVCodecAudioCodecImpl::Start()
     indexInput_ = 0;
     indexOutput_ = 0;
     if (inputTask_) {
-        inputTask_->RegisterHandler([this] { ProduceInputBuffer(); });
         inputTask_->Start();
     } else {
         AVCODEC_LOGE("Start failed, inputTask_ is nullptr, please check the inputTask_.");
@@ -122,7 +122,7 @@ int32_t AVCodecAudioCodecImpl::Start()
     if (outputTask_) {
         outputTask_->Start();
     } else {
-        AVCODEC_LOGE("Start failed, inputTask_ is nullptr, please check the inputTask_.");
+        AVCODEC_LOGE("Start failed, outputTask_ is nullptr, please check the outputTask_.");
         ret = AVCS_ERR_UNKNOWN;
     }
     AVCODEC_LOGI("Start,ret = %{public}d", ret);
@@ -133,8 +133,8 @@ int32_t AVCodecAudioCodecImpl::Stop()
 {
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
-    StopTask();
     int32_t ret = codecService_->Stop();
+    StopTask();
     ClearCache();
     return ret;
 }
@@ -143,8 +143,8 @@ int32_t AVCodecAudioCodecImpl::Flush()
 {
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
-    PauseTask();
     int32_t ret = codecService_->Flush();
+    PauseTask();
     ClearCache();
     return ret;
 }
@@ -153,9 +153,10 @@ int32_t AVCodecAudioCodecImpl::Reset()
 {
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
-    StopTask();
     int32_t ret = codecService_->Reset();
+    StopTask();
     ClearCache();
+    inputBufferSize_ = 0;
     return ret;
 }
 
@@ -163,9 +164,10 @@ int32_t AVCodecAudioCodecImpl::Release()
 {
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
-    StopTask();
     int32_t ret = codecService_->Release();
+    StopTask();
     ClearCache();
+    inputBufferSize_ = 0;
     return ret;
 }
 
@@ -175,9 +177,7 @@ int32_t AVCodecAudioCodecImpl::QueueInputBuffer(uint32_t index)
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
     CHECK_AND_RETURN_RET_LOG(mediaCodecProducer_ != nullptr, AVCS_ERR_INVALID_STATE,
                              "mediaCodecProducer_ is nullptr");
-    CHECK_AND_RETURN_RET_LOG(codecService_->GetStatus(), AVCS_ERR_INVALID_STATE,
-                             "GetStatus is not running");
-              
+    CHECK_AND_RETURN_RET_LOG(codecService_->GetStatus(), AVCS_ERR_INVALID_STATE, "GetStatus is not running");
     std::shared_ptr<AVBuffer> buffer;
     {
         std::unique_lock lock(inputMutex_);
@@ -188,8 +188,16 @@ int32_t AVCodecAudioCodecImpl::QueueInputBuffer(uint32_t index)
         inputBufferObjMap_.erase(index);
     }
     CHECK_AND_RETURN_RET_LOG(buffer != nullptr, AVCS_ERR_INVALID_STATE, "buffer not found");
-    Media::Status ret = mediaCodecProducer_->PushBuffer(buffer, true);
-    return StatusToAVCodecServiceErrCode(ret);
+    if (!(buffer->flag_ & AVCODEC_BUFFER_FLAG_EOS) && buffer->GetConfig().size <= 0) {
+        AVCODEC_LOGE("buffer size is 0,please fill audio buffer in");
+        return AVCS_ERR_UNKNOWN;
+    }
+    {
+        std::unique_lock lock(outputMutex_2);
+        inputIndexQueue.emplace(buffer);
+    }
+    outputCondition_.notify_one();
+    return AVCS_ERR_OK;
 }
 
 #ifdef SUPPORT_DRM
@@ -249,6 +257,7 @@ int32_t AVCodecAudioCodecImpl::SetParameter(const Format &format)
     AVCODEC_SYNC_TRACE;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
     auto meta = const_cast<Format &>(format).GetMeta();
+    inputBufferSize_ = 0;
     return codecService_->SetParameter(meta);
 }
 
@@ -258,7 +267,8 @@ int32_t AVCodecAudioCodecImpl::SetCallback(const std::shared_ptr<MediaCodecCallb
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, AVCS_ERR_INVALID_STATE, "service died");
     CHECK_AND_RETURN_RET_LOG(callback != nullptr, AVCS_ERR_INVALID_VAL, "callback is nullptr");
     callback_ = callback;
-    return AVCS_ERR_OK;
+    std::shared_ptr<AVCodecInnerCallback> innerCallback = std::make_shared<AVCodecInnerCallback>(this);
+    return codecService_->SetCallback(innerCallback);
 }
 
 void AVCodecAudioCodecImpl::Notify()
@@ -272,6 +282,9 @@ void AVCodecAudioCodecImpl::Notify()
 
 int32_t AVCodecAudioCodecImpl::GetInputBufferSize()
 {
+    if (inputBufferSize_ > 0) {
+        return inputBufferSize_;
+    }
     int32_t capacity = 0;
     CHECK_AND_RETURN_RET_LOG(codecService_ != nullptr, capacity, "codecService_ is nullptr");
     std::shared_ptr<Media::Meta> bufferConfig = std::make_shared<Media::Meta>();
@@ -280,6 +293,7 @@ int32_t AVCodecAudioCodecImpl::GetInputBufferSize()
     CHECK_AND_RETURN_RET_LOG(ret == 0, capacity, "GetOutputFormat fail");
     CHECK_AND_RETURN_RET_LOG(bufferConfig->Get<Media::Tag::AUDIO_MAX_INPUT_SIZE>(capacity), capacity,
                              "get max input buffer size fail");
+    inputBufferSize_ = capacity;
     return capacity;
 }
 
@@ -313,8 +327,9 @@ void AVCodecAudioCodecImpl::ProduceInputBuffer()
         callback_->OnInputBufferAvailable(indexInput_, emptyBuffer);
         indexInput_++;
     }
+
     inputCondition_.wait_for(lock2, std::chrono::milliseconds(MILLISECONDS),
-                             [this] { return ((bufferConsumerAvailableCount_ > 0) || !isRunning_); });
+                             [this] { return ((mediaCodecProducer_->GetQueueSize() > 0) || !isRunning_); });
     AVCODEC_LOGD_LIMIT(LOGD_FREQUENCY, "produceInputBuffer exit");
 }
 
@@ -327,25 +342,24 @@ void AVCodecAudioCodecImpl::ConsumerOutputBuffer()
         AVCODEC_LOGE("Consumer isRunning_ false");
         return;
     }
-    Media::Status ret = Media::Status::OK;
-    std::unique_lock lock2(outputMutex_2);
-    while (isRunning_ && (bufferConsumerAvailableCount_ > 0)) {
-        std::shared_ptr<AVBuffer> filledInputBuffer;
-        ret = implConsumer_->AcquireBuffer(filledInputBuffer);
+
+    while (isRunning_ && (!inputIndexQueue.empty())) {
+        std::shared_ptr<AVBuffer> buffer;
+        {
+            std::unique_lock lock2(outputMutex_2);
+            buffer = inputIndexQueue.front();
+            inputIndexQueue.pop();
+        }
+        Media::Status ret = mediaCodecProducer_->PushBuffer(buffer, true);
         if (ret != Media::Status::OK) {
-            AVCODEC_LOGE("Consumer AcquireBuffer fail,ret=%{public}d", ret);
+            AVCODEC_LOGW("ConsumerOutputBuffer PushBuffer fail, ret=%{public}d", ret);
             break;
         }
-        {
-            std::unique_lock lock(outputMutex_);
-            outputBufferObjMap_[indexOutput_] = filledInputBuffer;
-        }
-        callback_->OnOutputBufferAvailable(indexOutput_, filledInputBuffer);
-        indexOutput_++;
-        bufferConsumerAvailableCount_--;
+        inputCondition_.notify_all();
     }
+    std::unique_lock lock2(outputMutex_2);
     outputCondition_.wait_for(lock2, std::chrono::milliseconds(MILLISECONDS),
-                              [this] { return ((bufferConsumerAvailableCount_ > 0) || !isRunning_); });
+                              [this] { return ((!inputIndexQueue.empty()) || !isRunning_); });
     AVCODEC_LOGD_LIMIT(LOGD_FREQUENCY, "ConsumerOutputBuffer exit");
 }
 
@@ -357,11 +371,16 @@ void AVCodecAudioCodecImpl::ClearCache()
         implConsumer_->ReleaseBuffer(buffer);
     }
     inputBufferObjMap_.clear();
+    while (!inputIndexQueue.empty()) {
+        inputIndexQueue.pop();
+    }
 }
 
 void AVCodecAudioCodecImpl::StopTask()
 {
     isRunning_ = false;
+    inputCondition_.notify_one();
+    outputCondition_.notify_one();
     if (inputTask_) {
         inputTask_->Stop();
     }
@@ -373,6 +392,8 @@ void AVCodecAudioCodecImpl::StopTask()
 void AVCodecAudioCodecImpl::PauseTask()
 {
     isRunning_ = false;
+    inputCondition_.notify_one();
+    outputCondition_.notify_one();
     if (inputTask_) {
         inputTask_->Pause();
     }
@@ -380,5 +401,46 @@ void AVCodecAudioCodecImpl::PauseTask()
         outputTask_->Pause();
     }
 }
+
+AVCodecAudioCodecImpl::AVCodecInnerCallback::AVCodecInnerCallback(AVCodecAudioCodecImpl *impl) : impl_(impl) {}
+
+void AVCodecAudioCodecImpl::AVCodecInnerCallback::OnError(AVCodecErrorType errorType, int32_t errorCode)
+{
+    if (impl_->callback_) {
+        impl_->callback_->OnError(errorType, errorCode);
+    }
+}
+
+void AVCodecAudioCodecImpl::AVCodecInnerCallback::OnOutputFormatChanged(const Format &format)
+{
+    if (impl_->callback_) {
+        impl_->callback_->OnOutputFormatChanged(format);
+    }
+}
+
+void AVCodecAudioCodecImpl::AVCodecInnerCallback::OnInputBufferAvailable(uint32_t index,
+                                                                         std::shared_ptr<AVBuffer> buffer)
+{
+    (void)index;
+    (void)buffer;
+}
+
+void AVCodecAudioCodecImpl::AVCodecInnerCallback::OnOutputBufferAvailable(uint32_t index,
+                                                                          std::shared_ptr<AVBuffer> buffer)
+{
+    if (impl_->callback_) {
+        Media::Status ret = impl_->implConsumer_->AcquireBuffer(buffer);
+        if (ret != Media::Status::OK) {
+            AVCODEC_LOGE("Consumer AcquireBuffer fail,ret=%{public}d", ret);
+            return;
+        }
+        {
+            std::unique_lock lock(impl_->outputMutex_);
+            impl_->outputBufferObjMap_[impl_->indexOutput_] = buffer;
+        }
+        impl_->callback_->OnOutputBufferAvailable(impl_->indexOutput_, buffer);
+        impl_->indexOutput_++;
+    }
+}
 } // namespace MediaAVCodec
 } // namespace OHOS
diff --git a/frameworks/native/avcodec/avcodec_audio_codec_impl.h b/frameworks/native/avcodec/avcodec_audio_codec_impl.h
index 73f0f462b06c5fa1577fd1500985658ddc8a2cad..07d6bf9c2d0e9d578b4e1beec2ef15df8b818a6f 100644
--- a/frameworks/native/avcodec/avcodec_audio_codec_impl.h
+++ b/frameworks/native/avcodec/avcodec_audio_codec_impl.h
@@ -15,6 +15,7 @@
 #ifndef AVCODEC_AUDIO_CODEC_IMPL_H
 #define AVCODEC_AUDIO_CODEC_IMPL_H
 
+#include <queue>
 #include "avcodec_audio_codec.h"
 #include "nocopyable.h"
 #include "task_thread.h"
@@ -59,6 +60,20 @@ private:
     void StopTask();
     void PauseTask();
 
+private:
+    class AVCodecInnerCallback : public MediaCodecCallback {
+    public:
+        explicit AVCodecInnerCallback(AVCodecAudioCodecImpl *impl);
+        ~AVCodecInnerCallback() = default;
+        void OnError(AVCodecErrorType errorType, int32_t errorCode) override;
+        void OnOutputFormatChanged(const Format &format) override;
+        void OnInputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) override;
+        void OnOutputBufferAvailable(uint32_t index, std::shared_ptr<AVBuffer> buffer) override;
+
+    private:
+        AVCodecAudioCodecImpl *impl_;
+    };
+
 private:
     std::atomic<bool> isRunning_;
     std::shared_ptr<ICodecService> codecService_ = nullptr;
@@ -75,6 +90,8 @@ private:
     std::atomic<int32_t> bufferConsumerAvailableCount_ = 0;
     std::atomic<int32_t> indexInput_ = 0;
     std::atomic<int32_t> indexOutput_ = 0;
+    uint32_t inputBufferSize_ = 0;
+    std::queue<std::shared_ptr<AVBuffer>> inputIndexQueue;
     std::unordered_map<uint32_t, std::shared_ptr<AVBuffer>> inputBufferObjMap_;
     std::unordered_map<uint32_t, std::shared_ptr<AVBuffer>> outputBufferObjMap_;
     sptr<Media::AVBufferQueueProducer> mediaCodecProducer_;
diff --git a/services/engine/codec/include/audio/audio_codec.h b/services/engine/codec/include/audio/audio_codec.h
index 3d60665bf9e704b6fc2ea9989d5d7156970813d9..10b315ea4293c95e2118ff20d8f6b9f31ec06b53 100644
--- a/services/engine/codec/include/audio/audio_codec.h
+++ b/services/engine/codec/include/audio/audio_codec.h
@@ -24,7 +24,23 @@
 
 namespace OHOS {
 namespace MediaAVCodec {
-class AudioCodec : public CodecBase {
+class AudioCodec;
+class AudioCodecCallback : public Media::AudioBaseCodecCallback {
+public:
+    AudioCodecCallback(const std::shared_ptr<AudioCodec> &codec) : codec_(codec) {}
+    virtual ~AudioCodecCallback()
+    {
+        codec_ = nullptr;
+    }
+
+    void OnError(Media::CodecErrorType errorType, int32_t errorCode) override;
+
+    void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer) override;
+
+private:
+    std::shared_ptr<AudioCodec> codec_;
+};
+class AudioCodec : public std::enable_shared_from_this<AudioCodec>, public CodecBase {
 public:
     explicit AudioCodec()
     {
@@ -32,26 +48,35 @@ public:
     }
     int32_t CreateCodecByName(const std::string &name) override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Init(name)));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Init(name)));
     }
 
     int32_t Configure(const std::shared_ptr<Media::Meta> &meta) override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Configure(meta)));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Configure(meta)));
     }
     int32_t SetOutputBufferQueue(const sptr<Media::AVBufferQueueProducer> &bufferQueueProducer) override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>
-            (mediaCodec_->SetOutputBufferQueue(bufferQueueProducer)));
+        return StatusToAVCodecServiceErrCode(
+            static_cast<Media::Status>(mediaCodec_->SetOutputBufferQueue(bufferQueueProducer)));
     }
+
     int32_t SetCodecCallback(const std::shared_ptr<Media::CodecCallback> &codecCallback)
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->SetCodecCallback(codecCallback)));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetCodecCallback(codecCallback)));
+    }
+
+    int32_t SetCallback(const std::shared_ptr<MediaCodecCallback> &codecCallback) override
+    {
+        callback_ = codecCallback;
+        std::shared_ptr<Media::AudioBaseCodecCallback> mediaCallback =
+            std::make_shared<AudioCodecCallback>(shared_from_this());
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetCodecCallback(mediaCallback)));
     }
 
     int32_t Prepare() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Prepare()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Prepare()));
     }
 
     sptr<Media::AVBufferQueueProducer> GetInputBufferQueue() override
@@ -61,42 +86,42 @@ public:
 
     int32_t Start() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Start()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Start()));
     }
 
     int32_t Stop() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Stop()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Stop()));
     }
 
     int32_t Flush() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Flush()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Flush()));
     }
 
     int32_t Reset() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Reset()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Reset()));
     }
 
     int32_t Release() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->Release()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->Release()));
     }
 
     int32_t NotifyEos() override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->NotifyEos()));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->NotifyEos()));
     }
 
     int32_t SetParameter(const std::shared_ptr<Media::Meta> &parameter) override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->SetParameter(parameter)));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->SetParameter(parameter)));
     }
 
     int32_t GetOutputFormat(std::shared_ptr<Media::Meta> &parameter) override
     {
-        return StatusToAVCodecServiceErrCode(static_cast<Media::Status> (mediaCodec_->GetOutputFormat(parameter)));
+        return StatusToAVCodecServiceErrCode(static_cast<Media::Status>(mediaCodec_->GetOutputFormat(parameter)));
     }
 
     int32_t Configure(const MediaAVCodec::Format &format) override
@@ -122,18 +147,48 @@ public:
         return 0;
     }
 
+    void OnError(int32_t errorCode)
+    {
+        if (callback_) {
+            callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, errorCode);
+        }
+    }
+
+    void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
+    {
+        if (callback_) {
+            callback_->OnOutputBufferAvailable(0, outputBuffer);
+        }
+    }
+
 #ifdef SUPPORT_DRM
     int32_t SetAudioDecryptionConfig(const sptr<DrmStandard::IMediaKeySessionService> &keySession,
-        const bool svpFlag) override
+                                     const bool svpFlag) override
     {
         return StatusToAVCodecServiceErrCode(
-            static_cast<Media::Status> (mediaCodec_->SetAudioDecryptionConfig(keySession, svpFlag)));
+            static_cast<Media::Status>(mediaCodec_->SetAudioDecryptionConfig(keySession, svpFlag)));
     }
 #endif
 
 private:
     std::shared_ptr<Media::MediaCodec> mediaCodec_;
+    std::shared_ptr<MediaCodecCallback> callback_;
 };
+
+void AudioCodecCallback::OnError(Media::CodecErrorType errorType, int32_t errorCode)
+{
+    if (codec_) {
+        (void)errorType;
+        codec_->OnError(errorCode);
+    }
+}
+
+void AudioCodecCallback::OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
+{
+    if (codec_) {
+        codec_->OnOutputBufferDone(outputBuffer);
+    }
+}
 } // namespace MediaAVCodec
 } // namespace OHOS
 #endif
\ No newline at end of file
diff --git a/services/media_engine/modules/media_codec/media_codec.cpp b/services/media_engine/modules/media_codec/media_codec.cpp
index df59bccd6d65c33c7d70e831a52f44fcb33e3b28..5693f7023e3600c7222016bb9937738bdcc6317b 100644
--- a/services/media_engine/modules/media_codec/media_codec.cpp
+++ b/services/media_engine/modules/media_codec/media_codec.cpp
@@ -41,6 +41,22 @@ private:
     MediaCodec *mediaCodec_;
 };
 
+MediaCodec::MediaCodec()
+    : codecPlugin_(nullptr),
+      inputBufferQueue_(nullptr),
+      inputBufferQueueProducer_(nullptr),
+      inputBufferQueueConsumer_(nullptr),
+      outputBufferQueueProducer_(nullptr),
+      codecCallback_(nullptr),
+      mediaCodecCallback_(nullptr),
+      isEncoder_(false),
+      isSurfaceMode_(false),
+      isBufferMode_(false),
+      outputBufferCapacity_(0),
+      state_(CodecState::UNINITIALIZED)
+{
+}
+
 int32_t MediaCodec::Init(const std::string &mime, bool isEncoder)
 {
     AutoLock lock(stateMutex_);
@@ -162,6 +178,17 @@ int32_t MediaCodec::SetCodecCallback(const std::shared_ptr<CodecCallback> &codec
     return (int32_t)Status::OK;
 }
 
+int32_t MediaCodec::SetCodecCallback(const std::shared_ptr<AudioBaseCodecCallback> &codecCallback)
+{
+    AutoLock lock(stateMutex_);
+    FALSE_RETURN_V(state_ == CodecState::INITIALIZED || state_ == CodecState::CONFIGURED,
+                   (int32_t)Status::ERROR_INVALID_STATE);
+    FALSE_RETURN_V_MSG_E(codecCallback != nullptr, (int32_t)Status::ERROR_INVALID_PARAMETER,
+                         "codecCallback is nullptr");
+    mediaCodecCallback_ = codecCallback;
+    return (int32_t)Status::OK;
+}
+
 int32_t MediaCodec::SetOutputSurface(sptr<Surface> surface)
 {
     AutoLock lock(stateMutex_);
@@ -287,6 +314,7 @@ int32_t MediaCodec::Reset()
     }
     auto ret = codecPlugin_->Reset();
     FALSE_RETURN_V_MSG_E(ret == Status::OK, (int32_t)ret, "plugin reset failed");
+    ClearInputBuffer();
     state_ = CodecState::INITIALIZED;
     return (int32_t)ret;
 }
@@ -516,6 +544,10 @@ void MediaCodec::ProcessInputBuffer()
     Status ret;
     uint32_t eosStatus = 0;
     std::shared_ptr<AVBuffer> filledInputBuffer;
+    if (state_ != CodecState::RUNNING) {
+        MEDIA_LOG_E("status changed, current status is not running in ProcessInputBuffer");
+        return;
+    }
     ret = inputBufferQueueConsumer_->AcquireBuffer(filledInputBuffer);
     if (ret != Status::OK) {
         MEDIA_LOG_E("ProcessInputBuffer AcquireBuffer fail");
@@ -585,9 +617,12 @@ Status MediaCodec::HandleOutputBuffer(uint32_t eosStatus)
     AVBufferConfig avBufferConfig;
     do {
         ret = outputBufferQueueProducer_->RequestBuffer(emptyOutputBuffer, avBufferConfig, TIME_OUT_MS);
-    } while (ret != Status::OK);
+    } while (ret != Status::OK && state_ == CodecState::RUNNING);
+
     if (emptyOutputBuffer) {
         emptyOutputBuffer->flag_ = eosStatus;
+    } else if (state_ != CodecState::RUNNING) {
+        return Status::OK;
     } else {
         return Status::ERROR_NULL_POINTER;
     }
@@ -608,6 +643,9 @@ Status MediaCodec::HandleOutputBuffer(uint32_t eosStatus)
 
 void MediaCodec::ClearInputBuffer()
 {
+    if (!inputBufferQueueConsumer_) {
+        return;
+    }
     std::shared_ptr<AVBuffer> filledInputBuffer;
     Status ret = Status::OK;
     while (ret == Status::OK) {
@@ -629,6 +667,9 @@ void MediaCodec::OnInputBufferDone(const std::shared_ptr<AVBuffer> &inputBuffer)
 void MediaCodec::OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer)
 {
     Status ret = outputBufferQueueProducer_->PushBuffer(outputBuffer, true);
+    if (mediaCodecCallback_) {
+        mediaCodecCallback_->OnOutputBufferDone(outputBuffer);
+    }
     FALSE_RETURN_MSG(ret == Status::OK, "OnOutputBufferDone fail");
 }
 
diff --git a/services/media_engine/modules/media_codec/media_codec.h b/services/media_engine/modules/media_codec/media_codec.h
index 30eabd229cfb63f45fef4fdf76f7a5dd16e0a6c3..1be4361ca383bb2d0785a44a2335f3591a946910 100644
--- a/services/media_engine/modules/media_codec/media_codec.h
+++ b/services/media_engine/modules/media_codec/media_codec.h
@@ -67,9 +67,18 @@ public:
     virtual void OnOutputFormatChanged(const std::shared_ptr<Meta> &format) = 0;
 };
 
+class AudioBaseCodecCallback {
+public:
+    virtual ~AudioBaseCodecCallback() = default;
+
+    virtual void OnError(CodecErrorType errorType, int32_t errorCode) = 0;
+
+    virtual void OnOutputBufferDone(const std::shared_ptr<AVBuffer> &outputBuffer) = 0;
+};
+
 class MediaCodec : public Plugins::DataCallback {
 public:
-    MediaCodec() = default;
+    MediaCodec();
 
     int32_t Init(const std::string &mime, bool isEncoder);
 
@@ -81,6 +90,8 @@ public:
 
     int32_t SetCodecCallback(const std::shared_ptr<CodecCallback> &codecCallback);
 
+    int32_t SetCodecCallback(const std::shared_ptr<AudioBaseCodecCallback> &codecCallback);
+
     int32_t SetOutputSurface(sptr<Surface> surface);
 
     int32_t Prepare();
@@ -140,14 +151,15 @@ private:
     sptr<AVBufferQueueConsumer> inputBufferQueueConsumer_;
     sptr<AVBufferQueueProducer> outputBufferQueueProducer_;
     std::shared_ptr<CodecCallback> codecCallback_;
+    std::shared_ptr<AudioBaseCodecCallback> mediaCodecCallback_;
     AVBufferConfig outputBufferConfig_;
-    bool isEncoder_ = false;
-    bool isSurfaceMode_ = false;
-    bool isBufferMode_ = false;
-    int32_t outputBufferCapacity_ = 0;
+    bool isEncoder_;
+    bool isSurfaceMode_;
+    bool isBufferMode_;
+    int32_t outputBufferCapacity_;
 
     std::shared_ptr<MediaAVCodec::CodecDrmDecrypt> drmDecryptor_ = nullptr;
-    std::atomic<CodecState> state_ = CodecState::UNINITIALIZED;
+    std::atomic<CodecState> state_ ;
     Mutex stateMutex_;
 };
 } // namespace Media