• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_source_input.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 #include "dcamera_channel_source_impl.h"
25 #include "dcamera_source_data_process.h"
26 #include "dcamera_source_event.h"
27 #include "dcamera_source_input_channel_listener.h"
28 
29 namespace OHOS {
30 namespace DistributedHardware {
DCameraSourceInput(std::string devId,std::string dhId,std::shared_ptr<EventBus> & eventBus)31 DCameraSourceInput::DCameraSourceInput(std::string devId, std::string dhId, std::shared_ptr<EventBus>& eventBus)
32     : devId_(devId), dhId_(dhId), eventBus_(eventBus), isInit(false)
33 {
34     DHLOGI("DCameraSourceInput Constructor devId %s dhId %s", GetAnonyString(devId_).c_str(),
35         GetAnonyString(dhId_).c_str());
36 }
37 
~DCameraSourceInput()38 DCameraSourceInput::~DCameraSourceInput()
39 {
40     DHLOGI("DCameraSourceInput Destructor devId %s dhId %s", GetAnonyString(devId_).c_str(),
41         GetAnonyString(dhId_).c_str());
42     if (isInit) {
43         UnInit();
44     }
45 }
46 
ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>> & streamInfos)47 int32_t DCameraSourceInput::ConfigStreams(std::vector<std::shared_ptr<DCStreamInfo>>& streamInfos)
48 {
49     DHLOGI("DCameraSourceInput ConfigStreams devId %s dhId %s, size: %d", GetAnonyString(devId_).c_str(),
50         GetAnonyString(dhId_).c_str(), streamInfos.size());
51     int32_t ret = ReleaseAllStreams();
52     if (ret != DCAMERA_OK) {
53         DHLOGE("DCameraSourceInput ConfigStreams ReleaseAllStreams failed %d devId: %s, dhId: %s", ret,
54             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
55         return ret;
56     }
57 
58     if (streamInfos.empty()) {
59         return DCAMERA_OK;
60     }
61 
62     std::vector<std::shared_ptr<DCStreamInfo>> snapStreams;
63     std::vector<std::shared_ptr<DCStreamInfo>> continueStreams;
64     for (auto iter = streamInfos.begin(); iter != streamInfos.end(); iter++) {
65         std::shared_ptr<DCStreamInfo> streamInfo = *iter;
66         DHLOGI("DCameraSourceInput ConfigStreams devId: %s, dhId: %s, streamId: %d, width: %d, height: %d," +
67             "format: %d, dataspace: %d, encodeType:%d streamType: %d", GetAnonyString(devId_).c_str(),
68             GetAnonyString(dhId_).c_str(), streamInfo->streamId_, streamInfo->width_, streamInfo->height_,
69             streamInfo->format_, streamInfo->dataspace_, streamInfo->encodeType_, streamInfo->type_);
70         switch (streamInfo->type_) {
71             case CONTINUOUS_FRAME: {
72                 continueStreams.push_back(streamInfo);
73                 break;
74             }
75             case SNAPSHOT_FRAME: {
76                 snapStreams.push_back(streamInfo);
77                 break;
78             }
79             default:
80                 break;
81         }
82     }
83 
84     do {
85         ret = dataProcess_[CONTINUOUS_FRAME]->ConfigStreams(continueStreams);
86         if (ret != DCAMERA_OK) {
87             DHLOGE("DCameraSourceInput ConfigStreams continue failed %d devId %s dhId %s", ret,
88                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
89             break;
90         }
91         ret = dataProcess_[SNAPSHOT_FRAME]->ConfigStreams(snapStreams);
92         if (ret != DCAMERA_OK) {
93             DHLOGE("DCameraSourceInput ConfigStreams snapshot failed %d devId %s dhId %s", ret,
94                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
95             break;
96         }
97     } while (0);
98 
99     if (ret != DCAMERA_OK) {
100         ReleaseAllStreams();
101     }
102     return ret;
103 }
104 
ReleaseStreams(std::vector<int> & streamIds,bool & isAllRelease)105 int32_t DCameraSourceInput::ReleaseStreams(std::vector<int>& streamIds, bool& isAllRelease)
106 {
107     DHLOGI("DCameraSourceInput ReleaseStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
108         GetAnonyString(dhId_).c_str());
109     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(streamIds);
110     if (ret != DCAMERA_OK) {
111         DHLOGE("DCameraSourceInput ReleaseStreams continue stream ReleaseStreams ret: %d, devId: %s, dhId: %s", ret,
112             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
113         return ret;
114     }
115     ret = dataProcess_[SNAPSHOT_FRAME]->ReleaseStreams(streamIds);
116     if (ret != DCAMERA_OK) {
117         DHLOGE("DCameraSourceInput ReleaseStreams snapshot stream ReleaseStreams ret: %d, devId: %s, dhId: %s", ret,
118             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
119         return ret;
120     }
121 
122     std::vector<int32_t> continueStreamIds;
123     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
124     std::vector<int32_t> snapStreamIds;
125     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(snapStreamIds);
126     if (continueStreamIds.empty() && snapStreamIds.empty()) {
127         isAllRelease = true;
128     }
129     return DCAMERA_OK;
130 }
131 
StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>> & captureInfos)132 int32_t DCameraSourceInput::StartCapture(std::vector<std::shared_ptr<DCCaptureInfo>>& captureInfos)
133 {
134     DHLOGI("DCameraSourceInput StartCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
135         GetAnonyString(dhId_).c_str());
136     for (auto iter = captureInfos.begin(); iter != captureInfos.end(); iter++) {
137         int32_t ret = DCAMERA_OK;
138         for (auto iterSet = (*iter)->streamIds_.begin(); iterSet != (*iter)->streamIds_.end(); iterSet++) {
139             DHLOGI("DCameraSourceInput StartCapture devId %s dhId %s StartCapture id: %d",
140                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), *iterSet);
141         }
142         DHLOGI("DCameraSourceInput StartCapture Inner devId %s dhId %s streamType: %d idSize: %d isCap: %d",
143             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), (*iter)->type_, (*iter)->streamIds_.size(),
144             (*iter)->isCapture_ ? 1 : 0);
145         ret = dataProcess_[(*iter)->type_]->StartCapture(*iter);
146         if (ret != DCAMERA_OK) {
147             DHLOGE("DCameraSourceInput StartCapture ret: %d, devId: %s, dhId: %s", ret,
148                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
149             return ret;
150         }
151     }
152     return DCAMERA_OK;
153 }
154 
StopCapture(std::vector<int> & streamIds,bool & isAllStop)155 int32_t DCameraSourceInput::StopCapture(std::vector<int>& streamIds, bool& isAllStop)
156 {
157     DHLOGI("DCameraSourceInput StopCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
158         GetAnonyString(dhId_).c_str());
159     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(streamIds);
160     if (ret != DCAMERA_OK) {
161         DHLOGE("DCameraSourceInput StopCapture continue ret: %d, devId: %s, dhId: %s", ret,
162             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
163         return ret;
164     }
165 
166     int32_t size = dataProcess_[CONTINUOUS_FRAME]->GetProducerSize();
167     if (size == 0) {
168         isAllStop = true;
169         std::vector<int> snapStreamIds;
170         dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
171         ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(snapStreamIds);
172         if (ret != DCAMERA_OK) {
173             DHLOGE("DCameraSourceInput StopCapture snapshot ret: %d, devId: %s, dhId: %s", ret,
174                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
175             return ret;
176         }
177     }
178     return DCAMERA_OK;
179 }
180 
OpenChannel(std::vector<DCameraIndex> & indexs)181 int32_t DCameraSourceInput::OpenChannel(std::vector<DCameraIndex>& indexs)
182 {
183     DHLOGI("DCameraSourceInput OpenChannel devId %s dhId %s continue state: %d, snapshot state: %d",
184         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), channelState_[CONTINUOUS_FRAME],
185         channelState_[SNAPSHOT_FRAME]);
186     if (channelState_[CONTINUOUS_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
187         int32_t ret = DCAMERA_OK;
188         DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
189         ret = channels_[CONTINUOUS_FRAME]->CreateSession(indexs, CONTINUE_SESSION_FLAG, DCAMERA_SESSION_MODE_VIDEO,
190             listeners_[CONTINUOUS_FRAME]);
191         if (ret != DCAMERA_OK) {
192             DHLOGE("DCameraSourceInput CreateSession continue failed ret: %d, devId: %s, dhId: %s", ret,
193                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
194             DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
195             return ret;
196         }
197 
198         ret = channels_[CONTINUOUS_FRAME]->OpenSession();
199         if (ret != DCAMERA_OK) {
200             DHLOGE("DCameraSourceInput OpenChannel continue stream failed ret: %d, devId: %s, dhId: %s", ret,
201                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
202             DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
203             return ret;
204         }
205     }
206 
207     if (channelState_[SNAPSHOT_FRAME] == DCAMERA_CHANNEL_STATE_DISCONNECTED) {
208         DcameraStartAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
209         int32_t ret = DCAMERA_OK;
210         ret = channels_[SNAPSHOT_FRAME]->CreateSession(indexs, SNAP_SHOT_SESSION_FLAG, DCAMERA_SESSION_MODE_JPEG,
211             listeners_[SNAPSHOT_FRAME]);
212         if (ret != DCAMERA_OK) {
213             DHLOGE("DCameraSourceInput Init CreateSession snapshot failed ret: %d, devId: %s, dhId: %s", ret,
214                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
215             DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
216             return ret;
217         }
218 
219         ret = channels_[SNAPSHOT_FRAME]->OpenSession();
220         if (ret != DCAMERA_OK) {
221             DHLOGE("DCameraSourceInput OpenChannel snapshot stream failed ret: %d, devId: %s, dhId: %s", ret,
222                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
223             DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
224             return ret;
225         }
226     }
227     return DCAMERA_OK;
228 }
229 
CloseChannel()230 int32_t DCameraSourceInput::CloseChannel()
231 {
232     DHLOGI("DCameraSourceInput CloseChannel devId %s dhId %s continue state: %d, snapshot state: %d",
233         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), channelState_[CONTINUOUS_FRAME],
234         channelState_[SNAPSHOT_FRAME]);
235     if (channelState_[CONTINUOUS_FRAME] != DCAMERA_CHANNEL_STATE_DISCONNECTED) {
236         int32_t ret = DCAMERA_OK;
237         ret = channels_[CONTINUOUS_FRAME]->CloseSession();
238         if (ret != DCAMERA_OK) {
239             DHLOGE("DCameraSourceInput CloseChannel continue stream failed ret: %d, devId: %s, dhId: %s", ret,
240                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
241         }
242         channelState_[CONTINUOUS_FRAME] = DCAMERA_CHANNEL_STATE_DISCONNECTED;
243 
244         ret = channels_[CONTINUOUS_FRAME]->ReleaseSession();
245         if (ret != DCAMERA_OK) {
246             DHLOGI("DCameraSourceInput release continue session failed: %d devId %s dhId %s", ret,
247                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
248         }
249     }
250 
251     if (channelState_[SNAPSHOT_FRAME] != DCAMERA_CHANNEL_STATE_DISCONNECTED) {
252         int32_t ret = DCAMERA_OK;
253         ret = channels_[SNAPSHOT_FRAME]->CloseSession();
254         if (ret != DCAMERA_OK) {
255             DHLOGE("DCameraSourceInput CloseChannel snapshot stream failed ret: %d, devId: %s, dhId: %s", ret,
256                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
257         }
258         channelState_[SNAPSHOT_FRAME] = DCAMERA_CHANNEL_STATE_DISCONNECTED;
259 
260         ret = channels_[SNAPSHOT_FRAME]->ReleaseSession();
261         if (ret != DCAMERA_OK) {
262             DHLOGI("DCameraSourceInput release snapshot session failed: %d devId %s dhId %s", ret,
263                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
264         }
265     }
266     return DCAMERA_OK;
267 }
268 
Init()269 int32_t DCameraSourceInput::Init()
270 {
271     DHLOGI("DCameraSourceInput Init devId %s dhId %s", GetAnonyString(devId_).c_str(),
272         GetAnonyString(dhId_).c_str());
273     auto input = std::shared_ptr<DCameraSourceInput>(shared_from_this());
274     std::shared_ptr<ICameraSourceDataProcess> conDataProcess = std::make_shared<DCameraSourceDataProcess>(devId_, dhId_,
275         CONTINUOUS_FRAME);
276     std::shared_ptr<ICameraChannel> continueCh = std::make_shared<DCameraChannelSourceImpl>();
277     std::shared_ptr<ICameraChannelListener> conListener =
278         std::make_shared<DCameraSourceInputChannelListener>(input, CONTINUOUS_FRAME);
279     channels_.emplace(CONTINUOUS_FRAME, continueCh);
280     listeners_.emplace(CONTINUOUS_FRAME, conListener);
281     dataProcess_.emplace(CONTINUOUS_FRAME, conDataProcess);
282     channelState_.emplace(CONTINUOUS_FRAME, DCAMERA_CHANNEL_STATE_DISCONNECTED);
283 
284     std::shared_ptr<ICameraSourceDataProcess> snapDataProcess = std::make_shared<DCameraSourceDataProcess>(devId_,
285         dhId_, SNAPSHOT_FRAME);
286     std::shared_ptr<ICameraChannel> snapShotCh = std::make_shared<DCameraChannelSourceImpl>();
287     std::shared_ptr<ICameraChannelListener> snapListener =
288         std::make_shared<DCameraSourceInputChannelListener>(input, SNAPSHOT_FRAME);
289     channels_.emplace(SNAPSHOT_FRAME, snapShotCh);
290     listeners_.emplace(SNAPSHOT_FRAME, snapListener);
291     dataProcess_.emplace(SNAPSHOT_FRAME, snapDataProcess);
292     channelState_.emplace(SNAPSHOT_FRAME, DCAMERA_CHANNEL_STATE_DISCONNECTED);
293     isInit = true;
294     DHLOGI("DCameraSourceInput Init devId end %s dhId %s", GetAnonyString(devId_).c_str(),
295         GetAnonyString(dhId_).c_str());
296     return DCAMERA_OK;
297 }
298 
UnInit()299 int32_t DCameraSourceInput::UnInit()
300 {
301     DHLOGI("DCameraSourceInput UnInit devId %s dhId %s", GetAnonyString(devId_).c_str(),
302         GetAnonyString(dhId_).c_str());
303     channels_.clear();
304     listeners_.clear();
305     dataProcess_.clear();
306     channelState_.clear();
307     isInit = false;
308     return DCAMERA_OK;
309 }
310 
UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>> & settings)311 int32_t DCameraSourceInput::UpdateSettings(std::vector<std::shared_ptr<DCameraSettings>>& settings)
312 {
313     return DCAMERA_OK;
314 }
315 
OnSessionState(DCStreamType streamType,int32_t state)316 void DCameraSourceInput::OnSessionState(DCStreamType streamType, int32_t state)
317 {
318     DHLOGI("DCameraSourceInput OnSessionState devId: %s, dhId: %s, streamType: %d, state: %d",
319         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), streamType, state);
320     channelState_[streamType] = (DCameraChannelState)state;
321     switch (state) {
322         case DCAMERA_CHANNEL_STATE_DISCONNECTED: {
323             FinshFrameAsyncTrace(streamType);
324             DHLOGI("DCameraSourceDev PostTask CloseSession Input OnClose devId %s dhId %s",
325                 GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
326             DCameraIndex camIndex(devId_, dhId_);
327             DCameraSourceEvent event(*this, DCAMERA_EVENT_CLOSE, camIndex);
328             eventBus_->PostEvent<DCameraSourceEvent>(event);
329             std::shared_ptr<DCameraEvent> camEvent = std::make_shared<DCameraEvent>();
330             camEvent->eventType_ = DCAMERA_MESSAGE;
331             camEvent->eventResult_ = DCAMERA_EVENT_CHANNEL_DISCONNECTED;
332             DCameraSourceEvent srcEvent(*this, DCAMERA_EVENT_NOFIFY, camEvent);
333             eventBus_->PostEvent<DCameraSourceEvent>(srcEvent);
334             break;
335         }
336         case DCAMERA_CHANNEL_STATE_CONNECTED: {
337             FinshFrameAsyncTrace(streamType);
338             DHLOGI("DCameraSourceInput OnSessionState state %d", state);
339             break;
340         }
341         default: {
342             DHLOGI("DCameraSourceInput OnSessionState state %d", state);
343             break;
344         }
345     }
346 }
347 
FinshFrameAsyncTrace(DCStreamType streamType)348 void DCameraSourceInput::FinshFrameAsyncTrace(DCStreamType streamType)
349 {
350     if (streamType == CONTINUOUS_FRAME) {
351         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_CONTINUE, DCAMERA_OPEN_DATA_CONTINUE_TASKID);
352     } else if (streamType == SNAPSHOT_FRAME) {
353         DcameraFinishAsyncTrace(DCAMERA_OPEN_DATA_SNAPSHOT, DCAMERA_OPEN_DATA_SNAPSHOT_TASKID);
354     }
355 }
356 
OnSessionError(DCStreamType streamType,int32_t eventType,int32_t eventReason,std::string detail)357 void DCameraSourceInput::OnSessionError(DCStreamType streamType, int32_t eventType, int32_t eventReason,
358     std::string detail)
359 {
360     DHLOGI("DCameraSourceInput OnSessionError devId: %s, dhId: %s, eventType: %d, eventReason: %d, detail %s",
361         GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str(), eventType, eventReason, detail.c_str());
362 }
363 
OnDataReceived(DCStreamType streamType,std::vector<std::shared_ptr<DataBuffer>> & buffers)364 void DCameraSourceInput::OnDataReceived(DCStreamType streamType, std::vector<std::shared_ptr<DataBuffer>>& buffers)
365 {
366     int32_t ret = dataProcess_[streamType]->FeedStream(buffers);
367     if (ret != DCAMERA_OK) {
368         DHLOGE("DCameraSourceInput OnDataReceived FeedStream %d stream failed ret: %d, devId: %s, dhId: %s", streamType,
369             ret, GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
370     }
371 }
372 
ReleaseAllStreams()373 int32_t DCameraSourceInput::ReleaseAllStreams()
374 {
375     DHLOGI("DCameraSourceInput ReleaseAllStreams devId %s dhId %s", GetAnonyString(devId_).c_str(),
376         GetAnonyString(dhId_).c_str());
377     std::vector<int> continueStreamIds;
378     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
379     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->ReleaseStreams(continueStreamIds);
380     if (ret != DCAMERA_OK) {
381         DHLOGE("DCameraSourceInput ReleaseAllStreams continue stream ReleaseStreams ret: %d, devId: %s, dhId: %s", ret,
382             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
383         return ret;
384     }
385 
386     std::vector<int> snapStreamIds;
387     dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
388     ret = dataProcess_[SNAPSHOT_FRAME]->ReleaseStreams(snapStreamIds);
389     if (ret != DCAMERA_OK) {
390         DHLOGE("DCameraSourceInput ReleaseAllStreams snapshot stream ReleaseStreams ret: %d, devId: %s, dhId: %s", ret,
391             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
392         return ret;
393     }
394     return DCAMERA_OK;
395 }
396 
StopAllCapture()397 int32_t DCameraSourceInput::StopAllCapture()
398 {
399     DHLOGI("DCameraSourceInput StopAllCapture devId %s dhId %s", GetAnonyString(devId_).c_str(),
400         GetAnonyString(dhId_).c_str());
401     std::vector<int> continueStreamIds;
402     dataProcess_[CONTINUOUS_FRAME]->GetAllStreamIds(continueStreamIds);
403     int32_t ret = dataProcess_[CONTINUOUS_FRAME]->StopCapture(continueStreamIds);
404     if (ret != DCAMERA_OK) {
405         DHLOGE("DCameraSourceInput StopAllCapture continue ret: %d, devId: %s, dhId: %s", ret,
406             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
407         return ret;
408     }
409 
410     std::vector<int> snapStreamIds;
411     dataProcess_[SNAPSHOT_FRAME]->GetAllStreamIds(snapStreamIds);
412     ret = dataProcess_[SNAPSHOT_FRAME]->StopCapture(snapStreamIds);
413     if (ret != DCAMERA_OK) {
414         DHLOGE("DCameraSourceInput StopAllCapture snapshot ret: %d, devId: %s, dhId: %s", ret,
415             GetAnonyString(devId_).c_str(), GetAnonyString(dhId_).c_str());
416         return ret;
417     }
418     return DCAMERA_OK;
419 }
420 } // namespace DistributedHardware
421 } // namespace OHOS
422