1 /*
2 * Copyright (c) 2021-2022 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 "dcamera_source_data_process.h"
17
18 #include "anonymous_string.h"
19 #include "dcamera_hitrace_adapter.h"
20 #include "distributed_camera_constants.h"
21 #include "distributed_camera_errno.h"
22 #include "distributed_hardware_log.h"
23
24 namespace OHOS {
25 namespace DistributedHardware {
DCameraSourceDataProcess(std::string devId,std::string dhId,DCStreamType streamType)26 DCameraSourceDataProcess::DCameraSourceDataProcess(std::string devId, std::string dhId, DCStreamType streamType)
27 : devId_(devId), dhId_(dhId), streamType_(streamType), isFirstContStream_(true)
28 {
29 DHLOGI("DCameraSourceDataProcess Constructor devId %s dhId %s streamType %d", GetAnonyString(devId_).c_str(),
30 GetAnonyString(dhId_).c_str(), streamType_);
31 }
32
~DCameraSourceDataProcess()33 DCameraSourceDataProcess::~DCameraSourceDataProcess()
34 {
35 DHLOGI("DCameraSourceDataProcess Destructor devId %s dhId %s streamType %d", GetAnonyString(devId_).c_str(),
36 GetAnonyString(dhId_).c_str(), streamType_);
37 streamProcess_.clear();
38 streamIds_.clear();
39 }
40
FeedStream(std::vector<std::shared_ptr<DataBuffer>> & buffers)41 int32_t DCameraSourceDataProcess::FeedStream(std::vector<std::shared_ptr<DataBuffer>>& buffers)
42 {
43 if (isFirstContStream_ && streamType_ == CONTINUOUS_FRAME) {
44 DcameraFinishAsyncTrace(DCAMERA_CONTINUE_FIRST_FRAME, DCAMERA_CONTINUE_FIRST_FRAME_TASKID);
45 isFirstContStream_ = false;
46 } else if (streamType_ == SNAPSHOT_FRAME) {
47 DcameraFinishAsyncTrace(DCAMERA_SNAPSHOT_FIRST_FRAME, DCAMERA_SNAPSHOT_FIRST_FRAME_TASKID);
48 }
49 if (buffers.size() > DCAMERA_MAX_NUM) {
50 DHLOGI("DCameraSourceDataProcess FeedStream devId %s dhId %s size: %d over flow",
51 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), buffers.size());
52 return DCAMERA_BAD_VALUE;
53 }
54
55 auto buffer = *(buffers.begin());
56 DHLOGD("DCameraSourceDataProcess FeedStream devId %s dhId %s streamType %d streamSize: %d",
57 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, buffer->Size());
58 std::lock_guard<std::mutex> autoLock(streamMutex_);
59 for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
60 (*iter)->FeedStream(buffer);
61 }
62 return DCAMERA_OK;
63 }
64
ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>> & streamInfos)65 int32_t DCameraSourceDataProcess::ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
66 {
67 DHLOGI("DCameraSourceDataProcess ConfigStreams devId %s dhId %s streamType %d size %d",
68 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamInfos.size());
69 if (streamInfos.empty()) {
70 DHLOGI("DCameraSourceDataProcess ConfigStreams is empty");
71 return DCAMERA_OK;
72 }
73 std::map<DCameraStreamConfig, std::set<int>> streamConfigs;
74 for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
75 std::shared_ptr<DCStreamInfo> streamInfo = *iter;
76 DCameraStreamConfig streamConfig(streamInfo->width_, streamInfo->height_, streamInfo->format_,
77 streamInfo->dataspace_, streamInfo->encodeType_, streamInfo->type_);
78 DHLOGI("DCameraSourceDataProcess ConfigStreams devId %s dhId %s, streamId: %d info: width: %d, height: %d," +
79 "format: %d, dataspace: %d, encodeType: %d streamType: %d", GetAnonyString(devId_).c_str(),
80 GetAnonyString(dhId_).c_str(), streamInfo->streamId_, streamConfig.width_, streamConfig.height_,
81 streamConfig.format_, streamConfig.dataspace_, streamConfig.encodeType_, streamConfig.type_);
82 if (streamConfigs.find(streamConfig) == streamConfigs.end()) {
83 std::set<int> streamIdSet;
84 streamConfigs.emplace(streamConfig, streamIdSet);
85 }
86 streamConfigs[streamConfig].insert(streamInfo->streamId_);
87 streamIds_.insert(streamInfo->streamId_);
88 }
89
90 for (auto iter = streamConfigs.begin(); iter != streamConfigs.end(); iter++) {
91 DHLOGI("DCameraSourceDataProcess ConfigStreams devId %s dhId %s, info: width: %d, height: %d, format: %d," +
92 "dataspace: %d, encodeType: %d streamType: %d", GetAnonyString(devId_).c_str(),
93 GetAnonyString(dhId_).c_str(), iter->first.width_, iter->first.height_, iter->first.format_,
94 iter->first.dataspace_, iter->first.encodeType_, iter->first.type_);
95
96 std::shared_ptr<DCameraStreamDataProcess> streamProcess =
97 std::make_shared<DCameraStreamDataProcess>(devId_, dhId_, streamType_);
98 std::shared_ptr<DCameraStreamConfig> streamConfig =
99 std::make_shared<DCameraStreamConfig>(iter->first.width_, iter->first.height_, iter->first.format_,
100 iter->first.dataspace_, iter->first.encodeType_, iter->first.type_);
101 streamProcess->ConfigStreams(streamConfig, iter->second);
102
103 streamProcess_.push_back(streamProcess);
104 }
105
106 return DCAMERA_OK;
107 }
108
ReleaseStreams(std::vector<int32_t> & streamIds)109 int32_t DCameraSourceDataProcess::ReleaseStreams(std::vector<int32_t>& streamIds)
110 {
111 DHLOGI("DCameraSourceDataProcess ReleaseStreams devId %s dhId %s streamType: %d", GetAnonyString(devId_).c_str(),
112 GetAnonyString(dhId_).c_str(), streamType_);
113 std::lock_guard<std::mutex> autoLock(streamMutex_);
114 std::set<int32_t> streamIdSet(streamIds.begin(), streamIds.end());
115 auto iter = streamProcess_.begin();
116 while (iter != streamProcess_.end()) {
117 (*iter)->ReleaseStreams(streamIdSet);
118 std::set<int32_t> processStreamIds;
119 (*iter)->GetAllStreamIds(processStreamIds);
120 if (processStreamIds.empty()) {
121 iter = streamProcess_.erase(iter);
122 } else {
123 iter++;
124 }
125 }
126
127 std::string strStreams;
128 for (auto iterSet = streamIdSet.begin(); iterSet != streamIdSet.end(); iterSet++) {
129 strStreams += (std::to_string(*iterSet) + std::string(" "));
130 streamIds_.erase(*iterSet);
131 }
132 DHLOGI("DCameraSourceDataProcess ReleaseStreams devId %s dhId %s streamType: %d streamProcessSize: %d streams: %s",
133 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamProcess_.size(),
134 strStreams.c_str());
135 return DCAMERA_OK;
136 }
137
StartCapture(std::shared_ptr<DCCaptureInfo> & captureInfo)138 int32_t DCameraSourceDataProcess::StartCapture(std::shared_ptr<DCCaptureInfo>& captureInfo)
139 {
140 DHLOGI("DCameraSourceDataProcess StartCapture devId %s dhId %s width: %d, height: %d, format: %d, isCapture: %d," +
141 "dataspace: %d, encodeType: %d, streamType: %d", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(),
142 captureInfo->width_, captureInfo->height_, captureInfo->format_, captureInfo->isCapture_,
143 captureInfo->dataspace_, captureInfo->encodeType_, captureInfo->type_);
144 if (streamType_ == CONTINUOUS_FRAME && captureInfo->isCapture_ == true) {
145 isFirstContStream_ = true;
146 }
147
148 std::shared_ptr<DCameraStreamConfig> streamConfig =
149 std::make_shared<DCameraStreamConfig>(captureInfo->width_, captureInfo->height_, captureInfo->format_,
150 captureInfo->dataspace_, captureInfo->encodeType_, captureInfo->type_);
151 std::set<int32_t> streamIds(captureInfo->streamIds_.begin(), captureInfo->streamIds_.end());
152 for (auto iterSet = streamIds.begin(); iterSet != streamIds.end(); iterSet++) {
153 DHLOGI("DCameraSourceDataProcess StartCapture devId %s dhId %s StartCapture id: %d",
154 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
155 }
156 for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
157 (*iter)->StartCapture(streamConfig, streamIds);
158 }
159 return DCAMERA_OK;
160 }
161
StopCapture(std::vector<int32_t> & streamIds)162 int32_t DCameraSourceDataProcess::StopCapture(std::vector<int32_t>& streamIds)
163 {
164 DHLOGI("DCameraSourceDataProcess StopCapture devId %s dhId %s streamType: %d", GetAnonyString(devId_).c_str(),
165 GetAnonyString(dhId_).c_str(), streamType_);
166 std::set<int32_t> streamIdSet(streamIds.begin(), streamIds.end());
167 for (auto iterSet = streamIdSet.begin(); iterSet != streamIdSet.end(); iterSet++) {
168 DHLOGI("DCameraSourceDataProcess StopCapture devId %s dhId %s stream id: %d",
169 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
170 }
171 for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
172 (*iter)->StopCapture(streamIdSet);
173 }
174 if ((streamType_ == CONTINUOUS_FRAME) && (GetProducerSize() == 0)) {
175 DestroyPipeline();
176 }
177 return DCAMERA_OK;
178 }
179
DestroyPipeline()180 void DCameraSourceDataProcess::DestroyPipeline()
181 {
182 DHLOGI("DCameraSourceDataProcess DestroyPipeline devId %s dhId %s streamType: %d", GetAnonyString(devId_).c_str(),
183 GetAnonyString(dhId_).c_str(), streamType_);
184 for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
185 (*iter)->DestroyPipeline();
186 }
187 }
188
GetProducerSize()189 int32_t DCameraSourceDataProcess::GetProducerSize()
190 {
191 int32_t ret = 0;
192 for (auto iter = streamProcess_.begin(); iter != streamProcess_.end(); iter++) {
193 std::shared_ptr<DCameraStreamDataProcess> streamDataProcess = *iter;
194 int32_t size = streamDataProcess->GetProducerSize();
195 ret += size;
196 }
197 DHLOGI("DCameraSourceDataProcess GetProducerSize devId %s dhId %s size %d",
198 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), ret);
199 return ret;
200 }
201
GetAllStreamIds(std::vector<int32_t> & streamIds)202 void DCameraSourceDataProcess::GetAllStreamIds(std::vector<int32_t>& streamIds)
203 {
204 streamIds.assign(streamIds_.begin(), streamIds_.end());
205 }
206 } // namespace DistributedHardware
207 } // namespace OHOS
208