OLD | NEW |
| (Empty) |
1 /* | |
2 * libjingle | |
3 * Copyright 2008 Google Inc. | |
4 * | |
5 * Redistribution and use in source and binary forms, with or without | |
6 * modification, are permitted provided that the following conditions are met: | |
7 * | |
8 * 1. Redistributions of source code must retain the above copyright notice, | |
9 * this list of conditions and the following disclaimer. | |
10 * 2. Redistributions in binary form must reproduce the above copyright notice, | |
11 * this list of conditions and the following disclaimer in the documentation | |
12 * and/or other materials provided with the distribution. | |
13 * 3. The name of the author may not be used to endorse or promote products | |
14 * derived from this software without specific prior written permission. | |
15 * | |
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED | |
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | |
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO | |
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | |
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; | |
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, | |
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR | |
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF | |
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
26 */ | |
27 | |
28 #ifndef TALK_MEDIA_DEVICES_FAKEDEVICEMANAGER_H_ | |
29 #define TALK_MEDIA_DEVICES_FAKEDEVICEMANAGER_H_ | |
30 | |
31 #include <string> | |
32 #include <vector> | |
33 | |
34 #include "talk/media/base/fakevideocapturer.h" | |
35 #include "talk/media/base/mediacommon.h" | |
36 #include "talk/media/devices/devicemanager.h" | |
37 #include "webrtc/base/scoped_ptr.h" | |
38 #include "webrtc/base/window.h" | |
39 #include "webrtc/base/windowpicker.h" | |
40 | |
41 namespace cricket { | |
42 | |
43 class FakeDeviceManager : public DeviceManagerInterface { | |
44 public: | |
45 FakeDeviceManager() {} | |
46 virtual bool Init() { | |
47 return true; | |
48 } | |
49 virtual void Terminate() { | |
50 } | |
51 virtual int GetCapabilities() { | |
52 std::vector<Device> devices; | |
53 int caps = VIDEO_RECV; | |
54 if (!input_devices_.empty()) { | |
55 caps |= AUDIO_SEND; | |
56 } | |
57 if (!output_devices_.empty()) { | |
58 caps |= AUDIO_RECV; | |
59 } | |
60 if (!vidcap_devices_.empty()) { | |
61 caps |= VIDEO_SEND; | |
62 } | |
63 return caps; | |
64 } | |
65 virtual bool GetAudioInputDevices(std::vector<Device>* devs) { | |
66 *devs = input_devices_; | |
67 return true; | |
68 } | |
69 virtual bool GetAudioOutputDevices(std::vector<Device>* devs) { | |
70 *devs = output_devices_; | |
71 return true; | |
72 } | |
73 virtual bool GetAudioInputDevice(const std::string& name, Device* out) { | |
74 return GetAudioDevice(true, name, out); | |
75 } | |
76 virtual bool GetAudioOutputDevice(const std::string& name, Device* out) { | |
77 return GetAudioDevice(false, name, out); | |
78 } | |
79 virtual bool GetVideoCaptureDevices(std::vector<Device>* devs) { | |
80 *devs = vidcap_devices_; | |
81 return true; | |
82 } | |
83 virtual void SetVideoDeviceCapturerFactory( | |
84 VideoDeviceCapturerFactory* video_device_capturer_factory) { | |
85 } | |
86 virtual void SetScreenCapturerFactory( | |
87 ScreenCapturerFactory* screen_capturer_factory) { | |
88 screen_capturer_factory_.reset(screen_capturer_factory); | |
89 } | |
90 virtual void SetVideoCaptureDeviceMaxFormat(const std::string& usb_id, | |
91 const VideoFormat& max_format) { | |
92 max_formats_[usb_id] = max_format; | |
93 } | |
94 bool IsMaxFormatForDevice(const std::string& usb_id, | |
95 const VideoFormat& max_format) const { | |
96 std::map<std::string, VideoFormat>::const_iterator found = | |
97 max_formats_.find(usb_id); | |
98 return (found != max_formats_.end()) ? | |
99 max_format == found->second : | |
100 false; | |
101 } | |
102 virtual void ClearVideoCaptureDeviceMaxFormat(const std::string& usb_id) { | |
103 max_formats_.erase(usb_id); | |
104 } | |
105 virtual VideoCapturer* CreateVideoCapturer(const Device& device) const { | |
106 return new FakeVideoCapturer(); | |
107 } | |
108 virtual VideoCapturer* CreateScreenCapturer( | |
109 const ScreencastId& screenid) const { | |
110 if (!screen_capturer_factory_) { | |
111 return new FakeVideoCapturer(); | |
112 } | |
113 return screen_capturer_factory_->Create(screenid); | |
114 } | |
115 virtual bool GetWindows( | |
116 std::vector<rtc::WindowDescription>* descriptions) { | |
117 descriptions->clear(); | |
118 const uint32_t id = 1u; // Note that 0 is not a valid ID. | |
119 const rtc::WindowId window_id = | |
120 rtc::WindowId::Cast(id); | |
121 std::string title = "FakeWindow"; | |
122 rtc::WindowDescription window_description(window_id, title); | |
123 descriptions->push_back(window_description); | |
124 return true; | |
125 } | |
126 virtual VideoCapturer* CreateWindowCapturer(rtc::WindowId window) { | |
127 if (!window.IsValid()) { | |
128 return NULL; | |
129 } | |
130 return new FakeVideoCapturer; | |
131 } | |
132 virtual bool GetDesktops( | |
133 std::vector<rtc::DesktopDescription>* descriptions) { | |
134 descriptions->clear(); | |
135 const int id = 0; | |
136 const int valid_index = 0; | |
137 const rtc::DesktopId desktop_id = | |
138 rtc::DesktopId::Cast(id, valid_index); | |
139 std::string title = "FakeDesktop"; | |
140 rtc::DesktopDescription desktop_description(desktop_id, title); | |
141 descriptions->push_back(desktop_description); | |
142 return true; | |
143 } | |
144 virtual VideoCapturer* CreateDesktopCapturer(rtc::DesktopId desktop) { | |
145 if (!desktop.IsValid()) { | |
146 return NULL; | |
147 } | |
148 return new FakeVideoCapturer; | |
149 } | |
150 | |
151 virtual bool GetDefaultVideoCaptureDevice(Device* device) { | |
152 if (vidcap_devices_.empty()) { | |
153 return false; | |
154 } | |
155 *device = vidcap_devices_[0]; | |
156 return true; | |
157 } | |
158 | |
159 #if defined(WEBRTC_MAC) && !defined(WEBRTC_IOS) | |
160 bool QtKitToSgDevice(const std::string& qtkit_name, Device* out) { | |
161 out->name = qtkit_name; | |
162 out->id = "sg:" + qtkit_name; | |
163 return true; | |
164 } | |
165 #endif | |
166 | |
167 void SetAudioInputDevices(const std::vector<std::string>& devices) { | |
168 input_devices_.clear(); | |
169 for (size_t i = 0; i < devices.size(); ++i) { | |
170 input_devices_.push_back(Device(devices[i], | |
171 static_cast<int>(i))); | |
172 } | |
173 SignalDevicesChange(); | |
174 } | |
175 void SetAudioOutputDevices(const std::vector<std::string>& devices) { | |
176 output_devices_.clear(); | |
177 for (size_t i = 0; i < devices.size(); ++i) { | |
178 output_devices_.push_back(Device(devices[i], | |
179 static_cast<int>(i))); | |
180 } | |
181 SignalDevicesChange(); | |
182 } | |
183 void SetVideoCaptureDevices(const std::vector<std::string>& devices) { | |
184 vidcap_devices_.clear(); | |
185 for (size_t i = 0; i < devices.size(); ++i) { | |
186 vidcap_devices_.push_back(Device(devices[i], | |
187 static_cast<int>(i))); | |
188 } | |
189 SignalDevicesChange(); | |
190 } | |
191 virtual bool GetVideoCaptureDevice(const std::string& name, | |
192 Device* out) { | |
193 if (vidcap_devices_.empty()) | |
194 return false; | |
195 | |
196 // If the name is empty, return the default device. | |
197 if (name.empty() || name == kDefaultDeviceName) { | |
198 *out = vidcap_devices_[0]; | |
199 return true; | |
200 } | |
201 | |
202 return FindDeviceByName(vidcap_devices_, name, out); | |
203 } | |
204 bool GetAudioDevice(bool is_input, const std::string& name, | |
205 Device* out) { | |
206 // If the name is empty, return the default device. | |
207 if (name.empty() || name == kDefaultDeviceName) { | |
208 *out = Device(name, -1); | |
209 return true; | |
210 } | |
211 | |
212 return FindDeviceByName((is_input ? input_devices_ : output_devices_), | |
213 name, out); | |
214 } | |
215 static bool FindDeviceByName(const std::vector<Device>& devices, | |
216 const std::string& name, | |
217 Device* out) { | |
218 for (std::vector<Device>::const_iterator it = devices.begin(); | |
219 it != devices.end(); ++it) { | |
220 if (name == it->name) { | |
221 *out = *it; | |
222 return true; | |
223 } | |
224 } | |
225 return false; | |
226 } | |
227 | |
228 private: | |
229 std::vector<Device> input_devices_; | |
230 std::vector<Device> output_devices_; | |
231 std::vector<Device> vidcap_devices_; | |
232 std::map<std::string, VideoFormat> max_formats_; | |
233 rtc::scoped_ptr< | |
234 ScreenCapturerFactory> screen_capturer_factory_; | |
235 }; | |
236 | |
237 } // namespace cricket | |
238 | |
239 #endif // TALK_MEDIA_DEVICES_FAKEDEVICEMANAGER_H_ | |
OLD | NEW |