1 /*
2 * Copyright (c) 2021 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_stream_data_process_producer.h"
17
18 #include <chrono>
19 #include <securec.h>
20
21 #include "anonymous_string.h"
22 #include "dcamera_buffer_handle.h"
23 #include "distributed_camera_constants.h"
24 #include "distributed_camera_errno.h"
25 #include "distributed_hardware_log.h"
26
27 namespace OHOS {
28 namespace DistributedHardware {
DCameraStreamDataProcessProducer(std::string devId,std::string dhId,int32_t streamId,DCStreamType streamType)29 DCameraStreamDataProcessProducer::DCameraStreamDataProcessProducer(std::string devId, std::string dhId,
30 int32_t streamId, DCStreamType streamType)
31 : devId_(devId), dhId_(dhId), streamId_(streamId), streamType_(streamType), eventHandler_(nullptr),
32 camHdiProvider_(nullptr)
33 {
34 DHLOGI("DCameraStreamDataProcessProducer Constructor devId %s dhId %s streamType: %d streamId: %d",
35 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_);
36 state_ = DCAMERA_PRODUCER_STATE_STOP;
37 interval_ = DCAMERA_PRODUCER_ONE_MINUTE_MS / DCAMERA_PRODUCER_FPS_DEFAULT;
38 }
39
~DCameraStreamDataProcessProducer()40 DCameraStreamDataProcessProducer::~DCameraStreamDataProcessProducer()
41 {
42 DHLOGI("DCameraStreamDataProcessProducer Destructor devId %s dhId %s state: %d streamType: %d streamId: %d",
43 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), state_, streamType_, streamId_);
44 if (state_ == DCAMERA_PRODUCER_STATE_START) {
45 Stop();
46 }
47 }
48
Start()49 void DCameraStreamDataProcessProducer::Start()
50 {
51 DHLOGI("DCameraStreamDataProcessProducer Start producer devId: %s dhId: %s streamType: %d streamId: %d",
52 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_);
53 camHdiProvider_ = IDCameraProvider::Get(HDF_DCAMERA_EXT_SERVICE);
54 if (camHdiProvider_ == nullptr) {
55 DHLOGE("camHdiProvider_ is null.");
56 }
57 state_ = DCAMERA_PRODUCER_STATE_START;
58 if (streamType_ == CONTINUOUS_FRAME) {
59 eventThread_ = std::thread(&DCameraStreamDataProcessProducer::StartEvent, this);
60 std::unique_lock<std::mutex> lock(eventMutex_);
61 eventCon_.wait(lock, [this] {
62 return eventHandler_ != nullptr;
63 });
64 producerThread_ = std::thread(&DCameraStreamDataProcessProducer::LooperContinue, this);
65 } else {
66 producerThread_ = std::thread(&DCameraStreamDataProcessProducer::LooperSnapShot, this);
67 }
68 }
69
Stop()70 void DCameraStreamDataProcessProducer::Stop()
71 {
72 DHLOGI("DCameraStreamDataProcessProducer Stop devId: %s dhId: %s streamType: %d streamId: %d state: %d",
73 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
74 {
75 std::lock_guard<std::mutex> lock(bufferMutex_);
76 state_ = DCAMERA_PRODUCER_STATE_STOP;
77 }
78 producerCon_.notify_one();
79 producerThread_.join();
80 if (streamType_ == CONTINUOUS_FRAME) {
81 eventHandler_->GetEventRunner()->Stop();
82 eventThread_.join();
83 eventHandler_ = nullptr;
84 }
85 camHdiProvider_ = nullptr;
86 DHLOGI("DCameraStreamDataProcessProducer Stop end devId: %s dhId: %s streamType: %d streamId: %d state: %d",
87 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
88 }
89
FeedStream(const std::shared_ptr<DataBuffer> & buffer)90 void DCameraStreamDataProcessProducer::FeedStream(const std::shared_ptr<DataBuffer>& buffer)
91 {
92 DHLOGD("DCameraStreamDataProcessProducer FeedStream devId %s dhId %s streamId: %d streamType: %d streamSize: %d",
93 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, streamType_, buffer->Size());
94 std::unique_lock<std::mutex> lock(bufferMutex_);
95 if (buffers_.size() >= DCAMERA_PRODUCER_MAX_BUFFER_SIZE) {
96 DHLOGD("DCameraStreamDataProcessProducer FeedStream OverSize devId %s dhId %s streamType: %d streamSize: %d",
97 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, buffer->Size());
98 buffers_.pop();
99 }
100 buffers_.push(buffer);
101 if (streamType_ == SNAPSHOT_FRAME) {
102 producerCon_.notify_one();
103 }
104 }
105
StartEvent()106 void DCameraStreamDataProcessProducer::StartEvent()
107 {
108 auto runner = AppExecFwk::EventRunner::Create(false);
109 {
110 std::lock_guard<std::mutex> lock(eventMutex_);
111 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
112 }
113 eventCon_.notify_one();
114 runner->Run();
115 }
116
LooperContinue()117 void DCameraStreamDataProcessProducer::LooperContinue()
118 {
119 DHLOGI("LooperContinue producer devId: %s dhId: %s streamType: %d streamId: %d state: %d",
120 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
121 DHBase dhBase;
122 dhBase.deviceId_ = devId_;
123 dhBase.dhId_ = dhId_;
124
125 while (state_ == DCAMERA_PRODUCER_STATE_START) {
126 std::shared_ptr<DataBuffer> buffer = nullptr;
127 {
128 std::unique_lock<std::mutex> lock(bufferMutex_);
129 producerCon_.wait_for(lock, std::chrono::milliseconds(interval_), [this] {
130 return (this->state_ == DCAMERA_PRODUCER_STATE_STOP);
131 });
132 if (state_ == DCAMERA_PRODUCER_STATE_STOP || buffers_.empty()) {
133 continue;
134 }
135
136 buffer = buffers_.front();
137 if (buffers_.size() > 1) {
138 buffers_.pop();
139 DHLOGD("common devId %s dhId %s streamSize: %d bufferSize: %d streamType: %d streamId: %d",
140 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), buffer->Size(), buffers_.size(),
141 streamType_, streamId_);
142 } else {
143 DHLOGD("repeat devId %s dhId %s streamSize: %d bufferSize: %d streamType: %d streamId: %d",
144 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), buffer->Size(), buffers_.size(),
145 streamType_, streamId_);
146 }
147 }
148
149 auto feedFunc = [this, dhBase, buffer]() {
150 FeedStreamToDriver(dhBase, buffer);
151 };
152 if (eventHandler_ != nullptr) {
153 eventHandler_->PostTask(feedFunc);
154 }
155 }
156 DHLOGI("LooperContinue producer end devId: %s dhId: %s streamType: %d streamId: %d state: %d",
157 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
158 }
159
LooperSnapShot()160 void DCameraStreamDataProcessProducer::LooperSnapShot()
161 {
162 DHLOGI("LooperSnapShot producer devId: %s dhId: %s streamType: %d streamId: %d state: %d",
163 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
164 DHBase dhBase;
165 dhBase.deviceId_ = devId_;
166 dhBase.dhId_ = dhId_;
167
168 while (state_ == DCAMERA_PRODUCER_STATE_START) {
169 std::shared_ptr<DataBuffer> buffer = nullptr;
170 {
171 std::unique_lock<std::mutex> lock(bufferMutex_);
172 producerCon_.wait(lock, [this] {
173 return (!buffers_.empty() || state_ == DCAMERA_PRODUCER_STATE_STOP);
174 });
175 if (state_ == DCAMERA_PRODUCER_STATE_STOP) {
176 continue;
177 }
178
179 if (!buffers_.empty()) {
180 DHLOGI("LooperSnapShot producer get buffer devId: %s dhId: %s streamType: %d streamId: %d state: %d",
181 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
182 buffer = buffers_.front();
183 }
184 }
185
186 if (buffer == nullptr) {
187 DHLOGI("LooperSnapShot producer get buffer failed devId: %s dhId: %s streamType: %d streamId: %d state: %d",
188 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
189 continue;
190 }
191 int32_t ret = FeedStreamToDriver(dhBase, buffer);
192 if (ret != DCAMERA_OK) {
193 std::this_thread::sleep_for(std::chrono::milliseconds(DCAMERA_PRODUCER_RETRY_SLEEP_MS));
194 continue;
195 }
196 {
197 std::unique_lock<std::mutex> lock(bufferMutex_);
198 buffers_.pop();
199 }
200 }
201 DHLOGI("LooperSnapShot producer end devId: %s dhId: %s streamType: %d streamId: %d state: %d",
202 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType_, streamId_, state_);
203 }
204
FeedStreamToDriver(const DHBase & dhBase,const std::shared_ptr<DataBuffer> & buffer)205 int32_t DCameraStreamDataProcessProducer::FeedStreamToDriver(const DHBase& dhBase,
206 const std::shared_ptr<DataBuffer>& buffer)
207 {
208 DHLOGD("LooperFeed devId %s dhId %s streamSize: %d streamType: %d, streamId: %d", GetAnonyString(devId_).c_str(),
209 GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_, streamId_);
210 if (camHdiProvider_ == nullptr) {
211 DHLOGI("camHdiProvider is nullptr");
212 return DCAMERA_BAD_VALUE;
213 }
214 DCameraBuffer sharedMemory;
215 int32_t ret = camHdiProvider_->AcquireBuffer(dhBase, streamId_, sharedMemory);
216 if (ret != SUCCESS) {
217 DHLOGE("AcquireBuffer devId: %s dhId: %s streamId: %d ret: %d",
218 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, ret);
219 return DCAMERA_BAD_OPERATE;
220 }
221
222 do {
223 ret = CheckSharedMemory(sharedMemory, buffer);
224 if (ret != DCAMERA_OK) {
225 DHLOGE("CheckSharedMemory failed devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
226 GetAnonyString(dhId_).c_str());
227 break;
228 }
229 sharedMemory.bufferHandle_->GetBufferHandle()->virAddr =
230 DCameraMemoryMap(sharedMemory.bufferHandle_->GetBufferHandle());
231 if (sharedMemory.bufferHandle_->GetBufferHandle()->virAddr == nullptr) {
232 DHLOGE("mmap failed devId: %s dhId: %s", GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
233 break;
234 }
235 ret = memcpy_s(sharedMemory.bufferHandle_->GetBufferHandle()->virAddr, sharedMemory.size_, buffer->Data(),
236 buffer->Size());
237 if (ret != EOK) {
238 DHLOGE("memcpy_s devId: %s dhId: %s streamId: %d bufSize: %d, addressSize: %d",
239 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, buffer->Size(),
240 sharedMemory.size_);
241 break;
242 }
243 sharedMemory.size_ = buffer->Size();
244 } while (0);
245
246 ret = camHdiProvider_->ShutterBuffer(dhBase, streamId_, sharedMemory);
247 DCameraMemoryUnmap(sharedMemory.bufferHandle_->GetBufferHandle());
248 if (ret != SUCCESS) {
249 DHLOGE("ShutterBuffer devId: %s dhId: %s streamId: %d ret: %d",
250 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, ret);
251 return DCAMERA_BAD_OPERATE;
252 }
253 DHLOGD("LooperFeed end devId %s dhId %s streamSize: %d streamType: %d, streamId: %d",
254 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), buffer->Size(), streamType_, streamId_);
255 return ret;
256 }
257
CheckSharedMemory(const DCameraBuffer & sharedMemory,const std::shared_ptr<DataBuffer> & buffer)258 int32_t DCameraStreamDataProcessProducer::CheckSharedMemory(const DCameraBuffer& sharedMemory,
259 const std::shared_ptr<DataBuffer>& buffer)
260 {
261 if (sharedMemory.bufferHandle_ == nullptr || sharedMemory.bufferHandle_->GetBufferHandle() == nullptr) {
262 DHLOGE("bufferHandle read failed devId: %s dhId: %s", GetAnonyString(devId_).c_str(),
263 GetAnonyString(dhId_).c_str());
264 return DCAMERA_MEMORY_OPT_ERROR;
265 }
266
267 if (buffer->Size() > sharedMemory.size_) {
268 DHLOGE("sharedMemory devId: %s dhId: %s streamId: %d bufSize: %d, addressSize: %d",
269 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamId_, buffer->Size(),
270 sharedMemory.size_);
271 return DCAMERA_MEMORY_OPT_ERROR;
272 }
273
274 return DCAMERA_OK;
275 }
276 } // namespace DistributedHardware
277 } // namespace OHOS
278