midifile.cpp

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2007-2011 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================

#include "midifile.h"
#include "libmscore/xml.h"
#include "libmscore/part.h"
#include "libmscore/note.h"
#include "libmscore/drumset.h"
#include "libmscore/utils.h"

namespace Ms {

static const uchar gmOnMsg[] = {
      0x7e,       // Non-Real Time header
      0x7f,       // ID of target device (7f = all devices)
      0x09,
      0x01
      };
static const uchar gsOnMsg[] = {
      0x41,       // roland id
      0x10,       // Id of target device (default = 10h for roland)
      0x42,       // model id (42h = gs devices)
      0x12,       // command id (12h = data set)
      0x40,       // address & value
      0x00,
      0x7f,
      0x00,
      0x41        // checksum?
      };
static const uchar xgOnMsg[] = {
      0x43,       // yamaha id
      0x10,       // device number (0)
      0x4c,       // model id
      0x00,       // address (high, mid, low)
      0x00,
      0x7e,
      0x00        // data
      };

const int gmOnMsgLen = sizeof(gmOnMsg);
const int gsOnMsgLen = sizeof(gsOnMsg);
const int xgOnMsgLen = sizeof(xgOnMsg);

//---------------------------------------------------------
//   MidiFile
//---------------------------------------------------------

MidiFile::MidiFile()
      {
      fp               = 0;
      _division        = 0;
      _isDivisionInTps = false;
      _format          = 1;
      _midiType        = MidiType::UNKNOWN;
      _noRunningStatus = false;

      status           = 0;
      sstatus          = 0;
      click            = 0;
      curPos           = 0;
      }

//---------------------------------------------------------
//   write
//    returns true on error
//---------------------------------------------------------

bool MidiFile::write(QIODevice* out)
      {
      fp = out;
      write("MThd", 4);
      writeLong(6);                 // header len
      writeShort(_format);          // format
      writeShort(_tracks.size());
      writeShort(_division);
      for (const auto &t: _tracks) {
            if (writeTrack(t))
                  return true;
            }
      return false;
      }

//---------------------------------------------------------
//   write
//---------------------------------------------------------

void MidiFile::writeEvent(const MidiEvent& event)
      {
      switch(event.type()) {
            case ME_NOTEON:
                  writeStatus(ME_NOTEON, event.channel());
                  put(event.pitch());
                  put(event.velo());
                  break;

            case ME_NOTEOFF:
                  writeStatus(ME_NOTEOFF, event.channel());
                  put(event.pitch());
                  put(event.velo());
                  break;

            case ME_PITCHBEND:
                  writeStatus(ME_PITCHBEND, event.channel());
                  put(event.dataA());
                  put(event.dataB());
                  break;

            case ME_CONTROLLER:
                  switch(event.controller()) {
                        case CTRL_PROGRAM:
                              writeStatus(ME_PROGRAM, event.channel());
                              put(event.value() & 0x7f);
                              break;
                        case CTRL_PRESS:
                              writeStatus(ME_AFTERTOUCH, event.channel());
                              put(event.value() & 0x7f);
                              break;
                        default:
                              writeStatus(ME_CONTROLLER, event.channel());
                              put(event.controller());
                              put(event.value() & 0x7f);
                              break;
                        }
                  break;

            case ME_META:
                  put(ME_META);
                  put(event.metaType());
                  putvl(event.len());
                  write(event.edata(), event.len());
                  resetRunningStatus();     // really ?!
                  break;

            case ME_SYSEX:
                  put(ME_SYSEX);
                  putvl(event.len() + 1);  // including 0xf7
                  write(event.edata(), event.len());
                  put(ME_ENDSYSEX);
                  resetRunningStatus();
                  break;
            }
      }

//---------------------------------------------------------
//   writeTrack
//---------------------------------------------------------

bool MidiFile::writeTrack(const MidiTrack &t)
      {
      write("MTrk", 4);
      qint64 lenpos = fp->pos();
      writeLong(0);                 // dummy len

      status   = -1;
      int tick = 0;
      for (auto i : t.events()) {
            int ntick = i.first;
            putvl(ntick - tick);    // write tick delta
            //
            // if track channel != -1, then use this
            //    channel for all events in this track
            //
            if (t.outChannel() != -1)
                  writeEvent(i.second);
            tick = ntick;
            }

      //---------------------------------------------------
      //    write "End Of Track" Meta
      //    write Track Len
      //

      putvl(1);
      put(0xff);        // Meta
      put(0x2f);        // EOT
      putvl(0);         // len 0
      qint64 endpos = fp->pos();
      fp->seek(lenpos);
      writeLong(endpos-lenpos-4);   // tracklen
      fp->seek(endpos);
      return false;
      }

//---------------------------------------------------------
//   writeStatus
//---------------------------------------------------------

void MidiFile::writeStatus(int nstat, int c)
      {
      nstat |= (c & 0xf);
      //
      //  running status; except for Sysex- and Meta Events
      //
      if (_noRunningStatus || (((nstat & 0xf0) != 0xf0) && (nstat != status))) {
            status = nstat;
            put(nstat);
            }
      }

//---------------------------------------------------------
//   readMidi
//    return false on error
//---------------------------------------------------------

bool MidiFile::read(QIODevice* in)
     {
      fp = in;
      _tracks.clear();
      curPos    = 0;

      // === Read header_chunk = "MThd" + <header_length> + <format> + <n> + <division>
      //
      // "MThd" 4 bytes
      //    the literal string MThd, or in hexadecimal notation: 0x4d546864.
      //    These four characters at the start of the MIDI file
      //    indicate that this is a MIDI file.
      // <header_length> 4 bytes
      //    length of the header chunk (always =6 bytes long - the size of the next
      //    three fields which are considered the header chunk).
      //    Although the header chunk currently always contains 6 bytes of data,
      //    this should not be assumed, this value should always be read and acted upon,
      //    to allow for possible future extension to the standard.
      // <format> 2 bytes
      //    0 = single track file format
      //    1 = multiple track file format
      //    2 = multiple song file format (i.e., a series of type 0 files)
      // <n> 2 bytes
      //    number of track chunks that follow the header chunk
      // <division> 2 bytes
      //    unit of time for delta timing. If the value is positive, then it represents
      //    the units per beat. For example, +96 would mean 96 ticks per beat.
      //    If the value is negative, delta times are in SMPTE compatible units.

      char tmp[4];

      read(tmp, 4);
      int len = readLong();
      if (memcmp(tmp, "MThd", 4) || len < 6)
            throw(QString("bad midifile: MThd expected"));

      if (len > 6)
            throw(QString("unsupported MIDI header data size: %1 instead of 6").arg(len));

      _format     = readShort();
      int ntracks = readShort();

      // ================ Read MIDI division =================
      //
      //                        2 bytes
      //  +-------+---+-------------------+-----------------+
      //  |  bit  |15 | 14              8 | 7             0 |
      //  +-------+---+-------------------------------------+
      //  |       | 0 |       ticks per quarter note        |
      //  | value +---+-------------------------------------+
      //  |       | 1 |  -frames/second   |   ticks/frame   |
      //  +-------+---+-------------------+-----------------+

      char firstByte;
      fp->getChar(&firstByte);
      char secondByte;
      fp->getChar(&secondByte);
      const char topBit = (firstByte & 0x80) >> 7;

      if (topBit == 0) {            // ticks per beat
            _isDivisionInTps = false;
            _division = (firstByte << 8) | (secondByte & 0xff);
            }
      else {                        // ticks per second = fps * ticks per frame
            _isDivisionInTps = true;
            const int framesPerSecond = -((signed char) firstByte);
            const int ticksPerFrame = secondByte;
            if (framesPerSecond == 29)
                  _division = qRound(29.97 * ticksPerFrame);
            else
                  _division = framesPerSecond * ticksPerFrame;
            }

      // =====================================================

      switch (_format) {
            case 0:
                  if (readTrack())
                        return false;
                  break;
            case 1:
                  for (int i = 0; i < ntracks; i++) {
                        if (readTrack())
                              return false;
                        }
                  break;
            default:
                  throw(QString("midi file format %1 not implemented").arg(_format));

                  // Prevent "unreachable code" warning 
                  // return false;
            }
      return true;
      }

//---------------------------------------------------------
//   readTrack
//    return true on error
//---------------------------------------------------------

bool MidiFile::readTrack()
      {
      char tmp[4];
      read(tmp, 4);
      if (memcmp(tmp, "MTrk", 4))
            throw(QString("bad midifile: MTrk expected"));
      int len       = readLong();       // len
      qint64 endPos = curPos + len;
      status        = -1;
      sstatus       = -1;  // running status, will not be reset on meta or sysex
      click         =  0;
      _tracks.push_back(MidiTrack());

      int port = 0;
      _tracks.back().setOutPort(port);
      _tracks.back().setOutChannel(-1);

      for (;;) {
            MidiEvent event;
            if (!readEvent(&event))
                  return true;

            // check for end of track:
            if ((event.type() == ME_META) && (event.metaType() == META_EOT))
                  break;
            _tracks.back().insert(click, event);
            }
      if (curPos != endPos) {
            qWarning("bad track len: %lld != %lld, %lld bytes too much\n", endPos, curPos, endPos - curPos);
            if (curPos < endPos) {
                  qWarning("  skip %lld\n", endPos-curPos);
                  skip(endPos - curPos);
                  }
            }
      return false;
      }

/*---------------------------------------------------------
 *    read
 *    return false on error
 *---------------------------------------------------------*/

void MidiFile::read(void* p, qint64 len)
      {
      curPos += len;
      qint64 rv = fp->read((char*)p, len);
      if (rv != len)
            throw(QString("bad midifile: unexpected EOF"));
      }

//---------------------------------------------------------
//   write
//---------------------------------------------------------

bool MidiFile::write(const void* p, qint64 len)
      {
      qint64 rv = fp->write((char*)p, len);
      if (rv == len)
            return false;
      qDebug("write midifile failed: %s", fp->errorString().toLatin1().data());
      return true;
      }

//---------------------------------------------------------
//   readShort
//---------------------------------------------------------

int MidiFile::readShort()
      {
      char c;
      int val = 0;
      for (int i = 0; i < 2; ++i) {
            fp->getChar(&c);
            val <<= 8;
            val += (c & 0xff);
            }
      return val;
      }

//---------------------------------------------------------
//   writeShort
//---------------------------------------------------------

void MidiFile::writeShort(int i)
      {
      fp->putChar(i >> 8);
      fp->putChar(i);
      }

//---------------------------------------------------------
//   readLong
//   writeLong
//---------------------------------------------------------

int MidiFile::readLong()
      {
      char c;
      int val = 0;
      for (int i = 0; i < 4; ++i) {
            fp->getChar(&c);
            val <<= 8;
            val += (c & 0xff);
            }
      return val;
      }

//---------------------------------------------------------
//   writeLong
//---------------------------------------------------------

void MidiFile::writeLong(int i)
      {
      fp->putChar(i >> 24);
      fp->putChar(i >> 16);
      fp->putChar(i >> 8);
      fp->putChar(i);
      }

/*---------------------------------------------------------
 *    skip
 *    This is meant for skipping a few bytes in a
 *    file or fifo.
 *---------------------------------------------------------*/

void MidiFile::skip(qint64 len)
      {
      // Note: if MS is updated to use Qt 5.10, this can be implemented with QIODevice::skip(), which should be more efficient
      //       as bytes do not need to be moved around.
      if (len <= 0)
            return;
#if (!defined (_MSCVER) && !defined (_MSC_VER))
      char tmp[len];
      read(tmp, len);
#else
      const int tmp_size = 256;  // Size of fixed-length temporary buffer. MSVC does not support VLA.
      char tmp[tmp_size];
      while(len > tmp_size) {
            read(tmp, len);
            len -= tmp_size;
            }
      // Now len is <= tmp_size, last read fits in the buffer.
      read(tmp, tmp_size);
#endif
      }

/*---------------------------------------------------------
 *    getvl
 *    Read variable-length number (7 bits per byte, MSB first)
 *---------------------------------------------------------*/

int MidiFile::getvl()
      {
      int l = 0;
      for (int i = 0; i < 16; i++) {
            uchar c;
            read(&c, 1);
            l += (c & 0x7f);
            if (!(c & 0x80)) {
                  return l;
                  }
            l <<= 7;
            }
      return -1;
      }

/*---------------------------------------------------------
 *    putvl
 *    Write variable-length number (7 bits per byte, MSB first)
 *---------------------------------------------------------*/

void MidiFile::putvl(unsigned val)
      {
      unsigned long buf = val & 0x7f;
      while ((val >>= 7) > 0) {
            buf <<= 8;
            buf |= 0x80;
            buf += (val & 0x7f);
            }
      for (;;) {
            put(buf);
            if (buf & 0x80)
                  buf >>= 8;
            else
                  break;
            }
      }

//---------------------------------------------------------
//   MidiTrack
//---------------------------------------------------------

MidiTrack::MidiTrack()
      {
      _outChannel = -1;
      _outPort    = -1;
      _drumTrack  = false;
      }

MidiTrack::~MidiTrack()
      {
      }

//---------------------------------------------------------
//   insert
//---------------------------------------------------------

void MidiTrack::insert(int tick, const MidiEvent& event)
      {
      _events.insert({tick, event});
      }

//---------------------------------------------------------
//   readEvent
//    return true on success
//---------------------------------------------------------

bool MidiFile::readEvent(MidiEvent* event)
      {
      uchar me, a, b;

      int nclick = getvl();
      if (nclick == -1) {
            qDebug("readEvent: error 1(getvl)");
            return false;
            }
      click += nclick;
      for (;;) {
            read(&me, 1);
            if (me >= 0xf1 && me <= 0xfe && me != 0xf7) {
                  qDebug("Midi: Unknown Message 0x%02x", me & 0xff);
                  }
            else
                  break;
            }

      unsigned char* data;
      int dataLen;

      if (me == 0xf0 || me == 0xf7) {
            status  = -1;                  // no running status
            int len = getvl();
            if (len == -1) {
                  qDebug("readEvent: error 3");
                  return false;
                  }
            data    = new unsigned char[len+1];
            dataLen = len;
            read(data, len);
            data[dataLen] = 0;    // always terminate with zero
            if (data[len-1] != 0xf7) {
                  qDebug("SYSEX does not end with 0xf7!");
                  // more to come?
                  }
            else
                  dataLen--;      // don't count 0xf7
            event->setType(ME_SYSEX);
            event->setEData(data);
            event->setLen(dataLen);
            return true;
            }

      if (me == ME_META) {
            status = -1;                  // no running status
            uchar type;
            read(&type, 1);
            dataLen = getvl();                // read len
            if (dataLen == -1) {
                  qDebug("readEvent: error 6");
                  return false;
                  }
            data = new unsigned char[dataLen + 1];
            if (dataLen)
                  read(data, dataLen);
            data[dataLen] = 0;      // always terminate with zero so we get valid C++ strings

            event->setType(ME_META);
            event->setMetaType(type);
            event->setLen(dataLen);
            event->setEData(data);
            return true;
            }

      if (me & 0x80) {                     // status byte
            status   = me;
            sstatus  = status;
            read(&a, 1);
            }
      else {
            if (status == -1) {
                  qDebug("readEvent: no running status, read 0x%02x", me);
                  qDebug("sstatus ist 0x%02x", sstatus);
                  if (sstatus == -1) {
                        return 0;
                        }
                  status = sstatus;
                  }
            a = me;
            }
      int channel = status & 0x0f;
      b           = 0;
      switch (status & 0xf0) {
            case ME_NOTEOFF:
            case ME_NOTEON:
            case ME_POLYAFTER:
            case ME_CONTROLLER:        // controller
            case ME_PITCHBEND:        // pitch bend
                  read(&b, 1);
                  break;
            }
      event->setType(status & 0xf0);
      event->setChannel(channel);
      switch (status & 0xf0) {
            case ME_NOTEOFF:
                  event->setDataA(a & 0x7f);
                  event->setDataB(b & 0x7f);
                  break;
            case ME_NOTEON:
                  event->setDataA(a & 0x7f);
                  event->setDataB(b & 0x7f);
                  break;
            case ME_POLYAFTER:
                  event->setType(ME_CONTROLLER);
                  event->setController(CTRL_POLYAFTER);
                  event->setValue(((a & 0x7f) << 8) + (b & 0x7f));
                  break;
            case ME_CONTROLLER:        // controller
                  event->setController(a & 0x7f);
                  event->setValue(b & 0x7f);
                  break;
            case ME_PITCHBEND:        // pitch bend
                  event->setDataA(a & 0x7f);
                  event->setDataB(b & 0x7f);
                  break;
            case ME_PROGRAM:
                  event->setValue(a & 0x7f);
                  break;
            case ME_AFTERTOUCH:
                  event->setType(ME_CONTROLLER);
                  event->setController(CTRL_PRESS);
                  event->setValue(a & 0x7f);
                  break;
            default:          // f1 f2 f3 f4 f5 f6 f7 f8 f9
                  qDebug("BAD STATUS 0x%02x, me 0x%02x", status, me);
                  return false;
            }

      if ((a & 0x80) || (b & 0x80)) {
            qDebug("8't bit in data set(%02x %02x): tick %d read 0x%02x  status:0x%02x",
              a & 0xff, b & 0xff, click, me, status);
            qDebug("readEvent: error 16");
            if (b & 0x80) {
                  // Try to fix: interpret as channel byte
                  status   = b;
                  sstatus  = status;
                  return true;
                  }
            return false;
            }
      return true;
      }

//---------------------------------------------------------
//   setOutChannel
//---------------------------------------------------------

void MidiTrack::setOutChannel(int n)
      {
      _outChannel = n;
      if (_outChannel == 9)
            _drumTrack = true;
      }

//---------------------------------------------------------
//   mergeNoteOnOffAndFindMidiType
//    - find matching note on / note off events and merge
//      into a note event with tick duration
//    - find MIDI type
//---------------------------------------------------------

void MidiTrack::mergeNoteOnOffAndFindMidiType(MidiType *mt)
      {
      std::multimap<int, MidiEvent> el;

      int hbank = 0xff;
      int lbank = 0xff;
      int rpnh  = -1;
      int rpnl  = -1;
      int datah = 0;
      int datal = 0;
      int dataType = 0; // 0 : disabled, 0x20000 : rpn, 0x30000 : nrpn;

      for (auto i = _events.begin(); i != _events.end(); ++i) {
            MidiEvent& ev = i->second;
            if (ev.type() == ME_INVALID)
                  continue;
            if ((ev.type() != ME_NOTEON) && (ev.type() != ME_NOTEOFF)) {
                  if (ev.type() == ME_CONTROLLER) {
                        int val  = ev.value();
                        int cn   = ev.controller();
                        if (cn == CTRL_HBANK) {
                              hbank = val;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_LBANK) {
                              lbank = val;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_HDATA) {
                              datah = val;

                              // check if a CTRL_LDATA follows
                              // e.g. wie have a 14 bit controller:
                              auto ii = i;
                              ++ii;
                              bool found = false;
                              for (; ii != _events.end(); ++ii) {
                                    MidiEvent& ev1 = ii->second;
                                    if (ev1.type() == ME_CONTROLLER) {
                                          if (ev1.controller() == CTRL_LDATA) {
                                                // handle later
                                                found = true;
                                                }
                                          break;
                                          }
                                    }
                              if (!found) {
                                    if (rpnh == -1 || rpnl == -1) {
                                          qDebug("parameter number not defined, data 0x%x", datah);
                                          ev.setType(ME_INVALID);
                                          continue;
                                          }
                                    else {
                                          ev.setController(dataType | (rpnh << 8) | rpnl);
                                          ev.setValue(datah);
                                          }
                                    }
                              else {
                                    ev.setType(ME_INVALID);
                                    continue;
                                    }
                              }
                        else if (cn == CTRL_LDATA) {
                              datal = val;

                              if (rpnh == -1 || rpnl == -1) {
                                    qDebug("parameter number not defined, data 0x%x 0x%x, tick %d, channel %d",
                                       datah, datal, i->first, ev.channel());
                                    continue;
                                    }
                              // assume that the sequence is always
                              //    CTRL_HDATA - CTRL_LDATA
                              // eg. that LDATA is always send last

                              // 14 Bit RPN/NRPN
                              ev.setController((dataType+0x30000) | (rpnh << 8) | rpnl);
                              ev.setValue((datah << 7) | datal);
                              }
                        else if (cn == CTRL_HRPN) {
                              rpnh = val;
                              dataType = 0x20000;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_LRPN) {
                              rpnl = val;
                              dataType = 0x20000;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_HNRPN) {
                              rpnh = val;
                              dataType = 0x30000;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_LNRPN) {
                              rpnl = val;
                              dataType = 0x30000;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        else if (cn == CTRL_PROGRAM) {
                              ev.setValue((hbank << 16) | (lbank << 8) | ev.value());
                              // TODO el.insert(ev);
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        }
                  else if (ev.type() == ME_SYSEX) {
                        int len = ev.len();
                        const uchar* buffer = ev.edata();
                        if ((len == gmOnMsgLen) && memcmp(buffer, gmOnMsg, gmOnMsgLen) == 0) {
                              *mt = MidiType::GM;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        if ((len == gsOnMsgLen) && memcmp(buffer, gsOnMsg, gsOnMsgLen) == 0) {
                              *mt = MidiType::GS;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        if ((len == xgOnMsgLen) && memcmp(buffer, xgOnMsg, xgOnMsgLen) == 0) {
                              *mt = MidiType::XG;
                              ev.setType(ME_INVALID);
                              continue;
                              }
                        if (buffer[0] == 0x43) {    // Yamaha
                              *mt = MidiType::XG;
                              int type   = buffer[1] & 0xf0;
                              if (type == 0x10) {
//TODO                                    if (buffer[1] != 0x10) {
//                                          buffer[1] = 0x10;    // fix to Device 1
//                                          }
                                    if ((len == xgOnMsgLen) && memcmp(buffer, xgOnMsg, xgOnMsgLen) == 0) {
                                          *mt = MidiType::XG;
                                          ev.setType(ME_INVALID);
                                          continue;
                                          }
                                    if (len == 7 && buffer[2] == 0x4c && buffer[3] == 0x08 && buffer[5] == 7) {
                                          // part mode
                                          // 0 - normal
                                          // 1 - DRUM
                                          // 2 - DRUM 1
                                          // 3 - DRUM 2
                                          // 4 - DRUM 3
                                          // 5 - DRUM 4
                                          if (buffer[6] != 0 && buffer[4] == ev.channel()) {
                                                _drumTrack = true;
                                                }
                                          ev.setType(ME_INVALID);
                                          continue;
                                          }
                                    }
                              }
                        }
                  el.insert(std::pair<int,MidiEvent>(i->first, ev));
                  ev.setType(ME_INVALID);
                  continue;
                  }
            int tick = i->first;
            if (ev.type() == ME_NOTEOFF || ev.velo() == 0) {
                  qDebug("-extra note off at %d", tick);
                  ev.setType(ME_INVALID);
                  continue;
                  }
            MidiEvent note(ME_NOTE, ev.channel(), ev.dataA(), ev.dataB());

            auto k = i;
            ++k;
            for (; k != _events.end(); ++k) {
                  MidiEvent& e = k->second;
                  if (e.type() != ME_NOTEON && e.type() != ME_NOTEOFF)
                        continue;
                  if ((e.type() == ME_NOTEOFF || (e.type() == ME_NOTEON && e.velo() == 0))
                     && (e.pitch() == note.pitch())) {
                        int t = k->first - tick;
                        if (t <= 0)
                              t = 1;
                        note.setLen(t);
                        e.setType(ME_INVALID);
                        break;
                        }
                  }
            if (k == _events.end()) {
                  qDebug("-no note-off for note at %d", tick);
                  note.setLen(1);
                  }
            el.insert(std::pair<int,MidiEvent>(tick, note));
            ev.setType(ME_INVALID);
            }
      _events = el;
      }

//---------------------------------------------------------
//   separateChannel
//    if a track contains events for different midi channels,
//    then split events into separate tracks
//---------------------------------------------------------

void MidiFile::separateChannel()
      {
      for (int i = 0; i < _tracks.size(); ++i) {
                        // create a list of channels used in current track
            QList<int> channel;
            MidiTrack &mt = _tracks[i];      // current track
            for (const auto& ie : mt.events()) {
                  const MidiEvent& e = ie.second;
                  if (e.isChannelEvent() && !channel.contains(e.channel()))
                        channel.append(e.channel());
                  }
            mt.setOutChannel(channel.empty() ? 0 : channel[0]);
            int nn = channel.size();
            if (nn <= 1)
                  continue;
            std::sort(channel.begin(), channel.end());
                        // -- split --
                        // insert additional tracks, assign to them found channels
            for (int ii = 1; ii < nn; ++ii) {
                  MidiTrack t;
                  t.setOutChannel(channel[ii]);
                  _tracks.insert(i + ii, t);
                  }
                        // extract all different channel events from current track to inserted tracks
            for (auto ie = mt.events().begin(); ie != mt.events().end(); ) {
                  const MidiEvent& e = ie->second;
                  if (e.isChannelEvent()) {
                        int ch  = e.channel();
                        int idx = channel.indexOf(ch);
                        MidiTrack &t = _tracks[i + idx];
                        if (&t != &mt) {
                              t.insert(ie->first, e);
                              ie = mt.events().erase(ie);
                              continue;
                              }
                        }
                  ++ie;
                  }
            i += nn - 1;
            }
      }

} // namespace Ms