Sysex: Delay after F7 milliseconds ?

[creativespiral]

I've been experimenting with the sysex functions... trying to do some basic librarian type of operations (sending and receiving .syx patches/banks)

One of the most important settings in a program like MIDI-Ox, is the "Delay after F7" setting. Usually it's good to set it to at least 100ms, if not greater. When sending banks of .syx patches, this allows a moment for the target device to ingest the patches one-by-one, before receiving the next one. A bank might have 128 F0...F7 packets in the single .syx file.

If there is no delay after each F7, many instruments won't be able to ingest the patch data quick enough, and the result is corrupted patches.

Delay after F7: XXX milliseconds

As far as I can tell, there doesn't seem to be native support for this in WebMIDI -- I'm wondering if someone has created a workaround for this? - to add a delay of XXX milliseconds, each time a F7 (end of sysex) message is received.. then continue sending the information. Or @djipco or others, can you maybe point me in the right direction of where I could write in the code that might allow this behavior? I'm unclear on where in the process would be the best to inject a ms delay/timeout like this.

Can I add a "Delay after F7" milliseconds somewhere in sendSysex()?

sendSysex(manufacturer, data = [], options = {}) {
  manufacturer = [].concat(manufacturer); // Check if data is Uint8Array

  if (data instanceof Uint8Array) {
    const merged = new Uint8Array(1 + manufacturer.length + data.length + 1);
    merged[0] = Enumerations.MIDI_SYSTEM_MESSAGES.sysex;
    merged.set(Uint8Array.from(manufacturer), 1);
    merged.set(data, 1 + manufacturer.length);
    merged[merged.length - 1] = Enumerations.MIDI_SYSTEM_MESSAGES.sysexend;
    this.send(merged, {
      time: options.time
    });
  } else {
    const merged = manufacturer.concat(data, Enumerations.MIDI_SYSTEM_MESSAGES.sysexend);
    this.send([Enumerations.MIDI_SYSTEM_MESSAGES.sysex].concat(merged), {
      time: options.time
    });
  }

  return this;
}

Or can I add a "Delay after F7" milliseconds somewhere in send() function?

send(message, options = {
  time: 0
}, legacy = 0) {
  // If a Message object is passed in we extract the message data (the jzz plugin used on Node.js
  // does not support using Uint8Array).
  if (message instanceof Message) {
    message = Utilities.isNode ? message.data : message.rawData;
  } // If the data is a Uint8Array and we are on Node, we must convert it to array so it works with
  // the jzz module.


  if (message instanceof Uint8Array && Utilities.isNode) {
    message = Array.from(message);
  } // Validation


  if (wm.validation) {
    // If message is neither an array nor a Uint8Array, then we are in legacy mode
    if (!Array.isArray(message) && !(message instanceof Uint8Array)) {
      message = [message];
      if (Array.isArray(options)) message = message.concat(options);
      options = isNaN(legacy) ? {
        time: 0
      } : {
        time: legacy
      };
    }

    if (!(parseInt(message[0]) >= 128 && parseInt(message[0]) <= 255)) {
      throw new RangeError("The first byte (status) must be an integer between 128 and 255.");
    }

    message.slice(1).forEach(value => {
      value = parseInt(value);

      if (!(value >= 0 && value <= 255)) {
        throw new RangeError("Data bytes must be integers between 0 and 255.");
      }
    });
    if (!options) options = {
      time: 0
    };
  } // Send message and return `Output` for chaining


  this._midiOutput.send(message, Utilities.toTimestamp(options.time));

  return this;
}

[djipco]

As far as I can tell, there doesn't seem to be native support for this in WebMIDI

You are right. This is something that is on my roadmap and which I haven't had time to look at yet.

To implement it, we would need some sort of queue where the messages pile up and are sent according to the delay. I guess you could could do it on your side by simply waiting after calling sendSysex() before sending more data.

[dochin]

Hopefully this saves a headache rather than creating one. If you use setTimeout, be aware that some browsers throttle it to 1000ms, specifically on battery if the tab is not in focus. If you try to add 60ms after a sysex message and it actually takes 1000 that can lead to unpredictable results. This throttling doesn't seem to apply to webworkers.