1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hstream_operator_manager.h"
17 #include "hstream_operator.h"
18 #include "camera_dynamic_loader.h"
19 #include "camera_log.h"
20 #include "moving_photo_proxy.h"
21
22 namespace OHOS {
23 namespace CameraStandard {
24 sptr<HStreamOperatorManager> HStreamOperatorManager::streamOperatorManager_;
25 std::mutex HStreamOperatorManager::instanceMutex_;
26
HStreamOperatorManager()27 HStreamOperatorManager::HStreamOperatorManager() {}
28
~HStreamOperatorManager()29 HStreamOperatorManager::~HStreamOperatorManager()
30 {
31 MEDIA_INFO_LOG("~HStreamOperatorManager");
32 CHECK_RETURN(streamOperatorManagerMap_.empty());
33 MEDIA_INFO_LOG("~HStreamOperatorManager clear maps");
34 // avoid double free
35 {
36 decltype(streamOperatorManagerMap_) tempOpMap = std::move(streamOperatorManagerMap_);
37 }
38 MEDIA_INFO_LOG("~HStreamOperatorManager free dynamic lib");
39 CameraDynamicLoader::FreeDynamicLibDelayed(MEDIA_LIB_SO, LIB_DELAYED_UNLOAD_TIME);
40 }
41
GetInstance()42 sptr<HStreamOperatorManager> &HStreamOperatorManager::GetInstance()
43 {
44 if (HStreamOperatorManager::streamOperatorManager_ == nullptr) {
45 std::unique_lock<std::mutex> lock(instanceMutex_);
46 if (HStreamOperatorManager::streamOperatorManager_ == nullptr) {
47 MEDIA_INFO_LOG("Initializing stream operator manager instance");
48 HStreamOperatorManager::streamOperatorManager_ = new HStreamOperatorManager();
49 }
50 }
51 return HStreamOperatorManager::streamOperatorManager_;
52 }
53
AddStreamOperator(sptr<HStreamOperator> hStreamOperator)54 void HStreamOperatorManager::AddStreamOperator(sptr<HStreamOperator> hStreamOperator)
55 {
56 std::lock_guard<std::mutex> lock(mapMutex_);
57 MEDIA_INFO_LOG("HStreamOperatorManager::AddStreamOperator start");
58 int32_t streamOperatorId = GenerateStreamOperatorId();
59 streamOperatorManagerMap_[streamOperatorId] = hStreamOperator;
60 hStreamOperator->SetStreamOperatorId(streamOperatorId);
61 MEDIA_INFO_LOG("HStreamOperatorManager::AddStreamOperator end hStreamOperatorId is %{public}d", streamOperatorId);
62 return;
63 }
64
RemoveStreamOperator(int32_t & hStreamOperatorId)65 void HStreamOperatorManager::RemoveStreamOperator(int32_t& hStreamOperatorId)
66 {
67 MEDIA_INFO_LOG("HStreamOperatorManager::RemoveStreamOperator hStreamOperatorId is %{public}d", hStreamOperatorId);
68 std::lock_guard<std::mutex> lock(mapMutex_);
69 CHECK_RETURN(hStreamOperatorId < 0);
70 auto streamOperator = streamOperatorManagerMap_.find(hStreamOperatorId);
71 CHECK_RETURN_ELOG(streamOperator == streamOperatorManagerMap_.end(), "not found hStreamOperatorId: %{public}d",
72 hStreamOperatorId);
73 streamOperatorManagerMap_.erase(hStreamOperatorId);
74 if (streamOperatorManagerMap_.size() == 0) {
75 CameraDynamicLoader::FreeDynamicLibDelayed(MEDIA_LIB_SO, LIB_DELAYED_UNLOAD_TIME);
76 }
77 MEDIA_INFO_LOG("HStreamOperatorManager::RemoveStreamOperator end");
78 return;
79 }
80
AddTaskManager(int32_t & hStreamOperatorId,sptr<AvcodecTaskManagerIntf> avcodecTaskManagerProxy)81 void HStreamOperatorManager::AddTaskManager(int32_t& hStreamOperatorId,
82 sptr<AvcodecTaskManagerIntf> avcodecTaskManagerProxy)
83 {
84 CHECK_RETURN_ELOG(
85 avcodecTaskManagerProxy == nullptr, "HStreamOperatorManager::AddTaskManager avcodecTaskManagerProxy is null");
86 MEDIA_INFO_LOG("HStreamOperatorManager::AddTaskManager hStreamOperatorId is %{public}d", hStreamOperatorId);
87 taskManagerMap_.EnsureInsert(hStreamOperatorId, avcodecTaskManagerProxy);
88 }
89
RemoveTaskManager(int32_t & hStreamOperatorId)90 void HStreamOperatorManager::RemoveTaskManager(int32_t& hStreamOperatorId)
91 {
92 MEDIA_INFO_LOG("HStreamOperatorManager::RemoveTaskManager hStreamOperatorId is %{public}d", hStreamOperatorId);
93 sptr<AvcodecTaskManagerIntf> avcodecTaskManagerProxy = nullptr;
94 taskManagerMap_.Find(hStreamOperatorId, avcodecTaskManagerProxy);
95 CHECK_RETURN_ELOG(!avcodecTaskManagerProxy, "not found hStreamOperatorId: %{public}d", hStreamOperatorId);
96 thread asyncThread = thread([hStreamOperatorId, avcodecTaskManagerProxy]() {
97 CAMERA_SYNC_TRACE;
98 MEDIA_INFO_LOG(
99 "HStreamOperatorManager::RemoveTaskManager thread hStreamOperatorId: %{public}d", hStreamOperatorId);
100 int32_t delayTime = avcodecTaskManagerProxy == nullptr ||
101 (avcodecTaskManagerProxy && avcodecTaskManagerProxy->isEmptyVideoFdMap()) ? 0 : 30;
102 std::this_thread::sleep_for(std::chrono::seconds(delayTime));
103 });
104 taskManagerMap_.Erase(hStreamOperatorId);
105 asyncThread.detach();
106 }
107
UpdateStreamOperator(int32_t & hStreamOperatorId)108 void HStreamOperatorManager::UpdateStreamOperator(int32_t& hStreamOperatorId)
109 {
110 std::lock_guard<std::mutex> lock(mapMutex_);
111 MEDIA_INFO_LOG("HStreamOperatorManager::UpdateStreamOperator hStreamOperatorId is %{public}d", hStreamOperatorId);
112 auto StreamOperator = streamOperatorManagerMap_.find(hStreamOperatorId);
113 CHECK_RETURN(StreamOperator == streamOperatorManagerMap_.end());
114 }
115
GetOfflineOutputSize()116 int32_t HStreamOperatorManager::GetOfflineOutputSize()
117 {
118 MEDIA_INFO_LOG("HStreamOperatorManager::DfxReport size is %{public}zu", streamOperatorManagerMap_.size());
119 int32_t offlineOutputCount = 0;
120 for (auto streamOperator : streamOperatorManagerMap_) {
121 int32_t tempSize = (streamOperator.second)->GetOfflineOutptSize();
122 offlineOutputCount = offlineOutputCount + tempSize;
123 }
124 if (offlineOutputCount > 2) { // 2 is the threshold of the statistics
125 MEDIA_INFO_LOG("HStreamOperatorManager::DfxReport offlineOutputCount is %{public}d", offlineOutputCount);
126 }
127 return offlineOutputCount;
128 }
129
GetStreamOperatorByPid(pid_t pidRequest)130 std::vector<sptr<HStreamOperator>> HStreamOperatorManager::GetStreamOperatorByPid(pid_t pidRequest)
131 {
132 std::lock_guard<std::mutex> lock(mapMutex_);
133 std::vector<sptr<HStreamOperator>> streamOperatorVec = {};
134 for (auto streamOperator : streamOperatorManagerMap_) {
135 if (pidRequest == (streamOperator.second)->GetPid()) {
136 streamOperatorVec.push_back(streamOperator.second);
137 MEDIA_INFO_LOG("HStreamOperatorManager::GetCameraByPid find");
138 }
139 }
140 MEDIA_INFO_LOG("HStreamOperatorManager::GetStreamOperatorByPid pid is %{public}d size is %{public}zu", pidRequest,
141 streamOperatorVec.size());
142 return streamOperatorVec;
143 }
144 } // namespace CameraStandard
145 } // namespace OHOS
146