1 /*
2 * Copyright (c) 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 #include "usb_camera_test_mult.h"
16
SetUpTestCase(void)17 void UtestUSBCameraTestMult::SetUpTestCase(void)
18 {}
TearDownTestCase(void)19 void UtestUSBCameraTestMult::TearDownTestCase(void)
20 {}
SetUp(void)21 void UtestUSBCameraTestMult::SetUp(void)
22 {
23 if (cameraBase_ == nullptr)
24 cameraBase_ = std::make_shared<TestCameraBase>();
25 cameraBase_->UsbInit();
26 }
TearDown(void)27 void UtestUSBCameraTestMult::TearDown(void)
28 {
29 cameraBase_->Close();
30 }
31
SelectOpenCamera(std::string cameraId)32 CamRetCode UtestUSBCameraTestMult::SelectOpenCamera(std::string cameraId)
33 {
34 cameraBase_->cameraHost->GetCameraAbility(cameraId, vecAbility_);
35 MetadataUtils::ConvertVecToMetadata(vecAbility_, ability_);
36 const OHOS::sptr<DemoCameraDeviceCallback> callback = new DemoCameraDeviceCallback();
37 cameraBase_->rc = (CamRetCode)cameraBase_->cameraHost->OpenCamera(cameraId, callback, cameraDevice_);
38 if (cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR || cameraDevice_ == nullptr) {
39 std::cout << "OpenCamera2 failed, rc = " << cameraBase_->rc << std::endl;
40 return cameraBase_->rc;
41 }
42 std::cout << "OpenCamera2 success." << std::endl;
43 return cameraBase_->rc;
44 }
45
AchieveStreamOperator()46 void UtestUSBCameraTestMult::AchieveStreamOperator()
47 {
48 OHOS::sptr<DemoStreamOperatorCallback> streamOperatorCallback = new DemoStreamOperatorCallback();
49 cameraBase_->rc = (CamRetCode)cameraDevice_->GetStreamOperator(streamOperatorCallback, streamOperator_);
50 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
51 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
52 std::cout << "AchieveStreamOperator2 success." << std::endl;
53 } else {
54 std::cout << "AchieveStreamOperator2 fail, rc = " << cameraBase_->rc << std::endl;
55 }
56 }
57
DefaultInfosPreview()58 void UtestUSBCameraTestMult::DefaultInfosPreview()
59 {
60 if (streamCustomerPreview_ == nullptr) {
61 streamCustomerPreview_ = std::make_shared<StreamCustomer>();
62 }
63 streamInfoPre_.streamId_ = STREAM_ID_PREVIEW_DOUBLE;
64 streamInfoPre_.width_ = PREVIEW_WIDTH; // 640:picture width
65 streamInfoPre_.height_ = PREVIEW_HEIGHT; // 480:picture height
66 streamInfoPre_.format_ = PIXEL_FMT_RGBA_8888;
67 streamInfoPre_.dataspace_ = 8; // 8:picture dataspace
68 streamInfoPre_.intent_ = PREVIEW;
69 streamInfoPre_.tunneledMode_ = 5; // 5:tunnel mode
70 streamInfoPre_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerPreview_->CreateProducer());
71 ASSERT_NE(streamInfoPre_.bufferQueue_, nullptr);
72 streamInfoPre_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
73 std::cout << "preview success1." << std::endl;
74 std::vector<StreamInfo>().swap(streamInfos_);
75 streamInfos_.push_back(streamInfoPre_);
76 }
77
DefaultInfosVideo()78 void UtestUSBCameraTestMult::DefaultInfosVideo()
79 {
80 if (streamCustomerVideo_ == nullptr) {
81 streamCustomerVideo_ = std::make_shared<StreamCustomer>();
82 }
83 streamInfoVideo_.streamId_ = STREAM_ID_VIDEO_DOUBLE;
84 streamInfoVideo_.width_ = VIDEO_WIDTH; // 1280:picture width
85 streamInfoVideo_.height_ = VIDEO_HEIGHT; // 960:picture height
86 streamInfoVideo_.format_ = videoFormat_;
87 streamInfoVideo_.dataspace_ = 8; // 8:picture dataspace
88 streamInfoVideo_.intent_ = VIDEO;
89 streamInfoVideo_.encodeType_ = ENCODE_TYPE_H264;
90 streamInfoVideo_.tunneledMode_ = 5; // 5:tunnel mode
91 streamInfoVideo_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerVideo_->CreateProducer());
92 ASSERT_NE(streamInfoVideo_.bufferQueue_, nullptr);
93 streamInfoVideo_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
94 std::cout << "video success1." << std::endl;
95 std::vector<StreamInfo>().swap(streamInfos_);
96 streamInfos_.push_back(streamInfoVideo_);
97 }
98
DefaultInfosCapture()99 void UtestUSBCameraTestMult::DefaultInfosCapture()
100 {
101 if (streamCustomerCapture_ == nullptr) {
102 streamCustomerCapture_ = std::make_shared<StreamCustomer>();
103 }
104 streamInfoCapture_.streamId_ = STREAM_ID_CAPTURE_DOUBLE;
105 streamInfoCapture_.width_ = CAPTURE_WIDTH; // 1280:picture width
106 streamInfoCapture_.height_ = CAPTURE_HEIGHT; // 960:picture height
107 streamInfoCapture_.format_ = PIXEL_FMT_RGBA_8888;
108 streamInfoCapture_.dataspace_ = 8; // 8:picture dataspace
109 streamInfoCapture_.intent_ = STILL_CAPTURE;
110 streamInfoCapture_.encodeType_ = ENCODE_TYPE_JPEG;
111 streamInfoCapture_.tunneledMode_ = 5; // 5:tunnel mode
112 streamInfoCapture_.bufferQueue_ = new BufferProducerSequenceable(streamCustomerCapture_->CreateProducer());
113 ASSERT_NE(streamInfoCapture_.bufferQueue_, nullptr);
114 streamInfoCapture_.bufferQueue_->producer_->SetQueueSize(8); // 8:set bufferQueue size
115 std::cout << "capture success1." << std::endl;
116 std::vector<StreamInfo>().swap(streamInfos_);
117 streamInfos_.push_back(streamInfoCapture_);
118 }
119
StartStream(std::vector<StreamIntent> intents)120 void UtestUSBCameraTestMult::StartStream(std::vector<StreamIntent> intents)
121 {
122 for (auto& intent : intents) {
123 if (intent == PREVIEW) {
124 DefaultInfosPreview();
125 } else if (intent == VIDEO) {
126 DefaultInfosVideo();
127 } else if (intent == STILL_CAPTURE) {
128 DefaultInfosCapture();
129 }
130 cameraBase_->rc = (CamRetCode)streamOperator_->CreateStreams(streamInfos_);
131 EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
132 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
133 std::cout << "CreateStreams2 success." << std::endl;
134 } else {
135 std::cout << "CreateStreams2 fail, rc = " << cameraBase_->rc << std::endl;
136 }
137
138 cameraBase_->rc = (CamRetCode)streamOperator_->CommitStreams(NORMAL, vecAbility_);
139 EXPECT_EQ(false, cameraBase_->rc != HDI::Camera::V1_0::NO_ERROR);
140 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
141 std::cout << "CommitStreams2 success." << std::endl;
142 } else {
143 std::cout << "CommitStreams2 fail, rc = " << cameraBase_->rc << std::endl;
144 }
145 }
146 }
147
StoreImage(const unsigned char * bufStart,const uint32_t size)148 void UtestUSBCameraTestMult::StoreImage(const unsigned char *bufStart, const uint32_t size)
149 {
150 constexpr uint32_t pathLen = 64;
151 char path[pathLen] = {0};
152 #ifdef CAMERA_BUILT_ON_OHOS_LITE
153 char prefix[] = "/userdata/photo/";
154 #else
155 char prefix[] = "/data/";
156 #endif
157
158 int imgFD = 0;
159 int ret = 0;
160
161 struct timeval start = {};
162 gettimeofday(&start, nullptr);
163 if (sprintf_s(path, sizeof(path), "%spicture222_%ld.jpeg", prefix, start.tv_usec) < 0) {
164 CAMERA_LOGE("sprintf_s error .....\n");
165 return;
166 }
167
168 imgFD = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
169 if (imgFD == -1) {
170 CAMERA_LOGE("demo test:open image file error %{public}s.....\n", strerror(errno));
171 return;
172 }
173
174 CAMERA_LOGD("demo test:StoreImage2 %{public}s size == %{public}d\n", path, size);
175
176 ret = write(imgFD, bufStart, size);
177 if (ret == -1) {
178 CAMERA_LOGE("demo test:write image file error %{public}s.....\n", strerror(errno));
179 }
180
181 close(imgFD);
182 }
183
StoreVideo(const unsigned char * bufStart,const uint32_t size)184 void UtestUSBCameraTestMult::StoreVideo(const unsigned char *bufStart, const uint32_t size)
185 {
186 int ret = 0;
187
188 ret = write(videoFd_, bufStart, size);
189 if (ret == -1) {
190 CAMERA_LOGE("demo test:write video file error %{public}s.....\n", strerror(errno));
191 }
192 CAMERA_LOGD("demo test:StoreVideo size == %{public}d\n", size);
193 }
194
OpenVideoFile()195 void UtestUSBCameraTestMult::OpenVideoFile()
196 {
197 constexpr uint32_t pathLen = 64;
198 char path[pathLen] = {0};
199 #ifdef CAMERA_BUILT_ON_OHOS_LITE
200 char prefix[] = "/userdata/video/";
201 #else
202 char prefix[] = "/data/";
203 #endif
204 auto seconds = time(nullptr);
205 if (sprintf_s(path, sizeof(path), "%svideo222%ld.h264", prefix, seconds) < 0) {
206 CAMERA_LOGE("%{public}s: sprintf failed", __func__);
207 return;
208 }
209 videoFd_ = open(path, O_RDWR | O_CREAT, 00766); // 00766:file operate permission
210 if (videoFd_ < 0) {
211 CAMERA_LOGE("demo test: StartVideo open %s %{public}s failed", path, strerror(errno));
212 }
213 }
214
CloseFd()215 void UtestUSBCameraTestMult::CloseFd()
216 {
217 close(videoFd_);
218 videoFd_ = -1;
219 }
220
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)221 void UtestUSBCameraTestMult::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
222 {
223 // Get preview
224 captureInfo_.streamIds_ = {streamId};
225 captureInfo_.captureSetting_ = vecAbility_;
226 captureInfo_.enableShutterCallback_ = shutterCallback;
227 cameraBase_->rc = (CamRetCode)streamOperator_->Capture(captureId, captureInfo_, isStreaming);
228 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
229 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
230 std::cout << "check Capture: Capture2 success, captureId = " << captureId << std::endl;
231 } else {
232 std::cout << "check Capture: Capture2 fail, rc = " << cameraBase_->rc
233 << ", captureId = " << captureId<< std::endl;
234 }
235 if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
236 streamCustomerPreview_->ReceiveFrameOn(nullptr);
237 } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
238 streamCustomerCapture_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
239 StoreImage(addr, size);
240 });
241 } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
242 OpenVideoFile();
243 streamCustomerVideo_->ReceiveFrameOn([this](const unsigned char *addr, const uint32_t size) {
244 StoreVideo(addr, size);
245 });
246 }
247 sleep(2); // 2:sleep two second
248 }
249
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)250 void UtestUSBCameraTestMult::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
251 {
252 constexpr uint32_t TIME_FOR_WAIT_CANCEL_CAPTURE = 2;
253 sleep(TIME_FOR_WAIT_CANCEL_CAPTURE);
254 if (sizeof(captureIds) > 0) {
255 for (auto &captureId : captureIds) {
256 if (captureId == CAPTURE_ID_PREVIEW_DOUBLE) {
257 streamCustomerPreview_->ReceiveFrameOff();
258 } else if (captureId == CAPTURE_ID_CAPTURE_DOUBLE) {
259 streamCustomerCapture_->ReceiveFrameOff();
260 } else if (captureId == CAPTURE_ID_VIDEO_DOUBLE) {
261 streamCustomerVideo_->ReceiveFrameOff();
262 sleep(1);
263 CloseFd();
264 }
265 }
266 for (const auto &captureId : captureIds) {
267 std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
268 cameraBase_->rc = (CamRetCode)streamOperator_->CancelCapture(captureId);
269 sleep(TIME_FOR_WAIT_CANCEL_CAPTURE);
270 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
271 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
272 std::cout << "check Capture: CancelCapture success, captureId = " << captureId << std::endl;
273 } else {
274 std::cout << "check Capture: CancelCapture fail, rc = "
275 << cameraBase_->rc <<", captureId = " << captureId << std::endl;
276 }
277 }
278 }
279 sleep(1); // 1:sleep two second
280 if (sizeof(streamIds) > 0) {
281 // release stream
282 cameraBase_->rc = (CamRetCode)streamOperator_->ReleaseStreams(streamIds);
283 EXPECT_EQ(true, cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR);
284 if (cameraBase_->rc == HDI::Camera::V1_0::NO_ERROR) {
285 std::cout << "check Capture: ReleaseStreams success." << std::endl;
286 } else {
287 std::cout << "check Capture: ReleaseStreams fail, rc = "
288 << cameraBase_->rc << ", streamIds = " << streamIds.front() << std::endl;
289 }
290 }
291 }
292
293 const std::map<uint32_t, uint32_t> g_mapOhosFmtToPixFmt = {
294 { OHOS_CAMERA_FORMAT_RGBA_8888, PIXEL_FMT_RGBA_8888 },
295 { OHOS_CAMERA_FORMAT_YCRCB_420_SP, PIXEL_FMT_YCRCB_420_SP },
296 };
297
ConvertPixfmtHal2V4l2(uint32_t ohosfmt)298 uint32_t UtestUSBCameraTestMult::ConvertPixfmtHal2V4l2(uint32_t ohosfmt)
299 {
300 auto it = g_mapOhosFmtToPixFmt.find(ohosfmt);
301 if (it == g_mapOhosFmtToPixFmt.end()) {
302 CAMERA_LOGI("The ohosfmt is not find in g_mapOhosFmtToPixFmt");
303 return PIXEL_FMT_RGBA_8888; // default value
304 }
305 return it->second;
306 }
307
308 /**
309 * @tc.name: USB Camera
310 * @tc.desc: USB Camera, getCameraID success.
311 * @tc.level: Level0
312 * @tc.size: MediumTest
313 * @tc.type: Function
314 */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0001)315 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0001)
316 {
317 std::vector<std::string> usbCameraIds;
318 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
319 if (usbCameraIds.size() > 1) { // 1:number of cameras connect
320 usbCameraExit_ = true;
321 } else {
322 usbCameraExit_ = false;
323 }
324 if (!usbCameraExit_) {
325 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
326 }
327 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
328 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
329 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
330 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
331 cameraBase_->AchieveStreamOperator();
332 AchieveStreamOperator();
333
334 cameraBase_->intents = {PREVIEW};
335 cameraBase_->StartStream(cameraBase_->intents);
336 StartStream(cameraBase_->intents);
337 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
338 StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
339 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW};
340 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW};
341 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
342 cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE};
343 cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE};
344 StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
345 }
346
347 /**
348 * @tc.name: USB Camera
349 * @tc.desc: USB Camera, getCameraID success.
350 * @tc.level: Level0
351 * @tc.size: MediumTest
352 * @tc.type: Function
353 */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0002)354 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0002)
355 {
356 std::vector<std::string> usbCameraIds;
357 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
358 if (usbCameraIds.size() > 1) { // 1:number of cameras connect
359 usbCameraExit_ = true;
360 } else {
361 usbCameraExit_ = false;
362 }
363 if (!usbCameraExit_) {
364 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
365 }
366 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
367 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
368 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
369 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
370 cameraBase_->AchieveStreamOperator();
371 AchieveStreamOperator();
372
373 cameraBase_->intents = {PREVIEW, STILL_CAPTURE};
374 cameraBase_->StartStream(cameraBase_->intents);
375 StartStream(cameraBase_->intents);
376 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
377 cameraBase_->StartCapture(cameraBase_->STREAM_ID_CAPTURE, cameraBase_->CAPTURE_ID_CAPTURE, false, true);
378 StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
379 StartCapture(STREAM_ID_CAPTURE_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE, false, true);
380 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_CAPTURE};
381 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_CAPTURE};
382 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
383 cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE, CAPTURE_ID_CAPTURE_DOUBLE};
384 cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE, STREAM_ID_CAPTURE_DOUBLE};
385 StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
386 }
387
388 /**
389 * @tc.name: USB Camera
390 * @tc.desc: USB Camera, getCameraID success.
391 * @tc.level: Level0
392 * @tc.size: MediumTest
393 * @tc.type: Function
394 */
TEST_F(UtestUSBCameraTestMult,camera_usb_mult_0003)395 TEST_F(UtestUSBCameraTestMult, camera_usb_mult_0003)
396 {
397 std::vector<std::string> usbCameraIds;
398 cameraBase_->cameraHost->GetCameraIds(usbCameraIds);
399 if (usbCameraIds.size() > 1) { // 1:number of cameras connect
400 usbCameraExit_ = true;
401 } else {
402 usbCameraExit_ = false;
403 }
404 if (!usbCameraExit_) {
405 GTEST_SKIP() << "No usb camera plugged in" << std::endl;
406 }
407 cameraBase_->rc = cameraBase_->SelectOpenCamera(usbCameraIds[0]); // 0:first camera id
408 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
409 cameraBase_->rc = SelectOpenCamera(usbCameraIds[1]); // 1:second camera id
410 ASSERT_EQ(cameraBase_->rc, HDI::Camera::V1_0::NO_ERROR);
411 cameraBase_->AchieveStreamOperator();
412 AchieveStreamOperator();
413
414 ability_ = cameraBase_->GetCameraAbility();
415 EXPECT_NE(ability_, nullptr);
416 common_metadata_header_t *data = ability_->get();
417 EXPECT_NE(data, nullptr);
418 camera_metadata_item_t entry;
419 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
420
421 uint32_t format = 0;
422 if (ret == 0 && entry.data.i32 != nullptr && entry.count > 0) {
423 format = entry.data.i32[entry.count - 6]; // 6:The sixth digit from the bottom is the format of video
424 }
425 videoFormat_ = ConvertPixfmtHal2V4l2(format);
426 cameraBase_->intents = {PREVIEW, VIDEO};
427 cameraBase_->StartStream(cameraBase_->intents);
428 StartStream(cameraBase_->intents);
429 cameraBase_->StartCapture(cameraBase_->STREAM_ID_PREVIEW, cameraBase_->CAPTURE_ID_PREVIEW, false, true);
430 cameraBase_->StartCapture(cameraBase_->STREAM_ID_VIDEO, cameraBase_->CAPTURE_ID_VIDEO, false, true);
431 StartCapture(STREAM_ID_PREVIEW_DOUBLE, CAPTURE_ID_PREVIEW_DOUBLE, false, true);
432 StartCapture(STREAM_ID_VIDEO_DOUBLE, CAPTURE_ID_VIDEO_DOUBLE, false, true);
433 cameraBase_->captureIds = {cameraBase_->CAPTURE_ID_PREVIEW, cameraBase_->CAPTURE_ID_VIDEO};
434 cameraBase_->streamIds = {cameraBase_->STREAM_ID_PREVIEW, cameraBase_->STREAM_ID_VIDEO};
435 cameraBase_->StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
436 cameraBase_->captureIds = {CAPTURE_ID_PREVIEW_DOUBLE, CAPTURE_ID_VIDEO_DOUBLE};
437 cameraBase_->streamIds = {STREAM_ID_PREVIEW_DOUBLE, STREAM_ID_VIDEO_DOUBLE};
438 StopStream(cameraBase_->captureIds, cameraBase_->streamIds);
439 }
440