diff --git a/common/include/constants/distributed_camera_constants.h b/common/include/constants/distributed_camera_constants.h
index 984819735b49df25f4f19f61a07cb204a36493ef..46908bb136c83aca1135a6aad7f853e9e95937db 100644
--- a/common/include/constants/distributed_camera_constants.h
+++ b/common/include/constants/distributed_camera_constants.h
@@ -122,7 +122,7 @@ const int32_t HICOLLIE_INTERVAL_TIME_MS = 20 * 1000;
 const int32_t HICOLLIE_DELAY_TIME_MS = 5 * 1000;
 const size_t HICOLLIE_SLEEP_TIME_US = 5 * 1000 * 1000;
 
-const int32_t DCAMERA_QOS_TYPE_MIN_BW = 160 * 1024 * 1024;
+const int32_t DCAMERA_QOS_TYPE_MIN_BW = 40 * 1024 * 1024;
 const int32_t DCAMERA_QOS_TYPE_MAX_LATENCY = 4000;
 const int32_t DCAMERA_QOS_TYPE_MIN_LATENCY = 2000;
 
diff --git a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_sink/dcamera_sink_handler_test.cpp b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_sink/dcamera_sink_handler_test.cpp
index 84974e090b048d65dff9322c461eb57caf645430..883c26123850c5d46a967630b89db19bb4570936 100644
--- a/interfaces/inner_kits/native_cpp/test/unittest/common/camera_sink/dcamera_sink_handler_test.cpp
+++ b/interfaces/inner_kits/native_cpp/test/unittest/common/camera_sink/dcamera_sink_handler_test.cpp
@@ -40,6 +40,11 @@ using namespace testing::ext;
 
 namespace OHOS {
 namespace DistributedHardware {
+namespace {
+static int32_t OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX = 0;
+static int32_t OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX = 1;
+static int32_t OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX = 2;
+}
 class DCameraSinkHandlerTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
@@ -67,9 +72,9 @@ void DCameraSinkHandlerTest::SetUp(void)
     uint64_t tokenId;
     int32_t numberOfPermissions = 3;
     const char *perms[numberOfPermissions];
-    perms[0] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
-    perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
-    perms[2] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
+    perms[OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
     NativeTokenInfoParams infoInstance = {
         .dcapsNum = 0,
         .permsNum = numberOfPermissions,
diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_stub_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_stub_test.cpp
index 550e4f5e0c63e087a1a86dad23fab1ddcd841e9f..7a32020decfe4f73edec655ec33be7d4c978a014 100644
--- a/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_stub_test.cpp
+++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcamera/distributed_camera_sink_stub_test.cpp
@@ -29,6 +29,11 @@ using namespace testing::ext;
 
 namespace OHOS {
 namespace DistributedHardware {
+namespace {
+static int32_t OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX = 0;
+static int32_t OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX = 1;
+static int32_t OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX = 2;
+}
 class DcameraSinkStubTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
@@ -53,9 +58,9 @@ void DcameraSinkStubTest::SetUp(void)
     uint64_t tokenId;
     int32_t numberOfPermissions = 3;
     const char *perms[numberOfPermissions];
-    perms[0] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
-    perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
-    perms[2] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
+    perms[OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
     NativeTokenInfoParams infoInstance = {
         .dcapsNum = 0,
         .permsNum = numberOfPermissions,
diff --git a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_stub_test.cpp b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_stub_test.cpp
index 9a257e6c4c3018127af022bfe0646757f46fbea6..121f60bb734f1bb734b2db681ce569b03d6a4edf 100644
--- a/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_stub_test.cpp
+++ b/services/cameraservice/sourceservice/test/unittest/common/distributedcamera/distributed_camera_source_stub_test.cpp
@@ -31,6 +31,11 @@ using namespace testing::ext;
 
 namespace OHOS {
 namespace DistributedHardware {
+namespace {
+static int32_t OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX = 0;
+static int32_t OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX = 1;
+static int32_t OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX = 2;
+}
 class DcameraSourceStubTest : public testing::Test {
 public:
     static void SetUpTestCase(void);
@@ -55,9 +60,9 @@ void DcameraSourceStubTest::SetUp(void)
     uint64_t tokenId;
     int32_t numberOfPermissions = 3;
     const char *perms[numberOfPermissions];
-    perms[0] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
-    perms[1] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
-    perms[2] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_ENABLE_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
+    perms[OHOS_PERMISSION_DISTRIBUTED_DATASYNC_INDEX] = OHOS_PERMISSION_DISTRIBUTED_DATASYNC;
+    perms[OHOS_PERMISSION_ACCESS_DISTRIBUTED_HARDWARE_INDEX] = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
     NativeTokenInfoParams infoInstance = {
         .dcapsNum = 0,
         .permsNum = numberOfPermissions,
diff --git a/services/channel/include/dcamera_softbus_adapter.h b/services/channel/include/dcamera_softbus_adapter.h
index fced6d781f4f1bec7c967ebcdaa1347ca3b304ea..1e4afd47959f7c01b6c02f18fe1092818c0ee490 100644
--- a/services/channel/include/dcamera_softbus_adapter.h
+++ b/services/channel/include/dcamera_softbus_adapter.h
@@ -64,14 +64,12 @@ public:
         const StreamFrameInfo *param);
 
     int32_t HandleSourceStreamExt(std::shared_ptr<DataBuffer>& buffer, const StreamData *ext);
-    int32_t GetSinkSocketId();
     int32_t GetSourceSocketId();
+    void RecordSourceSocketSession(int32_t socket, std::shared_ptr<DCameraSoftbusSession> session);
 
 public:
     std::map<std::string, std::shared_ptr<DCameraSoftbusSession>> sourceSessions_;
     std::map<std::string, std::shared_ptr<DCameraSoftbusSession>> sinkSessions_;
-    std::map<int32_t, std::shared_ptr<DCameraSoftbusSession>> sinkSocketIdSessionMap_;
-    std::map<int32_t, std::shared_ptr<DCameraSoftbusSession>> sourceSocketIdSessionMap_;
 
 private:
     DCameraSoftbusAdapter();
@@ -94,13 +92,17 @@ private:
     std::mutex idMapLock_;
     std::map<int32_t, std::shared_ptr<DCameraSoftbusSession>> sessionIdMap_;
 
-    int32_t sinkSocketId_;
     int32_t sourceSocketId_;
     std::map<DCameraSessionMode, TransDataType> sessionModeAndDataTypeMap_;
     std::mutex mySessionNamePeerDevIdLock_;
     std::map<std::string, std::string> peerDevIdMySessionNameMap_;
     std::mutex mySessionNameLock_;
     std::set<std::string> mySessionNameSet_;
+
+    std::mutex sinkSocketLock_;
+    std::map<int32_t, std::shared_ptr<DCameraSoftbusSession>> sinkSocketSessionMap_;
+    std::mutex sourceSocketLock_;
+    std::map<int32_t, std::shared_ptr<DCameraSoftbusSession>> sourceSocketSessionMap_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/channel/include/dcamera_softbus_session.h b/services/channel/include/dcamera_softbus_session.h
index 3759c19785de18b515d3075e69f1c04c095fd7b1..429b9f7066e15926ae0f7a27e845e28249e349a9 100644
--- a/services/channel/include/dcamera_softbus_session.h
+++ b/services/channel/include/dcamera_softbus_session.h
@@ -37,14 +37,14 @@ public:
         std::string peerSessionName, std::shared_ptr<ICameraChannelListener> listener, DCameraSessionMode mode);
     ~DCameraSoftbusSession();
     int32_t CloseSession();
-    int32_t OnSessionOpened(int32_t socket, PeerSocketInfo info);
-    int32_t RefreshSessionStatus(int32_t socket);
+    int32_t OnSessionOpened(int32_t socket);
     int32_t OnSessionClose(int32_t sessionId);
     int32_t OnDataReceived(std::shared_ptr<DataBuffer>& buffer);
     int32_t SendData(DCameraSessionMode mode, std::shared_ptr<DataBuffer>& buffer);
     std::string GetPeerDevId();
     std::string GetPeerSessionName();
     std::string GetMySessionName();
+    int32_t GetSessionId();
 
 private:
     struct SessionDataHeader {
@@ -83,8 +83,9 @@ private:
     };
 
     static const uint32_t BINARY_DATA_MAX_TOTAL_LEN = 100 * 1024 * 1024;
-    static const uint32_t BINARY_DATA_MAX_LEN = 1000 * 1024;
-    static const uint32_t BINARY_DATA_PACKET_MAX_LEN = 62 * 1024;
+    static const uint32_t BINARY_DATA_MAX_LEN = 4 * 1024 * 1024;
+    static const uint32_t BINARY_DATA_PACKET_MAX_LEN = 4 * 1024 * 1024;
+    static const uint32_t BINARY_DATA_PACKET_RESERVED_BUFFER = 512;
     static const uint16_t PROTOCOL_VERSION = 1;
     static const uint16_t HEADER_UINT8_NUM = 1;
     static const uint16_t HEADER_UINT16_NUM = 2;
diff --git a/services/channel/src/dcamera_channel_source_impl.cpp b/services/channel/src/dcamera_channel_source_impl.cpp
index 8e8bbbb2fb873c220214dfe86f300add8b36793f..bd426df5f5e77ac1a7a9f615383fb246aef5d0bd 100644
--- a/services/channel/src/dcamera_channel_source_impl.cpp
+++ b/services/channel/src/dcamera_channel_source_impl.cpp
@@ -83,8 +83,8 @@ int32_t DCameraChannelSourceImpl::CreateSession(std::vector<DCameraIndex>& camIn
         int32_t sourceSocket = DCameraSoftbusAdapter::GetInstance().GetSourceSocketId();
         std::shared_ptr<DCameraSoftbusSession> softbusSess = std::make_shared<DCameraSoftbusSession>(myDevId,
             mySessionName_, peerDevId, peerSessionName, listener, sessionMode);
-        DCameraSoftbusAdapter::GetInstance().sourceSocketIdSessionMap_[sourceSocket] = softbusSess;
-        softbusSess->RefreshSessionStatus(sourceSocket);
+        softbusSess->OnSessionOpened(sourceSocket);
+        DCameraSoftbusAdapter::GetInstance().RecordSourceSocketSession(sourceSocket, softbusSess);
         softbusSessions_.push_back(softbusSess);
         DCameraSoftbusAdapter::GetInstance().sourceSessions_[peerDevId + peerSessionName] = softbusSess;
     }
diff --git a/services/channel/src/dcamera_softbus_adapter.cpp b/services/channel/src/dcamera_softbus_adapter.cpp
index ecc43630ca35c36ca019591c5487290b839bfbab..b8e32114b8a53517927d01695091e953d59a2022 100644
--- a/services/channel/src/dcamera_softbus_adapter.cpp
+++ b/services/channel/src/dcamera_softbus_adapter.cpp
@@ -105,7 +105,7 @@ DCameraSoftbusAdapter::DCameraSoftbusAdapter()
 {
     sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_CTRL] = TransDataType::DATA_TYPE_BYTES;
     sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_VIDEO] = TransDataType::DATA_TYPE_VIDEO_STREAM;
-    sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_JPEG] = TransDataType::DATA_TYPE_RAW_STREAM;
+    sessionModeAndDataTypeMap_[DCAMERA_SESSION_MODE_JPEG] = TransDataType::DATA_TYPE_BYTES;
 
     ISocketListener sourceListener;
     sourceListener.OnBind = DCameraSourceOnBind;
@@ -131,7 +131,7 @@ DCameraSoftbusAdapter::~DCameraSoftbusAdapter()
 int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessionName, DCAMERA_CHANNEL_ROLE role,
     DCameraSessionMode sessionMode, std::string peerDevId, std::string peerSessionName)
 {
-    DHLOGI("CreatSoftBusSinkSocketServer start, mySessionName: %s,peerSessionName: %s",
+    DHLOGI("create socket server start, mySessionName: %s,peerSessionName: %s",
         GetAnonyString(mySessionName).c_str(), GetAnonyString(peerSessionName).c_str());
     {
         std::lock_guard<std::mutex> autoLock(mySessionNameLock_);
@@ -143,28 +143,28 @@ int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessio
     }
     SocketInfo serverSocketInfo = {
         .name =  const_cast<char*>(mySessionName.c_str()),
-        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
-        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
         .peerName = const_cast<char*>(peerSessionName.c_str()),
+        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
+        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
         .dataType = sessionModeAndDataTypeMap_[sessionMode],
     };
     int socketId = Socket(serverSocketInfo);
     if (socketId < 0) {
-        DHLOGE("DCameraSoftbusAdapter CreatSoftBusSinkSocketServer Error, socket is invalid");
+        DHLOGE("create socket server error, socket is invalid");
         return DCAMERA_BAD_VALUE;
     }
     int ret = Listen(socketId, g_qosInfo, g_QosTV_Param_Index, &sessListeners_[role]);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter CreatSoftBusSinkSocketServer Error");
+        DHLOGE("create socket server error");
         Shutdown(socketId);
         return DCAMERA_BAD_VALUE;
     }
     {
-        std::string peerDevIdMySessionName = peerDevId + std::string("_") + mySessionName;
         std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
+        std::string peerDevIdMySessionName = peerDevId + std::string("_") + mySessionName;
         peerDevIdMySessionNameMap_[peerDevIdMySessionName] = mySessionName;
     }
-    DHLOGI("CreatSoftBusSinkSocketServer End, mySessionName: %s, peerSessionName: %s",
+    DHLOGI("create socket server end, mySessionName: %s, peerSessionName: %s",
         GetAnonyString(mySessionName).c_str(), GetAnonyString(peerSessionName).c_str());
     return DCAMERA_OK;
 }
@@ -172,29 +172,29 @@ int32_t DCameraSoftbusAdapter::CreatSoftBusSinkSocketServer(std::string mySessio
 int32_t DCameraSoftbusAdapter::CreateSoftBusSourceSocketClient(std::string myDevId, std::string peerSessionName,
     std::string peerDevId, DCameraSessionMode sessionMode, DCAMERA_CHANNEL_ROLE role)
 {
-    DHLOGI("CreateSoftBusSourceSocketClient start, myDevId: %s, peerSessionName: %s",
+    DHLOGI("create socket client start, myDevId: %s, peerSessionName: %s",
         GetAnonyString(myDevId).c_str(), GetAnonyString(peerSessionName).c_str());
     std::string myDevIdPeerSessionName = myDevId + std::string("_") + peerSessionName;
     SocketInfo clientSocketInfo = {
         .name = const_cast<char*>(myDevIdPeerSessionName.c_str()),
-        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
-        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
         .peerName = const_cast<char*>(peerSessionName.c_str()),
+        .peerNetworkId = const_cast<char*>(peerDevId.c_str()),
+        .pkgName = const_cast<char*>(PKG_NAME.c_str()),
         .dataType = sessionModeAndDataTypeMap_[sessionMode],
     };
     int socketId = Socket(clientSocketInfo);
     if (socketId < 0) {
-        DHLOGE("DCameraSoftbusAdapter CreateSoftBusSourceSocketClient Error, socket is invalid");
+        DHLOGE("create socket client error, socket is invalid");
         return DCAMERA_BAD_VALUE;
     }
     int ret = Bind(socketId, g_qosInfo, g_QosTV_Param_Index, &sessListeners_[role]);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter CreateSoftBusSourceSocketClient Error");
+        DHLOGE("create socket client error");
         Shutdown(socketId);
         return DCAMERA_BAD_VALUE;
     }
     sourceSocketId_ = socketId;
-    DHLOGI("DCameraSoftbusAdapter CreateSoftBusSourceSocketClient End, myDevId: %s, peerSessionName: %s",
+    DHLOGI("create socket client end, myDevId: %s, peerSessionName: %s",
         GetAnonyString(myDevId).c_str(), GetAnonyString(peerSessionName).c_str());
     return DCAMERA_OK;
 }
@@ -203,12 +203,12 @@ int32_t DCameraSoftbusAdapter::DestroySoftbusSessionServer(std::string sessionNa
 {
     std::lock_guard<std::mutex> autoLock(optLock_);
     if (sessionTotal_.find(sessionName) == sessionTotal_.end()) {
-        DHLOGI("DCameraSoftbusAdapter sessionName already destroy %s", sessionName.c_str());
+        DHLOGI("current sessionName already destroy, sessionName: %s", GetAnonyString(sessionName).c_str());
         return DCAMERA_OK;
     }
 
     sessionTotal_[sessionName]--;
-    DHLOGI("DCameraSoftbusAdapter sessionName destroy %s totalnum: %d", sessionName.c_str(),
+    DHLOGI("sessionName destroy %s totalnum: %d", GetAnonyString(sessionName).c_str(),
         sessionTotal_[sessionName]);
     uint32_t total_ = sessionTotal_[sessionName];
     if (total_ == 0) {
@@ -225,8 +225,14 @@ int32_t DCameraSoftbusAdapter::CloseSoftbusSession(int32_t socket)
         std::lock_guard<std::mutex> autoLock(idMapLock_);
         sessionIdMap_.erase(socket);
     }
-    sinkSocketIdSessionMap_.erase(socket);
-    sourceSocketIdSessionMap_.erase(socket);
+    {
+        std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
+        sinkSocketSessionMap_.erase(socket);
+    }
+    {
+        std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
+        sourceSocketSessionMap_.erase(socket);
+    }
     DHLOGI("Shutdown softbus socket: %d end", socket);
     return DCAMERA_OK;
 }
@@ -295,9 +301,10 @@ int32_t DCameraSoftbusAdapter::DCameraSoftbusGetSessionById(int32_t sessionId,
 int32_t DCameraSoftbusAdapter::DCameraSoftbusSourceGetSession(int32_t socket,
     std::shared_ptr<DCameraSoftbusSession>& session)
 {
-    auto iter =  sourceSocketIdSessionMap_.find(socket);
-    if (iter == sourceSocketIdSessionMap_.end()) {
-        DHLOGE("DCameraSoftbusAdapter DCameraSoftbusSourceGetSession can not find socket %d", socket);
+    std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
+    auto iter =  sourceSocketSessionMap_.find(socket);
+    if (iter == sourceSocketSessionMap_.end()) {
+        DHLOGE("source can not find current socket %d", socket);
         return DCAMERA_NOT_FOUND;
     }
     session = iter->second;
@@ -307,32 +314,32 @@ int32_t DCameraSoftbusAdapter::DCameraSoftbusSourceGetSession(int32_t socket,
 // source
 int32_t DCameraSoftbusAdapter::SourceOnBind(int32_t socket, PeerSocketInfo info)
 {
-    DHLOGI("DCameraSoftbusAdapter SourceOnBind socket: %d", socket);
+    DHLOGI("source bind socket begin, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnBind not find socket %d", socket);
+        DHLOGE("source bind socket can not find socket %d", socket);
         return DCAMERA_NOT_FOUND;
     }
 
-    ret = session->OnSessionOpened(socket, info);
+    ret = session->OnSessionOpened(socket);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnBind failed %d socket: %d", ret, socket);
+        DHLOGE("source bind socket failed, ret: %d socket: %d", ret, socket);
     } else {
         std::lock_guard<std::mutex> autoLock(idMapLock_);
         sessionIdMap_.emplace(socket, session);
     }
-    DHLOGI("DCameraSoftbusAdapter SourceOnBind socket: %d end", socket);
+    DHLOGI("source bind socket end, socket: %d end", socket);
     return ret;
 }
 
 void DCameraSoftbusAdapter::SourceOnShutDown(int32_t socket, ShutdownReason reason)
 {
-    DHLOGI("DCameraSoftbusAdapter SourceOnShutDown start socket: %d", socket);
+    DHLOGI("source on shutdown socket start, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnShutDown not find socket %d", socket);
+        DHLOGE("SourceOnShutDown can not find socket %d", socket);
         return;
     }
     {
@@ -340,32 +347,32 @@ void DCameraSoftbusAdapter::SourceOnShutDown(int32_t socket, ShutdownReason reas
         sessionIdMap_.erase(socket);
     }
     session->OnSessionClose(socket);
-    DHLOGI("DCameraSoftbusAdapter SourceOnShutDown end socket: %d end", socket);
+    DHLOGI("source on shutdown socket end socket: %d end", socket);
     return;
 }
 
 void DCameraSoftbusAdapter::SourceOnBytes(int32_t socket, const void *data, uint32_t dataLen)
 {
     if (dataLen == 0 || dataLen > DCAMERA_MAX_RECV_DATA_LEN || data == nullptr) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnBytes dataLen: %d, socket: %d", dataLen, socket);
+        DHLOGE("source callback send bytes error, dataLen: %d, socket: %d", dataLen, socket);
         return;
     }
-    DHLOGI("DCameraSoftbusAdapter SourceOnBytes Start socket: %d", socket);
+    DHLOGI("source callback send bytes start, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnBytes not find session %d", socket);
+        DHLOGE("source callback send bytes not find session %d", socket);
         return;
     }
 
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(dataLen);
     ret = memcpy_s(buffer->Data(), buffer->Capacity(), data, dataLen);
     if (ret != EOK) {
-        DHLOGE("DCameraSoftbusAdapter SourceOnBytes memcpy_s failed ret: %d", ret);
+        DHLOGE("source callback send bytes memcpy_s failed ret: %d", ret);
         return;
     }
     session->OnDataReceived(buffer);
-    DHLOGI("DCameraSoftbusAdapter SourceOnBytes end socket: %d", socket);
+    DHLOGI("source callback send bytes end, socket: %d", socket);
     return;
 }
 
@@ -382,18 +389,18 @@ void DCameraSoftbusAdapter::SourceOnStream(int32_t socket, const StreamData *dat
 {
     int64_t recvT = GetNowTimeStampUs();
     if (data == nullptr) {
-        DHLOGE("DCameraSoftbusAdapter::OnSourceStreamReceived, data is null, socket: %d.", socket);
+        DHLOGE("SourceOnStream Error, data is null, socket: %d.", socket);
         return;
     }
     int32_t dataLen = data->bufLen;
     if (dataLen <= 0 || dataLen > static_cast<int32_t>(DCAMERA_MAX_RECV_DATA_LEN)) {
-        DHLOGE("DCameraSoftbusAdapter OnSourceStreamReceived dataLen: %d, socket: %d", dataLen, socket);
+        DHLOGE("SourceOnStream Error, dataLen: %d, socket: %d", dataLen, socket);
         return;
     }
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSourceGetSession(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter OnSourceStreamReceived not find socket %d", socket);
+        DHLOGE("SourceOnStream not find socket %d", socket);
         return;
     }
 
@@ -401,7 +408,7 @@ void DCameraSoftbusAdapter::SourceOnStream(int32_t socket, const StreamData *dat
     buffer->SetInt64(RECV_TIME_US, recvT);
     ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(data->buf), data->bufLen);
     if (ret != EOK) {
-        DHLOGE("DCameraSoftbusAdapter OnSourceStreamReceived memcpy_s failed ret: %d", ret);
+        DHLOGE("SourceOnStream memcpy_s failed ret: %d", ret);
         return;
     }
     ret = HandleSourceStreamExt(buffer, ext);
@@ -447,82 +454,102 @@ int32_t DCameraSoftbusAdapter::HandleSourceStreamExt(std::shared_ptr<DataBuffer>
     return DCAMERA_OK;
 }
 
-int32_t DCameraSoftbusAdapter::GetSinkSocketId()
+int32_t DCameraSoftbusAdapter::GetSourceSocketId()
 {
-    return sinkSocketId_;
+    return sourceSocketId_;
 }
 
-int32_t DCameraSoftbusAdapter::GetSourceSocketId()
+void DCameraSoftbusAdapter::RecordSourceSocketSession(int32_t socket, std::shared_ptr<DCameraSoftbusSession> session)
 {
-    return sourceSocketId_;
+    if (session == nullptr) {
+        DHLOGE("RecordSourceSocketSession error, session is null");
+        return;
+    }
+    {
+        std::lock_guard<std::mutex> autoLock(sourceSocketLock_);
+        sourceSocketSessionMap_[socket] = session;
+    }
 }
 
 int32_t DCameraSoftbusAdapter::DCameraSoftbusSinkGetSession(int32_t socket,
     std::shared_ptr<DCameraSoftbusSession>& session)
 {
-    DHLOGI("DCameraSoftbusAdapter DCameraSoftbusSinkGetSession Start, socket: %d", socket);
-    auto iter = sinkSocketIdSessionMap_.find(socket);
-    if (iter == sinkSocketIdSessionMap_.end()) {
-        DHLOGE("DCameraSoftbusAdapter DCameraSoftbusSinkGetSession can not find socket %d", socket);
-        return DCAMERA_NOT_FOUND;
+    DHLOGI("sink find session start, socket: %d", socket);
+    {
+        std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
+        auto iter = sinkSocketSessionMap_.find(socket);
+        if (iter == sinkSocketSessionMap_.end()) {
+            DHLOGE("sink can not find socket %d", socket);
+            return DCAMERA_NOT_FOUND;
+        }
+        session = iter->second;
+        if (session->GetSessionId() < 0) {
+            DHLOGE("sink find session error, current sessionId is invalid");
+            return DCAMERA_BAD_VALUE;
+        }
     }
-    session = iter->second;
-    DHLOGI("DCameraSoftbusAdapter DCameraSoftbusSinkGetSession End, socket: %d", socket);
+    DHLOGI("sink find session end, socket: %d", socket);
     return DCAMERA_OK;
 }
 
 int32_t DCameraSoftbusAdapter::DCameraSoftBusGetSessionByPeerSocket(int32_t socket,
     std::shared_ptr<DCameraSoftbusSession> &session, PeerSocketInfo info)
 {
-    DHLOGI("DCameraSoftbusAdapter DCameraSoftBusGetSessionByPeerSocket Start, socket %d", socket);
+    DHLOGI("find session by peer socket start, socket %d", socket);
     std::string mySessionName = "";
-    auto sessionNameIter = peerDevIdMySessionNameMap_.find(info.name);
-    if (sessionNameIter == peerDevIdMySessionNameMap_.end()) {
-        DHLOGI("DCameraSoftbusAdapter DCameraSoftBusGetSessionByPeerSocket error, socket %d", socket);
-        return DCAMERA_NOT_FOUND;
+    {
+        std::lock_guard<std::mutex> autoLock(mySessionNamePeerDevIdLock_);
+        auto sessionNameIter = peerDevIdMySessionNameMap_.find(info.name);
+        if (sessionNameIter == peerDevIdMySessionNameMap_.end()) {
+            DHLOGE("find session by peer socket error, socket %d", socket);
+            return DCAMERA_NOT_FOUND;
+        }
+        mySessionName = sessionNameIter->second;
     }
-    mySessionName = sessionNameIter->second;
     auto iter = sinkSessions_.find(std::string(mySessionName));
     if (iter == sinkSessions_.end()) {
-        DHLOGI("DCameraSoftbusAdapter DCameraSoftBusGetSessionByPeerSocket error, mySessionName %s",
+        DHLOGE("find session by peer socket error, mySessionName %s",
             GetAnonyString(mySessionName).c_str());
         return DCAMERA_NOT_FOUND;
     }
     session = iter->second;
-    sinkSocketIdSessionMap_[socket] = session;
-    DHLOGI("DCameraSoftbusAdapter DCameraSoftBusGetSessionByPeerSocket End, socket %d", socket);
+    {
+        std::lock_guard<std::mutex> autoLock(sinkSocketLock_);
+        sinkSocketSessionMap_[socket] = session;
+    }
+    DHLOGI("find session by peer socket end, socket %d", socket);
     return DCAMERA_OK;
 }
 
 // sink
 int32_t DCameraSoftbusAdapter::SinkOnBind(int32_t socket, PeerSocketInfo info)
 {
-    DHLOGI("DCameraSoftbusAdapter SinkOnBind Start socket: %d", socket);
+    DHLOGI("sink bind socket start, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftBusGetSessionByPeerSocket(socket, session, info);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnBind not find socket %d", socket);
+        DHLOGE("sink bind socket error, can not find socket %d", socket);
         return DCAMERA_NOT_FOUND;
     }
 
-    ret = session->OnSessionOpened(socket, info);
+    ret = session->OnSessionOpened(socket);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnBind not find socket %d", socket);
+        DHLOGE("sink bind socket error, not find socket %d", socket);
     } else {
         std::lock_guard<std::mutex> autoLock(idMapLock_);
         sessionIdMap_.emplace(socket, session);
     }
-    DHLOGI("DCameraSoftbusAdapter SinkOnBind End socket: %d", socket);
+    DHLOGI("sink bind socket end, socket: %d", socket);
     return ret;
 }
 
 void DCameraSoftbusAdapter::SinkOnShutDown(int32_t socket, ShutdownReason reason)
 {
-    DHLOGI("DCameraSoftbusAdapter SinkOnShutDown Start socket: %d", socket);
+    DHLOGI("sink on shutdown socket start, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusGetSessionById(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnShutDown not find session %d", socket);
+        DHLOGE("sink on shutdown socket can not find socket %d", socket);
         return;
     }
     {
@@ -530,31 +557,31 @@ void DCameraSoftbusAdapter::SinkOnShutDown(int32_t socket, ShutdownReason reason
         sessionIdMap_.erase(socket);
     }
     session->OnSessionClose(socket);
-    DHLOGI("DCameraSoftbusAdapter SinkOnShutDown End socket: %d", socket);
+    DHLOGI("sink on shutdown socket end, socket: %d", socket);
     return;
 }
 
 void DCameraSoftbusAdapter::SinkOnBytes(int32_t socket, const void *data, uint32_t dataLen)
 {
     if (dataLen == 0 || dataLen > DCAMERA_MAX_RECV_DATA_LEN || data == nullptr) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnBytes dataLen: %d, socket: %d", dataLen, socket);
+        DHLOGE("sink on bytes error, dataLen: %d, socket: %d", dataLen, socket);
         return;
     }
-    DHLOGI("DCameraSoftbusAdapter SinkOnBytes Start socket: %d", socket);
+    DHLOGI("sink on bytes start, socket: %d", socket);
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnBytes not find session %d", socket);
+        DHLOGE("sink on bytes error, can not find session %d", socket);
         return;
     }
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(dataLen);
     ret = memcpy_s(buffer->Data(), buffer->Capacity(), data, dataLen);
     if (ret != EOK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnBytes memcpy_s failed ret: %d", ret);
+        DHLOGE("sink on bytes memcpy_s failed ret: %d", ret);
         return;
     }
     session->OnDataReceived(buffer);
-    DHLOGI("DCameraSoftbusAdapter SinkOnBytes End socket: %d", socket);
+    DHLOGI("sink on bytes end, socket: %d", socket);
     return;
 }
 
@@ -567,25 +594,25 @@ void DCameraSoftbusAdapter::SinkOnStream(int32_t socket, const StreamData *data,
     const StreamFrameInfo *param)
 {
     if (data == nullptr) {
-        DHLOGE("DCameraSoftbusAdapter::SinkOnStream, data is null, socket: %d.", socket);
+        DHLOGE("SinkOnStream error, data is null, socket: %d.", socket);
         return;
     }
     int32_t dataLen = data->bufLen;
     if (dataLen <= 0 || dataLen > static_cast<int32_t>(DCAMERA_MAX_RECV_DATA_LEN)) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnStream dataLen: %d socket: %d", dataLen, socket);
+        DHLOGE("SinkOnStream error, dataLen: %d socket: %d", dataLen, socket);
         return;
     }
     std::shared_ptr<DCameraSoftbusSession> session = nullptr;
     int32_t ret = DCameraSoftbusSinkGetSession(socket, session);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnStream not find session %d", socket);
+        DHLOGE("SinkOnStream error, can not find socket %d", socket);
         return;
     }
 
     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(data->bufLen);
     ret = memcpy_s(buffer->Data(), buffer->Capacity(), reinterpret_cast<uint8_t *>(data->buf), data->bufLen);
     if (ret != EOK) {
-        DHLOGE("DCameraSoftbusAdapter SinkOnStream memcpy_s failed ret: %d", ret);
+        DHLOGE("SinkOnStream error, memcpy_s failed ret: %d", ret);
         return;
     }
     session->OnDataReceived(buffer);
@@ -597,7 +624,7 @@ int32_t DCameraSoftbusAdapter::GetLocalNetworkId(std::string& myDevId)
     NodeBasicInfo basicInfo = { { 0 } };
     int32_t ret = GetLocalNodeDeviceInfo(PKG_NAME.c_str(), &basicInfo);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusAdapter GetLocalNodeDeviceInfo failed ret: %d", ret);
+        DHLOGE("GetLocalNodeDeviceInfo failed ret: %d", ret);
         return ret;
     }
 
diff --git a/services/channel/src/dcamera_softbus_session.cpp b/services/channel/src/dcamera_softbus_session.cpp
index 6bad31292d0a7084c3d00acdaf13b733b459daad..b6257e2edec070d6b1e88f5b16a8b775835a5f6f 100644
--- a/services/channel/src/dcamera_softbus_session.cpp
+++ b/services/channel/src/dcamera_softbus_session.cpp
@@ -41,7 +41,7 @@ DCameraSoftbusSession::DCameraSoftbusSession(std::string myDevId, std::string my
 {
     sendFuncMap_[DCAMERA_SESSION_MODE_CTRL] = &DCameraSoftbusSession::SendBytes;
     sendFuncMap_[DCAMERA_SESSION_MODE_VIDEO] = &DCameraSoftbusSession::SendStream;
-    sendFuncMap_[DCAMERA_SESSION_MODE_JPEG] = &DCameraSoftbusSession::SendStream;
+    sendFuncMap_[DCAMERA_SESSION_MODE_JPEG] = &DCameraSoftbusSession::SendBytes;
     auto runner = AppExecFwk::EventRunner::Create(mySessionName);
     eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
     ResetAssembleFrag();
@@ -62,16 +62,16 @@ DCameraSoftbusSession::~DCameraSoftbusSession()
 
 int32_t DCameraSoftbusSession::CloseSession()
 {
-    DHLOGI("DCameraSoftbusSession CloseSession sessionId: %d peerDevId: %s peerSessionName: %s", sessionId_,
+    DHLOGI("close session sessionId: %d peerDevId: %s peerSessionName: %s", sessionId_,
         GetAnonyString(peerDevId_).c_str(), GetAnonyString(peerSessionName_).c_str());
     if (sessionId_ == -1) {
-        DHLOGI("DCameraSoftbusSession CloseSession has already close peerDevId: %s peerSessionName: %s",
+        DHLOGI("current session has already close peerDevId: %s peerSessionName: %s",
             GetAnonyString(peerDevId_).c_str(), GetAnonyString(peerSessionName_).c_str());
         return DCAMERA_OK;
     }
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CloseSoftbusSession(sessionId_);
     if (ret != DCAMERA_OK) {
-        DHLOGE("DCameraSoftbusSession CloseSession failed, ret: %d, peerDevId: %s peerSessionName: %s", ret,
+        DHLOGE("close session failed, ret: %d, peerDevId: %s peerSessionName: %s", ret,
             GetAnonyString(peerDevId_).c_str(), GetAnonyString(peerSessionName_).c_str());
         return ret;
     }
@@ -81,38 +81,19 @@ int32_t DCameraSoftbusSession::CloseSession()
     return DCAMERA_OK;
 }
 
-int32_t DCameraSoftbusSession::OnSessionOpened(int32_t socket, PeerSocketInfo info)
+int32_t DCameraSoftbusSession::OnSessionOpened(int32_t socket)
 {
-    DHLOGI("DCameraSoftbusSession OnSessionOpened Start, socket is: %d", socket);
-    if (info.networkId == nullptr) {
-        DHLOGE("DCameraSoftbusSession OnSessionOpened error, PeerDevId is null", socket);
-        listener_->OnSessionState(DCAMERA_CHANNEL_STATE_DISCONNECTED);
-        listener_->OnSessionError(DCAMERA_MESSAGE, DCAMERA_EVENT_OPEN_CHANNEL_ERROR,
-            std::string("softbus internal error"));
-        return DCAMERA_WRONG_STATE;
-    }
-    DHLOGI("peerDevId: %s peerSessionName: %s", GetAnonyString(info.networkId).c_str(),
-        GetAnonyString(info.name).c_str());
-    sessionId_ = socket;
-    state_ = DCAMERA_SOFTBUS_STATE_OPENED;
-    listener_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
-    DHLOGI("DCameraSoftbusSession OnSessionOpened End, socket: %d", socket);
-    return DCAMERA_OK;
-}
-
-int32_t DCameraSoftbusSession::RefreshSessionStatus(int32_t socket)
-{
-    DHLOGI("DCameraSoftbusSession RefreshSessionStatus Start, socket: %d", socket);
+    DHLOGI("open current session start, socket: %d", socket);
     sessionId_ = socket;
     state_ = DCAMERA_SOFTBUS_STATE_OPENED;
     listener_->OnSessionState(DCAMERA_CHANNEL_STATE_CONNECTED);
-    DHLOGI("DCameraSoftbusSession RefreshSessionStatus End, socket: %d", socket);
+    DHLOGI("open current session end, socket: %d", socket);
     return DCAMERA_OK;
 }
 
 int32_t DCameraSoftbusSession::OnSessionClose(int32_t sessionId)
 {
-    DHLOGI("DCameraSoftbusSession OnSessionClose sessionId: %d peerDevId: %s peerSessionName: %s", sessionId,
+    DHLOGI("OnSessionClose sessionId: %d peerDevId: %s peerSessionName: %s", sessionId,
         GetAnonyString(peerDevId_).c_str(), GetAnonyString(peerSessionName_).c_str());
     sessionId_ = -1;
     state_ = DCAMERA_SOFTBUS_STATE_CLOSED;
@@ -144,7 +125,7 @@ void DCameraSoftbusSession::DealRecvData(std::shared_ptr<DataBuffer>& buffer)
 void DCameraSoftbusSession::PackRecvData(std::shared_ptr<DataBuffer>& buffer)
 {
     if (buffer->Size() < BINARY_HEADER_FRAG_LEN) {
-        DHLOGE("DCameraSoftbusSession PackRecvData failed, size: %d, sess: %s peerSess: %s",
+        DHLOGE("pack recv data error, size: %d, sess: %s peerSess: %s",
             buffer->Size(), mySessionName_.c_str(), peerSessionName_.c_str());
         return;
     }
@@ -153,18 +134,18 @@ void DCameraSoftbusSession::PackRecvData(std::shared_ptr<DataBuffer>& buffer)
     GetFragDataLen(ptrPacket, headerPara);
     if (buffer->Size() != (headerPara.dataLen + BINARY_HEADER_FRAG_LEN) || headerPara.dataLen > headerPara.totalLen ||
         headerPara.dataLen > BINARY_DATA_MAX_LEN || headerPara.totalLen > BINARY_DATA_MAX_TOTAL_LEN) {
-        DHLOGE("DCameraSoftbusSession PackRecvData failed, size: %d, dataLen: %d, totalLen: %d sess: %s peerSess: %s",
+        DHLOGE("pack recv data failed, size: %d, dataLen: %d, totalLen: %d sess: %s peerSess: %s",
             buffer->Size(), headerPara.dataLen, headerPara.totalLen, mySessionName_.c_str(), peerSessionName_.c_str());
         return;
     }
-    DHLOGD("DCameraSoftbusSession PackRecvData Assemble, size: %d, dataLen: %d, totalLen: %d, nowTime: %lld start",
+    DHLOGD("pack recv data Assemble, size: %d, dataLen: %d, totalLen: %d, nowTime: %lld start",
         buffer->Size(), headerPara.dataLen, headerPara.totalLen, GetNowTimeStampUs());
     if (headerPara.fragFlag == FRAG_START_END) {
         AssembleNoFrag(buffer, headerPara);
     } else {
         AssembleFrag(buffer, headerPara);
     }
-    DHLOGD("DCameraSoftbusSession PackRecvData Assemble, size: %d, dataLen: %d, totalLen: %d, nowTime: %lld end",
+    DHLOGD("pack recv data Assemble, size: %d, dataLen: %d, totalLen: %d, nowTime: %lld end",
         buffer->Size(), headerPara.dataLen, headerPara.totalLen, GetNowTimeStampUs());
 }
 
@@ -368,7 +349,7 @@ void DCameraSoftbusSession::SetHeadParaDataLen(SessionDataHeader& headPara, cons
     const uint32_t offset)
 {
     if (totalLen - offset > BINARY_DATA_PACKET_MAX_LEN) {
-        headPara.dataLen = BINARY_DATA_PACKET_MAX_LEN;
+        headPara.dataLen = BINARY_DATA_PACKET_MAX_LEN - BINARY_DATA_PACKET_RESERVED_BUFFER;
     } else {
         headPara.fragFlag = FRAG_END;
         headPara.dataLen = totalLen - offset;
@@ -453,5 +434,10 @@ std::string DCameraSoftbusSession::GetMySessionName()
 {
     return mySessionName_;
 }
+
+int32_t DCameraSoftbusSession::GetSessionId()
+{
+    return sessionId_;
+}
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp
index d3bdb3772904f043f4895359e5881c846183ba7c..c3c6cc9314a533d3f0a66f8e61a46eb4e7ad1c2b 100644
--- a/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_softbus_adapter_test.cpp
@@ -224,7 +224,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_008, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
     DCameraSoftbusAdapter::GetInstance().sourceSessions_.emplace(peerDevId + mySessName, session);
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
@@ -250,7 +255,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_009, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
 
     DCameraSoftbusAdapter::GetInstance().SourceOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
@@ -276,7 +286,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_010, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
     const void *data = "testdata";
     uint32_t dataLen = 8;
@@ -304,7 +319,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_011, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
     const void *data = "testdata";
     uint32_t dataLen = 8;
@@ -332,7 +352,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_012, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
     std::string buff01 = "testbuffer01";
     StreamData test01;
@@ -377,7 +402,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_013, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
     DCameraSoftbusAdapter::GetInstance().sinkSessions_.emplace(peerDevId + mySessName, session);
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
@@ -402,7 +432,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_014, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_VIDEO_STREAM,
+    };
     DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
 
     DCameraSoftbusAdapter::GetInstance().SinkOnShutDown(sessionId, ShutdownReason::SHUTDOWN_REASON_LOCAL);
@@ -428,7 +463,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_015, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     const void *data = "testdata";
     uint32_t dataLen = 8;
@@ -456,7 +496,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_016, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     const void *data = "testdata";
     uint32_t dataLen = 8;
@@ -484,7 +529,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_017, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     std::string buff01 = "testbuffer01";
     StreamData test01;
@@ -523,7 +573,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_018, TestSize.L
         sessionMode, role);
     int32_t sessionId = 2;
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session);
 
@@ -549,7 +604,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_019, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSinkGetSession(sessionId, session);
@@ -576,7 +636,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_020, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = 2;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session);
@@ -603,7 +668,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_023, TestSize.L
     int32_t ret = DCameraSoftbusAdapter::GetInstance().CreateSoftBusSourceSocketClient(myDevId, peerSessName, peerDevId,
         sessionMode, role);
     int32_t sessionId = -1;
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
     ret = DCameraSoftbusAdapter::GetInstance().SinkOnBind(sessionId, info);
     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusGetSessionById(sessionId, session);
@@ -631,7 +701,12 @@ HWTEST_F(DCameraSoftbusAdapterTest, dcamera_softbus_adapter_test_027, TestSize.L
         sessionMode, role);
     int32_t sessionId = 27;
     std::shared_ptr<DCameraSoftbusSession> session = std::make_shared<DCameraSoftbusSession>();
-    PeerSocketInfo info = {};
+    PeerSocketInfo info = {
+        .name = const_cast<char*>(peerSessName.c_str()),
+        .pkgName = const_cast<char*>(DCAMERA_PKG_NAME.c_str()),
+        .networkId = const_cast<char*>(peerDevId.c_str()),
+        .dataType = TransDataType::DATA_TYPE_BYTES,
+    };
     ret = DCameraSoftbusAdapter::GetInstance().SourceOnBind(sessionId, info);
     ret = DCameraSoftbusAdapter::GetInstance().DCameraSoftbusSourceGetSession(sessionId, session);
     EXPECT_EQ(DCAMERA_MEMORY_OPT_ERROR, ret);
diff --git a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
index fffb2d5eb6376f29acdc1ae8f573426a2339d2e0..6b3ff9c9a6738ee29b418620e5bd09d937d3a1e8 100644
--- a/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
+++ b/services/channel/test/unittest/common/channel/dcamera_softbus_session_test.cpp
@@ -113,12 +113,7 @@ HWTEST_F(DCameraSoftbusSessionTest, dcamera_softbus_session_test_002, TestSize.L
     std::string sessionName = "dcamera_softbus_session_test_002";
     std::string pkgName = "ohos.dhardware.dcamera";
     std::string networkId = "abcdefg123";
-    PeerSocketInfo info = {
-        .name = const_cast<char*>(sessionName.c_str()),
-        .pkgName = const_cast<char*>(pkgName.c_str()),
-        .networkId = const_cast<char*>(networkId.c_str()),
-    };
-    int32_t ret = softbusSession_->OnSessionOpened(sessionId, info);
+    int32_t ret = softbusSession_->OnSessionOpened(sessionId);
     EXPECT_EQ(DCAMERA_OK, ret);
 }
 
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 36dff26b2ca9dd542bcb7587803e24c48c127d87..4ba8e84671c173e64d6bc4f984f083febc4a3215 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
@@ -501,9 +501,9 @@ int32_t EncodeDataProcess::GetEncoderOutputBuffer(uint32_t index, MediaAVCodec::
     }
     int64_t timeStamp = info.presentationTimeUs;
     struct timespec time = {0, 0};
-    clock_gettime(CLOCK_REALTIME, &time);
+    clock_gettime(CLOCK_MONOTONIC, &time);
     int64_t timeNs = static_cast<int64_t>(time.tv_sec) * S2NS + static_cast<int64_t>(time.tv_nsec);
-    int64_t encodeT = timeNs / static_cast<int64_t>(US2NS) - timeStamp;
+    int64_t encodeT = (timeNs - timeStamp) / static_cast<int64_t>(US2NS);
     int64_t finishEncodeT = GetNowTimeStampUs();
     int64_t startEncodeT = finishEncodeT - encodeT;
     bufferOutput->SetInt64(START_ENCODE_TIME_US, startEncodeT);