diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h index d637245da954636b4609a9df731d50d474ba39f3..ff01db11d1d32463cd954eb551fe6b512a8d05c2 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/include/v4l2_temp.h @@ -26,9 +26,10 @@ namespace OHOS::Camera { enum CameraBufferStatus { + CAMERA_BUFFER_STATUS_OK = 0, CAMERA_BUFFER_STATUS_DROP, + CAMERA_BUFFER_STATUS_INVALID, }; - class IBuffer { public: IBuffer() {} diff --git a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp index ebfd9d89223d3d02ba63bc695159e5985539dde5..005d5093152148d38d700c64dcff74ad77dbad7f 100644 --- a/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp +++ b/camera/hal/adapter/platform/v4l2/src/driver_adapter/src/v4l2_buffer.cpp @@ -139,12 +139,14 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) buf.index, (void*)buf.m.userptr, buf.length); } - auto IterMap = queueBuffers_.find(fd); - if (IterMap == queueBuffers_.end()) { + std::lock_guard l(bufferLock_); + + auto iterMap = queueBuffers_.find(fd); + if (iterMap == queueBuffers_.end()) { CAMERA_LOGE("std::map queueBuffers_ no fd\n"); return RC_ERROR; } - auto& bufferMap = IterMap->second; + auto& bufferMap = iterMap->second; auto Iter = bufferMap.find(buf.index); if (Iter == bufferMap.end()) { @@ -154,14 +156,12 @@ RetCode HosV4L2Buffers::V4L2DequeueBuffer(int fd) if (dequeueBuffer_ == nullptr) { CAMERA_LOGE("V4L2DequeueBuffer buf.index == %{public}d no callback\n", buf.index); - std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_ERROR; } // callback to up dequeueBuffer_(Iter->second); - std::lock_guard l(bufferLock_); bufferMap.erase(Iter); return RC_OK; @@ -240,7 +240,31 @@ void HosV4L2Buffers::SetCallback(BufCallback cb) } RetCode HosV4L2Buffers::Flush(int fd) { - CAMERA_LOGE("HosV4L2Buffers::Flush\n"); + CAMERA_LOGD("HosV4L2Buffers::Flush enter\n"); + std::lock_guard l(bufferLock_); + + if (dequeueBuffer_ == nullptr) { + CAMERA_LOGE("HosV4L2Buffers::Flush dequeueBuffer_ == nullptr"); + return RC_ERROR; + } + + auto iterMap = queueBuffers_.find(fd); + if (iterMap == queueBuffers_.end()) { + CAMERA_LOGE("HosV4L2Buffers::Flush std::map queueBuffers_ no fd"); + return RC_ERROR; + } + auto& bufferMap = iterMap->second; + + for (auto& it : bufferMap) { + std::shared_ptr frameSpec = it.second; + CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer begin, buffpool=%{public}d", + (int32_t)frameSpec->bufferPoolId_); + frameSpec->buffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + dequeueBuffer_(frameSpec); + CAMERA_LOGD("HosV4L2Buffers::Flush throw up buffer end"); + } + + bufferMap.clear(); return RC_OK; } } // namespace OHOS::Camera diff --git a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp index 8a5b991b4552b1c578f7792f971e6533a24af247..3b4e978fbe9880b8a29cb9ffc8ce6a399e0d95cb 100644 --- a/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp +++ b/camera/hal/adapter/platform/v4l2/src/pipeline_core/nodes/v4l2_source_node/v4l2_source_node.cpp @@ -75,19 +75,23 @@ V4L2SourceNode::~V4L2SourceNode() RetCode V4L2SourceNode::Flush(const int32_t streamId) { - RetCode rc = RC_OK; - rc = SourceNode::Flush(streamId); - CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + RetCode rc; rc = sensorController_->Flush(streamId); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); + rc = SourceNode::Flush(streamId); + return rc; } RetCode V4L2SourceNode::Stop(const int32_t streamId) { - SourceNode::Stop(streamId); + RetCode rc; + + rc = sensorController_->Stop(); + CHECK_IF_NOT_EQUAL_RETURN_VALUE(rc, RC_OK, RC_ERROR); - return sensorController_->Stop(); + return SourceNode::Stop(streamId); } void V4L2SourceNode::SetBufferCallback() diff --git a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp index a774b4e636ddc6c72de4b512da91abb0b7145b22..15c08fc70dd46ddc4a8917281a9633917d189692 100644 --- a/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp +++ b/camera/hal/hdi_impl/src/stream_operator/stream_base.cpp @@ -426,6 +426,7 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) } if (r->GetCaptureId() == captureId) { request = r; + break; } } } @@ -440,7 +441,6 @@ void StreamBase::HandleResult(std::shared_ptr& buffer) // To synchronize multiple stream, bottom-layer device stream need be synchronized first. request->OnResult(streamId_); lastRequest_ = request; - return; } RetCode StreamBase::OnFrame(const std::shared_ptr& request) diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp index 89cb91d98139fe98ed293169e62effe0c5270a51..838b84e695a8bb93b5472765364d7df1d257a81e 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.cpp @@ -22,30 +22,49 @@ ForkNode::ForkNode(const std::string& name, const std::string& type) : NodeBase( ForkNode::~ForkNode() { - streamRunning_ = false; - cv_.notify_all(); - if (forkThread_ != nullptr) { - CAMERA_LOGI("forkThread need join"); - forkThread_->join(); - forkThread_ = nullptr; - } - CAMERA_LOGI("fork Node exit."); + StopForkThread(); } RetCode ForkNode::Start(const int32_t streamId) { + int32_t id = 0; + uint64_t bufferPoolId = 0; + CAMERA_LOGI("ForkNode::Start streamId = %{public}d\n", streamId); - if (streamRunning_ == true) + if (streamRunning_) { return RC_OK; + } inPutPorts_ = GetInPorts(); outPutPorts_ = GetOutPorts(); - if (streamRunning_ == false) { - CAMERA_LOGI("ForkNode::Start::streamrunning = false"); - streamRunning_ = true; - ForkBuffers(); + + for (auto& in : inPutPorts_) { + for (auto& out : outPutPorts_) { + if (out->format_.streamId_ != in->format_.streamId_) { + id = out->format_.streamId_; + bufferPoolId = out->format_.bufferPoolId_; + CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); + } + } + } + + BufferManager* bufferManager = Camera::BufferManager::GetInstance(); + if (bufferManager == nullptr) { + CAMERA_LOGE("fork buffer get instance failed"); + return RC_ERROR; } + + bufferPool_ = bufferManager->GetBufferPool(bufferPoolId); + if (bufferPool_ == nullptr) { + CAMERA_LOGE("get bufferpool failed: %{public}zu", bufferPoolId); + return RC_ERROR; + } + + streamId_ = id; + RunForkThread(); + streamRunning_ = true; + return RC_OK; } @@ -53,19 +72,25 @@ RetCode ForkNode::Stop(const int32_t streamId) { CAMERA_LOGI("ForkNode::Stop streamId = %{public}d\n", streamId); - streamRunning_ = false; - cv_.notify_all(); - if (forkThread_ != nullptr) { - CAMERA_LOGI("ForkNode::Stop need join"); - forkThread_->join(); - forkThread_ = nullptr; + if (!streamRunning_) { + return RC_OK; } + + StopForkThread(); + DrainForkBufferPool(); + + streamRunning_ = false; + return RC_OK; } RetCode ForkNode::Flush(const int32_t streamId) { - CAMERA_LOGI("ForkNode::Flush streamId = %{public}d\n", streamId); + if (streamId_ == streamId) { + StopForkThread(); + DrainForkBufferPool(); + } + return RC_OK; } @@ -75,12 +100,24 @@ void ForkNode::DeliverBuffer(std::shared_ptr& buffer) CAMERA_LOGE("frameSpec is null"); return; } - int32_t id = buffer->GetStreamId(); - { + + if (buffer->GetBufferStatus() == CAMERA_BUFFER_STATUS_OK && bufferPool_ != nullptr) { std::unique_lock lck(mtx_); - tmpBuffer_ = buffer; - cv_.notify_one(); + // If previous pending buffer was not handled, do not replace it. + if (pendingBuffer_ == nullptr) { + pendingBuffer_ = bufferPool_->AcquireBuffer(0); + if (pendingBuffer_ != nullptr) { + if (memcpy_s(pendingBuffer_->GetVirAddress(), pendingBuffer_->GetSize(), + buffer->GetVirAddress(), buffer->GetSize()) != 0) { + pendingBuffer_->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + CAMERA_LOGE("memcpy_s failed."); + } + cv_.notify_all(); + } + } } + + int32_t id = buffer->GetStreamId(); for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { it->DeliverBuffer(buffer); @@ -120,39 +157,47 @@ RetCode ForkNode::CancelCapture(const int32_t streamId) return RC_OK; } -void ForkNode::ForkBuffers() +void ForkNode::RunForkThread() { - int32_t id = 0; - uint64_t bufferPoolId = 0; - for (auto& in : inPutPorts_) { - for (auto& out : outPutPorts_) { - if (out->format_.streamId_ != in->format_.streamId_) { - id = out->format_.streamId_; - bufferPoolId = out->format_.bufferPoolId_; - CAMERA_LOGI("fork buffer get buffer streamId = %{public}d", out->format_.streamId_); - } - } + if (forkThread_ != nullptr) { + CAMERA_LOGI("Fork thread is running."); + return; } - forkThread_ = std::make_shared([this, id, bufferPoolId] { - prctl(PR_SET_NAME, "fork_buffers"); - std::shared_ptr frameSpec = std::make_shared(); + + forkThreadRunFlag_ = true; + + forkThread_ = std::make_shared([this] { + prctl(PR_SET_NAME, "deliver_fork_buffers"); std::shared_ptr buffer = nullptr; - while (streamRunning_ == true) { - if (CopyBuffer(bufferPoolId, buffer) != RC_OK) { - continue; + int32_t id = streamId_; + + while (true) { + { + std::unique_lock lck(mtx_); + // Break the loop when stream was stopped and there was no pending buffer. + if (!forkThreadRunFlag_ && (pendingBuffer_ == nullptr)) { + break; + } + + if (pendingBuffer_ == nullptr) { + cv_.wait(lck); + continue; // rewind to the front of loop to check breaking condition. + } + // go ahead to deliver buffer. + buffer = pendingBuffer_; + pendingBuffer_ = nullptr; } + for (auto& it : outPutPorts_) { if (it->format_.streamId_ == id) { - CAMERA_LOGI("fork node deliver buffer streamid = %{public}d", it->format_.streamId_); + CAMERA_LOGI("fork node deliver buffer streamid = %{public}d begin", it->format_.streamId_); int32_t id = buffer->GetStreamId(); { std::lock_guard l(requestLock_); CAMERA_LOGV("ForkNode::deliver a buffer to stream id:%{public}d, queue size:%{public}u", id, captureRequests_[id].size()); - if (captureRequests_.count(id) == 0) { - buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); - } else if (captureRequests_[id].empty()) { + if (captureRequests_.count(id) == 0 || captureRequests_[id].empty()) { buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); } else { buffer->SetCaptureId(captureRequests_[id].front()); @@ -164,44 +209,42 @@ void ForkNode::ForkBuffers() } } } - CAMERA_LOGI("fork thread closed"); + CAMERA_LOGI("ForkNode RunForkThread closed"); return RC_OK; }); return; } -RetCode ForkNode::CopyBuffer(uint64_t poolId, std::shared_ptr& buffer) +void ForkNode::StopForkThread() { - BufferManager* bufferManager = Camera::BufferManager::GetInstance(); - CHECK_IF_PTR_NULL_RETURN_VALUE(bufferManager, RC_ERROR); - std::unique_lock lck(mtx_); - cv_.wait(lck); - - if (tmpBuffer_ == nullptr) { - CAMERA_LOGE("tempBuffer_ is null"); - return RC_ERROR; + if (forkThread_ != nullptr) { + { + std::unique_lock lck(mtx_); + forkThreadRunFlag_ = false; + cv_.notify_all(); + } + forkThread_->join(); + forkThread_ = nullptr; } +} - std::shared_ptr bufferPool = bufferManager->GetBufferPool(poolId); - if (bufferPool == nullptr) { - CAMERA_LOGE("get bufferpool failed"); - return RC_ERROR; - } - CAMERA_LOGI("fork node acquirebuffer enter"); - buffer = bufferPool->AcquireBuffer(); - CAMERA_LOGI("fork node acquirebuffer exit"); - if (buffer == nullptr) { - CAMERA_LOGE("acquire buffer failed."); - return RC_ERROR; - } - if (memcpy_s(buffer->GetVirAddress(), buffer->GetSize(), - tmpBuffer_->GetVirAddress(), tmpBuffer_->GetSize()) != 0) { - CAMERA_LOGE("memcpy_s failed."); +void ForkNode::DrainForkBufferPool() +{ + // Drain all buffers from Buffer Pool to Stream Tunnel. + if (bufferPool_ != nullptr) { + std::shared_ptr buffer = nullptr; + + while ((buffer = bufferPool_->AcquireBuffer(0)) != nullptr) { + buffer->SetBufferStatus(CAMERA_BUFFER_STATUS_INVALID); + + for (auto& it : outPutPorts_) { + if (it->format_.streamId_ == streamId_) { + it->DeliverBuffer(buffer); + break; + } + } + } } - buffer->SetEsFrameSize(buffer->GetSize()); - buffer->SetEsTimestamp(tmpBuffer_->GetEsFrameInfo().timestamp); - return RC_OK; } - REGISTERNODE(ForkNode, {"fork"}) } // namespace OHOS::Camera diff --git a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h index 8e9a3076f6893942a67b937af885f0f03ec162b9..37c88c38cb9433af46ab590c72ee2387acc08de4 100644 --- a/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h +++ b/camera/hal/pipeline_core/nodes/src/fork_node/fork_node.h @@ -29,20 +29,23 @@ public: RetCode Start(const int32_t streamId) override; RetCode Stop(const int32_t streamId) override; void DeliverBuffer(std::shared_ptr& buffer) override; - void ForkBuffers(); RetCode Capture(const int32_t streamId, const int32_t captureId) override; RetCode CancelCapture(const int32_t streamId) override; RetCode Flush(const int32_t streamId); private: - RetCode CopyBuffer(uint64_t poolId, std::shared_ptr& buffer); -private: + void RunForkThread(); + void StopForkThread(); + void DrainForkBufferPool(); std::mutex mtx_; std::condition_variable cv_; std::shared_ptr forkThread_ = nullptr; - std::shared_ptr tmpBuffer_ = nullptr; std::vector> inPutPorts_; std::vector> outPutPorts_; - std::atomic_bool streamRunning_ = false; + std::atomic_bool streamRunning_ = false; + std::atomic_bool forkThreadRunFlag_ = false; + std::shared_ptr bufferPool_ = nullptr; // buffer pool of branch stream + int32_t streamId_; // stream id of branch stream + std::shared_ptr pendingBuffer_ = nullptr; // pending buffer for branch stream std::mutex requestLock_; std::unordered_map> captureRequests_ = {}; }; diff --git a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h index eff0e5a070f0946b5c48baaf23d40843ad20b5c7..8bccd2c2cc8ce4c531549152ca90c1de77c747b3 100644 --- a/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h +++ b/camera/hal/pipeline_core/nodes/src/sink_node/sink_node.h @@ -15,10 +15,10 @@ #define HOS_CAMERA_SINK_NODE_H #include -#include "device_manager_adapter.h" -#include "utils.h" #include "camera.h" +#include "device_manager_adapter.h" #include "node_base.h" +#include "utils.h" namespace OHOS::Camera { class SinkNode : virtual public NodeBase { @@ -34,7 +34,7 @@ public: } protected: - BufferCb cb_; + BufferCb cb_; }; -}// namespace OHOS::Camera +} // namespace OHOS::Camera #endif diff --git a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp index 6bbf46f57baa588fdfc675e0405b59191e567d92..9fb1a3c60603696ce963edac030b5f7fe77c537b 100644 --- a/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp +++ b/camera/hal/pipeline_core/nodes/src/source_node/source_node.cpp @@ -257,31 +257,34 @@ RetCode SourceNode::PortHandler::StartDistributeBuffers() RetCode SourceNode::PortHandler::StopDistributeBuffers() { CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers enter"); - FlushBuffers(); dbtRun = false; rbcv.notify_one(); if (distributor != nullptr) { distributor->join(); } + FlushBuffers(); // flush buffers after stopping distributor CAMERA_LOGV("SourceNode::PortHandler::StopDistributeBuffers exit"); return RC_OK; } void SourceNode::PortHandler::DistributeBuffers() { - std::unique_lock l(rblock); - rbcv.wait(l, [this] { return dbtRun == false || !respondBufferList.empty(); }); - if (!dbtRun) { - return; + std::shared_ptr buffer = nullptr; + { + std::unique_lock l(rblock); + rbcv.wait(l, [this] { return dbtRun == false || !respondBufferList.empty(); }); + if (!dbtRun) { + return; + } + + buffer = respondBufferList.front(); + respondBufferList.pop_front(); } auto node = port->GetNode(); CHECK_IF_PTR_NULL_RETURN_VOID(node); - auto buffer = respondBufferList.front(); node->DeliverBuffer(buffer); - respondBufferList.pop_front(); - return; } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp index 058d0fda629af501b25f203015a7a8bc07271787..b3862ca557c9de16d83d49b2a6b2cb8bf814acc6 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.cpp @@ -43,7 +43,7 @@ RetCode StreamPipelineCore::PreConfig(const ModeMeta& meta) RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr spec = strategy_->GeneratePipelineSpec(mode); if (spec == nullptr) { return RC_ERROR; @@ -57,7 +57,7 @@ RetCode StreamPipelineCore::CreatePipeline(const int32_t& mode) RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Destroy(it) | re; @@ -69,7 +69,7 @@ RetCode StreamPipelineCore::DestroyPipeline(const std::vector& streamIds) RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Prepare(it) | re; @@ -79,7 +79,7 @@ RetCode StreamPipelineCore::Prepare(const std::vector& streamIds) RetCode StreamPipelineCore::Start(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Start(it) | re; @@ -90,7 +90,7 @@ RetCode StreamPipelineCore::Start(const std::vector& streamIds) RetCode StreamPipelineCore::SetCallback(const MetaDataCb cb) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->SetCallback(cb); return re; @@ -109,7 +109,7 @@ RetCode StreamPipelineCore::Stop(const std::vector& streamIds) RetCode StreamPipelineCore::Config(const std::vector& streamIds, const CaptureMeta& meta) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Config(it, meta) | re; @@ -120,7 +120,7 @@ RetCode StreamPipelineCore::Config(const std::vector& streamIds, const Capt RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) { CAMERA_LOGE("StreamPipelineCore %{public}s: line: %{public}d", __FUNCTION__, __LINE__); - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; dispatcher_->UpdateSettingsConfig(meta); return re; @@ -128,7 +128,7 @@ RetCode StreamPipelineCore::UpdateSettingsConfig(const CaptureMeta& meta) RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int32_t captureId) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->Capture(it, captureId) | re; @@ -138,7 +138,7 @@ RetCode StreamPipelineCore::Capture(const std::vector& streamIds, const int RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { re = dispatcher_->CancelCapture(it) | re; @@ -148,7 +148,7 @@ RetCode StreamPipelineCore::CancelCapture(const std::vector& streamIds) RetCode StreamPipelineCore::Flush(const std::vector& streamIds) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); RetCode re = RC_OK; for (const auto& it : streamIds) { CAMERA_LOGV("flush stream %{public}d begin", it); @@ -160,7 +160,7 @@ RetCode StreamPipelineCore::Flush(const std::vector& streamIds) std::shared_ptr StreamPipelineCore::GetOfflinePipeline(const int32_t id) { - std::lock_guard l(mutex_); + std::lock_guard l(mutex_); std::shared_ptr node = dispatcher_->GetNode(id, "ipp"); return std::static_pointer_cast(node); } diff --git a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h index d3688cd42ce1dd57ee06ce14ab7df49fcadbee34..cdcd162d88e1ef69d08f9a340a721059d29029f3 100644 --- a/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h +++ b/camera/hal/pipeline_core/pipeline_impl/src/stream_pipeline_core.h @@ -45,7 +45,7 @@ public: const ModeMeta& meta, const std::vector& configs) override; protected: - std::mutex mutex_; + std::recursive_mutex mutex_; OperationMode mode_ = NORMAL; std::shared_ptr context_ = nullptr; std::unique_ptr strategy_ = nullptr;