OLD | NEW |
---|---|
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 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/midi/dynamically_initialized_midi_manager_win.h" | 5 #include "media/midi/dynamically_initialized_midi_manager_win.h" |
6 | 6 |
7 #include <windows.h> | 7 #include <windows.h> |
8 | 8 |
9 #include <mmreg.h> | 9 #include <mmreg.h> |
10 #include <mmsystem.h> | 10 #include <mmsystem.h> |
11 | 11 |
12 #include <algorithm> | 12 #include <algorithm> |
13 #include <string> | 13 #include <string> |
14 | 14 |
15 #include "base/callback.h" | 15 #include "base/callback.h" |
16 #include "base/logging.h" | 16 #include "base/logging.h" |
17 #include "base/memory/ptr_util.h" | 17 #include "base/memory/ptr_util.h" |
18 #include "base/strings/string16.h" | 18 #include "base/strings/string16.h" |
19 #include "base/strings/stringprintf.h" | 19 #include "base/strings/stringprintf.h" |
20 #include "base/strings/utf_string_conversions.h" | 20 #include "base/strings/utf_string_conversions.h" |
21 #include "base/synchronization/lock.h" | 21 #include "base/synchronization/lock.h" |
22 #include "media/midi/midi_port_info.h" | 22 #include "media/midi/midi_port_info.h" |
23 #include "media/midi/midi_service.h" | 23 #include "media/midi/midi_service.h" |
24 | 24 |
25 namespace midi { | 25 namespace midi { |
26 | 26 |
27 namespace { | 27 namespace { |
28 | 28 |
29 // Assumes that nullptr represents an invalid MIDI handle. | |
30 constexpr HMIDIIN kInvalidInHandle = nullptr; | |
31 constexpr HMIDIOUT kInvalidOutHandle = nullptr; | |
32 | |
29 // Global variables to identify MidiManager instance. | 33 // Global variables to identify MidiManager instance. |
30 constexpr int kInvalidInstanceId = -1; | 34 constexpr int kInvalidInstanceId = -1; |
31 int g_active_instance_id = kInvalidInstanceId; | 35 int g_active_instance_id = kInvalidInstanceId; |
32 DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr; | 36 DynamicallyInitializedMidiManagerWin* g_manager_instance = nullptr; |
33 | 37 |
34 // Obtains base::Lock instance pointer to lock instance_id. | 38 // Obtains base::Lock instance pointer to lock instance_id. |
35 base::Lock* GetInstanceIdLock() { | 39 base::Lock* GetInstanceIdLock() { |
36 static base::Lock* lock = new base::Lock; | 40 static base::Lock* lock = new base::Lock; |
37 return lock; | 41 return lock; |
38 } | 42 } |
39 | 43 |
40 // Issues unique MidiManager instance ID. | 44 // Issues unique MidiManager instance ID. |
41 int IssueNextInstanceId() { | 45 int IssueNextInstanceId() { |
42 static int id = kInvalidInstanceId; | 46 static int id = kInvalidInstanceId; |
43 return ++id; | 47 return ++id; |
44 } | 48 } |
45 | 49 |
46 // Use single TaskRunner for all tasks running outside the I/O thread. | 50 // Use single TaskRunner for all tasks running outside the I/O thread. |
47 constexpr int kTaskRunner = 0; | 51 constexpr int kTaskRunner = 0; |
48 | 52 |
49 // Obtains base::Lock instance pointer to ensure tasks run safely on TaskRunner. | 53 // Obtains base::Lock instance pointer to ensure tasks run safely on TaskRunner. |
54 // Since all tasks on TaskRunner run behind a lock of *GetTaskLock(), we can | |
55 // access all members even on the I/O thread if a lock of *GetTaskLock() is | |
56 // obtained. | |
50 base::Lock* GetTaskLock() { | 57 base::Lock* GetTaskLock() { |
51 static base::Lock* lock = new base::Lock; | 58 static base::Lock* lock = new base::Lock; |
52 return lock; | 59 return lock; |
53 } | 60 } |
54 | 61 |
55 // Helper function to run a posted task on TaskRunner safely. | 62 // Helper function to run a posted task on TaskRunner safely. |
56 void RunTask(int instance_id, const base::Closure& task) { | 63 void RunTask(int instance_id, const base::Closure& task) { |
57 // Obtains task lock to ensure that the instance should not complete | 64 // Obtains task lock to ensure that the instance should not complete |
58 // Finalize() while running the |task|. | 65 // Finalize() while running the |task|. |
59 base::AutoLock task_lock(*GetTaskLock()); | 66 base::AutoLock task_lock(*GetTaskLock()); |
60 { | 67 { |
61 // If Finalize() finished before the lock avobe, do nothing. | 68 // If Finalize() finished before the lock avobe, do nothing. |
62 base::AutoLock lock(*GetInstanceIdLock()); | 69 base::AutoLock lock(*GetInstanceIdLock()); |
63 if (instance_id != g_active_instance_id) | 70 if (instance_id != g_active_instance_id) |
64 return; | 71 return; |
65 } | 72 } |
66 task.Run(); | 73 task.Run(); |
67 } | 74 } |
68 | 75 |
69 // TODO(toyoshim): Factor out TaskRunner related functionaliries above, and | 76 // TODO(toyoshim): Factor out TaskRunner related functionaliries above, and |
70 // deprecate MidiScheduler. It should be available via MidiManager::scheduler(). | 77 // deprecate MidiScheduler. It should be available via MidiManager::scheduler(). |
71 | 78 |
79 // Helper functions to close MIDI device handles on TaskRunner asynchronously. | |
80 void FinalizeInPort(HMIDIIN handle) { | |
81 midiInClose(handle); | |
82 } | |
83 | |
84 void FinalizeOutPort(HMIDIOUT handle) { | |
85 midiOutClose(handle); | |
86 } | |
87 | |
88 // Handles MIDI input port callbacks that runs on a system provided thread. | |
89 void CALLBACK HandleMidiInCallback(HMIDIIN hmi, | |
90 UINT msg, | |
91 DWORD_PTR instance, | |
92 DWORD_PTR param1, | |
93 DWORD_PTR param2) { | |
94 // TODO(toyoshim): Following patches will implement actual functions. | |
95 } | |
96 | |
97 // Handles MIDI output port callbacks that runs on a system provided thread. | |
98 void CALLBACK HandleMidiOutCallback(HMIDIOUT hmo, | |
99 UINT msg, | |
100 DWORD_PTR instance, | |
101 DWORD_PTR param1, | |
102 DWORD_PTR param2) { | |
103 // TODO(toyoshim): Following patches will implement actual functions. | |
104 } | |
105 | |
106 // All instances of Port subclasses are always accessed behind a lock of | |
107 // *GetTaskLock(). Port and subclasses implementation do not need to | |
108 // consider thread safety. | |
72 class Port { | 109 class Port { |
73 public: | 110 public: |
74 Port(const std::string& type, | 111 Port(const std::string& type, |
75 uint32_t device_id, | 112 uint32_t device_id, |
76 uint16_t manufacturer_id, | 113 uint16_t manufacturer_id, |
77 uint16_t product_id, | 114 uint16_t product_id, |
78 uint32_t driver_version, | 115 uint32_t driver_version, |
79 const std::string& product_name) | 116 const std::string& product_name) |
80 : index_(0u), | 117 : index_(0u), |
81 type_(type), | 118 type_(type), |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
155 // TODO(toyoshim): Following patches will implement actual functions. | 192 // TODO(toyoshim): Following patches will implement actual functions. |
156 class DynamicallyInitializedMidiManagerWin::InPort final : public Port { | 193 class DynamicallyInitializedMidiManagerWin::InPort final : public Port { |
157 public: | 194 public: |
158 InPort(UINT device_id, const MIDIINCAPS2W& caps) | 195 InPort(UINT device_id, const MIDIINCAPS2W& caps) |
159 : Port("input", | 196 : Port("input", |
160 device_id, | 197 device_id, |
161 caps.wMid, | 198 caps.wMid, |
162 caps.wPid, | 199 caps.wPid, |
163 caps.vDriverVersion, | 200 caps.vDriverVersion, |
164 base::WideToUTF8( | 201 base::WideToUTF8( |
165 base::string16(caps.szPname, wcslen(caps.szPname)))) {} | 202 base::string16(caps.szPname, wcslen(caps.szPname)))), |
203 in_handle_(kInvalidInHandle) {} | |
166 | 204 |
167 static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts() { | 205 static std::vector<std::unique_ptr<InPort>> EnumerateActivePorts() { |
168 std::vector<std::unique_ptr<InPort>> ports; | 206 std::vector<std::unique_ptr<InPort>> ports; |
169 const UINT num_devices = midiInGetNumDevs(); | 207 const UINT num_devices = midiInGetNumDevs(); |
170 for (UINT device_id = 0; device_id < num_devices; ++device_id) { | 208 for (UINT device_id = 0; device_id < num_devices; ++device_id) { |
171 MIDIINCAPS2W caps; | 209 MIDIINCAPS2W caps; |
172 MMRESULT result = midiInGetDevCaps( | 210 MMRESULT result = midiInGetDevCaps( |
173 device_id, reinterpret_cast<LPMIDIINCAPSW>(&caps), sizeof(caps)); | 211 device_id, reinterpret_cast<LPMIDIINCAPSW>(&caps), sizeof(caps)); |
174 if (result != MMSYSERR_NOERROR) { | 212 if (result != MMSYSERR_NOERROR) { |
175 LOG(ERROR) << "midiInGetDevCaps fails on device " << device_id; | 213 LOG(ERROR) << "midiInGetDevCaps fails on device " << device_id; |
176 continue; | 214 continue; |
177 } | 215 } |
178 ports.push_back(base::MakeUnique<InPort>(device_id, caps)); | 216 ports.push_back(base::MakeUnique<InPort>(device_id, caps)); |
179 } | 217 } |
180 return ports; | 218 return ports; |
181 } | 219 } |
182 | 220 |
221 void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) { | |
222 if (in_handle_ != kInvalidInHandle) { | |
223 runner->PostTask(FROM_HERE, base::Bind(&FinalizeInPort, in_handle_)); | |
yhirano
2017/02/24 04:18:05
in_handle_ = kInvalidInHandle;
Takashi Toyoshima
2017/02/24 06:17:56
this is not mandatory, but ok just in case.
| |
224 } | |
225 } | |
226 | |
183 void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) { | 227 void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) { |
184 manager->PostReplyTask( | 228 manager->PostReplyTask( |
185 base::Bind(&DynamicallyInitializedMidiManagerWin::SetInputPortState, | 229 base::Bind(&DynamicallyInitializedMidiManagerWin::SetInputPortState, |
186 base::Unretained(manager), index_, info_.state)); | 230 base::Unretained(manager), index_, info_.state)); |
187 } | 231 } |
188 | 232 |
189 void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) { | 233 void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) { |
190 manager->PostReplyTask( | 234 manager->PostReplyTask( |
191 base::Bind(&DynamicallyInitializedMidiManagerWin::AddInputPort, | 235 base::Bind(&DynamicallyInitializedMidiManagerWin::AddInputPort, |
192 base::Unretained(manager), info_)); | 236 base::Unretained(manager), info_)); |
193 } | 237 } |
238 | |
239 // Port overrides: | |
240 bool Disconnect() override { | |
241 if (in_handle_ != kInvalidInHandle) { | |
242 // Following API call may fail because device was already disconnected. | |
243 // But just in case. | |
244 midiInClose(in_handle_); | |
245 in_handle_ = kInvalidInHandle; | |
246 } | |
247 return Port::Disconnect(); | |
248 } | |
249 | |
250 void Open() override { | |
251 // TODO(toyoshim): Pass instance_id to implement HandleMidiInCallback. | |
Takashi Toyoshima
2017/02/24 06:17:56
Just in case, |instance_id| is needed only by call
| |
252 MMRESULT result = | |
253 midiInOpen(&in_handle_, device_id_, | |
254 reinterpret_cast<DWORD_PTR>(&HandleMidiInCallback), 0, | |
255 CALLBACK_FUNCTION); | |
256 if (result == MMSYSERR_NOERROR) | |
257 Port::Open(); | |
258 else | |
yhirano
2017/02/24 04:18:05
Why isn't this symmetric to OutPort::Open?
Takashi Toyoshima
2017/02/24 06:17:56
Ah, I set kInvalidOutHandle for OutPort::Open just
| |
259 Disconnect(); | |
260 } | |
261 | |
262 private: | |
263 HMIDIIN in_handle_; | |
194 }; | 264 }; |
195 | 265 |
196 // TODO(toyoshim): Following patches will implement actual functions. | 266 // TODO(toyoshim): Following patches will implement actual functions. |
197 class DynamicallyInitializedMidiManagerWin::OutPort final : public Port { | 267 class DynamicallyInitializedMidiManagerWin::OutPort final : public Port { |
198 public: | 268 public: |
199 OutPort(UINT device_id, const MIDIOUTCAPS2W& caps) | 269 OutPort(UINT device_id, const MIDIOUTCAPS2W& caps) |
200 : Port("output", | 270 : Port("output", |
201 device_id, | 271 device_id, |
202 caps.wMid, | 272 caps.wMid, |
203 caps.wPid, | 273 caps.wPid, |
204 caps.vDriverVersion, | 274 caps.vDriverVersion, |
205 base::WideToUTF8( | 275 base::WideToUTF8( |
206 base::string16(caps.szPname, wcslen(caps.szPname)))), | 276 base::string16(caps.szPname, wcslen(caps.szPname)))), |
207 software_(caps.wTechnology == MOD_SWSYNTH) {} | 277 software_(caps.wTechnology == MOD_SWSYNTH), |
278 out_handle_(kInvalidOutHandle) {} | |
208 | 279 |
209 static std::vector<std::unique_ptr<OutPort>> EnumerateActivePorts() { | 280 static std::vector<std::unique_ptr<OutPort>> EnumerateActivePorts() { |
210 std::vector<std::unique_ptr<OutPort>> ports; | 281 std::vector<std::unique_ptr<OutPort>> ports; |
211 const UINT num_devices = midiOutGetNumDevs(); | 282 const UINT num_devices = midiOutGetNumDevs(); |
212 for (UINT device_id = 0; device_id < num_devices; ++device_id) { | 283 for (UINT device_id = 0; device_id < num_devices; ++device_id) { |
213 MIDIOUTCAPS2W caps; | 284 MIDIOUTCAPS2W caps; |
214 MMRESULT result = midiOutGetDevCaps( | 285 MMRESULT result = midiOutGetDevCaps( |
215 device_id, reinterpret_cast<LPMIDIOUTCAPSW>(&caps), sizeof(caps)); | 286 device_id, reinterpret_cast<LPMIDIOUTCAPSW>(&caps), sizeof(caps)); |
216 if (result != MMSYSERR_NOERROR) { | 287 if (result != MMSYSERR_NOERROR) { |
217 LOG(ERROR) << "midiOutGetDevCaps fails on device " << device_id; | 288 LOG(ERROR) << "midiOutGetDevCaps fails on device " << device_id; |
218 continue; | 289 continue; |
219 } | 290 } |
220 ports.push_back(base::MakeUnique<OutPort>(device_id, caps)); | 291 ports.push_back(base::MakeUnique<OutPort>(device_id, caps)); |
221 } | 292 } |
222 return ports; | 293 return ports; |
223 } | 294 } |
224 | 295 |
296 void Finalize(scoped_refptr<base::SingleThreadTaskRunner> runner) { | |
297 if (out_handle_ != kInvalidOutHandle) | |
298 runner->PostTask(FROM_HERE, base::Bind(&FinalizeOutPort, out_handle_)); | |
yhirano
2017/02/24 04:18:05
out_handle_ = kInvalidOutHandle;
Takashi Toyoshima
2017/02/24 06:17:56
Acknowledged.
| |
299 } | |
300 | |
301 void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) { | |
302 manager->PostReplyTask( | |
303 base::Bind(&DynamicallyInitializedMidiManagerWin::SetOutputPortState, | |
304 base::Unretained(manager), index_, info_.state)); | |
305 } | |
306 | |
307 void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) { | |
308 manager->PostReplyTask( | |
309 base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort, | |
310 base::Unretained(manager), info_)); | |
311 } | |
312 | |
225 // Port overrides: | 313 // Port overrides: |
226 bool Connect() override { | 314 bool Connect() override { |
227 // Until |software| option is supported, disable Microsoft GS Wavetable | 315 // Until |software| option is supported, disable Microsoft GS Wavetable |
228 // Synth that has a known security issue. | 316 // Synth that has a known security issue. |
229 if (software_ && manufacturer_id_ == MM_MICROSOFT && | 317 if (software_ && manufacturer_id_ == MM_MICROSOFT && |
230 (product_id_ == MM_MSFT_WDMAUDIO_MIDIOUT || | 318 (product_id_ == MM_MSFT_WDMAUDIO_MIDIOUT || |
231 product_id_ == MM_MSFT_GENERIC_MIDISYNTH)) { | 319 product_id_ == MM_MSFT_GENERIC_MIDISYNTH)) { |
232 return false; | 320 return false; |
233 } | 321 } |
234 return Port::Connect(); | 322 return Port::Connect(); |
235 } | 323 } |
236 | 324 |
237 // Port Overrides: | 325 bool Disconnect() override { |
238 void NotifyPortStateSet(DynamicallyInitializedMidiManagerWin* manager) { | 326 if (out_handle_ != kInvalidOutHandle) { |
239 manager->PostReplyTask( | 327 // Following API call may fail because device was already disconnected. |
240 base::Bind(&DynamicallyInitializedMidiManagerWin::SetOutputPortState, | 328 // But just in case. |
241 base::Unretained(manager), index_, info_.state)); | 329 midiOutClose(out_handle_); |
330 out_handle_ = kInvalidOutHandle; | |
331 } | |
332 return Port::Disconnect(); | |
242 } | 333 } |
243 | 334 |
244 void NotifyPortAdded(DynamicallyInitializedMidiManagerWin* manager) { | 335 void Open() override { |
245 manager->PostReplyTask( | 336 MMRESULT result = |
246 base::Bind(&DynamicallyInitializedMidiManagerWin::AddOutputPort, | 337 midiOutOpen(&out_handle_, device_id_, |
247 base::Unretained(manager), info_)); | 338 reinterpret_cast<DWORD_PTR>(&HandleMidiOutCallback), 0, |
339 CALLBACK_FUNCTION); | |
340 if (result == MMSYSERR_NOERROR) { | |
341 Port::Open(); | |
342 } else { | |
343 out_handle_ = kInvalidOutHandle; | |
344 Disconnect(); | |
345 } | |
248 } | 346 } |
249 | 347 |
250 const bool software_; | 348 const bool software_; |
349 HMIDIOUT out_handle_; | |
251 }; | 350 }; |
252 | 351 |
253 DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin( | 352 DynamicallyInitializedMidiManagerWin::DynamicallyInitializedMidiManagerWin( |
254 MidiService* service) | 353 MidiService* service) |
255 : MidiManager(service), instance_id_(IssueNextInstanceId()) { | 354 : MidiManager(service), instance_id_(IssueNextInstanceId()) { |
256 base::AutoLock lock(*GetInstanceIdLock()); | 355 base::AutoLock lock(*GetInstanceIdLock()); |
257 CHECK_EQ(kInvalidInstanceId, g_active_instance_id); | 356 CHECK_EQ(kInvalidInstanceId, g_active_instance_id); |
258 | 357 |
259 // Obtains the task runner for the current thread that hosts this instnace. | 358 // Obtains the task runner for the current thread that hosts this instnace. |
260 thread_runner_ = base::ThreadTaskRunnerHandle::Get(); | 359 thread_runner_ = base::ThreadTaskRunnerHandle::Get(); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
297 base::AutoLock lock(*GetInstanceIdLock()); | 396 base::AutoLock lock(*GetInstanceIdLock()); |
298 CHECK_EQ(instance_id_, g_active_instance_id); | 397 CHECK_EQ(instance_id_, g_active_instance_id); |
299 g_active_instance_id = kInvalidInstanceId; | 398 g_active_instance_id = kInvalidInstanceId; |
300 CHECK_EQ(this, g_manager_instance); | 399 CHECK_EQ(this, g_manager_instance); |
301 g_manager_instance = nullptr; | 400 g_manager_instance = nullptr; |
302 } | 401 } |
303 | 402 |
304 // Ensures that no task runs on TaskRunner so to destruct the instance safely. | 403 // Ensures that no task runs on TaskRunner so to destruct the instance safely. |
305 // Tasks that did not started yet will do nothing after invalidate the | 404 // Tasks that did not started yet will do nothing after invalidate the |
306 // instance ID above. | 405 // instance ID above. |
406 // Behind the lock below, we can safely access all members for finalization | |
407 // even on the I/O thread. | |
307 base::AutoLock lock(*GetTaskLock()); | 408 base::AutoLock lock(*GetTaskLock()); |
409 | |
410 // Posts tasks that finalize each device port without MidiManager instance | |
411 // on TaskRunner. If another MidiManager instance is created, its | |
412 // initialization runs on the same task runner after all tasks posted here | |
413 // finish. | |
414 for (const auto& port : input_ports_) | |
415 port->Finalize(service()->GetTaskRunner(kTaskRunner)); | |
416 for (const auto& port : output_ports_) | |
417 port->Finalize(service()->GetTaskRunner(kTaskRunner)); | |
308 } | 418 } |
309 | 419 |
310 void DynamicallyInitializedMidiManagerWin::DispatchSendMidiData( | 420 void DynamicallyInitializedMidiManagerWin::DispatchSendMidiData( |
311 MidiManagerClient* client, | 421 MidiManagerClient* client, |
312 uint32_t port_index, | 422 uint32_t port_index, |
313 const std::vector<uint8_t>& data, | 423 const std::vector<uint8_t>& data, |
314 double timestamp) { | 424 double timestamp) { |
315 // TODO(toyoshim): Following patches will implement. | 425 // TODO(toyoshim): Following patches will implement. |
316 } | 426 } |
317 | 427 |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
391 size_t index = known_ports->size(); | 501 size_t index = known_ports->size(); |
392 port->set_index(index); | 502 port->set_index(index); |
393 known_ports->push_back(std::move(port)); | 503 known_ports->push_back(std::move(port)); |
394 (*known_ports)[index]->Connect(); | 504 (*known_ports)[index]->Connect(); |
395 (*known_ports)[index]->NotifyPortAdded(this); | 505 (*known_ports)[index]->NotifyPortAdded(this); |
396 } | 506 } |
397 } | 507 } |
398 } | 508 } |
399 | 509 |
400 } // namespace midi | 510 } // namespace midi |
OLD | NEW |