2 * Copyright (C) 2015 Tim Mayberry <mojofunk@gmail.com>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "pbd/error.h"
26 #include "pbd/compose.h"
27 #include "pbd/windows_timer_utils.h"
29 #include "winmmemidi_io.h"
34 using namespace ARDOUR;
36 WinMMEMidiIO::WinMMEMidiIO()
40 , m_changed_callback (0)
43 pthread_mutex_init (&m_device_lock, 0);
46 WinMMEMidiIO::~WinMMEMidiIO()
48 pthread_mutex_lock (&m_device_lock);
50 pthread_mutex_unlock (&m_device_lock);
51 pthread_mutex_destroy (&m_device_lock);
55 WinMMEMidiIO::cleanup()
57 DEBUG_MIDI ("MIDI cleanup\n");
60 destroy_input_devices ();
61 destroy_output_devices ();
65 WinMMEMidiIO::dequeue_input_event (uint32_t port,
66 uint64_t timestamp_start,
67 uint64_t timestamp_end,
75 assert(port < m_inputs.size());
77 // m_inputs access should be protected by trylock
78 return m_inputs[port]->dequeue_midi_event (
79 timestamp_start, timestamp_end, timestamp, d, s);
83 WinMMEMidiIO::enqueue_output_event (uint32_t port,
91 assert(port < m_outputs.size());
93 // m_outputs access should be protected by trylock
94 return m_outputs[port]->enqueue_midi_event (timestamp, d, s);
99 WinMMEMidiIO::port_id (uint32_t port, bool input)
101 std::stringstream ss;
104 ss << "system:midi_capture_";
107 ss << "system:midi_playback_";
113 std::string WinMMEMidiIO::port_name(uint32_t port, bool input)
116 if (port < m_inputs.size ()) {
117 return m_inputs[port]->name ();
120 if (port < m_outputs.size ()) {
121 return m_outputs[port]->name ();
128 WinMMEMidiIO::start ()
131 DEBUG_MIDI ("MIDI driver already started\n");
136 DEBUG_MIDI ("Starting MIDI driver\n");
138 PBD::MMTIMERS::set_min_resolution();
145 WinMMEMidiIO::stop ()
148 DEBUG_MIDI ("MIDI driver already stopped\n");
151 DEBUG_MIDI ("Stopping MIDI driver\n");
154 pthread_mutex_lock (&m_device_lock);
156 pthread_mutex_unlock (&m_device_lock);
158 PBD::MMTIMERS::reset_resolution();
162 WinMMEMidiIO::start_devices ()
164 for (std::vector<WinMMEMidiInputDevice*>::iterator i = m_inputs.begin ();
167 if (!(*i)->start ()) {
168 PBD::error << string_compose (_("Unable to start MIDI input device %1\n"),
169 (*i)->name ()) << endmsg;
172 for (std::vector<WinMMEMidiOutputDevice*>::iterator i = m_outputs.begin ();
175 if (!(*i)->start ()) {
176 PBD::error << string_compose (_ ("Unable to start MIDI output device %1\n"),
177 (*i)->name ()) << endmsg;
183 WinMMEMidiIO::stop_devices ()
185 for (std::vector<WinMMEMidiInputDevice*>::iterator i = m_inputs.begin ();
188 if (!(*i)->stop ()) {
189 PBD::error << string_compose (_ ("Unable to stop MIDI input device %1\n"),
190 (*i)->name ()) << endmsg;
193 for (std::vector<WinMMEMidiOutputDevice*>::iterator i = m_outputs.begin ();
196 if (!(*i)->stop ()) {
197 PBD::error << string_compose (_ ("Unable to stop MIDI output device %1\n"),
198 (*i)->name ()) << endmsg;
204 WinMMEMidiIO::clear_device_info ()
206 for (std::vector<MidiDeviceInfo*>::iterator i = m_device_info.begin();
207 i != m_device_info.end();
211 m_device_info.clear();
215 WinMMEMidiIO::get_input_name_from_index (int index, std::string& name)
217 MIDIINCAPS capabilities;
218 MMRESULT result = midiInGetDevCaps(index, &capabilities, sizeof(capabilities));
219 if (result == MMSYSERR_NOERROR) {
220 name = capabilities.szPname;
227 WinMMEMidiIO::get_output_name_from_index (int index, std::string& name)
229 MIDIOUTCAPS capabilities;
230 MMRESULT result = midiOutGetDevCaps(index, &capabilities, sizeof(capabilities));
231 if (result == MMSYSERR_NOERROR) {
232 name = capabilities.szPname;
239 WinMMEMidiIO::update_device_info ()
241 std::set<std::string> device_names;
243 int in_count = midiInGetNumDevs ();
245 for (int i = 0; i < in_count; ++i) {
246 std::string input_name;
247 if (get_input_name_from_index(i, input_name)) {
248 device_names.insert(input_name);
252 int out_count = midiOutGetNumDevs ();
254 for (int i = 0; i < out_count; ++i) {
255 std::string output_name;
256 if (get_output_name_from_index(i, output_name)) {
257 device_names.insert(output_name);
261 clear_device_info ();
263 for (std::set<std::string>::const_iterator i = device_names.begin();
264 i != device_names.end();
266 m_device_info.push_back(new MidiDeviceInfo(*i));
271 WinMMEMidiIO::get_device_info (const std::string& name)
273 for (std::vector<MidiDeviceInfo*>::const_iterator i = m_device_info.begin();
274 i != m_device_info.end();
276 if ((*i)->device_name == name) {
284 WinMMEMidiIO::create_input_devices ()
286 int srcCount = midiInGetNumDevs ();
288 DEBUG_MIDI (string_compose ("MidiIn count: %1\n", srcCount));
290 for (int i = 0; i < srcCount; ++i) {
291 std::string input_name;
292 if (!get_input_name_from_index (i, input_name)) {
293 DEBUG_MIDI ("Unable to get MIDI input name from index\n");
297 MidiDeviceInfo* info = get_device_info (input_name);
300 DEBUG_MIDI ("Unable to MIDI device info from name\n");
305 DEBUG_MIDI(string_compose(
306 "MIDI input device %1 not enabled, not opening device\n", input_name));
311 WinMMEMidiInputDevice* midi_input = new WinMMEMidiInputDevice (i);
313 m_inputs.push_back (midi_input);
317 DEBUG_MIDI ("Unable to create MIDI input\n");
323 WinMMEMidiIO::create_output_devices ()
325 int dstCount = midiOutGetNumDevs ();
327 DEBUG_MIDI (string_compose ("MidiOut count: %1\n", dstCount));
329 for (int i = 0; i < dstCount; ++i) {
330 std::string output_name;
331 if (!get_output_name_from_index (i, output_name)) {
332 DEBUG_MIDI ("Unable to get MIDI output name from index\n");
336 MidiDeviceInfo* info = get_device_info (output_name);
339 DEBUG_MIDI ("Unable to MIDI device info from name\n");
344 DEBUG_MIDI(string_compose(
345 "MIDI output device %1 not enabled, not opening device\n", output_name));
350 WinMMEMidiOutputDevice* midi_output = new WinMMEMidiOutputDevice(i);
352 m_outputs.push_back(midi_output);
355 DEBUG_MIDI ("Unable to create MIDI output\n");
362 WinMMEMidiIO::destroy_input_devices ()
364 while (!m_inputs.empty ()) {
365 WinMMEMidiInputDevice* midi_input = m_inputs.back ();
366 // assert(midi_input->stopped ());
367 m_inputs.pop_back ();
373 WinMMEMidiIO::destroy_output_devices ()
375 while (!m_outputs.empty ()) {
376 WinMMEMidiOutputDevice* midi_output = m_outputs.back ();
377 // assert(midi_output->stopped ());
378 m_outputs.pop_back ();
384 WinMMEMidiIO::discover()
390 if (pthread_mutex_trylock (&m_device_lock)) {
396 create_input_devices ();
397 create_output_devices ();
399 if (!(m_inputs.size () || m_outputs.size ())) {
400 DEBUG_MIDI ("No midi inputs or outputs\n");
401 pthread_mutex_unlock (&m_device_lock);
405 DEBUG_MIDI (string_compose ("Discovered %1 inputs and %2 outputs\n",
409 if (m_changed_callback) {
410 m_changed_callback(m_changed_arg);
414 pthread_mutex_unlock (&m_device_lock);