diff --git a/camera_hdf/hdi_impl/include/dcamera_provider/dcamera_provider.h b/camera_hdf/hdi_impl/include/dcamera_provider/dcamera_provider.h
index 166d81497391fec8905d10a6f78f7161c5b51741..21ad7a29c310eb2953eebb97a5d0c400e57e1d49 100644
--- a/camera_hdf/hdi_impl/include/dcamera_provider/dcamera_provider.h
+++ b/camera_hdf/hdi_impl/include/dcamera_provider/dcamera_provider.h
@@ -51,7 +51,7 @@ public:
     DCamRetCode ReleaseStreams(const std::shared_ptr<DHBase> &dhBase, const std::vector<int> &streamIds);
     DCamRetCode StartCapture(const std::shared_ptr<DHBase> &dhBase,
                              const std::vector<std::shared_ptr<DCCaptureInfo>> &captureInfos);
-    DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase);
+    DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase, const std::vector<int> &streamIds);
     DCamRetCode UpdateSettings(const std::shared_ptr<DHBase> &dhBase,
                                const std::vector<std::shared_ptr<DCameraSettings>> &settings);
 
diff --git a/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h b/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h
index 4f1a4bc3f3805b8ef2442a9c932342cc6a9c23ce..9b09988291141a20b66fa6bd2008901418fa35c8 100644
--- a/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h
+++ b/camera_hdf/hdi_impl/include/dstream_operator/dstream_operator.h
@@ -65,6 +65,7 @@ public:
     DCamRetCode SetDeviceCallback(function<void(ErrorType, int)> &errorCbk,
                                   function<void(uint64_t, std::shared_ptr<Camera::CameraMetadata>)> &resultCbk);
     void Release();
+    std::vector<int> GetStreamIds();
 
 private:
     bool IsCapturing();
@@ -83,6 +84,7 @@ private:
     std::shared_ptr<DCCaptureInfo> BuildSuitableCaptureInfo(const shared_ptr<CaptureInfo>& srcCaptureInfo,
         std::vector<std::shared_ptr<DCStreamInfo>> &srcStreamInfo);
     void SnapShotStreamOnCaptureEnded(int32_t captureId, int streamId);
+    bool HasContinuousCaptureInfo(int captureId);
 
 private:
     std::shared_ptr<DMetadataProcessor> dMetadataProcessor_;
diff --git a/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp b/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp
index bad778bd81ed98bdd69cc04d244ba1e9a39e6e30..a84061ca3fc098c123797d66b7e6349e2ac3cff1 100644
--- a/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp
+++ b/camera_hdf/hdi_impl/src/dcamera_device/dcamera_device.cpp
@@ -224,8 +224,9 @@ void DCameraDevice::Close()
     DHLOGI("DCameraDevice::Close distributed camera: %s", dCameraId_.c_str());
 
     std::shared_ptr<DCameraProvider> provider = DCameraProvider::GetInstance();
-    if (provider != nullptr) {
-        provider->StopCapture(dhBase_);
+    if ((provider != nullptr) && (dCameraStreamOperator_ != nullptr)) {
+        std::vector<int> streamIds = dCameraStreamOperator_->GetStreamIds();
+        provider->StopCapture(dhBase_, streamIds);
     }
     if (dCameraStreamOperator_ != nullptr) {
         dCameraStreamOperator_->Release();
@@ -393,8 +394,9 @@ DCamRetCode DCameraDevice::Notify(const std::shared_ptr<DCameraHDFEvent> &event)
                 dCameraDeviceCallback_->OnError(ErrorType::REQUEST_TIMEOUT, 0);
             }
             std::shared_ptr<DCameraProvider> provider = DCameraProvider::GetInstance();
-            if (provider != nullptr) {
-                provider->StopCapture(dhBase_);
+            if ((provider != nullptr) && (dCameraStreamOperator_ != nullptr)) {
+                std::vector<int> streamIds = dCameraStreamOperator_->GetStreamIds();
+                provider->StopCapture(dhBase_, streamIds);
             }
             if (dCameraStreamOperator_ != nullptr) {
                 dCameraStreamOperator_->Release();
diff --git a/camera_hdf/hdi_impl/src/dcamera_provider/dcamera_provider.cpp b/camera_hdf/hdi_impl/src/dcamera_provider/dcamera_provider.cpp
index 7476c8541b61096145bb2ab50ff2c98ca89daecd..0417ada32630a27f395a96a585f3756f1adf45fe 100644
--- a/camera_hdf/hdi_impl/src/dcamera_provider/dcamera_provider.cpp
+++ b/camera_hdf/hdi_impl/src/dcamera_provider/dcamera_provider.cpp
@@ -285,14 +285,15 @@ DCamRetCode DCameraProvider::StartCapture(const std::shared_ptr<DHBase> &dhBase,
         for (int id : info->streamIds_) {
             idString += (std::to_string(id) + ", ");
         }
-        DHLOGI("StartCapture: ids=[%s], width=%d, height=%d, format=%d, type=%d.",
+        DHLOGI("DCameraProvider::StartCapture: ids=[%s], width=%d, height=%d, format=%d, type=%d, isCapture=%d.",
             (idString.empty() ? idString.c_str() : (idString.substr(0, idString.length() - INGNORE_STR_LEN)).c_str()),
-            info->width_, info->height_, info->format_, info->type_);
+            info->width_, info->height_, info->format_, info->type_, info->isCapture_);
     }
     return callback->StartCapture(dhBase, captureInfos);
 }
 
-DCamRetCode DCameraProvider::StopCapture(const std::shared_ptr<DHBase> &dhBase)
+DCamRetCode DCameraProvider::StopCapture(const std::shared_ptr<DHBase> &dhBase,
+    const std::vector<int> &streamIds)
 {
     if (dhBase == nullptr) {
         DHLOGE("DCameraProvider::StopCapture, dhBase is null.");
@@ -307,7 +308,13 @@ DCamRetCode DCameraProvider::StopCapture(const std::shared_ptr<DHBase> &dhBase)
         return DCamRetCode::INVALID_ARGUMENT;
     }
 
-    return callback->StopCapture(dhBase);
+    std::string idString = "";
+    for (int id : streamIds) {
+        idString += (std::to_string(id) + ", ");
+    }
+    DHLOGI("DCameraProvider::StopCapture: ids=[%s].",
+        idString.empty() ? idString.c_str() : (idString.substr(0, idString.length() - INGNORE_STR_LEN)).c_str());
+    return callback->StopCapture(dhBase, streamIds);
 }
 
 DCamRetCode DCameraProvider::UpdateSettings(const std::shared_ptr<DHBase> &dhBase,
diff --git a/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp b/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp
index 98e1f877a3b7f42d3e84a5c6f3c077c94753e119..c8e678b902081576baed201bee9a0aa67438122f 100644
--- a/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp
+++ b/camera_hdf/hdi_impl/src/dstream_operator/dstream_operator.cpp
@@ -109,7 +109,7 @@ CamRetCode DStreamOperator::ReleaseStreams(const std::vector<int>& streamIds)
                 DHLOGE("Release distributed camera buffer queue for stream %d failed.", id);
                 return MapToExternalRetCode(ret);
             } else {
-                DHLOGE("Release distributed camera buffer queue for stream %d successs.", id);
+                DHLOGI("Release distributed camera buffer queue for stream %d successs.", id);
             }
             stream = nullptr;
             halStreamMap_.erase(id);
@@ -304,17 +304,18 @@ CamRetCode DStreamOperator::CancelCapture(int captureId)
 
     std::unique_lock<std::mutex> lock(requestLock_);
     if (captureId < 0 || halCaptureInfoMap_.find(captureId) == halCaptureInfoMap_.end()) {
-        DHLOGE("Input captureId %d is exist.", captureId);
+        DHLOGE("Input captureId %d is not exist.", captureId);
         return CamRetCode::INVALID_ARGUMENT;
     }
 
-    SetCapturing(false);
     std::shared_ptr<DCameraProvider> provider = DCameraProvider::GetInstance();
     if (provider == nullptr) {
         DHLOGE("Distributed camera provider not init.");
         return CamRetCode::DEVICE_ERROR;
     }
-    DCamRetCode ret = provider->StopCapture(dhBase_);
+
+    std::vector<int> streamIds = halCaptureInfoMap_[captureId]->streamIds_;
+    DCamRetCode ret = provider->StopCapture(dhBase_, streamIds);
     if (ret != SUCCESS) {
         DHLOGE("Cancel distributed camera capture failed.");
         return MapToExternalRetCode(ret);
@@ -335,12 +336,39 @@ CamRetCode DStreamOperator::CancelCapture(int captureId)
     if (dcStreamOperatorCallback_) {
         dcStreamOperatorCallback_->OnCaptureEnded(captureId, info);
     }
-    cachedDCaptureInfoList_.clear();
-    halCaptureInfoMap_.erase(captureId);
 
+    halCaptureInfoMap_.erase(captureId);
+    if (!HasContinuousCaptureInfo(captureId)) {
+        SetCapturing(false);
+        cachedDCaptureInfoList_.clear();
+    }
+    DHLOGI("DStreamOperator::CancelCapture success, captureId=%d.", captureId);
     return CamRetCode::NO_ERROR;
 }
 
+bool DStreamOperator::HasContinuousCaptureInfo(int captureId)
+{
+    bool flag = false;
+    for (auto iter : halCaptureInfoMap_) {
+        for (auto id : iter.second->streamIds_) {
+            auto dcStreamInfo = dcStreamInfoMap_.find(id);
+            if (dcStreamInfo == dcStreamInfoMap_.end()) {
+                continue;
+            }
+
+            DHLOGI("DStreamOperator::HasContinuousCaptureInfo, captureId=%d, streamId=%d, streamType=%d",
+                captureId, id, dcStreamInfo->second->type_);
+            if (dcStreamInfo->second->type_ == DCStreamType::CONTINUOUS_FRAME) {
+                DHLOGI("DStreamOperator::HasContinuousCaptureInfo, captureId=%d, stream %d is continuous stream.",
+                    captureId, id);
+                flag = true;
+                break;
+            }
+        }
+    }
+    return flag;
+}
+
 CamRetCode DStreamOperator::ChangeToOfflineStream(const std::vector<int>& streamIds,
     OHOS::sptr<IStreamOperatorCallback>& callback, OHOS::sptr<IOfflineStreamOperator>& offlineOperator)
 {
@@ -580,6 +608,19 @@ void DStreamOperator::Release()
     dcStreamOperatorCallback_ = nullptr;
 }
 
+std::vector<int> DStreamOperator::GetStreamIds()
+{
+    DHLOGI("DStreamOperator::GetStreamIds, begin get stream id.");
+    std::vector<int> streamIds;
+    std::string idString = "";
+    for (auto iter : halStreamMap_) {
+        streamIds.push_back(iter.first);
+        idString += (std::to_string(iter.first) + ", ");
+    }
+    DHLOGI("DStreamOperator::GetStreamIds, ids=[%s]", idString.c_str());
+    return streamIds;
+}
+
 bool DStreamOperator::IsCapturing()
 {
     std::unique_lock<mutex> lock(isCapturingLock_);
@@ -659,6 +700,9 @@ DCamRetCode DStreamOperator::NegotiateSuitableCaptureInfo(const std::shared_ptr<
                 break;
             }
         }
+        if (isStreaming) {
+            inputCaptureInfo->isCapture_ = false;
+        }
     }
     cachedDCaptureInfoList_.clear();
     cachedDCaptureInfoList_.push_back(inputCaptureInfo);
diff --git a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.cpp b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.cpp
index fb93aed127eada1618acc0d1b64a0bbdd44433d3..b822feba41001aada16502b51bd2929f95740dd8 100644
--- a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.cpp
+++ b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.cpp
@@ -51,7 +51,8 @@ DCamRetCode DCameraProviderCallback::StartCapture(const std::shared_ptr<DHBase>
     return DCamRetCode::SUCCESS;
 }
 
-DCamRetCode DCameraProviderCallback::StopCapture(const std::shared_ptr<DHBase> &dhBase)
+DCamRetCode DCameraProviderCallback::StopCapture(const std::shared_ptr<DHBase> &dhBase,
+    const std::vector<int> &streamIds)
 {
     DHLOGW("DCameraProviderCallback::StopCapture enter.");
     return DCamRetCode::SUCCESS;
diff --git a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.h b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.h
index c36cd351e3734ceff55711c2e321dec8b7484c13..d5602676d67e858f53dcef84cae3d7a4751ccf34 100644
--- a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.h
+++ b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback.h
@@ -34,7 +34,8 @@ public:
                                        const std::vector<int> &streamIds) override;
     virtual DCamRetCode StartCapture(const std::shared_ptr<DHBase> &dhBase,
                                      const std::vector<std::shared_ptr<DCCaptureInfo>> &captureInfos) override;
-    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase) override;
+    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase,
+                                    const std::vector<int> &streamIds) override;
     virtual DCamRetCode UpdateSettings(const std::shared_ptr<DHBase> &dhBase,
                                        const std::vector<std::shared_ptr<DCameraSettings>> &settings) override;
 };
diff --git a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback_stub.cpp b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback_stub.cpp
index 607f5def460ba614fb2b18f89050b033e119c53a..da4f979c65405ae800495af735c8224305a8676a 100644
--- a/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback_stub.cpp
+++ b/camera_hdf/interfaces/hdi_ipc/client/provider/dcamera_provider_callback_stub.cpp
@@ -218,7 +218,13 @@ int32_t DCameraProviderCallbackStub::DCProviderStopCaptureStub(MessageParcel &da
 
     std::shared_ptr<DHBase> dhBase = std::make_shared<DHBase>(data.ReadString(), data.ReadString());
 
-    DCamRetCode ret = StopCapture(dhBase);
+    std::vector<int> streamIds;
+    if (!data.ReadInt32Vector(&streamIds)) {
+        DHLOGE("Read streamIds failed.");
+        return HDF_FAILURE;
+    }
+
+    DCamRetCode ret = StopCapture(dhBase, streamIds);
     if (!reply.WriteInt32(static_cast<int32_t>(ret))) {
         DHLOGE("Write retcode failed.");
         return HDF_FAILURE;
diff --git a/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.cpp b/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.cpp
index 7a2208b71e077ae04c56edd90d73483c045b1a70..f49c7d30017a6e9dfbf947e544ffaf39cf499093 100644
--- a/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.cpp
+++ b/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.cpp
@@ -201,7 +201,8 @@ DCamRetCode DCameraProviderCallbackProxy::StartCapture(const std::shared_ptr<DHB
     return static_cast<DCamRetCode>(reply.ReadInt32());
 }
 
-DCamRetCode DCameraProviderCallbackProxy::StopCapture(const std::shared_ptr<DHBase> &dhBase)
+DCamRetCode DCameraProviderCallbackProxy::StopCapture(const std::shared_ptr<DHBase> &dhBase,
+    const std::vector<int> &streamIds)
 {
     MessageParcel data;
     MessageParcel reply;
@@ -217,6 +218,12 @@ DCamRetCode DCameraProviderCallbackProxy::StopCapture(const std::shared_ptr<DHBa
         return DCamRetCode::INVALID_ARGUMENT;
     }
 
+    std::vector<int32_t> pxyStreamIds = streamIds;
+    if (!data.WriteInt32Vector(pxyStreamIds)) {
+        DHLOGE("Write streamId failed.");
+        return INVALID_ARGUMENT;
+    }
+
     int32_t ret = Remote()->SendRequest(CMD_DISTRIBUTED_CAMERA_PROVIDER_CALLBACK_STOP_CAPTURE, data, reply, option);
     if (ret != HDF_SUCCESS) {
         DHLOGE("SendRequest failed, error code is %d.", ret);
diff --git a/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.h b/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.h
index a7f5e3ede4e6a028249c8a46c8fca7d1a93eacb3..d83c7359325d93affc285fa1f5a1948e49366548 100644
--- a/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.h
+++ b/camera_hdf/interfaces/hdi_ipc/server/provider/dcamera_provider_callback_proxy.h
@@ -36,7 +36,8 @@ public:
                                        const std::vector<int> &streamIds);
     virtual DCamRetCode StartCapture(const std::shared_ptr<DHBase> &dhBase,
                                      const std::vector<std::shared_ptr<DCCaptureInfo>> &captureInfos);
-    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase);
+    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase,
+                                    const std::vector<int> &streamIds);
     virtual DCamRetCode UpdateSettings(const std::shared_ptr<DHBase> &dhBase,
                                        const std::vector<std::shared_ptr<DCameraSettings>> &settings);
 
diff --git a/camera_hdf/interfaces/include/idistributed_camera_provider_callback.h b/camera_hdf/interfaces/include/idistributed_camera_provider_callback.h
index 6f4f5210ed47029ad1e54ece85224a0eedb92ce9..bce2bc45f5653daadc280eff9419f2fc19133406 100644
--- a/camera_hdf/interfaces/include/idistributed_camera_provider_callback.h
+++ b/camera_hdf/interfaces/include/idistributed_camera_provider_callback.h
@@ -136,7 +136,7 @@ public:
      * @since 1.0
      * @version 1.0
      */
-    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase) = 0;
+    virtual DCamRetCode StopCapture(const std::shared_ptr<DHBase> &dhBase, const std::vector<int> &streamIds) = 0;
 
     /**
      * @brief Updates distributed camera device control parameters.
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
index cb5b41d9985fb868fbcb863cd1e67ea29519e4a5..401ccd64733b4bdfba53ad7561a0551d75edc00a 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamera_source_dev.h
@@ -46,7 +46,7 @@ public:
     int32_t ConfigStreams(const std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos);
     int32_t ReleaseStreams(const std::vector<int>& streamIds);
     int32_t StartCapture(const std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos);
-    int32_t StopCapture();
+    int32_t StopCapture(const std::vector<int>& streamIds);
     int32_t UpdateCameraSettings(const std::vector<std::shared_ptr<DCameraSettings>>& settings);
 
     void OnEvent(DCameraSourceEvent& event) override;
@@ -60,7 +60,8 @@ public:
     virtual int32_t ExecuteReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease);
     virtual int32_t ExecuteReleaseAllStreams();
     virtual int32_t ExecuteStartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos);
-    virtual int32_t ExecuteStopCapture();
+    virtual int32_t ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop);
+    virtual int32_t ExecuteStopAllCapture();
     virtual int32_t ExecuteUpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings);
     virtual int32_t ExecuteCameraEventNotify(std::shared_ptr<DCameraEvent>& events);
 
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_data_process.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_data_process.h
index 7690058f65e95e843c3b0eea29095b0aa3162d44..d5c53cffcd7510376d42eb1d7efc92985a5f6ac2 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_data_process.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_data_process.h
@@ -35,7 +35,8 @@ public:
     int32_t ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos) override;
     int32_t ReleaseStreams(std::vector<int32_t>& streamIds) override;
     int32_t StartCapture(std::shared_ptr<DCCaptureInfo>& captureInfo) override;
-    int32_t StopCapture() override;
+    int32_t StopCapture(std::vector<int32_t>& streamIds) override;
+    int32_t GetProducerSize() override;
     void GetAllStreamIds(std::vector<int32_t>& streamIds) override;
 
 private:
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 072487c46b3f5c4d9a5c270fd1eaed68f38bad65..9ffec16ca0bfc268c8b4f99a7cf3d93d823557de 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h
@@ -36,7 +36,8 @@ public:
     int32_t ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease) override;
     int32_t ReleaseAllStreams() override;
     int32_t StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos) override;
-    int32_t StopCapture() override;
+    int32_t StopCapture(std::vector<int>& streamIds, bool& isAllStop) override;
+    int32_t StopAllCapture() override;
     int32_t OpenChannel(std::vector<DCameraIndex>& indexs) override;
     int32_t CloseChannel() override;
     int32_t Init() override;
@@ -57,8 +58,6 @@ private:
     std::shared_ptr<EventBus> eventBus_;
 
     bool isInit = false;
-    std::mutex inputMutex_;
-    bool isCapture_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_stream_data_process.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_stream_data_process.h
index dea0a58f77b0e928676db476de3883bed7a9ff1b..a687196903937db51c59ff9e48cbe6de7d93831b 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_stream_data_process.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_stream_data_process.h
@@ -16,6 +16,7 @@
 #ifndef OHOS_DCAMERA_STREAM_DATA_PROCESS_H
 #define OHOS_DCAMERA_STREAM_DATA_PROCESS_H
 
+#include <mutex>
 #include <set>
 
 #include "data_buffer.h"
@@ -36,8 +37,9 @@ public:
     void ConfigStreams(std::shared_ptr<DCameraStreamConfig>& dstConfig, std::set<int32_t>& streamIds);
     void ReleaseStreams(std::set<int32_t>& streamIds);
     void StartCapture(std::shared_ptr<DCameraStreamConfig>& srcConfig, std::set<int32_t>& streamIds);
-    void StopCapture();
+    void StopCapture(std::set<int32_t>& streamIds);
     void GetAllStreamIds(std::set<int32_t>& streamIds);
+    int32_t GetProducerSize();
 
     void OnProcessedVideoBuffer(const std::shared_ptr<DataBuffer>& videoResult);
     void OnError(DataProcessErrorType errorType);
@@ -55,6 +57,9 @@ private:
     std::string dhId_;
     DCStreamType streamType_;
 
+    std::mutex pipelineMutex_;
+    std::mutex producerMutex_;
+
     std::set<int32_t> streamIds_;
     std::shared_ptr<DCameraStreamConfig> srcConfig_;
     std::shared_ptr<DCameraStreamConfig> dstConfig_;
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.h
index ebe3b9d352cab392ed69d63a9163c268eb03b97a..f0d1c2bef1678eee5736ad0eb3bac9dd99a9583f 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.h
@@ -33,7 +33,7 @@ public:
     DCamRetCode ReleaseStreams(const std::shared_ptr<DHBase>& dhBase, const std::vector<int>& streamIds) override;
     DCamRetCode StartCapture(const std::shared_ptr<DHBase>& dhBase,
         const std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos) override;
-    DCamRetCode StopCapture(const std::shared_ptr<DHBase>& dhBase) override;
+    DCamRetCode StopCapture(const std::shared_ptr<DHBase>& dhBase, const std::vector<int>& streamIds) override;
     DCamRetCode UpdateSettings(const std::shared_ptr<DHBase>& dhBase,
         const std::vector<std::shared_ptr<DCameraSettings>>& settings) override;
 
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_input.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_input.h
index 3733723debf17c65a1d5269a676f486dee194de8..30b851cd61b8e76bdc449673a2b4a07479c9d9f0 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_input.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_input.h
@@ -28,7 +28,8 @@ public:
     virtual int32_t ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease) = 0;
     virtual int32_t ReleaseAllStreams() = 0;
     virtual int32_t StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos) = 0;
-    virtual int32_t StopCapture() = 0;
+    virtual int32_t StopCapture(std::vector<int>& streamIds, bool& isAllStop) = 0;
+    virtual int32_t StopAllCapture() = 0;
     virtual int32_t OpenChannel(std::vector<DCameraIndex>& indexs) = 0;
     virtual int32_t CloseChannel() = 0;
     virtual int32_t Init() = 0;
diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_source_data_process.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_source_data_process.h
index 12934cac4802adcc028bc8b51e7925f0108d611c..95e3a611990f3c9cafb70369125f1b9121dfe0ad 100644
--- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_source_data_process.h
+++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcamerainterface/icamera_source_data_process.h
@@ -59,7 +59,8 @@ public:
     virtual int32_t ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInos) = 0;
     virtual int32_t ReleaseStreams(std::vector<int32_t>& streamIds) = 0;
     virtual int32_t StartCapture(std::shared_ptr<DCCaptureInfo>& captureInfo) = 0;
-    virtual int32_t StopCapture() = 0;
+    virtual int32_t StopCapture(std::vector<int32_t>& streamIds) = 0;
+    virtual int32_t GetProducerSize() = 0;
     virtual void GetAllStreamIds(std::vector<int32_t>& streamIds) = 0;
 };
 } // namespace DistributedHardware
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
index 80dd25527a96be3933569341ba6c7effe38e36dc..7911b2d4614e36ea47ff2b2c1b684b94f8e27abb 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamera_source_dev.cpp
@@ -181,11 +181,11 @@ int32_t DCameraSourceDev::StartCapture(const std::vector<std::shared_ptr<DCCaptu
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDev::StopCapture()
+int32_t DCameraSourceDev::StopCapture(const std::vector<int>& streamIds)
 {
     DHLOGI("DCameraSourceDev PostTask StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    DCameraSourceEvent event(*this, DCAMERA_EVENT_STOP_CAPTURE);
+    DCameraSourceEvent event(*this, DCAMERA_EVENT_STOP_CAPTURE, streamIds);
     eventBus_->PostEvent<DCameraSourceEvent>(event);
     return DCAMERA_OK;
 }
@@ -436,19 +436,38 @@ int32_t DCameraSourceDev::ExecuteStartCapture(std::vector<std::shared_ptr<DCCapt
     return ret;
 }
 
-int32_t DCameraSourceDev::ExecuteStopCapture()
+int32_t DCameraSourceDev::ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop)
 {
     DHLOGI("DCameraSourceDev Execute StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    int32_t ret = input_->StopCapture();
+    int32_t ret = input_->StopCapture(streamIds, isAllStop);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceDev Execute StopCapture input StopCapture failed, ret: %d, devId: %s dhId: %s", ret,
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
     }
+    if (isAllStop) {
+        ret = controller_->StopCapture();
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSourceDev Execute StopCapture controller StopCapture failed, ret: %d, devId: %s dhId: %s",
+                ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+        }
+    }
+    return DCAMERA_OK;
+}
+
+int32_t DCameraSourceDev::ExecuteStopAllCapture()
+{
+    DHLOGI("DCameraSourceDev Execute StopAllCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
+        GetAnonyString(dhId_).c_str());
+    int32_t ret = input_->StopAllCapture();
+    if (ret != DCAMERA_OK) {
+        DHLOGE("DCameraSourceDev Execute StopAllCapture input StopAllCapture failed, ret: %d, devId: %s dhId: %s",
+            ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+    }
     ret = controller_->StopCapture();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceDev Execute StopCapture controller StopCapture failed, ret: %d, devId: %s dhId: %s", ret,
-            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+        DHLOGE("DCameraSourceDev Execute StopAllCapture controller StopAllCapture failed, ret: %d, devId: %s dhId: %s",
+            ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
     }
     return DCAMERA_OK;
 }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
index 73497f80dfbd4901510b738b4b28725215b02f42..04d483d1dde316a03ff8ebd255b38a0d0f621d50 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_data_process.cpp
@@ -128,10 +128,10 @@ int32_t DCameraSourceDataProcess::ReleaseStreams(std::vector<int32_t>& streamIds
 
 int32_t DCameraSourceDataProcess::StartCapture(std::shared_ptr<DCCaptureInfo>& captureInfo)
 {
-    DHLOGI("DCameraSourceDataProcess StartCapture devId %s dhId %s, info: width: %d, height: %d, format: %d,\
-        dataspace: %d, encodeType: %d streamType: %d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
-        captureInfo->width_, captureInfo->height_, captureInfo->format_, captureInfo->dataspace_,
-        captureInfo->encodeType_, captureInfo->type_);
+    DHLOGI("DCameraSourceDataProcess StartCapture devId %s dhId %s width: %d, height: %d, format: %d, isCapture: %d," +
+        "dataspace: %d, encodeType: %d, streamType: %d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
+        captureInfo->width_, captureInfo->height_, captureInfo->format_, captureInfo->isCapture_,
+        captureInfo->dataspace_, captureInfo->encodeType_, captureInfo->type_);
 
     std::shared_ptr<DCameraStreamConfig> streamConfig =
         std::make_shared<DCameraStreamConfig>(captureInfo->width_, captureInfo->height_, captureInfo->format_,
@@ -147,16 +147,34 @@ int32_t DCameraSourceDataProcess::StartCapture(std::shared_ptr<DCCaptureInfo>& c
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceDataProcess::StopCapture()
+int32_t DCameraSourceDataProcess::StopCapture(std::vector<int32_t>& streamIds)
 {
     DHLOGI("DCameraSourceDataProcess StopCapture devId %s dhId %s streamType: %d", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str(), streamType_);
+    std::set<int32_t> streamIdSet(streamIds.begin(), streamIds.end());
+    for (auto iterSet = streamIdSet.begin(); iterSet != streamIdSet.end(); iterSet++) {
+        DHLOGI("DCameraSourceDataProcess StopCapture devId %s dhId %s stream id: %d",
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
+    }
     for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
-        (*iter)->StopCapture();
+        (*iter)->StopCapture(streamIdSet);
     }
     return DCAMERA_OK;
 }
 
+int32_t DCameraSourceDataProcess::GetProducerSize()
+{
+    int32_t ret = 0;
+    for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
+        std::shared_ptr<DCameraStreamDataProcess> streamDataProcess = *iter;
+        int32_t size = streamDataProcess->GetProducerSize();
+        ret += size;
+    }
+    DHLOGI("DCameraSourceDataProcess GetProducerSize devId %s dhId %s size %d",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), ret);
+    return ret;
+}
+
 void DCameraSourceDataProcess::GetAllStreamIds(std::vector<int32_t>& streamIds)
 {
     streamIds.assign(streamIds_.begin(), streamIds_.end());
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 c1de16dcfe4719ada0419b84c29a1c335ad41aed..89cca1d28524945ac452a3e98f4a5747d51d4b18 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp
@@ -28,7 +28,7 @@
 namespace OHOS {
 namespace DistributedHardware {
 DCameraSourceInput::DCameraSourceInput(std::string devId, std::string dhId, std::shared_ptr<EventBus>& eventBus)
-    : devId_(devId), dhId_(dhId), eventBus_(eventBus), isInit(false), isCapture_(false)
+    : devId_(devId), dhId_(dhId), eventBus_(eventBus), isInit(false)
 {
     DHLOGI("DCameraSourceInput Constructor devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -148,29 +148,29 @@ int32_t DCameraSourceInput::StartCapture(std::vector<std::shared_ptr<DCCaptureIn
             return ret;
         }
     }
-    std::lock_guard<std::mutex> autoLock(inputMutex_);
-    isCapture_ = true;
     return DCAMERA_OK;
 }
 
-int32_t DCameraSourceInput::StopCapture()
+int32_t DCameraSourceInput::StopCapture(std::vector<int>& streamIds, bool& isAllStop)
 {
     DHLOGI("DCameraSourceInput StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
-    std::lock_guard<std::mutex> autoLock(inputMutex_);
-    isCapture_ = false;
-    int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture();
+    int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(streamIds);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceInput StopCapture continue ret: %d, devId: %s, dhId: %s", ret,
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
         return ret;
     }
 
-    ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture();
-    if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceInput StopCapture snapshot ret: %d, devId: %s, dhId: %s", ret,
-            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
-        return ret;
+    int32_t size = dataProcess_[CONTINUOUS_FRAME]->GetProducerSize();
+    if (size == 0) {
+        isAllStop = true;
+        ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(streamIds);
+        if (ret != DCAMERA_OK) {
+            DHLOGE("DCameraSourceInput StopCapture snapshot ret: %d, devId: %s, dhId: %s", ret,
+                GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+            return ret;
+        }
     }
     return DCAMERA_OK;
 }
@@ -337,12 +337,6 @@ void DCameraSourceInput::OnSessionError(DCStreamType streamType, int32_t eventTy
 
 void DCameraSourceInput::OnDataReceived(DCStreamType streamType, std::vector<std::shared_ptr<DataBuffer>>& buffers)
 {
-    std::lock_guard<std::mutex> autoLock(inputMutex_);
-    if (!isCapture_) {
-        DHLOGE("DCameraSourceInput OnDataReceived FeedStream %d stream capture stop, devId: %s, dhId: %s", streamType,
-            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
-        return;
-    }
     int32_t ret = dataProcess_[streamType]->FeedStream(buffers);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceInput OnDataReceived FeedStream %d stream failed ret: %d, devId: %s, dhId: %s", streamType,
@@ -373,5 +367,29 @@ int32_t DCameraSourceInput::ReleaseAllStreams()
     }
     return DCAMERA_OK;
 }
+
+int32_t DCameraSourceInput::StopAllCapture()
+{
+    DHLOGI("DCameraSourceInput StopAllCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
+        GetAnonyString(dhId_).c_str());
+    std::vector<int> continueStreamIds;
+    dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
+    int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(continueStreamIds);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("DCameraSourceInput StopAllCapture continue ret: %d, devId: %s, dhId: %s", ret,
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+        return ret;
+    }
+
+    std::vector<int> snapStreamIds;
+    dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
+    ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(snapStreamIds);
+    if (ret != DCAMERA_OK) {
+        DHLOGE("DCameraSourceInput StopAllCapture snapshot ret: %d, devId: %s, dhId: %s", ret,
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+        return ret;
+    }
+    return DCAMERA_OK;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
index ac68366102e837b067671b2eed3b01e29f866516..ace5b3ecb0b993cdb6edd351e74d7fc8b942f24a 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process.cpp
@@ -74,6 +74,9 @@ void DCameraStreamDataProcess::ConfigStreams(std::shared_ptr<DCameraStreamConfig
 
 void DCameraStreamDataProcess::ReleaseStreams(std::set<int32_t>& streamIds)
 {
+    DHLOGI("DCameraStreamDataProcess ReleaseStreams devId %s dhId %s streamType: %d",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_);
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
     for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
         int32_t streamId = *iter;
         DHLOGI("DCameraStreamDataProcess ReleaseStreams devId %s dhId %s streamId: %d", GetAnonyString(devId_).c_str(),
@@ -91,14 +94,20 @@ void DCameraStreamDataProcess::ReleaseStreams(std::set<int32_t>& streamIds)
 void DCameraStreamDataProcess::StartCapture(std::shared_ptr<DCameraStreamConfig>& srcConfig,
     std::set<int32_t>& streamIds)
 {
+    for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
+        DHLOGI("DCameraStreamDataProcess StartCapture devId %s dhId %s streamType: %d streamId: %d, " +
+            "srcConfig: width: %d, height: %d, format: %d, dataspace: %d, streamType: %d, encodeType: %d",
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, *iter,
+            srcConfig->width_,  srcConfig->height_, srcConfig->format_, srcConfig->dataspace_,
+            srcConfig->type_, srcConfig->encodeType_);
+    }
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
     srcConfig_ = srcConfig;
     if (streamType_ == CONTINUOUS_FRAME) {
         CreatePipeline();
     }
     for (auto iter = streamIds_.begin(); iter != streamIds_.end(); iter++) {
         uint32_t streamId = *iter;
-        DHLOGI("DCameraStreamDataProcess StartCapture devId %s dhId %s streamType: %d streamId: %d",
-            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId);
         if (streamIds.find(streamId) == streamIds.end()) {
             continue;
         }
@@ -116,17 +125,34 @@ void DCameraStreamDataProcess::StartCapture(std::shared_ptr<DCameraStreamConfig>
     }
 }
 
-void DCameraStreamDataProcess::StopCapture()
+void DCameraStreamDataProcess::StopCapture(std::set<int32_t>& streamIds)
 {
-    DHLOGI("DCameraStreamDataProcess StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
-        GetAnonyString(dhId_).c_str());
-    if (streamType_ == CONTINUOUS_FRAME) {
-        DestroyPipeline();
+    for (auto iter = streamIds.begin(); iter != streamIds.end(); iter++) {
+        DHLOGI("DCameraStreamDataProcess StopCapture devId %s dhId %s streamType: %d streamId: %d",
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, *iter);
+    }
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
+    for (auto iter = streamIds_.begin(); iter != streamIds_.end(); iter++) {
+        uint32_t streamId = *iter;
+        if (streamIds.find(streamId) == streamIds.end()) {
+            continue;
+        }
+
+        DHLOGI("DCameraStreamDataProcess StopCapture findProducer devId %s dhId %s streamType: %d streamId: %d",
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId);
+        auto producerIter = producers_.find(streamId);
+        if (producerIter == producers_.end()) {
+            DHLOGE("DCameraStreamDataProcess StopCapture no producer, devId %s dhId %s streamType: %d streamId: %d",
+                GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId);
+            continue;
+        }
+        DHLOGI("DCameraStreamDataProcess StopCapture stop producer, devId %s dhId %s streamType: %d streamId: %d",
+            GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId);
+        producerIter->second->Stop();
+        producerIter = producers_.erase(producerIter);
     }
-    auto iter = producers_.begin();
-    while (iter != producers_.end()) {
-        iter->second->Stop();
-        iter = producers_.erase(iter);
+    if (streamType_ == CONTINUOUS_FRAME && producers_.empty()) {
+        DestroyPipeline();
     }
 }
 
@@ -135,10 +161,19 @@ void DCameraStreamDataProcess::GetAllStreamIds(std::set<int32_t>& streamIds)
     streamIds = streamIds_;
 }
 
+int32_t DCameraStreamDataProcess::GetProducerSize()
+{
+    DHLOGI("DCameraStreamDataProcess GetProducerSize devId %s dhId %s",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
+    return producers_.size();
+}
+
 void DCameraStreamDataProcess::FeedStreamToSnapShot(const std::shared_ptr<DataBuffer>& buffer)
 {
     DHLOGD("DCameraStreamDataProcess FeedStreamToSnapShot devId %s dhId %s streamType %d streamSize: %d",
         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, buffer->Size());
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
     for (auto iter = producers_.begin(); iter != producers_.end(); iter++) {
         iter->second->FeedStream(buffer);
     }
@@ -148,6 +183,7 @@ void DCameraStreamDataProcess::FeedStreamToContinue(const std::shared_ptr<DataBu
 {
     DHLOGD("DCameraStreamDataProcess FeedStreamToContinue devId %s dhId %s streamType %d streamSize: %d",
         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, buffer->Size());
+    std::lock_guard<std::mutex> autoLock(pipelineMutex_);
     std::vector<std::shared_ptr<DataBuffer>> buffers;
     buffers.push_back(buffer);
     if (pipeline_ == nullptr) {
@@ -165,6 +201,7 @@ void DCameraStreamDataProcess::OnProcessedVideoBuffer(const std::shared_ptr<Data
 {
     DHLOGI("DCameraStreamDataProcess OnProcessedVideoBuffer devId %s dhId %s streamType: %d streamSize: %d",
         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, videoResult->Size());
+    std::lock_guard<std::mutex> autoLock(producerMutex_);
     for (auto iter = producers_.begin(); iter != producers_.end(); iter++) {
         iter->second->FeedStream(videoResult);
     }
@@ -177,6 +214,9 @@ void DCameraStreamDataProcess::OnError(DataProcessErrorType errorType)
 
 void DCameraStreamDataProcess::CreatePipeline()
 {
+    DHLOGI("DCameraStreamDataProcess CreatePipeline devId %s dhId %s",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+    std::lock_guard<std::mutex> autoLock(pipelineMutex_);
     if (pipeline_ != nullptr) {
         DHLOGI("DCameraStreamDataProcess CreatePipeline already exist, devId %s dhId %s",
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
@@ -197,6 +237,9 @@ void DCameraStreamDataProcess::CreatePipeline()
 
 void DCameraStreamDataProcess::DestroyPipeline()
 {
+    DHLOGI("DCameraStreamDataProcess DestroyPipeline devId %s dhId %s",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
+    std::lock_guard<std::mutex> autoLock(pipelineMutex_);
     if (pipeline_ == nullptr) {
         return;
     }
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
index 98195202ccb86a6d86892c40c0b6ec84a2f2b26d..bd611bc87304be4188214bf23d0bf639bbb88db0 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_stream_data_process_producer.cpp
@@ -178,8 +178,8 @@ void DCameraStreamDataProcessProducer::LooperSnapShot()
 int32_t DCameraStreamDataProcessProducer::FeedStreamToDriver(const std::shared_ptr<DHBase>& dhBase,
     const std::shared_ptr<DataBuffer>& buffer)
 {
-    DHLOGD("LooperFeed devId %s dhId %s streamSize: %d streamType: %d", GetAnonyString(devId_).c_str(),
-        GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_);
+    DHLOGD("LooperFeed devId %s dhId %s streamSize: %d streamType: %d, streamId: %d", GetAnonyString(devId_).c_str(),
+        GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_, streamId_);
     sptr<IDCameraProvider> camHdiProvider = IDCameraProvider::Get();
     if (camHdiProvider == nullptr) {
         DHLOGI("camHdiProvider is nullptr");
@@ -227,8 +227,8 @@ int32_t DCameraStreamDataProcessProducer::FeedStreamToDriver(const std::shared_p
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, retHdi);
         return DCAMERA_BAD_OPERATE;
     }
-    DHLOGD("LooperFeed end devId %s dhId %s streamSize: %d streamType: %d", GetAnonyString(devId_).c_str(),
-        GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_);
+    DHLOGD("LooperFeed end devId %s dhId %s streamSize: %d streamType: %d, streamId: %d",
+        GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_, streamId_);
     return ret;
 }
 } // namespace DistributedHardware
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.cpp
index f0014a5b440dbdb86557e666df99e7589ccea7e9..20d7f303576607f9bde874a9aff3fa6ceb8272a3 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerahdf/dcamera_provider_callback_impl.cpp
@@ -139,7 +139,8 @@ DCamRetCode DCameraProviderCallbackImpl::StartCapture(const std::shared_ptr<DHBa
     return SUCCESS;
 }
 
-DCamRetCode DCameraProviderCallbackImpl::StopCapture(const std::shared_ptr<DHBase>& dhBase)
+DCamRetCode DCameraProviderCallbackImpl::StopCapture(const std::shared_ptr<DHBase>& dhBase,
+    const std::vector<int>& streamIds)
 {
     DHLOGI("DCameraProviderCallbackImpl StopCapture devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
         GetAnonyString(dhId_).c_str());
@@ -149,7 +150,7 @@ DCamRetCode DCameraProviderCallbackImpl::StopCapture(const std::shared_ptr<DHBas
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
         return FAILED;
     }
-    int32_t ret = sourceDev->StopCapture();
+    int32_t ret = sourceDev->StopCapture(streamIds);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraProviderCallbackImpl StopCapture failed, ret: %d, devId: %s, dhId: %s", ret,
             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
index 8823d109f7b373fe481a49187ce2212525745910..cbc7e26c20f5fc8da955c76d64e8c39942318ffe 100644
--- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
+++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcamerastate/dcamera_source_capture_state.cpp
@@ -75,9 +75,9 @@ int32_t DCameraSourceCaptureState::DoUnregisterTask(std::shared_ptr<DCameraSourc
         return ret;
     }
 
-    ret = camDev->ExecuteStopCapture();
+    ret = camDev->ExecuteStopAllCapture();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteStopCapture failed: %d", ret);
+        DHLOGE("DCameraSourceCaptureState DoUnregisterTask ExecuteStopAllCapture failed: %d", ret);
         return ret;
     }
 
@@ -120,9 +120,9 @@ int32_t DCameraSourceCaptureState::DoOpenTask(std::shared_ptr<DCameraSourceDev>&
 
 int32_t DCameraSourceCaptureState::DoCloseTask(std::shared_ptr<DCameraSourceDev>& camDev, DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteStopCapture();
+    int32_t ret = camDev->ExecuteStopAllCapture();
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSourceCaptureState ExecuteStopCapture failed, ret: %d", ret);
+        DHLOGE("DCameraSourceCaptureState ExecuteStopAllCapture failed, ret: %d", ret);
         return ret;
     }
 
@@ -166,17 +166,27 @@ int32_t DCameraSourceCaptureState::DoStartCaptureTask(std::shared_ptr<DCameraSou
 int32_t DCameraSourceCaptureState::DoStopCaptureTask(std::shared_ptr<DCameraSourceDev>& camDev,
     DCameraSourceEvent& event)
 {
-    int32_t ret = camDev->ExecuteStopCapture();
+    std::vector<int> streamIds;
+    int32_t ret = event.GetStreamIds(streamIds);
+    if (ret != DCAMERA_OK) {
+        return ret;
+    }
+
+    bool isAllStop = false;
+    ret = camDev->ExecuteStopCapture(streamIds, isAllStop);
     if (ret != DCAMERA_OK) {
         DHLOGE("DCameraSourceCaptureState ExecuteStopCapture failed, ret: %d", ret);
         return ret;
     }
-    std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
-    if (stateMachine == nullptr) {
-        DHLOGE("DCameraSourceCaptureState DoStopCaptureTask can not get stateMachine");
-        return DCAMERA_BAD_VALUE;
+
+    if (isAllStop) {
+        std::shared_ptr<DCameraSourceStateMachine> stateMachine = stateMachine_.lock();
+        if (stateMachine == nullptr) {
+            DHLOGE("DCameraSourceCaptureState DoStopCaptureTask can not get stateMachine");
+            return DCAMERA_BAD_VALUE;
+        }
+        stateMachine->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
     }
-    stateMachine->UpdateState(DCAMERA_STATE_CONFIG_STREAM);
     return DCAMERA_OK;
 }
 
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
index 2e736ff5788840a0f0de284be8c87622142b945a..cadfb7c9eee5b91d1cc5b1dab61c3e58df7227ce 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/dcamera_source_state_machine_test.cpp
@@ -272,7 +272,7 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_004, T
     DCameraSourceEvent event4(*camDev_, DCAMERA_EVENT_CONFIG_STREAMS, g_streamInfosSnap);
     DCameraSourceEvent event5(*camDev_, DCAMERA_EVENT_RELEASE_STREAMS, g_streamIdSnap);
     DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
-    DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE);
+    DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
     DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
     DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
     stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
@@ -323,7 +323,7 @@ HWTEST_F(DCameraSourceStateMachineTest, dcamera_source_state_machine_test_005, T
     DCameraSourceEvent event2(*camDev_, DCAMERA_EVENT_OPEN, g_camIndex);
     DCameraSourceEvent event3(*camDev_, DCAMERA_EVENT_CLOSE, g_camIndex);
     DCameraSourceEvent event6(*camDev_, DCAMERA_EVENT_START_CAPTURE, g_captureInfoSnap);
-    DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE);
+    DCameraSourceEvent event7(*camDev_, DCAMERA_EVENT_STOP_CAPTURE, g_streamIdSnap);
     DCameraSourceEvent event8(*camDev_, DCAMERA_EVENT_UPDATE_SETTINGS, g_cameraSettingSnap);
     DCameraSourceEvent event9(*camDev_, DCAMERA_EVENT_NOFIFY, g_camEvent);
     stateMachine_ ->UpdateState(DCAMERA_STATE_INIT);
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
index 78480d94da3b73a9dc8210d47d51bb34753b05d5..29b637b0e697140fdd099a8283d26df974a0275b 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcameramgr/mock_dcamera_source_dev.h
@@ -51,6 +51,7 @@ public:
     }
     int32_t ExecuteReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
     {
+        isAllRelease = true;
         return DCAMERA_OK;
     }
     int32_t ExecuteReleaseAllStreams()
@@ -61,7 +62,12 @@ public:
     {
         return DCAMERA_OK;
     }
-    int32_t ExecuteStopCapture()
+    int32_t ExecuteStopCapture(std::vector<int>& streamIds, bool& isAllStop)
+    {
+        isAllStop = true;
+        return DCAMERA_OK;
+    }
+    int32_t ExecuteStopAllCapture()
     {
         return DCAMERA_OK;
     }