diff --git a/services/cameraservice/cameraoperator/client/include/dcamera_client.h b/services/cameraservice/cameraoperator/client/include/dcamera_client.h
index 1df19c7b12cc643a9d4ab797ea0c095b6d78ed35..9fe39811bb6f2d9a8f9bb550d53e8f51637b558c 100644
--- a/services/cameraservice/cameraoperator/client/include/dcamera_client.h
+++ b/services/cameraservice/cameraoperator/client/include/dcamera_client.h
@@ -49,7 +49,6 @@ public:
     int32_t SetResultCallback(std::shared_ptr<ResultCallback>& callback) override;
     int32_t PauseCapture() override;
     int32_t ResumeCapture() override;
-    int32_t PrelaunchCamera() override;
 
 private:
     int32_t ConfigCaptureSession(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos, int32_t sceneMode);
diff --git a/services/cameraservice/cameraoperator/client/include/icamera_operator.h b/services/cameraservice/cameraoperator/client/include/icamera_operator.h
index 90daa089d4f0084af5a70fe942c5311045e1b863..97309ff73f91c035fd566fc5e465e6a35c792fe3 100644
--- a/services/cameraservice/cameraoperator/client/include/icamera_operator.h
+++ b/services/cameraservice/cameraoperator/client/include/icamera_operator.h
@@ -64,7 +64,6 @@ public:
     virtual int32_t SetResultCallback(std::shared_ptr<ResultCallback>& callback) = 0;
     virtual int32_t PauseCapture() = 0;
     virtual int32_t ResumeCapture() = 0;
-    virtual int32_t PrelaunchCamera() = 0;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
index 099cf53a91c9acbf4d678b085604cb7c7f6774ff..78851383b43a990d28ba773d53e6f0ebe31af427 100644
--- a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
+++ b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
@@ -665,19 +665,5 @@ int32_t DCameraClient::ResumeCapture()
     }
     return ret;
 }
-
-int32_t DCameraClient::PrelaunchCamera()
-{
-    if (cameraManager_ == nullptr) {
-        DHLOGE("DCameraClient cameraManager_ is nullptr.");
-        return DCAMERA_BAD_VALUE;
-    }
-    int32_t ret = cameraManager_->PrelaunchCamera();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraClient PrelaunchCamera Start failed, cameraId: %{public}s, ret: %{public}d",
-            GetAnonyString(cameraId_).c_str(), ret);
-    }
-    return ret;
-}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
index 0a81725d3713dfc1645987fe80df831548827ab6..3660d51ef58d181b05b89c8962d72d5af3d1f385 100644
--- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
+++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
@@ -85,9 +85,6 @@ private:
     void ProcessPostAuthorization(const AppExecFwk::InnerEvent::Pointer &event);
     int32_t CreateCtrlSession();
     int32_t CheckSensitive();
-    void HandleConnecting();
-    void HandleConnected(std::string networkId);
-    void HandleDisconnected();
 
     bool isInit_;
     int32_t sessionState_;
diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
index 9e2d39b2baf9d6928c6bd7e9f1dd8d2acf5c2f88..6ac21696b396024286495d7ed68b5dd30f1cdcbd 100644
--- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
@@ -544,21 +544,45 @@ void DCameraSinkController::OnMetadataResult(std::vector<std::shared_ptr<DCamera
 void DCameraSinkController::OnSessionState(int32_t state, std::string networkId)
 {
     DHLOGI("DCameraSinkController::OnSessionState dhId: %{public}s, state: %{public}d",
-           GetAnonyString(dhId_).c_str(), state);
+        GetAnonyString(dhId_).c_str(), state);
     sessionState_ = state;
     switch (state) {
         case DCAMERA_CHANNEL_STATE_CONNECTING:
-            HandleConnecting();
+            DHLOGI("channel is connecting");
             break;
-        case DCAMERA_CHANNEL_STATE_CONNECTED:
-            HandleConnected(networkId);
+        case DCAMERA_CHANNEL_STATE_CONNECTED: {
+            DHLOGI("channel is connected");
+            if (!ManageSelectChannel::GetInstance().GetSinkConnect()) {
+                break;
+            }
+            srcDevId_ = networkId;
+            int32_t ret = CheckSensitive();
+            if (ret != DCAMERA_OK) {
+                DHLOGE("Check sensitive error. ret %{public}d.", ret);
+                return;
+            }
+            ret = PullUpPage();
+            CHECK_AND_RETURN_LOG(ret != DCAMERA_OK, "PullUpPage failed");
             break;
+        }
         case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
-            std::shared_ptr<DCameraEvent> events = std::make_shared<DCameraEvent>();
-            events->eventType_ = DCAMERA_SINK_STOP;
-            events->eventResult_ = DCAMERA_EVENT_SINK_STOP;
-            DCameraNotify(events);
-            HandleDisconnected();
+            DHLOGI("channel is disconnected");
+            ffrt::submit([this]() {
+                DHLOGI("DCameraSinkController::OnSessionState %{public}s new thread session state: %{public}d",
+                    GetAnonyString(dhId_).c_str(), sessionState_);
+                prctl(PR_SET_NAME, CHANNEL_DISCONNECTED.c_str());
+                std::lock_guard<std::mutex> autoLock(autoLock_);
+                int32_t ret = CloseChannel();
+                if (ret != DCAMERA_OK) {
+                    DHLOGE("session state: %{public}d, %{public}s close channel failed, ret: %{public}d",
+                        sessionState_, GetAnonyString(dhId_).c_str(), ret);
+                }
+                ret = StopCapture();
+                if (ret != DCAMERA_OK) {
+                    DHLOGE("session state: %{public}d, %{public}s stop capture failed, ret: %{public}d",
+                        sessionState_, GetAnonyString(dhId_).c_str(), ret);
+                }
+            });
             break;
         }
         default:
@@ -567,54 +591,6 @@ void DCameraSinkController::OnSessionState(int32_t state, std::string networkId)
     }
 }
 
-void DCameraSinkController::HandleConnecting()
-{
-    DHLOGI("channel is connecting");
-}
-
-void DCameraSinkController::HandleConnected(std::string networkId)
-{
-    if (!ManageSelectChannel::GetInstance().GetSinkConnect()) {
-        return;
-    }
-    srcDevId_ = networkId;
-    int32_t ret = CheckSensitive();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("Check sensitive error. ret %{public}d.", ret);
-        return;
-    }
-    ret = PullUpPage();
-    CHECK_AND_RETURN_LOG(ret != DCAMERA_OK, "PullUpPage failed");
-    if (operator_ == nullptr) {
-        DHLOGE("operator_ is nullptr");
-        return;
-    }
-    ret = operator_->PrelaunchCamera();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("operator_ PrelaunchCamera error. ret %{public}d.", ret);
-    }
-}
-
-void DCameraSinkController::HandleDisconnected()
-{
-    ffrt::submit([this]() {
-        DHLOGI("DCameraSinkController::OnSessionState %{public}s new thread session state: %{public}d",
-               GetAnonyString(dhId_).c_str(), sessionState_);
-        prctl(PR_SET_NAME, CHANNEL_DISCONNECTED.c_str());
-        std::lock_guard<std::mutex> autoLock(autoLock_);
-        int32_t ret = CloseChannel();
-        if (ret != DCAMERA_OK) {
-            DHLOGE("session state: %{public}d, %{public}s close channel failed, ret: %{public}d",
-                   sessionState_, GetAnonyString(dhId_).c_str(), ret);
-        }
-        ret = StopCapture();
-        if (ret != DCAMERA_OK) {
-            DHLOGE("session state: %{public}d, %{public}s stop capture failed, ret: %{public}d",
-                   sessionState_, GetAnonyString(dhId_).c_str(), ret);
-        }
-    });
-}
-
 void DCameraSinkController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail)
 {
     DHLOGI("DCameraSinkController::OnSessionError dhId: %{public}s, eventType: %{public}d, eventReason: %{public}d,"
diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp
index 1adafec195029917a97ec564c08cf04264cd14ad..82a001b0a06442c4cc131b987d26d1a56776f729 100644
--- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp
+++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp
@@ -289,17 +289,5 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_008, TestSize.Level1)
     ret = output_->GetProperty(name, propertyCarrier);
     EXPECT_NE(DCAMERA_OK, ret);
 }
-
-/**
- * @tc.name: dcamera_sink_output_test_009
- * @tc.desc: Verify the PrelaunchCamera function.
- * @tc.type: FUNC
- * @tc.require: I5N1JI
- */
-HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_009, TestSize.Level1)
-{
-    int32_t ret = operator_->PrelaunchCamera();
-    EXPECT_EQ(DCAMERA_OK, ret);
-}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h
index 2a712d6af2937495e90ad5c70b45a6ab8a6bb0d5..67fc84e97d4ca9121b40bd106a6813065136f306 100644
--- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h
+++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h
@@ -110,11 +110,6 @@ public:
         }
         return DCAMERA_OK;
     }
-
-    int32_t PrelaunchCamera()
-    {
-        return DCAMERA_OK;
-    }
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
index f3d3edf43bb0308e78f1d6090e36cb2652afa086..6fa3b270903d2fbbe7a4026833446791d3e7c583 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
@@ -68,11 +68,6 @@ private:
     std::atomic<bool> isChannelConnected_ = false;
     std::mutex channelMtx_;
     std::condition_variable channelCond_;
-
-    static constexpr std::chrono::seconds TIMEOUT_1_SEC = std::chrono::seconds(1);
-    std::atomic<bool> isOpenChannel_ = false;
-    std::mutex isOpenChannelMtx_;
-    std::condition_variable isOpenChannelCond_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
index 8362419a06c3568ed9499d4cb0c943d13ce46368..f6b615c5a3ee8bf0157f0fb8289bf362350068e7 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameracontrol/dcamera_source_controller.cpp
@@ -64,7 +64,7 @@ DCameraSourceController::~DCameraSourceController()
 int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCameraCaptureInfo>>& captureInfos,
     int32_t sceneMode)
 {
-    if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("StartCapture not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
@@ -110,7 +110,7 @@ int32_t DCameraSourceController::StartCapture(std::vector<std::shared_ptr<DCamer
 
 int32_t DCameraSourceController::StopCapture()
 {
-    if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("StopCapture not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
@@ -162,7 +162,7 @@ int32_t DCameraSourceController::StopCapture()
 int32_t DCameraSourceController::ChannelNeg(std::shared_ptr<DCameraChannelInfo>& info)
 {
     if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
-        if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+        if (indexs_.size() > DCAMERA_MAX_NUM) {
             DHLOGE("ChannelNeg not support operate %{public}zu camera", indexs_.size());
             return DCAMERA_BAD_OPERATE;
         }
@@ -236,7 +236,7 @@ int32_t DCameraSourceController::DCameraNotify(std::shared_ptr<DCameraEvent>& ev
 
 int32_t DCameraSourceController::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
 {
-    if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("UpdateSettings not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
@@ -280,7 +280,7 @@ int32_t DCameraSourceController::UpdateSettings(std::vector<std::shared_ptr<DCam
 int32_t DCameraSourceController::GetCameraInfo(std::shared_ptr<DCameraInfo>& camInfo)
 {
     if (!ManageSelectChannel::GetInstance().GetSrcConnect()) {
-        if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+        if (indexs_.size() > DCAMERA_MAX_NUM) {
             DHLOGE("GetCameraInfo not support operate %{public}zu camera", indexs_.size());
             return DCAMERA_BAD_OPERATE;
         }
@@ -314,7 +314,7 @@ int32_t DCameraSourceController::GetCameraInfo(std::shared_ptr<DCameraInfo>& cam
 
 int32_t DCameraSourceController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& openInfo)
 {
-    if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("OpenChannel not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
@@ -362,7 +362,7 @@ int32_t DCameraSourceController::OpenChannel(std::shared_ptr<DCameraOpenInfo>& o
 
 int32_t DCameraSourceController::CloseChannel()
 {
-    if (indexs_.empty() || indexs_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.size() > DCAMERA_MAX_NUM) {
         DHLOGE("CloseChannel not support operate %{public}zu camera", indexs_.size());
         return DCAMERA_BAD_OPERATE;
     }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
index aa24885b4b15e6d625975028037edefa19e44417..85a23569074348b0e5515670fb3f499abf1bed90 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
@@ -180,21 +180,13 @@ int32_t DCameraSourceInput::OpenChannel(std::vector<DCameraIndex>& indexs)
     DHLOGI("DCameraSourceInput OpenChannel devId %{public}s dhId %{public}s continue state: %{public}d, snapshot "
         "state: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
         channelState_[CONTINUOUS_FRAME], channelState_[SNAPSHOT_FRAME]);
-    std::shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(true);
-    auto handler = std::make_shared<AppExecFwk::EventHandler>(runner);
-    std::vector<DCameraIndex> &localIndexs = indexs;
     if (channelState_[CONTINUOUS_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
-        auto task = [&]() {
-            int32_t ret = EstablishContinuousFrameSession(localIndexs);
-            if (ret != DCAMERA_OK) {
-                DHLOGE("esdablish continuous frame failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
-                    GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
-            }
-            std::unique_lock<std::mutex> lock(isOpenChannelMtx_);
-            isOpenChannel_.store(true);
-            isOpenChannelCond_.notify_one();
-        };
-        handler->PostTask(task, "DCameraSourceInput:OpenChannel", 0, AppExecFwk::EventQueue::Priority::HIGH);
+        int32_t ret = EstablishContinuousFrameSession(indexs);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("esdablish continuous frame failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret,
+                GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+            return ret;
+        }
     }
     if (channelState_[SNAPSHOT_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
         int32_t ret = EstablishSnapshotFrameSession(indexs);
@@ -202,12 +194,7 @@ int32_t DCameraSourceInput::OpenChannel(std::vector<DCameraIndex>& indexs)
             DHLOGE("esdablish snapshot frame failed ret: %{public}d,"
                 "devId: %{public}s, dhId: %{public}s", ret, GetAnonyString(devId_).c_str(),
                 GetAnonyString(dhId_).c_str());
-        }
-        {
-            std::unique_lock<std::mutex> lock(isOpenChannelMtx_);
-            while (!isOpenChannel_.load()) {
-                isOpenChannelCond_.wait_for(lock, TIMEOUT_1_SEC, [this] { return isOpenChannel_.load(); });
-            }
+            return ret;
         }
     }
     return DCAMERA_OK;
diff --git a/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h b/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h
index 7adb87dcac9b097ba823072dc579ae28fc39cc58..bf90e19e4b9b30fa6a7c9426a5b232e9cee78f58 100644
--- a/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h
+++ b/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h
@@ -120,7 +120,6 @@ private:
     const static std::map<std::int64_t, int32_t> ENCODER_BITRATE_TABLE;
     constexpr static uint64_t S2NS = 1000000000;
     constexpr static uint32_t US2NS = 1000;
-    constexpr static std::chrono::seconds TIMEOUT_1_SEC = std::chrono::seconds(1);
 
     std::weak_ptr<DCameraPipelineSink> callbackPipelineSink_;
     std::mutex mtxEncoderState_;
@@ -133,8 +132,6 @@ private:
     sptr<Surface> encodeProducerSurface_ = nullptr;
 
     std::atomic<bool> isEncoderProcess_ = false;
-    std::mutex isEncoderProcessMtx_;
-    std::condition_variable isEncoderProcessCond_;
 
     int32_t waitEncoderOutputCount_ = 0;
     int64_t lastFeedEncoderInputBufferTimeUs_ = 0;
diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
index 17fa55ad2106d201ef8436d7e5136770b54ba673..d309f0821dbdd2b7c5f9d34d5ee8df0f2d53f138 100644
--- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
+++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp
@@ -75,7 +75,6 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const
         processedConfig_ = sourceConfig;
         processedConfig = processedConfig_;
         isEncoderProcess_.store(true);
-        isEncoderProcessCond_.notify_one();
         return DCAMERA_OK;
     }
 
@@ -89,7 +88,6 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const
     }
     processedConfig = processedConfig_;
     isEncoderProcess_.store(true);
-    isEncoderProcessCond_.notify_one();
     return DCAMERA_OK;
 }
 
@@ -546,9 +544,9 @@ void EncodeDataProcess::OnOutputFormatChanged(const Media::Format &format)
 void EncodeDataProcess::OnOutputBufferAvailable(uint32_t index, MediaAVCodec::AVCodecBufferInfo info,
     MediaAVCodec::AVCodecBufferFlag flag, std::shared_ptr<Media::AVSharedMemory> buffer)
 {
-    std::unique_lock<std::mutex> lock(isEncoderProcessMtx_);
-    while (!isEncoderProcess_.load()) {
-        isEncoderProcessCond_.wait_for(lock, TIMEOUT_1_SEC, [this] { return isEncoderProcess_.load(); });
+    if (!isEncoderProcess_.load()) {
+        DHLOGE("EncodeNode occurred error or start release.");
+        return;
     }
     DHLOGD("Video encode buffer info: presentation TimeUs %{public}" PRId64", size %{public}d, offset %{public}d, "
         "flag %{public}d", info.presentationTimeUs, info.size, info.offset, flag);
diff --git a/services/data_process/test/unittest/common/pipeline_node/encode_data_process_test.cpp b/services/data_process/test/unittest/common/pipeline_node/encode_data_process_test.cpp
index 694c21591922f31eaf5aeefb5ac2fe4b0d4b8980..161a4534a717e10ba89be3000e69b010c01dc4f0 100644
--- a/services/data_process/test/unittest/common/pipeline_node/encode_data_process_test.cpp
+++ b/services/data_process/test/unittest/common/pipeline_node/encode_data_process_test.cpp
@@ -465,11 +465,11 @@ HWTEST_F(EncodeDataProcessTest, encode_data_process_test_014, TestSize.Level1)
     MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_CODEC_DATA;
     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
     testEncodeDataProcess_->OnOutputBufferAvailable(index, info, flag, buffer);
+    testEncodeDataProcess_->OnError();
     testEncodeDataProcess_->OnInputBufferAvailable(index, buffer);
     Media::Format format;
     testEncodeDataProcess_->OnOutputFormatChanged(format);
     testEncodeDataProcess_->OnOutputBufferAvailable(index, info, flag, buffer);
-    testEncodeDataProcess_->OnError();
     EXPECT_EQ(rc, DCAMERA_OK);
 }