diff --git a/services/cameraservice/cameraoperator/client/include/dcamera_client.h b/services/cameraservice/cameraoperator/client/include/dcamera_client.h
index 09167840f44723aebdcc3c851d7d99aadb18e331..1df19c7b12cc643a9d4ab797ea0c095b6d78ed35 100644
--- a/services/cameraservice/cameraoperator/client/include/dcamera_client.h
+++ b/services/cameraservice/cameraoperator/client/include/dcamera_client.h
@@ -49,6 +49,7 @@ 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);
@@ -91,4 +92,4 @@ private:
 };
 } // namespace DistributedHardware
 } // namespace OHOS
-#endif // OHOS_DCAMERA_CLIENT_H
\ No newline at end of file
+#endif // OHOS_DCAMERA_CLIENT_H
diff --git a/services/cameraservice/cameraoperator/client/include/icamera_operator.h b/services/cameraservice/cameraoperator/client/include/icamera_operator.h
index 0c0a2e40b97e5bc36bea36accd83fc5cfd97518c..90daa089d4f0084af5a70fe942c5311045e1b863 100644
--- a/services/cameraservice/cameraoperator/client/include/icamera_operator.h
+++ b/services/cameraservice/cameraoperator/client/include/icamera_operator.h
@@ -64,7 +64,8 @@ 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
-#endif // OHOS_ICAMERA_OPERATOR_H
\ No newline at end of file
+#endif // OHOS_ICAMERA_OPERATOR_H
diff --git a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
index 78851383b43a990d28ba773d53e6f0ebe31af427..099cf53a91c9acbf4d678b085604cb7c7f6774ff 100644
--- a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
+++ b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp
@@ -665,5 +665,19 @@ 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 e053ae9d847a48f55b28fb1cc45835d4a5c9e62b..0a81725d3713dfc1645987fe80df831548827ab6 100644
--- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
+++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h
@@ -85,6 +85,9 @@ 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_;
@@ -116,4 +119,4 @@ class DeviceInitCallback : public DmInitCallback {
 };
 } // namespace DistributedHardware
 } // namespace OHOS
-#endif // OHOS_DCAMERA_SINK_CONTROLLER_H
\ No newline at end of file
+#endif // OHOS_DCAMERA_SINK_CONTROLLER_H
diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
index 8760e9e58059a38a3c141487dece8605a869c899..327de1cdcff00ea1a680ec520ed7e6fda6bf8501 100644
--- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
+++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp
@@ -544,45 +544,17 @@ 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:
-            DHLOGI("channel is connecting");
+            HandleConnecting();
             break;
-        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");
+        case DCAMERA_CHANNEL_STATE_CONNECTED:
+            HandleConnected(networkId);
             break;
-        }
         case DCAMERA_CHANNEL_STATE_DISCONNECTED:
-            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);
-                }
-            });
+            HandleDisconnected();
             break;
         default:
             DHLOGE("unknown session state");
@@ -590,6 +562,54 @@ 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,"
@@ -846,4 +866,4 @@ void DeviceInitCallback::OnRemoteDied()
     DHLOGI("DeviceInitCallback OnRemoteDied");
 }
 } // namespace DistributedHardware
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
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 0a5fe02f10f602c1a6dc64ee97dc691177eb4fd6..1adafec195029917a97ec564c08cf04264cd14ad 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,5 +289,17 @@ 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
\ No newline at end of file
+} // 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 e3a28ded3ac8d03210c33224b392192eb816dfda..2a712d6af2937495e90ad5c70b45a6ab8a6bb0d5 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,7 +110,12 @@ public:
         }
         return DCAMERA_OK;
     }
+
+    int32_t PrelaunchCamera()
+    {
+        return DCAMERA_OK;
+    }
 };
 } // namespace DistributedHardware
 } // namespace OHOS
-#endif // OHOS_MOCK_CAMERA_OPERATOR_H
\ No newline at end of file
+#endif // OHOS_MOCK_CAMERA_OPERATOR_H
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 6fa3b270903d2fbbe7a4026833446791d3e7c583..9949ec5bd848dc61ea1a1f2f41cf8b12bf21b3f9 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
@@ -68,6 +68,11 @@ private:
     std::atomic<bool> isChannelConnected_ = false;
     std::mutex channelMtx_;
     std::condition_variable channelCond_;
+
+    const auto 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 f6b615c5a3ee8bf0157f0fb8289bf362350068e7..8362419a06c3568ed9499d4cb0c943d13ce46368 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_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+        if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+        if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.empty() || 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_.size() > DCAMERA_MAX_NUM) {
+    if (indexs_.empty() || 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 85a23569074348b0e5515670fb3f499abf1bed90..aa24885b4b15e6d625975028037edefa19e44417 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
@@ -180,13 +180,21 @@ 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) {
-        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;
-        }
+        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);
     }
     if (channelState_[SNAPSHOT_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
         int32_t ret = EstablishSnapshotFrameSession(indexs);
@@ -194,7 +202,12 @@ 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());
-            return ret;
+        }
+        {
+            std::unique_lock<std::mutex> lock(isOpenChannelMtx_);
+            while (!isOpenChannel_.load()) {
+                isOpenChannelCond_.wait_for(lock, TIMEOUT_1_SEC, [this] { return isOpenChannel_.load(); });
+            }
         }
     }
     return DCAMERA_OK;
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
index cc7628aecf949ddc53b1920d3f0936026f7d5334..dc9ad94be0c4daea5fb5bb99c23ebe2da370c8e2 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_controller_test.cpp
@@ -571,4 +571,4 @@ HWTEST_F(DCameraSourceControllerTest, dcamera_source_controller_test_020, TestSi
     EXPECT_EQ(ret, DCAMERA_BAD_OPERATE);
 }
 }
-}
\ No newline at end of file
+}
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
index d0d351dcbdd23808db3d0bd8078cf4cb0361d1bc..b7ab980cea055bfbda5ee96e60b9ef4731b170b5 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_dev_test.cpp
@@ -679,4 +679,4 @@ HWTEST_F(DCameraSourceDevTest, GetFullCaps_001, TestSize.Level1)
     EXPECT_EQ(DCAMERA_BAD_VALUE, camDev1_->GetFullCaps());
 }
 } // namespace DistributedHardware
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp
index 80ada963d057acfa5eb3bfc4b4d9e8d5077d772a..6d4a44a9d5613da20bfe494f227e37151393db3c 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_stream_data_process_producer_test.cpp
@@ -229,4 +229,4 @@ HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_produ
     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
 }
 }
-}
\ No newline at end of file
+}
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 87b1dfff60d87452586ac37877f0a786e13f3c3e..59bf4b1e5e513e7fe9532a152b66a21ecf142bd0 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,6 +120,7 @@ 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;
+    const auto TIMEOUT_1_SEC = std::chrono::seconds(1);
 
     std::weak_ptr<DCameraPipelineSink> callbackPipelineSink_;
     std::mutex mtxEncoderState_;
@@ -132,6 +133,9 @@ 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;
     int64_t inputTimeStampUs_ = 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 09bbc9344875d560ba72f12ee03672ffcc49d915..ee703df646d0ea24ffdfe51f8f53c043a4298c3b 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
@@ -74,6 +74,7 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const
         processedConfig_ = sourceConfig;
         processedConfig = processedConfig_;
         isEncoderProcess_.store(true);
+        isEncoderProcessCond_.notify_one();
         return DCAMERA_OK;
     }
 
@@ -85,6 +86,7 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const
     }
     processedConfig = processedConfig_;
     isEncoderProcess_.store(true);
+    isEncoderProcessCond_.notify_one();
     return DCAMERA_OK;
 }
 
@@ -460,7 +462,7 @@ int32_t EncodeDataProcess::GetEncoderOutputBuffer(uint32_t index, MediaAVCodec::
         DHLOGE("Failed to get the output shared memory, index : %{public}u", index);
         return DCAMERA_BAD_OPERATE;
     }
-    
+
     CHECK_AND_RETURN_RET_LOG(info.size <= 0 || info.size > DATABUFF_MAX_SIZE, DCAMERA_BAD_VALUE,
         "AVCodecBufferInfo error, buffer size : %{public}d", info.size);
     size_t outputMemoDataSize = static_cast<size_t>(info.size);
@@ -541,9 +543,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)
 {
-    if (!isEncoderProcess_.load()) {
-        DHLOGE("EncodeNode occurred error or start release.");
-        return;
+    std::unique_lock<std::mutex> lock(isEncoderProcessMtx_);
+    while (!isEncoderProcess_.load()) {
+        isEncoderProcessCond_.wait_for(lock, TIMEOUT_1_SEC, [this] { return isEncoderProcess_.load(); });
     }
     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 161a4534a717e10ba89be3000e69b010c01dc4f0..694c21591922f31eaf5aeefb5ac2fe4b0d4b8980 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);
 }