Using MIDI devices with the same name on Windows

[thammer]

Hi.

I'm developing a node.js app using JZZ.js. I have 2 MIDI devices with the same device name in Windows ("ZOOM MS Series"), and I would like to access both using JZZ,js.

If I loop through info().inputs, I can see both devices. The JZZ docs says I should be able to open the port by index. https://jazz-soft.net/doc/JZZ/midiin.html.

However, as far as I can see, even if I specify an index as parameter to the openMidiIn() function, JZZ looks up the device name and passes that to impl.plugin.MidiInOpen(), in line 923. So in jazz-midi, the plugin function napi_value MidiInOpen(napi_env env, napi_callback_info args) is always called with a string input, and as a result MidiInOpen(const char_type*, void*) is called, with the device name as parameter.

Since the jazz-midi library has a function that allows opening a MIDI device given an index, MidiInOpen(int, void*), I was hoping to be able to call that function from JZZ. As far as I can see that is not currently possible.

The only solution I've been able to come up with so far is for me to do a slight modification to JZZ.js so that if the user passes an index (number) to midiInOpen(), that index is sent to the plugin function napi_value MidiInOpen(napi_env env, napi_callback_info args), and MidiInOpen(int, void*) is called in jazz-midi.

I'm not sure that is the best approach. I'm concerned I might break something for other platforms than node.js/Windows. But that's what I'm currently exploring. I'm not there yet, but hope to be able to figure this out in a couple of days.

I'd appreciate any advice on how to proceed if anyone has experience with this. Otherwise, I'll just post my findings here as I stumble along :-).

[jazz-soft]

Hi! Thank you for asking!
I don't know any good solution for the current version of jazz-midi.
Hopefully I'll address this issue when the MIDI 2.0 version is ready...

[thammer]

I'm having a go at fixing it in JZZ.js, and the results look promising. I'll post a link to my branch in a fork soon, but I came across a peculiarity while debugging that it'd be nice to get some help figuring out.

If I call openMidiOut() with a number as parameter, I would expect _engine._openOut() to be called once, with the name of the synth to be opened as parameter. However, I see that _engine._openOut() is sometimes called multiple times, resulting in devices being opened that I haven't asked to be opened (impl.plugin.MidiOutOpen() is called on devices I haven't asked to be opened).

I haven't tracked down the cause yet, but one thing that keeps throwing me off is that when _filterList(q, _outs) is called with q equal to some number (for instance 0), _filterList does not return one item, as I would expect, but it returns a list of items starting from the given number and up to the length of _outs.

From _filterList() :

        for (n = 0; n < etc.length; n++) if (q[i] + '' === n + '' || q[i] === etc[n].name || (q[i] instanceof Object && q[i].name === etc[n].name)) {
          a.push(etc[n]);
          etc.splice(n, 1);
          n--;
        }

If q = [0], an array with the number 0 in it, a.push() will be called for all the remaining items in arr/etc. This is due to the "n--" line in the snippet above which will make sure q[i] + '' === n + '' will evaluate to true again and again as etc is traversed.

Is that the intended behavior?

Having _filterList() return only those items that match the given q would make more sense to me. So if q is 0, I would expect _filterList(0, _outs) to return _outs[0].

I'm still trying to wrap my head around the code in JZZ.js related to opening midi devices, so I might have misunderstood how the code is supposed to work :-).

[thammer]

The problem with openMidiOut() being called multiple times was a bug in my own code that incorrectly called port._break() even after opening a device succeeded.

That made me realize if I call openMidiOut() with a number as an argument, and opening that device fails, JZZ will continue trying to open devices after that number in the _outs list.

I'm guessing that isn't the intended behavior.

But it doesn't break anything for me. I would think it might confuse a user if he tries to open a device and he ends up getting the next device in the list instead of the one he asked for, if the device he asked for couldn't be opened.

[thammer]

I had a go at adding support for multiple MIDI devices with identical device names in JZZ.js, for node.js and the Jazz-Plugin and jazz-midi engines.

I modified _refresh() so that if multiple identical device names were encountered, the names in _engine._outs and _engine._ins were replaced with unique device names (adding " #2", " #3", etc. after the device name). I keep the original device name and the device index in the info object.

In the _engine._openIn() function, I check to see if the unique name and the original device name match. If they match, the device is opened using device name, just like before. If the names do not match, we have multiple devices with identical names and the device is opened using the device index.

This works fine for me, on Windows 10, running node.js, with three Zoom MS pedals connected - all of which report device name "ZOOM MS Series".

As far as I can see, I haven't broken anything, and the behavior for devices without identical names should be the same as before. The changed behavior only affects the Jazz-Plugin and jazz-midi engines for node.js, and the changes should only come into play if there are multiple devices with identical names connected, and only for the second, third, etc. devices. The first of the devices with identical names are opened using the name string, just as before..

When devices with identical names are disconnected or reconnected, using any of the other already opened devices with identical names might not work (depending on which device was removed). So the client code has to connect to the onChange event and open all the devices with identical names again. I'm currently looking into this, to see if any changes in JZZ.js is required, or if this can be handled purely on the client side. Aside from that, everything works as it should on my machine at least.

My changes to the JZZ.js library are here: https://github.com/thammer/JZZ/tree/feature/support-identical-device-names

The test-identical-device-names.js file is an example demonstrating how this works.

I'd be very happy to tidy it up and submit a PR for you if you're interested in incorporating these changes into JZZ.js.

[thammer]

Here's the output when I run test-identical-device-names.js:

C:\Program Files\nodejs\node.exe .\test-identical-device-names.js
Inputs:
  0: ZOOM MS Series
  1: ZOOM MS Series #2
  2: ZOOM MS Series #3
Outputs:
  0: Microsoft GS Wavetable Synth
  1: ZOOM MS Series
  2: ZOOM MS Series #2
  3: ZOOM MS Series #3
Listening for MIDI input
  Opened MIDI in device ZOOM MS Series using name -> ZOOM MS Series
  Listening for incoming MIDI messages from device 0: ZOOM MS Series
  Opened MIDI in device ZOOM MS Series #2 using index 1 -> ZOOM MS Series
  Listening for incoming MIDI messages from device 1: ZOOM MS Series #2
  Opened MIDI in device ZOOM MS Series #3 using index 2 -> ZOOM MS Series
  Listening for incoming MIDI messages from device 2: ZOOM MS Series #3
Sending MIDI identity requests
  Opened MIDI out device Microsoft GS Wavetable Synth using name -> Microsoft GS Wavetable Synth
  Sending MIDI identity request to device 0: Microsoft GS Wavetable Synth
  Opened MIDI out device ZOOM MS Series using name -> ZOOM MS Series
  Sending MIDI identity request to device 1: ZOOM MS Series
  Received MIDI message from device 0 "ZOOM MS Series": f0 7e 00 06 02 52 58 00 00 00 33 2e 31 30 f7
  Opened MIDI out device ZOOM MS Series #2 using index 2 -> ZOOM MS Series
  Sending MIDI identity request to device 2: ZOOM MS Series #2
  Received MIDI message from device 1 "ZOOM MS Series #2": f0 7e 00 06 02 52 61 00 00 00 32 2e 31 30 f7
  Opened MIDI out device ZOOM MS Series #3 using index 3 -> ZOOM MS Series
  Sending MIDI identity request to device 3: ZOOM MS Series #3
  Received MIDI message from device 2 "ZOOM MS Series #3": f0 7e 00 06 02 52 61 00 00 00 32 2e 31 30 f7
Flashing tuners on Zoom devices
  Opened MIDI out device ZOOM MS Series using name -> ZOOM MS Series
  Flashing tuner on MIDI device 2, Zoom device 1: ZOOM MS Series
  Opened MIDI out device ZOOM MS Series #2 using index 2 -> ZOOM MS Series
  Flashing tuner on MIDI device 3, Zoom device 2: ZOOM MS Series #2
  Opened MIDI out device ZOOM MS Series #3 using index 3 -> ZOOM MS Series
  Flashing tuner on MIDI device 4, Zoom device 3: ZOOM MS Series #3

[thammer]

The seventh byte in the MIDI identity response message is the device type, 0x58 corresponds to a Zoom MS-50G and 0x61 corresponds to a Zoom MS-70CDR. So from the output above, you can see that I have one MS-50G and two MS-70CDRs connected to my computer.

The example code flashes the tuners on the three pedals in order - one flash on the first pedal, two flashes on the second pedal, three flashes on the third pedal. That way I can identify the different pedals and see that they match the index/order that Windows enumerates them, which is the same order that jazz-midi and JZZ.js lists them in the info objects.

[jazz-soft]

Hi! Thank you for looking into the issue!
Your solution seems nice, but there is a case that needs a good testing:
What happens if one of the identically named devices gets disconnected between the calls?

[thammer]

That's a good point.

My current theory is that we'll just have to assume all devices with identical names are invalid after one of them is connected or disconnected. As far as I know, Windows will enumerate these in more or less random order whenever one of them is connected or disconnected. It often appears to be in the same order, but sometimes, Windows decides that what was once the first device is suddenly the last, even if you just disconnect it and connect it again to the same USB port.

I'm currently looking into a simpler case - letting the client know that a device which is one of multiple identically named devices has been disconnected or connected, and that all those devices need to be closed and opened again on the client side. Perhaps that's what we have to settle with as long as the only code changes are in the JZZ.js repository.

Ideally, only the connected / disconnected device would be affected. However, I don't think this can be achieved reliably in JZZ.js alone. The fix would probably have to be in jazz-midi, and to my understanding it would involve more than just using the Windows Multimedia API. I'm guessing one would have to listen for USB device connection messages and inspect registry data about the USB devices and use that to detect which device was disconnected/connected. And even then, it might not be possible. Googling this problem didn't reveal any obvious solutions. One could of course just try to send some midi data to a device and see if that fails, but that's a bit intrusive as well. It might be that to fix this properly for all cases, jazz-midi would have to switch the backend to WinRT MIDI or to the next generation MIDI API Microsoft is currently working on.

Anyway, I'll do some testing of the case you mentioned after I have found a good solution for the simpler case.

[jazz-soft]

As you mentioned, the fix should be done in the jazz-midi module.
I'm currently looking for a way to make it MIDI 2.0 compatible and there is a possibility that I'll have to rewrite it from scratch.
It's probably better not to waste time with the old version and try to fix the same-named devices issue in the new version.

[thammer]

Cool. Let me know if you need someone to beta-test this.

[thammer]

My latest commits to the branch mentioned above lets the application handle the disconnect/connects. It seems to work fine no matter which devices I connect or disconnect. Although I haven't stress-tested it thoroughly yet.

The problem I'm solving with these commits is that when a device with device name identical to another device is disconnected or connected, I don't think it's possible for JZZ.js to know which of these devices were connected or disconnected (jazz-midi doesn't tell JZZ.js which of these were connected/disconnected, just that one of them was). So JZZ.js has to assume that all devices were disconnected and that some of them were connected again. The application will need to respond to that in a reasonable manner, typically by closing all the devices with identical device names (if JZZ.js hasn't closed them already) and opening the devices again, as well as connecting MIDI input handlers.

The solution I currently implemented requires the application to test if a disconnected or connected device is one of multiple devices with identical device names, by reading the deviceName property of the info object in the onChange handler and compare that to the deviceName of other devices. This leaks implementation details from inside the JZZ.js library to the application and makes the client slightly more complicated than necessary.

A cleaner approach would be to have JZZ.js populate the diff object passed to the onChange handlers with removed and added devices, and close all the removed devices (including all devices with same device name as one that has been removed or added). Then the application's onChange handler could just loop through the inputs.added and outputs.added and reopen these.

One way to do this in JZZ.js is to modify _postRefresh() so that after calling

var diff = _diff(_insW, _outsW, _jzz._info.inputs, _jzz._info.outputs);

it would do

_engine._diff(diff, _jzz._info.inputs, _jzz._info.outputs).

Then the Jazz-Plugin / jazz-midi engine could add the extra devices to the diff object, whereas the other engines would do nothing.

Here's an example where one of the devices are removed (it doesn't matter which, the diff would be the same)

var diff = _diff(_insW, _outsW, _jzz._info.inputs, _jzz._info.outputs);
// diff = 
// {
//   inputs: 
//   { 
//     removed: [ { name: "ZOOM MS Series #3", deviceName: "ZOOM MS Series", ... } ]
//   }
// }

_engine._diff(diff, _jzz._info.inputs, _jzz._info.outputs).
// diff = 
// {
//   inputs: 
//   { 
//     removed: [ { name: "ZOOM MS Series", deviceName: "ZOOM MS Series", ... },
//     { name: "ZOOM MS Series #2", deviceName: "ZOOM MS Series", ... },
//     { name: "ZOOM MS Series #3", deviceName: "ZOOM MS Series", ... } ],
//     added: [ { name: "ZOOM MS Series", deviceName: "ZOOM MS Series", ... },
//     { name: "ZOOM MS Series #2", deviceName: "ZOOM MS Series", ... } ]
//   }
// }

If you're interested in merging this stuff into JZZ.js, I'm happy to hear your thoughts on how that could best be done, and to do my best to make a proper PR for you.

If not - then what I have done so far solves the problem for me in the application I'm creating, and I can keep using my own fork just for my application, and just be grateful for all the work you have put into the JZZ.js library so far, sharing the source code to JZZ.js and allowing me to use it as I do. I'm happy either way :-).