diff --git a/services/cameraservice/cameraoperator/client/include/dcamera_client.h b/services/cameraservice/cameraoperator/client/include/dcamera_client.h index 09167840f44723aebdcc3c851d7d99aadb18e331..1df19c7b12cc643a9d4ab797ea0c095b6d78ed35 100644 --- a/services/cameraservice/cameraoperator/client/include/dcamera_client.h +++ b/services/cameraservice/cameraoperator/client/include/dcamera_client.h @@ -49,6 +49,7 @@ public: int32_t SetResultCallback(std::shared_ptr& callback) override; int32_t PauseCapture() override; int32_t ResumeCapture() override; + int32_t PrelaunchCamera() override; private: int32_t ConfigCaptureSession(std::vector>& captureInfos, int32_t sceneMode); @@ -91,4 +92,4 @@ private: }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DCAMERA_CLIENT_H \ No newline at end of file +#endif // OHOS_DCAMERA_CLIENT_H diff --git a/services/cameraservice/cameraoperator/client/include/icamera_operator.h b/services/cameraservice/cameraoperator/client/include/icamera_operator.h index 0c0a2e40b97e5bc36bea36accd83fc5cfd97518c..90daa089d4f0084af5a70fe942c5311045e1b863 100644 --- a/services/cameraservice/cameraoperator/client/include/icamera_operator.h +++ b/services/cameraservice/cameraoperator/client/include/icamera_operator.h @@ -64,7 +64,8 @@ public: virtual int32_t SetResultCallback(std::shared_ptr& callback) = 0; virtual int32_t PauseCapture() = 0; virtual int32_t ResumeCapture() = 0; + virtual int32_t PrelaunchCamera() = 0; }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_ICAMERA_OPERATOR_H \ No newline at end of file +#endif // OHOS_ICAMERA_OPERATOR_H diff --git a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp index 78851383b43a990d28ba773d53e6f0ebe31af427..099cf53a91c9acbf4d678b085604cb7c7f6774ff 100644 --- a/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp +++ b/services/cameraservice/cameraoperator/client/src/dcamera_client.cpp @@ -665,5 +665,19 @@ int32_t DCameraClient::ResumeCapture() } return ret; } + +int32_t DCameraClient::PrelaunchCamera() +{ + if (cameraManager_ == nullptr) { + DHLOGE("DCameraClient cameraManager_ is nullptr."); + return DCAMERA_BAD_VALUE; + } + int32_t ret = cameraManager_->PrelaunchCamera(); + if (ret != DCAMERA_OK) { + DHLOGE("DCameraClient PrelaunchCamera Start failed, cameraId: %{public}s, ret: %{public}d", + GetAnonyString(cameraId_).c_str(), ret); + } + return ret; +} } // namespace DistributedHardware } // namespace OHOS diff --git a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h index e053ae9d847a48f55b28fb1cc45835d4a5c9e62b..0a81725d3713dfc1645987fe80df831548827ab6 100644 --- a/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h +++ b/services/cameraservice/sinkservice/include/distributedcameramgr/dcamera_sink_controller.h @@ -85,6 +85,9 @@ private: void ProcessPostAuthorization(const AppExecFwk::InnerEvent::Pointer &event); int32_t CreateCtrlSession(); int32_t CheckSensitive(); + void HandleConnecting(); + void HandleConnected(std::string networkId); + void HandleDisconnected(); bool isInit_; int32_t sessionState_; @@ -116,4 +119,4 @@ class DeviceInitCallback : public DmInitCallback { }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_DCAMERA_SINK_CONTROLLER_H \ No newline at end of file +#endif // OHOS_DCAMERA_SINK_CONTROLLER_H diff --git a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp index 8760e9e58059a38a3c141487dece8605a869c899..f2afa285d6d6071e81ec5b52e47590a940b83e05 100644 --- a/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp +++ b/services/cameraservice/sinkservice/src/distributedcameramgr/dcamera_sink_controller.cpp @@ -544,45 +544,17 @@ void DCameraSinkController::OnMetadataResult(std::vector autoLock(autoLock_); - int32_t ret = CloseChannel(); - if (ret != DCAMERA_OK) { - DHLOGE("session state: %{public}d, %{public}s close channel failed, ret: %{public}d", - sessionState_, GetAnonyString(dhId_).c_str(), ret); - } - ret = StopCapture(); - if (ret != DCAMERA_OK) { - DHLOGE("session state: %{public}d, %{public}s stop capture failed, ret: %{public}d", - sessionState_, GetAnonyString(dhId_).c_str(), ret); - } - }); + HandleDisconnected(); break; default: DHLOGE("unknown session state"); @@ -590,6 +562,55 @@ void DCameraSinkController::OnSessionState(int32_t state, std::string networkId) } } +void DCameraSinkController::HandleConnecting() +{ + DHLOGI("channel is connecting"); +} + +void DCameraSinkController::HandleConnected(std::string networkId) +{ + if (!ManageSelectChannel::GetInstance().GetSinkConnect()) { + return; + } + srcDevId_ = networkId; + int32_t ret = CheckSensitive(); + if (ret != DCAMERA_OK) { + DHLOGE("Check sensitive error. ret %{public}d.", ret); + return; + } + ret = PullUpPage(); + CHECK_AND_RETURN_LOG(ret != DCAMERA_OK, "PullUpPage failed"); + if (operator_ == nullptr) { + DHLOGE("operator_ is nullptr"); + return; + } + ret = operator_->PrelaunchCamera(); + if (ret != DCAMERA_OK) { + DHLOGE("operator_ PrelaunchCamera error. ret %{public}d.", ret); + return; + } +} + +void DCameraSinkController::HandleDisconnected() +{ + ffrt::submit([this]() { + DHLOGI("DCameraSinkController::OnSessionState %{public}s new thread session state: %{public}d", + GetAnonyString(dhId_).c_str(), sessionState_); + prctl(PR_SET_NAME, CHANNEL_DISCONNECTED.c_str()); + std::lock_guard autoLock(autoLock_); + int32_t ret = CloseChannel(); + if (ret != DCAMERA_OK) { + DHLOGE("session state: %{public}d, %{public}s close channel failed, ret: %{public}d", + sessionState_, GetAnonyString(dhId_).c_str(), ret); + } + ret = StopCapture(); + if (ret != DCAMERA_OK) { + DHLOGE("session state: %{public}d, %{public}s stop capture failed, ret: %{public}d", + sessionState_, GetAnonyString(dhId_).c_str(), ret); + } + }); +} + void DCameraSinkController::OnSessionError(int32_t eventType, int32_t eventReason, std::string detail) { DHLOGI("DCameraSinkController::OnSessionError dhId: %{public}s, eventType: %{public}d, eventReason: %{public}d," @@ -846,4 +867,4 @@ void DeviceInitCallback::OnRemoteDied() DHLOGI("DeviceInitCallback OnRemoteDied"); } } // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp index 0a5fe02f10f602c1a6dc64ee97dc691177eb4fd6..1adafec195029917a97ec564c08cf04264cd14ad 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/dcamera_sink_output_test.cpp @@ -289,5 +289,17 @@ HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_008, TestSize.Level1) ret = output_->GetProperty(name, propertyCarrier); EXPECT_NE(DCAMERA_OK, ret); } + +/** + * @tc.name: dcamera_sink_output_test_009 + * @tc.desc: Verify the PrelaunchCamera function. + * @tc.type: FUNC + * @tc.require: I5N1JI + */ +HWTEST_F(DCameraSinkOutputTest, dcamera_sink_output_test_009, TestSize.Level1) +{ + int32_t ret = operator_->PrelaunchCamera(); + EXPECT_EQ(DCAMERA_OK, ret); +} } // namespace DistributedHardware -} // namespace OHOS \ No newline at end of file +} // namespace OHOS diff --git a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h index e3a28ded3ac8d03210c33224b392192eb816dfda..2a712d6af2937495e90ad5c70b45a6ab8a6bb0d5 100644 --- a/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h +++ b/services/cameraservice/sinkservice/test/unittest/common/distributedcameramgr/mock_camera_operator.h @@ -110,7 +110,12 @@ public: } return DCAMERA_OK; } + + int32_t PrelaunchCamera() + { + return DCAMERA_OK; + } }; } // namespace DistributedHardware } // namespace OHOS -#endif // OHOS_MOCK_CAMERA_OPERATOR_H \ No newline at end of file +#endif // OHOS_MOCK_CAMERA_OPERATOR_H diff --git a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h index 6fa3b270903d2fbbe7a4026833446791d3e7c583..20e0a306e86866f420495a54c90f907c0e73076d 100644 --- a/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h +++ b/services/cameraservice/sourceservice/include/distributedcameramgr/dcameradata/dcamera_source_input.h @@ -68,6 +68,10 @@ private: std::atomic isChannelConnected_ = false; std::mutex channelMtx_; std::condition_variable channelCond_; + + std::atomic isOpenChannel_ = false; + std::mutex isOpenChannelMtx_; + std::condition_variable isOpenChannelCond_; }; } // namespace DistributedHardware } // namespace OHOS diff --git a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp index 85a23569074348b0e5515670fb3f499abf1bed90..3a026d76cd6ce42bc35073fd0d5a20504846dc86 100644 --- a/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp +++ b/services/cameraservice/sourceservice/src/distributedcameramgr/dcameradata/dcamera_source_input.cpp @@ -180,13 +180,21 @@ int32_t DCameraSourceInput::OpenChannel(std::vector& indexs) DHLOGI("DCameraSourceInput OpenChannel devId %{public}s dhId %{public}s continue state: %{public}d, snapshot " "state: %{public}d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), channelState_[CONTINUOUS_FRAME], channelState_[SNAPSHOT_FRAME]); + std::shared_ptr runner = AppExecFwk::EventRunner::Create(true); + auto handler = std::make_shared(runner); + std::vector &localIndexs = indexs; if (channelState_[CONTINUOUS_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) { - int32_t ret = EstablishContinuousFrameSession(indexs); - if (ret != DCAMERA_OK) { - DHLOGE("esdablish continuous frame failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret, - GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); - return ret; - } + auto task = [&]() { + int32_t ret = EstablishContinuousFrameSession(localIndexs); + if (ret != DCAMERA_OK) { + DHLOGE("esdablish continuous frame failed ret: %{public}d, devId: %{public}s, dhId: %{public}s", ret, + GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str()); + } + std::unique_lock lock(isOpenChannelMtx_); + isOpenChannel_.store(true); + isOpenChannelCond_.notify_one(); + }; + handler->PostTask(task, "DCameraSourceInput:OpenChannel", 0, AppExecFwk::EventQueue::Priority::HIGH); } if (channelState_[SNAPSHOT_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) { int32_t ret = EstablishSnapshotFrameSession(indexs); @@ -196,6 +204,12 @@ int32_t DCameraSourceInput::OpenChannel(std::vector& indexs) GetAnonyString(dhId_).c_str()); return ret; } + { + std::unique_lock lock(isOpenChannelMtx_); + while (!isOpenChannel_.load()) { + isOpenChannelCond_.wait_for(lock, std::chrono::seconds(1), [this] { return isOpenChannel_.load(); }); + } + } } return DCAMERA_OK; } diff --git a/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h b/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h index 87b1dfff60d87452586ac37877f0a786e13f3c3e..ea3b151a9e076089db0f335cad97962e042413b3 100644 --- a/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h +++ b/services/data_process/include/pipeline_node/multimedia_codec/encoder/encode_data_process.h @@ -132,6 +132,9 @@ private: sptr encodeProducerSurface_ = nullptr; std::atomic isEncoderProcess_ = false; + std::mutex isEncoderProcessMtx_; + std::condition_variable isEncoderProcessCond_; + int32_t waitEncoderOutputCount_ = 0; int64_t lastFeedEncoderInputBufferTimeUs_ = 0; int64_t inputTimeStampUs_ = 0; diff --git a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp index 09bbc9344875d560ba72f12ee03672ffcc49d915..9d4e1f52a85e01cb8855961e82ddfb95b7ef0b9f 100644 --- a/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp +++ b/services/data_process/src/pipeline_node/multimedia_codec/encoder/encode_data_process.cpp @@ -74,6 +74,7 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const processedConfig_ = sourceConfig; processedConfig = processedConfig_; isEncoderProcess_.store(true); + isEncoderProcessCond_.notify_one(); return DCAMERA_OK; } @@ -85,6 +86,7 @@ int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const } processedConfig = processedConfig_; isEncoderProcess_.store(true); + isEncoderProcessCond_.notify_one(); return DCAMERA_OK; } @@ -460,7 +462,7 @@ int32_t EncodeDataProcess::GetEncoderOutputBuffer(uint32_t index, MediaAVCodec:: DHLOGE("Failed to get the output shared memory, index : %{public}u", index); return DCAMERA_BAD_OPERATE; } - + CHECK_AND_RETURN_RET_LOG(info.size <= 0 || info.size > DATABUFF_MAX_SIZE, DCAMERA_BAD_VALUE, "AVCodecBufferInfo error, buffer size : %{public}d", info.size); size_t outputMemoDataSize = static_cast(info.size); @@ -541,9 +543,9 @@ void EncodeDataProcess::OnOutputFormatChanged(const Media::Format &format) void EncodeDataProcess::OnOutputBufferAvailable(uint32_t index, MediaAVCodec::AVCodecBufferInfo info, MediaAVCodec::AVCodecBufferFlag flag, std::shared_ptr buffer) { - if (!isEncoderProcess_.load()) { - DHLOGE("EncodeNode occurred error or start release."); - return; + std::unique_lock lock(isEncoderProcessMtx_); + while (!isEncoderProcess_.load()) { + isEncoderProcessCond_.wait_for(lock, std::chrono::seconds(1), [this] { return isEncoderProcess_.load(); }); } DHLOGD("Video encode buffer info: presentation TimeUs %{public}" PRId64", size %{public}d, offset %{public}d, " "flag %{public}d", info.presentationTimeUs, info.size, info.offset, flag);