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_factory.h" | 5 #include "media/capture/video/fake_video_capture_device_factory.h" |
6 | 6 |
7 #include "base/command_line.h" | 7 #include "base/command_line.h" |
8 #include "base/strings/string_number_conversions.h" | 8 #include "base/strings/string_number_conversions.h" |
9 #include "base/strings/string_split.h" | 9 #include "base/strings/string_split.h" |
10 #include "base/strings/string_tokenizer.h" | 10 #include "base/strings/string_tokenizer.h" |
11 #include "base/strings/string_util.h" | 11 #include "base/strings/string_util.h" |
12 #include "base/strings/stringprintf.h" | 12 #include "base/strings/stringprintf.h" |
13 #include "build/build_config.h" | 13 #include "build/build_config.h" |
14 #include "media/base/media_switches.h" | 14 #include "media/base/media_switches.h" |
15 | 15 |
16 namespace { | |
17 | |
18 media::VideoPixelFormat get_pixelformat(const std::string& device_id) { | |
19 if (device_id == "/dev/video1") | |
20 return media::PIXEL_FORMAT_Y16; | |
21 return media::PIXEL_FORMAT_I420; | |
mcasas
2016/10/25 22:13:12
Suggestion: send the device index (|n| in l.49
me
aleksandar.stojiljkovic
2016/10/25 23:20:40
Changed the name but kept the parameter - the reas
mcasas
2016/10/26 02:03:15
I meant calling the function with the parameter |n
aleksandar.stojiljkovic
2016/10/26 14:46:00
Sorry, my previous explanation was wrong.
l.53/l.9
| |
22 } | |
23 | |
24 } | |
25 | |
16 namespace media { | 26 namespace media { |
17 | 27 |
18 // Cap the frame rate command line input to reasonable values. | 28 // Cap the frame rate command line input to reasonable values. |
19 static const float kFakeCaptureMinFrameRate = 5.0f; | 29 static const float kFakeCaptureMinFrameRate = 5.0f; |
20 static const float kFakeCaptureMaxFrameRate = 60.0f; | 30 static const float kFakeCaptureMaxFrameRate = 60.0f; |
21 // Default rate if none is specified as part of the command line. | 31 // Default rate if none is specified as part of the command line. |
22 static const float kFakeCaptureDefaultFrameRate = 20.0f; | 32 static const float kFakeCaptureDefaultFrameRate = 20.0f; |
33 // Cap the device count command line input to reasonable values. | |
34 static const int kFakeCaptureMinDeviceCount = 1; | |
35 static const int kFakeCaptureMaxDeviceCount = 10; | |
23 | 36 |
37 // Factory has two devices by default; I420 and Y16. See also get_pixelformat(). | |
24 FakeVideoCaptureDeviceFactory::FakeVideoCaptureDeviceFactory() | 38 FakeVideoCaptureDeviceFactory::FakeVideoCaptureDeviceFactory() |
25 : number_of_devices_(1), | 39 : number_of_devices_(1), |
26 fake_vcd_ownership_(FakeVideoCaptureDevice::BufferOwnership::OWN_BUFFERS), | 40 fake_vcd_ownership_(FakeVideoCaptureDevice::BufferOwnership::OWN_BUFFERS), |
27 frame_rate_(kFakeCaptureDefaultFrameRate) {} | 41 frame_rate_(kFakeCaptureDefaultFrameRate) {} |
28 | 42 |
29 std::unique_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceFactory::CreateDevice( | 43 std::unique_ptr<VideoCaptureDevice> FakeVideoCaptureDeviceFactory::CreateDevice( |
30 const VideoCaptureDeviceDescriptor& device_descriptor) { | 44 const VideoCaptureDeviceDescriptor& device_descriptor) { |
31 DCHECK(thread_checker_.CalledOnValidThread()); | 45 DCHECK(thread_checker_.CalledOnValidThread()); |
32 | 46 |
33 parse_command_line(); | 47 parse_command_line(); |
34 | 48 |
35 for (int n = 0; n < number_of_devices_; ++n) { | 49 for (int n = 0; n < number_of_devices_; ++n) { |
36 std::string possible_id = base::StringPrintf("/dev/video%d", n); | 50 std::string possible_id = base::StringPrintf("/dev/video%d", n); |
37 if (device_descriptor.device_id.compare(possible_id) == 0) { | 51 if (device_descriptor.device_id.compare(possible_id) == 0) { |
38 return std::unique_ptr<VideoCaptureDevice>( | 52 return std::unique_ptr<VideoCaptureDevice>(new FakeVideoCaptureDevice( |
39 new FakeVideoCaptureDevice(fake_vcd_ownership_, frame_rate_)); | 53 fake_vcd_ownership_, frame_rate_, get_pixelformat(possible_id))); |
40 } | 54 } |
41 } | 55 } |
42 return std::unique_ptr<VideoCaptureDevice>(); | 56 return std::unique_ptr<VideoCaptureDevice>(); |
43 } | 57 } |
44 | 58 |
45 void FakeVideoCaptureDeviceFactory::GetDeviceDescriptors( | 59 void FakeVideoCaptureDeviceFactory::GetDeviceDescriptors( |
46 VideoCaptureDeviceDescriptors* device_descriptors) { | 60 VideoCaptureDeviceDescriptors* device_descriptors) { |
47 DCHECK(thread_checker_.CalledOnValidThread()); | 61 DCHECK(thread_checker_.CalledOnValidThread()); |
48 DCHECK(device_descriptors->empty()); | 62 DCHECK(device_descriptors->empty()); |
63 | |
64 parse_command_line(); | |
65 | |
49 for (int n = 0; n < number_of_devices_; ++n) { | 66 for (int n = 0; n < number_of_devices_; ++n) { |
50 device_descriptors->emplace_back(base::StringPrintf("fake_device_%d", n), | 67 device_descriptors->emplace_back(base::StringPrintf("fake_device_%d", n), |
51 base::StringPrintf("/dev/video%d", n), | 68 base::StringPrintf("/dev/video%d", n), |
52 #if defined(OS_LINUX) | 69 #if defined(OS_LINUX) |
53 VideoCaptureApi::LINUX_V4L2_SINGLE_PLANE | 70 VideoCaptureApi::LINUX_V4L2_SINGLE_PLANE |
54 #elif defined(OS_MACOSX) | 71 #elif defined(OS_MACOSX) |
55 VideoCaptureApi::MACOSX_AVFOUNDATION | 72 VideoCaptureApi::MACOSX_AVFOUNDATION |
56 #elif defined(OS_WIN) | 73 #elif defined(OS_WIN) |
57 VideoCaptureApi::WIN_DIRECT_SHOW | 74 VideoCaptureApi::WIN_DIRECT_SHOW |
58 #elif defined(OS_ANDROID) | 75 #elif defined(OS_ANDROID) |
59 VideoCaptureApi::ANDROID_API2_LEGACY | 76 VideoCaptureApi::ANDROID_API2_LEGACY |
60 #endif | 77 #endif |
61 ); | 78 ); |
62 } | 79 } |
63 } | 80 } |
64 | 81 |
65 void FakeVideoCaptureDeviceFactory::GetSupportedFormats( | 82 void FakeVideoCaptureDeviceFactory::GetSupportedFormats( |
66 const VideoCaptureDeviceDescriptor& device_descriptor, | 83 const VideoCaptureDeviceDescriptor& device_descriptor, |
67 VideoCaptureFormats* supported_formats) { | 84 VideoCaptureFormats* supported_formats) { |
68 DCHECK(thread_checker_.CalledOnValidThread()); | 85 DCHECK(thread_checker_.CalledOnValidThread()); |
69 const gfx::Size supported_sizes[] = {gfx::Size(320, 240), | 86 const gfx::Size supported_sizes[] = {gfx::Size(96, 96), // To test cubemap. |
87 gfx::Size(320, 240), | |
70 gfx::Size(640, 480), | 88 gfx::Size(640, 480), |
71 gfx::Size(1280, 720), | 89 gfx::Size(1280, 720), |
72 gfx::Size(1920, 1080)}; | 90 gfx::Size(1920, 1080)}; |
73 supported_formats->clear(); | 91 supported_formats->clear(); |
74 for (const auto& size : supported_sizes) { | 92 for (const auto& size : supported_sizes) { |
75 supported_formats->push_back( | 93 supported_formats->push_back(VideoCaptureFormat( |
76 VideoCaptureFormat(size, frame_rate_, media::PIXEL_FORMAT_I420)); | 94 size, frame_rate_, get_pixelformat(device_descriptor.device_id))); |
77 } | 95 } |
78 } | 96 } |
79 | 97 |
80 // Optional comma delimited parameters to the command line can specify buffer | 98 // Optional comma delimited parameters to the command line can specify buffer |
81 // ownership, buffer planarity, and the fake video device FPS. | 99 // ownership, device count, and the fake video devices FPS. |
82 // Examples: "ownership=client, planarity=triplanar, fps=60" "fps=30" | 100 // Examples: "ownership=client, device-count=2, fps=60" "fps=30" |
83 void FakeVideoCaptureDeviceFactory::parse_command_line() { | 101 void FakeVideoCaptureDeviceFactory::parse_command_line() { |
102 if (command_line_parsed_) | |
103 return; | |
104 command_line_parsed_ = true; | |
84 const std::string option = | 105 const std::string option = |
85 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII( | 106 base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII( |
86 switches::kUseFakeDeviceForMediaStream); | 107 switches::kUseFakeDeviceForMediaStream); |
87 base::StringTokenizer option_tokenizer(option, ", "); | 108 base::StringTokenizer option_tokenizer(option, ", "); |
88 option_tokenizer.set_quote_chars("\""); | 109 option_tokenizer.set_quote_chars("\""); |
89 | 110 |
90 while (option_tokenizer.GetNext()) { | 111 while (option_tokenizer.GetNext()) { |
91 std::vector<std::string> param = | 112 std::vector<std::string> param = |
92 base::SplitString(option_tokenizer.token(), "=", base::TRIM_WHITESPACE, | 113 base::SplitString(option_tokenizer.token(), "=", base::TRIM_WHITESPACE, |
93 base::SPLIT_WANT_NONEMPTY); | 114 base::SPLIT_WANT_NONEMPTY); |
94 | 115 |
95 if (param.size() != 2u) { | 116 if (param.size() != 2u) { |
96 LOG(WARNING) << "Forget a value '" << option << "'? Use name=value for " | 117 LOG(WARNING) << "Forget a value '" << option << "'? Use name=value for " |
97 << switches::kUseFakeDeviceForMediaStream << "."; | 118 << switches::kUseFakeDeviceForMediaStream << "."; |
98 return; | 119 return; |
99 } | 120 } |
100 | 121 |
101 if (base::EqualsCaseInsensitiveASCII(param.front(), "ownership") && | 122 if (base::EqualsCaseInsensitiveASCII(param.front(), "ownership") && |
102 base::EqualsCaseInsensitiveASCII(param.back(), "client")) { | 123 base::EqualsCaseInsensitiveASCII(param.back(), "client")) { |
103 fake_vcd_ownership_ = | 124 fake_vcd_ownership_ = |
104 FakeVideoCaptureDevice::BufferOwnership::CLIENT_BUFFERS; | 125 FakeVideoCaptureDevice::BufferOwnership::CLIENT_BUFFERS; |
105 } else if (base::EqualsCaseInsensitiveASCII(param.front(), "fps")) { | 126 } else if (base::EqualsCaseInsensitiveASCII(param.front(), "fps")) { |
106 double fps = 0; | 127 double fps = 0; |
107 if (base::StringToDouble(param.back(), &fps)) { | 128 if (base::StringToDouble(param.back(), &fps)) { |
108 frame_rate_ = | 129 frame_rate_ = |
109 std::max(kFakeCaptureMinFrameRate, static_cast<float>(fps)); | 130 std::max(kFakeCaptureMinFrameRate, static_cast<float>(fps)); |
110 frame_rate_ = std::min(kFakeCaptureMaxFrameRate, frame_rate_); | 131 frame_rate_ = std::min(kFakeCaptureMaxFrameRate, frame_rate_); |
111 } | 132 } |
133 } else if (base::EqualsCaseInsensitiveASCII(param.front(), | |
134 "device-count")) { | |
135 unsigned count = 0; | |
mcasas
2016/10/25 22:13:12
unsigned int? I think it's uncommon to see just |u
aleksandar.stojiljkovic
2016/10/25 23:20:40
Done.
| |
136 if (base::StringToUint(param.back(), &count)) { | |
137 number_of_devices_ = | |
138 std::min(kFakeCaptureMaxDeviceCount, static_cast<int>(count)); | |
139 number_of_devices_ = std::max(kFakeCaptureMinDeviceCount, | |
140 static_cast<int>(number_of_devices_)); | |
mcasas
2016/10/25 22:13:12
One line less if we do:
number_of_devices_ =
aleksandar.stojiljkovic
2016/10/25 23:20:40
Done.
| |
141 } | |
112 } | 142 } |
113 } | 143 } |
114 } | 144 } |
115 | 145 |
116 } // namespace media | 146 } // namespace media |
OLD | NEW |