OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "media/capture/video/fake_video_capture_device.h" | 5 #include "media/capture/video/fake_video_capture_device.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 #include <stdint.h> | 8 #include <stdint.h> |
9 | 9 |
10 #include <memory> | 10 #include <memory> |
(...skipping 242 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
253 | 253 |
254 const VideoCaptureFormat& last_format() const { return last_format_; } | 254 const VideoCaptureFormat& last_format() const { return last_format_; } |
255 | 255 |
256 VideoCaptureDeviceDescriptors descriptors_; | 256 VideoCaptureDeviceDescriptors descriptors_; |
257 const std::unique_ptr<base::MessageLoop> loop_; | 257 const std::unique_ptr<base::MessageLoop> loop_; |
258 std::unique_ptr<base::RunLoop> run_loop_; | 258 std::unique_ptr<base::RunLoop> run_loop_; |
259 std::unique_ptr<MockClient> client_; | 259 std::unique_ptr<MockClient> client_; |
260 const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_; | 260 const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_; |
261 const scoped_refptr<ImageCaptureClient> image_capture_client_; | 261 const scoped_refptr<ImageCaptureClient> image_capture_client_; |
262 VideoCaptureFormat last_format_; | 262 VideoCaptureFormat last_format_; |
263 const std::unique_ptr<VideoCaptureDeviceFactory> | 263 const std::unique_ptr<FakeVideoCaptureDeviceFactory> |
264 video_capture_device_factory_; | 264 video_capture_device_factory_; |
265 }; | 265 }; |
266 | 266 |
267 class FakeVideoCaptureDeviceTest | 267 class FakeVideoCaptureDeviceTest |
268 : public FakeVideoCaptureDeviceBase, | 268 : public FakeVideoCaptureDeviceBase, |
269 public ::testing::WithParamInterface< | 269 public ::testing::WithParamInterface< |
270 ::testing::tuple<FakeVideoCaptureDeviceMaker::PixelFormat, | 270 ::testing::tuple<VideoPixelFormat, |
271 FakeVideoCaptureDeviceMaker::DeliveryMode, | 271 FakeVideoCaptureDevice::DeliveryMode, |
272 float>> {}; | 272 float>> {}; |
273 | 273 |
274 // Tests that a frame is delivered with the expected settings. | 274 // Tests that a frame is delivered with the expected settings. |
275 // Sweeps through a fixed set of requested/expected resolutions. | 275 // Sweeps through a fixed set of requested/expected resolutions. |
276 TEST_P(FakeVideoCaptureDeviceTest, CaptureUsing) { | 276 TEST_P(FakeVideoCaptureDeviceTest, CaptureUsing) { |
277 if (testing::get<1>(GetParam()) == FakeVideoCaptureDeviceMaker::DeliveryMode:: | 277 if (testing::get<1>(GetParam()) == |
278 USE_CLIENT_PROVIDED_BUFFERS && | 278 FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS && |
279 testing::get<0>(GetParam()) == | 279 testing::get<0>(GetParam()) == media::PIXEL_FORMAT_MJPEG) { |
280 FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG) { | |
281 // Unsupported case | 280 // Unsupported case |
282 return; | 281 return; |
283 } | 282 } |
284 | 283 |
285 const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( | 284 const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( |
286 EnumerateDevices()); | 285 EnumerateDevices()); |
287 ASSERT_FALSE(descriptors->empty()); | 286 ASSERT_FALSE(descriptors->empty()); |
288 | 287 |
289 auto device = FakeVideoCaptureDeviceMaker::MakeInstance( | 288 auto device = |
290 testing::get<0>(GetParam()), testing::get<1>(GetParam()), | 289 FakeVideoCaptureDeviceFactory::CreateDeviceWithDefaultResolutions( |
291 testing::get<2>(GetParam())); | 290 testing::get<0>(GetParam()), testing::get<1>(GetParam()), |
| 291 testing::get<2>(GetParam())); |
292 ASSERT_TRUE(device); | 292 ASSERT_TRUE(device); |
293 | 293 |
294 // First: Requested, Second: Expected | 294 // First: Requested, Second: Expected |
295 std::vector<std::pair<gfx::Size, gfx::Size>> resolutions_to_test; | 295 std::vector<std::pair<gfx::Size, gfx::Size>> resolutions_to_test; |
296 resolutions_to_test.emplace_back(gfx::Size(640, 480), gfx::Size(640, 480)); | 296 resolutions_to_test.emplace_back(gfx::Size(640, 480), gfx::Size(640, 480)); |
297 resolutions_to_test.emplace_back(gfx::Size(104, 105), gfx::Size(320, 240)); | 297 resolutions_to_test.emplace_back(gfx::Size(104, 105), gfx::Size(320, 240)); |
298 resolutions_to_test.emplace_back(gfx::Size(0, 0), gfx::Size(96, 96)); | 298 resolutions_to_test.emplace_back(gfx::Size(0, 0), gfx::Size(96, 96)); |
299 resolutions_to_test.emplace_back(gfx::Size(0, 720), gfx::Size(96, 96)); | 299 resolutions_to_test.emplace_back(gfx::Size(0, 720), gfx::Size(96, 96)); |
300 resolutions_to_test.emplace_back(gfx::Size(1920, 1080), | 300 resolutions_to_test.emplace_back(gfx::Size(1920, 1080), |
301 gfx::Size(1920, 1080)); | 301 gfx::Size(1920, 1080)); |
302 | 302 |
303 for (const auto& resolution : resolutions_to_test) { | 303 for (const auto& resolution : resolutions_to_test) { |
304 auto client = CreateClient(); | 304 auto client = CreateClient(); |
305 EXPECT_CALL(*client, OnError(_, _)).Times(0); | 305 EXPECT_CALL(*client, OnError(_, _)).Times(0); |
306 EXPECT_CALL(*client, OnStarted()); | 306 EXPECT_CALL(*client, OnStarted()); |
307 | 307 |
308 VideoCaptureParams capture_params; | 308 VideoCaptureParams capture_params; |
309 capture_params.requested_format.frame_size = resolution.first; | 309 capture_params.requested_format.frame_size = resolution.first; |
310 capture_params.requested_format.frame_rate = testing::get<2>(GetParam()); | 310 capture_params.requested_format.frame_rate = testing::get<2>(GetParam()); |
311 device->AllocateAndStart(capture_params, std::move(client)); | 311 device->AllocateAndStart(capture_params, std::move(client)); |
312 | 312 |
313 WaitForCapturedFrame(); | 313 WaitForCapturedFrame(); |
314 EXPECT_EQ(resolution.second.width(), last_format().frame_size.width()); | 314 EXPECT_EQ(resolution.second.width(), last_format().frame_size.width()); |
315 EXPECT_EQ(resolution.second.height(), last_format().frame_size.height()); | 315 EXPECT_EQ(resolution.second.height(), last_format().frame_size.height()); |
316 EXPECT_EQ(last_format().pixel_format, | 316 EXPECT_EQ(last_format().pixel_format, testing::get<0>(GetParam())); |
317 static_cast<VideoPixelFormat>(testing::get<0>(GetParam()))); | |
318 EXPECT_EQ(last_format().frame_rate, testing::get<2>(GetParam())); | 317 EXPECT_EQ(last_format().frame_rate, testing::get<2>(GetParam())); |
319 device->StopAndDeAllocate(); | 318 device->StopAndDeAllocate(); |
320 } | 319 } |
321 } | 320 } |
322 | 321 |
323 INSTANTIATE_TEST_CASE_P( | 322 INSTANTIATE_TEST_CASE_P( |
324 , | 323 , |
325 FakeVideoCaptureDeviceTest, | 324 FakeVideoCaptureDeviceTest, |
326 Combine(Values(FakeVideoCaptureDeviceMaker::PixelFormat::I420, | 325 Combine( |
327 FakeVideoCaptureDeviceMaker::PixelFormat::Y16, | 326 Values(PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG), |
328 FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG), | 327 Values( |
329 Values(FakeVideoCaptureDeviceMaker::DeliveryMode:: | 328 FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS, |
330 USE_DEVICE_INTERNAL_BUFFERS, | 329 FakeVideoCaptureDevice::DeliveryMode::USE_CLIENT_PROVIDED_BUFFERS), |
331 FakeVideoCaptureDeviceMaker::DeliveryMode:: | 330 Values(20, 29.97, 30, 50, 60))); |
332 USE_CLIENT_PROVIDED_BUFFERS), | |
333 Values(20, 29.97, 30, 50, 60))); | |
334 | 331 |
335 TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) { | 332 TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) { |
336 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 333 video_capture_device_factory_->SetToDefaultDevicesConfig(4); |
337 switches::kUseFakeDeviceForMediaStream, "device-count=4"); | |
338 std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( | 334 std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( |
339 EnumerateDevices()); | 335 EnumerateDevices()); |
340 ASSERT_EQ(4u, descriptors->size()); | 336 ASSERT_EQ(4u, descriptors->size()); |
341 const VideoPixelFormat expected_format_by_device_index[] = { | 337 const VideoPixelFormat expected_format_by_device_index[] = { |
342 PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG, | 338 PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG, |
343 PIXEL_FORMAT_I420}; | 339 PIXEL_FORMAT_I420}; |
344 | 340 |
345 int device_index = 0; | 341 int device_index = 0; |
346 for (const auto& descriptors_iterator : *descriptors) { | 342 for (const auto& descriptors_iterator : *descriptors) { |
347 VideoCaptureFormats supported_formats; | 343 VideoCaptureFormats supported_formats; |
(...skipping 20 matching lines...) Expand all Loading... |
368 EXPECT_GE(supported_formats[3].frame_rate, 20.0); | 364 EXPECT_GE(supported_formats[3].frame_rate, 20.0); |
369 EXPECT_EQ(1920, supported_formats[4].frame_size.width()); | 365 EXPECT_EQ(1920, supported_formats[4].frame_size.width()); |
370 EXPECT_EQ(1080, supported_formats[4].frame_size.height()); | 366 EXPECT_EQ(1080, supported_formats[4].frame_size.height()); |
371 EXPECT_EQ(expected_format, supported_formats[4].pixel_format); | 367 EXPECT_EQ(expected_format, supported_formats[4].pixel_format); |
372 EXPECT_GE(supported_formats[4].frame_rate, 20.0); | 368 EXPECT_GE(supported_formats[4].frame_rate, 20.0); |
373 device_index++; | 369 device_index++; |
374 } | 370 } |
375 } | 371 } |
376 | 372 |
377 TEST_F(FakeVideoCaptureDeviceTest, GetCameraCalibration) { | 373 TEST_F(FakeVideoCaptureDeviceTest, GetCameraCalibration) { |
378 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 374 const size_t device_count = 2; |
379 switches::kUseFakeDeviceForMediaStream, "device-count=2"); | 375 video_capture_device_factory_->SetToDefaultDevicesConfig(device_count); |
380 std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( | 376 std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( |
381 EnumerateDevices()); | 377 EnumerateDevices()); |
382 ASSERT_EQ(2u, descriptors->size()); | 378 ASSERT_EQ(device_count, descriptors->size()); |
383 ASSERT_FALSE(descriptors->at(0).camera_calibration); | 379 ASSERT_FALSE(descriptors->at(0).camera_calibration); |
384 const VideoCaptureDeviceDescriptor& depth_device = descriptors->at(1); | 380 const VideoCaptureDeviceDescriptor& depth_device = descriptors->at(1); |
385 EXPECT_EQ("/dev/video1", depth_device.device_id); | 381 EXPECT_EQ("/dev/video1", depth_device.device_id); |
386 ASSERT_TRUE(depth_device.camera_calibration); | 382 ASSERT_TRUE(depth_device.camera_calibration); |
387 EXPECT_EQ(135.0, depth_device.camera_calibration->focal_length_x); | 383 EXPECT_EQ(135.0, depth_device.camera_calibration->focal_length_x); |
388 EXPECT_EQ(135.6, depth_device.camera_calibration->focal_length_y); | 384 EXPECT_EQ(135.6, depth_device.camera_calibration->focal_length_y); |
389 EXPECT_EQ(0.0, depth_device.camera_calibration->depth_near); | 385 EXPECT_EQ(0.0, depth_device.camera_calibration->depth_near); |
390 EXPECT_EQ(65.535, depth_device.camera_calibration->depth_far); | 386 EXPECT_EQ(65.535, depth_device.camera_calibration->depth_far); |
391 } | 387 } |
392 | 388 |
| 389 TEST_F(FakeVideoCaptureDeviceTest, ErrorDeviceReportsError) { |
| 390 auto device = FakeVideoCaptureDeviceFactory::CreateErrorDevice(); |
| 391 ASSERT_TRUE(device); |
| 392 EXPECT_CALL(*client_, OnError(_, _)); |
| 393 VideoCaptureParams capture_params; |
| 394 capture_params.requested_format.frame_size.SetSize(640, 480); |
| 395 capture_params.requested_format.frame_rate = 30.0; |
| 396 device->AllocateAndStart(capture_params, std::move(client_)); |
| 397 } |
| 398 |
393 TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) { | 399 TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) { |
394 auto device = FakeVideoCaptureDeviceMaker::MakeInstance( | 400 auto device = |
395 FakeVideoCaptureDeviceMaker::PixelFormat::I420, | 401 FakeVideoCaptureDeviceFactory::CreateDeviceWithDefaultResolutions( |
396 FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS, | 402 PIXEL_FORMAT_I420, |
397 30.0); | 403 FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS, |
| 404 30.0); |
398 ASSERT_TRUE(device); | 405 ASSERT_TRUE(device); |
399 | 406 |
400 VideoCaptureParams capture_params; | 407 VideoCaptureParams capture_params; |
401 capture_params.requested_format.frame_size.SetSize(640, 480); | 408 capture_params.requested_format.frame_size.SetSize(640, 480); |
402 capture_params.requested_format.frame_rate = 30.0; | 409 capture_params.requested_format.frame_rate = 30.0; |
403 EXPECT_CALL(*client_, OnStarted()); | 410 EXPECT_CALL(*client_, OnStarted()); |
404 device->AllocateAndStart(capture_params, std::move(client_)); | 411 device->AllocateAndStart(capture_params, std::move(client_)); |
405 | 412 |
406 VideoCaptureDevice::GetPhotoCapabilitiesCallback scoped_get_callback( | 413 VideoCaptureDevice::GetPhotoCapabilitiesCallback scoped_get_callback( |
407 base::Bind(&ImageCaptureClient::DoOnGetPhotoCapabilities, | 414 base::Bind(&ImageCaptureClient::DoOnGetPhotoCapabilities, |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
496 device->GetPhotoCapabilities(std::move(scoped_get_callback2)); | 503 device->GetPhotoCapabilities(std::move(scoped_get_callback2)); |
497 run_loop_.reset(new base::RunLoop()); | 504 run_loop_.reset(new base::RunLoop()); |
498 run_loop_->Run(); | 505 run_loop_->Run(); |
499 EXPECT_EQ(max_zoom_value, | 506 EXPECT_EQ(max_zoom_value, |
500 image_capture_client_->capabilities()->zoom->current); | 507 image_capture_client_->capabilities()->zoom->current); |
501 | 508 |
502 device->StopAndDeAllocate(); | 509 device->StopAndDeAllocate(); |
503 } | 510 } |
504 | 511 |
505 TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) { | 512 TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) { |
506 auto device = FakeVideoCaptureDeviceMaker::MakeInstance( | 513 auto device = |
507 FakeVideoCaptureDeviceMaker::PixelFormat::I420, | 514 FakeVideoCaptureDeviceFactory::CreateDeviceWithDefaultResolutions( |
508 FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS, | 515 PIXEL_FORMAT_I420, |
509 30.0); | 516 FakeVideoCaptureDevice::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS, |
| 517 30.0); |
510 ASSERT_TRUE(device); | 518 ASSERT_TRUE(device); |
511 | 519 |
512 VideoCaptureParams capture_params; | 520 VideoCaptureParams capture_params; |
513 capture_params.requested_format.frame_size.SetSize(640, 480); | 521 capture_params.requested_format.frame_size.SetSize(640, 480); |
514 capture_params.requested_format.frame_rate = 30.0; | 522 capture_params.requested_format.frame_rate = 30.0; |
515 EXPECT_CALL(*client_, OnStarted()); | 523 EXPECT_CALL(*client_, OnStarted()); |
516 device->AllocateAndStart(capture_params, std::move(client_)); | 524 device->AllocateAndStart(capture_params, std::move(client_)); |
517 | 525 |
518 VideoCaptureDevice::TakePhotoCallback scoped_callback( | 526 VideoCaptureDevice::TakePhotoCallback scoped_callback( |
519 base::Bind(&ImageCaptureClient::DoOnPhotoTaken, image_capture_client_), | 527 base::Bind(&ImageCaptureClient::DoOnPhotoTaken, image_capture_client_), |
(...skipping 12 matching lines...) Expand all Loading... |
532 std::string switch_value_string; | 540 std::string switch_value_string; |
533 float expected_fps; | 541 float expected_fps; |
534 size_t expected_device_count; | 542 size_t expected_device_count; |
535 std::vector<VideoPixelFormat> expected_pixel_formats; | 543 std::vector<VideoPixelFormat> expected_pixel_formats; |
536 }; | 544 }; |
537 | 545 |
538 class FakeVideoCaptureDeviceFactoryTest | 546 class FakeVideoCaptureDeviceFactoryTest |
539 : public FakeVideoCaptureDeviceBase, | 547 : public FakeVideoCaptureDeviceBase, |
540 public ::testing::WithParamInterface<CommandLineTestData> {}; | 548 public ::testing::WithParamInterface<CommandLineTestData> {}; |
541 | 549 |
| 550 TEST_F(FakeVideoCaptureDeviceFactoryTest, DeviceWithNoSupportedFormats) { |
| 551 std::vector<FakeVideoCaptureDeviceSettings> config; |
| 552 FakeVideoCaptureDeviceSettings device_setting; |
| 553 device_setting.device_id = "Device with no supported formats"; |
| 554 config.emplace_back(device_setting); |
| 555 video_capture_device_factory_->SetToCustomDevicesConfig(config); |
| 556 |
| 557 const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( |
| 558 EnumerateDevices()); |
| 559 EXPECT_EQ(1u, descriptors->size()); |
| 560 media::VideoCaptureFormats supported_formats; |
| 561 video_capture_device_factory_->GetSupportedFormats(descriptors->at(0), |
| 562 &supported_formats); |
| 563 EXPECT_EQ(0u, supported_formats.size()); |
| 564 auto device = video_capture_device_factory_->CreateDevice(descriptors->at(0)); |
| 565 EXPECT_TRUE(device.get()); |
| 566 |
| 567 auto client = CreateClient(); |
| 568 EXPECT_CALL(*client, OnError(_, _)); |
| 569 VideoCaptureParams capture_params; |
| 570 capture_params.requested_format.frame_size.SetSize(1280, 720); |
| 571 device->AllocateAndStart(capture_params, std::move(client)); |
| 572 } |
| 573 |
542 // Tests that the FakeVideoCaptureDeviceFactory delivers the expected number | 574 // Tests that the FakeVideoCaptureDeviceFactory delivers the expected number |
543 // of devices and formats when being configured using command-line switches. | 575 // of devices and formats when being configured using command-line switches. |
544 TEST_P(FakeVideoCaptureDeviceFactoryTest, FrameRateAndDeviceCount) { | 576 TEST_P(FakeVideoCaptureDeviceFactoryTest, FrameRateAndDeviceCount) { |
545 base::CommandLine::ForCurrentProcess()->AppendSwitchASCII( | 577 std::vector<FakeVideoCaptureDeviceSettings> config; |
546 switches::kUseFakeDeviceForMediaStream, GetParam().switch_value_string); | 578 FakeVideoCaptureDeviceFactory::ParseFakeDevicesConfigFromOptionsString( |
| 579 GetParam().switch_value_string, &config); |
| 580 video_capture_device_factory_->SetToCustomDevicesConfig(config); |
| 581 |
547 const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( | 582 const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors( |
548 EnumerateDevices()); | 583 EnumerateDevices()); |
549 EXPECT_EQ(GetParam().expected_device_count, descriptors->size()); | 584 EXPECT_EQ(GetParam().expected_device_count, descriptors->size()); |
550 ASSERT_FALSE(descriptors->empty()); | |
551 | 585 |
552 int device_index = 0; | 586 int device_index = 0; |
553 for (const auto& descriptors_iterator : *descriptors) { | 587 for (const auto& descriptors_iterator : *descriptors) { |
554 media::VideoCaptureFormats supported_formats; | 588 media::VideoCaptureFormats supported_formats; |
555 video_capture_device_factory_->GetSupportedFormats(descriptors_iterator, | 589 video_capture_device_factory_->GetSupportedFormats(descriptors_iterator, |
556 &supported_formats); | 590 &supported_formats); |
557 for (const auto& supported_formats_entry : supported_formats) { | 591 for (const auto& supported_formats_entry : supported_formats) { |
558 EXPECT_EQ(GetParam().expected_pixel_formats[device_index], | 592 EXPECT_EQ(GetParam().expected_pixel_formats[device_index], |
559 supported_formats_entry.pixel_format); | 593 supported_formats_entry.pixel_format); |
560 } | 594 } |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
595 60, | 629 60, |
596 2u, | 630 2u, |
597 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16}}, | 631 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16}}, |
598 CommandLineTestData{"fps=1000,device-count=-1", | 632 CommandLineTestData{"fps=1000,device-count=-1", |
599 60, | 633 60, |
600 1u, | 634 1u, |
601 {PIXEL_FORMAT_I420}}, | 635 {PIXEL_FORMAT_I420}}, |
602 CommandLineTestData{"device-count=4", | 636 CommandLineTestData{"device-count=4", |
603 20, | 637 20, |
604 4u, | 638 4u, |
605 | |
606 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, | 639 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, |
607 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}}, | 640 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}}, |
608 CommandLineTestData{"device-count=4,ownership=client", | 641 CommandLineTestData{"device-count=4,ownership=client", |
609 20, | 642 20, |
610 4u, | 643 4u, |
611 | |
612 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, | 644 {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, |
613 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}}, | 645 PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}}, |
614 CommandLineTestData{"device-count=0", 20, 1u, {PIXEL_FORMAT_I420}})); | 646 CommandLineTestData{"device-count=0", 20, 0u, {PIXEL_FORMAT_I420}})); |
615 }; // namespace media | 647 }; // namespace media |
OLD | NEW |