Add MJPEG support to FakeVideoCaptureDevice

media/capture/video/fake_video_capture_device_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/capture/video/fake_video_capture_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 248 matching lines @@
   const scoped_refptr<DeviceEnumerationListener> device_enumeration_listener_;
   const scoped_refptr<ImageCaptureClient> image_capture_client_;
   VideoCaptureFormat last_format_;
   const std::unique_ptr<VideoCaptureDeviceFactory>
       video_capture_device_factory_;
 };
 
 class FakeVideoCaptureDeviceTest
     : public FakeVideoCaptureDeviceBase,
       public ::testing::WithParamInterface<
-          ::testing::tuple<VideoPixelFormat,
+          ::testing::tuple<FakeVideoCaptureDeviceMaker::PixelFormat,
                            FakeVideoCaptureDeviceMaker::DeliveryMode,
                            float>> {};
 
 // Tests that a frame is delivered with the expected settings.
 // Sweeps through a fixed set of requested/expected resolutions.
 TEST_P(FakeVideoCaptureDeviceTest, CaptureUsing) {
+  if (testing::get<1>(GetParam()) ==
+          FakeVideoCaptureDeviceMaker::DeliveryMode::
+              USE_CLIENT_PROVIDED_BUFFERS &&
+      testing::get<0>(GetParam()) ==
+          FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG) {
+    // Unsupported case
+    return;
+  }
+
   const std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
       EnumerateDevices());
   ASSERT_FALSE(descriptors->empty());
 
   auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
       testing::get<0>(GetParam()), testing::get<1>(GetParam()),
       testing::get<2>(GetParam()));
   ASSERT_TRUE(device);
 
   // First: Requested, Second: Expected
@@ skipping 10 matching lines @@
     EXPECT_CALL(*client, OnError(_, _)).Times(0);
 
     VideoCaptureParams capture_params;
     capture_params.requested_format.frame_size = resolution.first;
     capture_params.requested_format.frame_rate = testing::get<2>(GetParam());
     device->AllocateAndStart(capture_params, std::move(client));
 
     WaitForCapturedFrame();
     EXPECT_EQ(resolution.second.width(), last_format().frame_size.width());
     EXPECT_EQ(resolution.second.height(), last_format().frame_size.height());
-    EXPECT_EQ(last_format().pixel_format, testing::get<0>(GetParam()));
+    EXPECT_EQ(last_format().pixel_format,
+              static_cast<VideoPixelFormat>(testing::get<0>(GetParam())));
     EXPECT_EQ(last_format().frame_rate, testing::get<2>(GetParam()));
     device->StopAndDeAllocate();
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     ,
     FakeVideoCaptureDeviceTest,
-    Combine(Values(PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_ARGB),
+    Combine(Values(FakeVideoCaptureDeviceMaker::PixelFormat::I420,
+                   FakeVideoCaptureDeviceMaker::PixelFormat::Y16,
+                   FakeVideoCaptureDeviceMaker::PixelFormat::MJPEG),
             Values(FakeVideoCaptureDeviceMaker::DeliveryMode::
                        USE_DEVICE_INTERNAL_BUFFERS,
                    FakeVideoCaptureDeviceMaker::DeliveryMode::
                        USE_CLIENT_PROVIDED_BUFFERS),
             Values(20, 29.97, 30, 50, 60)));
 
 TEST_F(FakeVideoCaptureDeviceTest, GetDeviceSupportedFormats) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
-      switches::kUseFakeDeviceForMediaStream, "device-count=3");
+      switches::kUseFakeDeviceForMediaStream, "device-count=4");
   std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
       EnumerateDevices());
-  ASSERT_EQ(3u, descriptors->size());
+  ASSERT_EQ(4u, descriptors->size());
+  VideoPixelFormat expected_format_by_device_index[] = {

[mcasas, 2017/02/23 21:46:18]

nit: const

+      PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_MJPEG,
+      PIXEL_FORMAT_I420};
 
+  int device_index = 0;
   for (const auto& descriptors_iterator : *descriptors) {
     VideoCaptureFormats supported_formats;
     video_capture_device_factory_->GetSupportedFormats(descriptors_iterator,
                                                        &supported_formats);
     ASSERT_EQ(5u, supported_formats.size());
-    const std::string device_id = descriptors_iterator.device_id;
     VideoPixelFormat expected_format =
-        (device_id == "/dev/video1") ? PIXEL_FORMAT_Y16 : PIXEL_FORMAT_I420;
+        expected_format_by_device_index[device_index];
     EXPECT_EQ(96, supported_formats[0].frame_size.width());
     EXPECT_EQ(96, supported_formats[0].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[0].pixel_format);
     EXPECT_GE(supported_formats[0].frame_rate, 20.0);
     EXPECT_EQ(320, supported_formats[1].frame_size.width());
     EXPECT_EQ(240, supported_formats[1].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[1].pixel_format);
     EXPECT_GE(supported_formats[1].frame_rate, 20.0);
     EXPECT_EQ(640, supported_formats[2].frame_size.width());
     EXPECT_EQ(480, supported_formats[2].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[2].pixel_format);
     EXPECT_GE(supported_formats[2].frame_rate, 20.0);
     EXPECT_EQ(1280, supported_formats[3].frame_size.width());
     EXPECT_EQ(720, supported_formats[3].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[3].pixel_format);
     EXPECT_GE(supported_formats[3].frame_rate, 20.0);
     EXPECT_EQ(1920, supported_formats[4].frame_size.width());
     EXPECT_EQ(1080, supported_formats[4].frame_size.height());
     EXPECT_EQ(expected_format, supported_formats[4].pixel_format);
     EXPECT_GE(supported_formats[4].frame_rate, 20.0);
+    device_index++;
   }
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, GetCameraCalibration) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kUseFakeDeviceForMediaStream, "device-count=2");
   std::unique_ptr<VideoCaptureDeviceDescriptors> descriptors(
       EnumerateDevices());
   ASSERT_EQ(2u, descriptors->size());
   ASSERT_FALSE(descriptors->at(0).camera_calibration);
   const VideoCaptureDeviceDescriptor& depth_device = descriptors->at(1);
   EXPECT_EQ("/dev/video1", depth_device.device_id);
   ASSERT_TRUE(depth_device.camera_calibration);
   EXPECT_EQ(135.0, depth_device.camera_calibration->focal_length_x);
   EXPECT_EQ(135.6, depth_device.camera_calibration->focal_length_y);
   EXPECT_EQ(0.0, depth_device.camera_calibration->depth_near);
   EXPECT_EQ(65.535, depth_device.camera_calibration->depth_far);
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, GetAndSetCapabilities) {
   auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
-      PIXEL_FORMAT_I420,
+      FakeVideoCaptureDeviceMaker::PixelFormat::I420,
       FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS,
       30.0);
   ASSERT_TRUE(device);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30.0;
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::GetPhotoCapabilitiesCallback scoped_get_callback(
@@ skipping 90 matching lines @@
   run_loop_.reset(new base::RunLoop());
   run_loop_->Run();
   EXPECT_EQ(max_zoom_value,
             image_capture_client_->capabilities()->zoom->current);
 
   device->StopAndDeAllocate();
 }
 
 TEST_F(FakeVideoCaptureDeviceTest, TakePhoto) {
   auto device = FakeVideoCaptureDeviceMaker::MakeInstance(
-      PIXEL_FORMAT_I420,
+      FakeVideoCaptureDeviceMaker::PixelFormat::I420,
       FakeVideoCaptureDeviceMaker::DeliveryMode::USE_DEVICE_INTERNAL_BUFFERS,
       30.0);
   ASSERT_TRUE(device);
 
   VideoCaptureParams capture_params;
   capture_params.requested_format.frame_size.SetSize(640, 480);
   capture_params.requested_format.frame_rate = 30.0;
   device->AllocateAndStart(capture_params, std::move(client_));
 
   VideoCaptureDevice::TakePhotoCallback scoped_callback(
@@ skipping 71 matching lines @@
                                1u,
                                {PIXEL_FORMAT_I420}},
            CommandLineTestData{"fps=60,device-count=2",
                                60,
                                2u,
                                {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16}},
            CommandLineTestData{"fps=1000,device-count=-1",
                                60,
                                1u,
                                {PIXEL_FORMAT_I420}},
-           CommandLineTestData{
-               "device-count=3",
-               20,
-               3u,
-               {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_I420}},
-           CommandLineTestData{
-               "device-count=3,ownership=client",
-               20,
-               3u,
-               {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16, PIXEL_FORMAT_I420}},
+           CommandLineTestData{"device-count=4",
+                               20,
+                               4u,
+
+                               {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
+                                PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
+           CommandLineTestData{"device-count=4,ownership=client",
+                               20,
+                               4u,
+
+                               {PIXEL_FORMAT_I420, PIXEL_FORMAT_Y16,
+                                PIXEL_FORMAT_MJPEG, PIXEL_FORMAT_I420}},
            CommandLineTestData{"device-count=0", 20, 1u, {PIXEL_FORMAT_I420}}));
 };  // namespace media