//=============================================================================
//  MusE Score
//  Linux Music Score Editor
//  $Id: jackaudio.cpp 5660 2012-05-22 14:17:39Z wschweer $
//
//  Copyright (C) 2002-2010 Werner Schweer and others
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//=============================================================================

#include "jackaudio.h"
#include "musescore.h"
#include "libmscore/mscore.h"
#include "preferences.h"
// #include "msynth/synti.h"
#include "seq.h"
#include "libmscore/score.h"
#include "libmscore/repeatlist.h"
#include "mscore/playpanel.h"
#include <jack/midiport.h>

// Prevent killing sequencer with wrong data
#define less128(__less) ((__less >=0 && __less <= 127) ? __less : 0)

namespace Ms {

//---------------------------------------------------------
//   JackAudio
//---------------------------------------------------------

JackAudio::JackAudio(Seq* s)
   : Driver(s)
      {
      client = 0;
      }

//---------------------------------------------------------
//   ~JackAudio
//---------------------------------------------------------

JackAudio::~JackAudio()
      {
      if (client) {
            stop();
            if (jack_client_close(client)) {
                  qDebug("jack_client_close() failed: %s",
                     strerror(errno));
                  }
            }
      }

//---------------------------------------------------------
//   updateOutPortCount
//   Add/remove JACK MIDI Out ports
//---------------------------------------------------------

void JackAudio::updateOutPortCount(int maxport)
      {
      if (!preferences.useJackMidi || maxport == midiOutputPorts.size())
            return;
      if (MScore::debugMode)
            qDebug()<<"JACK number of ports:"<<midiOutputPorts.size()<<", change to:"<<maxport;

      bool oldremember = preferences.rememberLastConnections;
      preferences.rememberLastConnections = true;

      if (maxport > midiOutputPorts.size()) {
            for (int i = midiOutputPorts.size(); i < maxport; ++i)
                  registerPort(QString("mscore-midi-%1").arg(i+1), false, true);
            restoreMidiConnections();
            }
      else if (maxport < midiOutputPorts.size()) {
            rememberMidiConnections();
            for(int i = midiOutputPorts.size() - 1; i >= maxport; --i) {
                  unregisterPort(midiOutputPorts[i]);
                  midiOutputPorts.removeAt(i);
                  }
            }
      preferences.rememberLastConnections = oldremember;
      }

//---------------------------------------------------------
//   registerPort
//---------------------------------------------------------

void JackAudio::registerPort(const QString& name, bool input, bool midi)
      {
      int portFlag         = input ? JackPortIsInput : JackPortIsOutput;
      const char* portType = midi ? JACK_DEFAULT_MIDI_TYPE : JACK_DEFAULT_AUDIO_TYPE;

      jack_port_t* port = jack_port_register(client, qPrintable(name), portType, portFlag, 0);
      if (port == 0) {
            qDebug("JackAudio:registerPort(%s) failed", qPrintable(name));
            return;
            }
      if (midi) {
            if (input)
                  midiInputPorts.append(port);
            else
                  midiOutputPorts.append(port);
            }
      else
            ports.append(port);
      }

//---------------------------------------------------------
//   unregisterPort
//---------------------------------------------------------

void JackAudio::unregisterPort(jack_port_t* port)
      {
      if (jack_port_is_mine(client,port)) {
            jack_port_unregister(client, port);
            port = 0;
            }
      else
            qDebug("Trying to unregister port that is not my!");
      }

//---------------------------------------------------------
//   inputPorts
//---------------------------------------------------------

QList<QString> JackAudio::inputPorts()
      {
      const char** ports = jack_get_ports(client, 0, 0, 0);
      QList<QString> clientList;
      for (const char** p = ports; p && *p; ++p) {
            jack_port_t* port = jack_port_by_name(client, *p);
            int flags = jack_port_flags(port);
            if (!(flags & JackPortIsInput))
                  continue;
            char buffer[128];
            strncpy(buffer, *p, sizeof(buffer) - 1);
            buffer[sizeof(buffer) - 1] = 0;
            if (strncmp(buffer, "Mscore", 6) == 0)
                  continue;
            clientList.append(QString(buffer));
            }
      return clientList;
      }

//---------------------------------------------------------
//   connect
//---------------------------------------------------------

void JackAudio::connect(void* src, void* dst)
      {
      const char* sn = jack_port_name((jack_port_t*) src);
      const char* dn = jack_port_name((jack_port_t*) dst);

      if (sn == 0 || dn == 0) {
            qDebug("JackAudio::connect: unknown jack ports");
            return;
            }
      if (jack_connect(client, sn, dn)) {
            qDebug("jack connect <%s>%p - <%s>%p failed",
               sn, src, dn, dst);
            }
      }

//---------------------------------------------------------
//   connect
//---------------------------------------------------------

void JackAudio::connect(const char* src, const char* dst)
      {
      if (src == 0 || dst == 0) {
            qDebug("JackAudio::connect: unknown jack ports");
            return;
            }
      qDebug("JackAudio::connect <%s> <%s>", src, dst);
      int rv = jack_connect(client, src, dst);
      if (rv)
            qDebug("jack connect port <%s> - <%s> failed: %d", src, dst, rv);
      }

//---------------------------------------------------------
//   disconnect
//---------------------------------------------------------

void JackAudio::disconnect(void* src, void* dst)
      {
      const char* sn = jack_port_name((jack_port_t*) src);
      const char* dn = jack_port_name((jack_port_t*) dst);
      if (sn == 0 || dn == 0) {
            qDebug("JackAudio::disconnect: unknown jack ports");
            return;
            }
      if (jack_disconnect(client, sn, dn)) {
            qDebug("jack disconnect <%s> - <%s> failed", sn, dn);
            }
      }

//---------------------------------------------------------
//   start
//    return false on error
//---------------------------------------------------------

bool JackAudio::start(bool hotPlug)
      {
      bool oldremember = preferences.rememberLastConnections;
      if (hotPlug)
            preferences.rememberLastConnections = true;

      if (jack_activate(client)) {
            qDebug("JACK: cannot activate client");
            return false;
            }
      /* connect the ports. Note: you can't do this before
         the client is activated, because we can't allow
         connections to be made to clients that aren't
         running.
       */
      if (preferences.useJackAudio)
            restoreAudioConnections();
      if (preferences.useJackMidi)
            restoreMidiConnections();

      if (hotPlug)
            preferences.rememberLastConnections = oldremember;
      return true;
      }

//---------------------------------------------------------
//   stop
//    return false on error
//---------------------------------------------------------

bool JackAudio::stop()
      {
      if (preferences.useJackMidi)
            rememberMidiConnections();
      if (preferences.useJackAudio)
            rememberAudioConnections();

      if (jack_deactivate(client)) {
            qDebug("cannot deactivate client");
            return false;
            }
      return true;
      }

//---------------------------------------------------------
//   framePos
//---------------------------------------------------------

int JackAudio::framePos() const
      {
      jack_nframes_t n = jack_frame_time(client);
      return (int)n;
      }

//---------------------------------------------------------
//   freewheel_callback
//---------------------------------------------------------

static void freewheel_callback(int /*starting*/, void*)
      {
      }

//---------------------------------------------------------
//   sampleRateCallback
//---------------------------------------------------------

int sampleRateCallback(jack_nframes_t sampleRate, void*)
      {
      qDebug("JACK: sample rate changed: %d", sampleRate);
      MScore::sampleRate = sampleRate;
      return 0;
      }

//---------------------------------------------------------
//   bufferSizeCallback called if JACK buffer changed
//---------------------------------------------------------

int bufferSizeCallback(jack_nframes_t nframes, void *arg)
      {
      JackAudio* audio = (JackAudio*)arg;
      audio->setBufferSize(nframes);
      return 0;
      }

static void registration_callback(jack_port_id_t, int, void*)
      {
//      qDebug("JACK: registration changed");
      }

static int graph_callback(void*)
      {
//      qDebug("JACK: graph changed");
      return 0;
      }

//---------------------------------------------------------
//   timebase
//---------------------------------------------------------

void JackAudio::timebase(jack_transport_state_t state, jack_nframes_t /*nframes*/, jack_position_t *pos, int /*new_pos*/, void *arg)
      {
      JackAudio* audio = (JackAudio*)arg;
      if (!audio->seq->score()) {
            if (state==JackTransportLooping || state==JackTransportRolling)
                  audio->stopTransport();
            }
      else if (audio->seq->isRunning()) {
            if (!audio->seq->score()->repeatList() || !audio->seq->score()->sigmap())
                  return;

            pos->valid = JackPositionBBT;
            int curTick = audio->seq->score()->repeatList()->utick2tick(audio->seq->getCurTick());
            int bar,beat,tick;
            audio->seq->score()->sigmap()->tickValues(curTick, &bar, &beat, &tick);
            // Providing the final tempo
            pos->beats_per_minute = 60 * audio->seq->curTempo() * audio->seq->score()->tempomap()->relTempo();
            pos->ticks_per_beat   = MScore::division;
            pos->tick             = tick;
            pos->bar              = bar+1;
            pos->beat             = beat+1;

            if (audio->timeSigTempoChanged) {
                  Fraction timeSig = audio->seq->score()->sigmap()->timesig(curTick).nominal();
                  pos->beats_per_bar =  timeSig.numerator();
                  pos->beat_type = timeSig.denominator();
                  audio->timeSigTempoChanged = false;
                  qDebug()<<"Time signature changed: "<< pos->beats_per_minute<<", bar: "<< pos->bar<<",beat: "<<pos->beat<<", tick:"<<pos->tick<<", time sig: "<<pos->beats_per_bar<<"/"<<pos->beat_type;
                  }
            }
      // TODO: Handle new_pos
      }
//---------------------------------------------------------
//   processAudio
//    JACK callback
//---------------------------------------------------------

int JackAudio::processAudio(jack_nframes_t frames, void* p)
      {
      JackAudio* audio = (JackAudio*)p;
      // Prevent from crash if score not opened yet
      if(!audio->seq->score())
            return 0;

      float* l;
      float* r;
      if (preferences.useJackAudio && audio->ports.size() == 2) {
            l = (float*)jack_port_get_buffer(audio->ports[0], frames);
            r = (float*)jack_port_get_buffer(audio->ports[1], frames);
            }
      else {
            l = 0;
            r = 0;
            }
      if (preferences.useJackMidi) {
            foreach(jack_port_t* port, audio->midiOutputPorts) {
                  void* portBuffer = jack_port_get_buffer(port, frames);
                  jack_midi_clear_buffer(portBuffer);
                  }
            foreach(jack_port_t* port, audio->midiInputPorts) {
                  void* portBuffer = jack_port_get_buffer(port, frames);
                  if (portBuffer) {
                        jack_nframes_t n = jack_midi_get_event_count(portBuffer);
                        for (jack_nframes_t i = 0; i < n; ++i) {
                              jack_midi_event_t event;
                              int r = jack_midi_event_get(&event, portBuffer, i);
                              if (r != 0)
                                    continue;
                              int nn = event.size;
                              int type = event.buffer[0];
                              if (nn && (type == ME_CLOCK || type == ME_SENSE))
                                    continue;
                              Event e;
                              e.setChannel(type & 0xf);
                              type &= 0xf0;
                              e.setType(type);
                              if (type == ME_NOTEON || type == ME_NOTEOFF) {
                                    e.setPitch(event.buffer[1]);
                                    e.setVelo(event.buffer[2]);
                                    audio->seq->eventToGui(e);
                                    }
                              else if (type == ME_CONTROLLER) {
                                    e.setController(event.buffer[1]);
                                    e.setValue(event.buffer[2]);
                                    audio->seq->eventToGui(e);
                                    }
                              }
                        }
                  }
            }
      if (l && r) {
            float buffer[frames * 2];
            audio->seq->process((unsigned)frames, buffer);
            float* sp = buffer;
            for (unsigned i = 0; i < frames; ++i) {
                  *l++ = *sp++;
                  *r++ = *sp++;
                  }
            }
      else {
            // JACK MIDI only
            float buffer[frames * 2];
            audio->seq->process((unsigned)frames, buffer);
            }
      return 0;
      }

//---------------------------------------------------------
//   jackError
//---------------------------------------------------------

static void jackError(const char *s)
      {
      qDebug("JACK ERROR: %s", s);
      }

//---------------------------------------------------------
//   noJackError
//---------------------------------------------------------

static void noJackError(const char*  s )
      {
      qDebug("noJACK ERROR: %s", s);
      }

//---------------------------------------------------------
//   init
//    return false on error
//---------------------------------------------------------

bool JackAudio::init(bool hot)
      {
      if (hot) {
            hotPlug();
            return true;
            }
      jack_set_error_function(noJackError);

      client = 0;
      timeSigTempoChanged = false;
      fakeState = Transport::STOP;
      strcpy(_jackName, "mscore");

      jack_options_t options = (jack_options_t)0;
      jack_status_t status;
      client = jack_client_open(_jackName, options, &status);

      if (client == 0) {
            qDebug("JackAudio()::init(): failed, status 0x%0x", status);
            return false;
            }

      jack_set_error_function(jackError);
      jack_set_process_callback(client, processAudio, this);
      //jack_on_shutdown(client, processShutdown, this);
      jack_set_sample_rate_callback(client, sampleRateCallback, this);
      jack_set_port_registration_callback(client, registration_callback, this);
      jack_set_graph_order_callback(client, graph_callback, this);
      jack_set_freewheel_callback (client, freewheel_callback, this);
      if (preferences.jackTimebaseMaster)
            setTimebaseCallback();
      if (jack_set_buffer_size_callback (client, bufferSizeCallback, this) != 0)
            qDebug("Can not set bufferSizeCallback");
      _segmentSize  = jack_get_buffer_size(client);

      MScore::sampleRate = sampleRate();
      // register mscore left/right output ports
      if (preferences.useJackAudio) {
            registerPort("left", false, false);
            registerPort("right", false, false);
            }

      if (preferences.useJackMidi) {
            registerPort(QString("mscore-midi-1"), false, true);
            registerPort(QString("mscore-midiin-1"), true, true);
            }
      return true;
      }

//---------------------------------------------------------
//   startTransport
//---------------------------------------------------------

void JackAudio::startTransport()
      {
      if (preferences.useJackTransport)
            jack_transport_start(client);
      else
            fakeState = Transport::PLAY;
      }

//---------------------------------------------------------
//   stopTrasnport
//---------------------------------------------------------

void JackAudio::stopTransport()
      {
      if (preferences.useJackTransport)
            jack_transport_stop(client);
      else
            fakeState = Transport::STOP;
      }

//---------------------------------------------------------
//   getState
//---------------------------------------------------------

Transport JackAudio::getState()
      {
      if (!preferences.useJackTransport)
            return fakeState;
      int transportState = jack_transport_query(client, NULL);
      switch (transportState) {
            case JackTransportStopped:  return Transport::STOP;
            case JackTransportLooping:
            case JackTransportRolling:  return Transport::PLAY;
            case JackTransportStarting: return seq->isPlaying()?Transport::PLAY:Transport::STOP;// Keep current state
            default:
                  return Transport::STOP;
            }
      }

//---------------------------------------------------------
//   putEvent
//---------------------------------------------------------

void JackAudio::putEvent(const NPlayEvent& e, unsigned framePos)
      {
      if (!preferences.useJackMidi)
            return;

      int portIdx = seq->score()->midiPort(e.channel());
      int chan    = seq->score()->midiChannel(e.channel());

// qDebug("JackAudio::putEvent %d:%d  pos %d(%d)", portIdx, chan, framePos, _segmentSize);

      if (portIdx < 0 || portIdx >= midiOutputPorts.size()) {
            qDebug("JackAudio::putEvent: invalid port %d", portIdx);
            return;
            }
      jack_port_t* port = midiOutputPorts[portIdx];
      if (midiOutputTrace) {
            const char* portName = jack_port_name(port);
            int a     = e.dataA();
            int b     = e.dataB();
            qDebug("MidiOut<%s>: jackMidi: %02x %02x %02x, chan: %i", portName, e.type(), a, b, chan);
            // e.dump();
            }
      void* pb = jack_port_get_buffer(port, _segmentSize);

      if (pb == NULL) {
            qDebug()<<"jack_port_get_buffer failed, cannot send anything";
            }

      if (framePos >= _segmentSize) {
            qDebug("JackAudio::putEvent: time out of range %d(seg=%d)", framePos, _segmentSize);
            if (framePos > _segmentSize)
                  framePos = _segmentSize - 1;
            }

      switch(e.type()) {
            case ME_NOTEON:
            case ME_NOTEOFF:
            case ME_POLYAFTER:
            case ME_CONTROLLER:
                  // Catch CTRL_PROGRAM and let other ME_CONTROLLER events to go
                  if (e.dataA() == CTRL_PROGRAM) {
                        // Convert CTRL_PROGRAM event to ME_PROGRAM
                        unsigned char* p = jack_midi_event_reserve(pb, framePos, 2);
                        if (p == 0) {
                              qDebug("JackMidi: buffer overflow, event lost");
                              return;
                              }
                        p[0] = ME_PROGRAM | chan;
                        p[1] = less128(e.dataB());
                        break;
                        }
                  //Fallback
            case ME_PITCHBEND:
                  {
                  unsigned char* p = jack_midi_event_reserve(pb, framePos, 3);
                  if (p == 0) {
                        qDebug("JackMidi: buffer overflow, event lost");
                        return;
                        }
                  p[0] = e.type() | chan;
                  p[1] = less128(e.dataA());
                  p[2] = less128(e.dataB());
                  }
                  break;

            case ME_PROGRAM:
            case ME_AFTERTOUCH:
                  {
                  unsigned char* p = jack_midi_event_reserve(pb, framePos, 2);
                  if (p == 0) {
                        qDebug("JackMidi: buffer overflow, event lost");
                        return;
                        }
                  p[0] = e.type() | chan;
                  p[1] = less128(e.dataA());
                  }
                  break;
          // Do we really need to handle ME_SYSEX?
          /*  case ME_SYSEX:
                  {
                  const unsigned char* data = e.edata();
                  int len = e.len();
                  unsigned char* p = jack_midi_event_reserve(pb, framePos, len+2);
                  if (p == 0) {
                        qDebug("JackMidi: buffer overflow, event lost");
                        return;
                        }
                  p[0]     = 0xf0;
                  p[len+1] = 0xf7;
                  memcpy(p+1, data, len);
                  }
                  break;*/
            case ME_SONGPOS:
            case ME_CLOCK:
            case ME_START:
            case ME_CONTINUE:
            case ME_STOP:
                  qDebug("JackMidi: event type %x not supported", e.type());
                  break;
            }
      }

//---------------------------------------------------------
//   midiRead
//---------------------------------------------------------

void JackAudio::midiRead()
      {
//      midiDriver->read();
      }

//---------------------------------------------------------
//   handleTimeSigTempoChanged
//   Called after tempo or time signature
//   changed while playback
//---------------------------------------------------------

void JackAudio::handleTimeSigTempoChanged()
      {
      timeSigTempoChanged = true;
      }

//---------------------------------------------------------
//   checkTransportSeek
//   The opposite of Timebase master:
//   check JACK Transport for a new position or tempo.
//---------------------------------------------------------

void JackAudio::checkTransportSeek(int cur_frame, int nframes, bool inCountIn)
      {
      if (!seq || !seq->score() || inCountIn)
            return;

      // Obtaining the current JACK Transport position
      jack_position_t pos;
      jack_transport_query(client, &pos);

      if (preferences.useJackTransport) {
            if (mscore->getPlayPanel() && mscore->getPlayPanel()->isTempoSliderPressed())
                  return;
            int cur_utick = seq->score()->utime2utick((qreal)cur_frame / MScore::sampleRate);
            int utick     = seq->score()->utime2utick((qreal)pos.frame / MScore::sampleRate);

            // Conversion is not precise, should check frames and uticks
            if (labs((long int)cur_frame - (long int)pos.frame)>nframes + 1 && abs(utick - cur_utick)> seq->score()->utime2utick((qreal)nframes / MScore::sampleRate) + 1) {
                  if (MScore::debugMode)
                        qDebug()<<"JACK Transport position changed, cur_frame: "<<cur_frame<<",pos.frame: "<<pos.frame<<", frame diff: "<<labs((long int)cur_frame - (long int)pos.frame)<<"cur utick:"<<cur_utick<<",seek to utick: "<<utick<<", tick diff: "<<abs(utick - cur_utick);
                  seq->seekRT(utick);
                  }
            }

      // Tempo
      if (!preferences.jackTimebaseMaster  && (pos.valid & JackPositionBBT)) {
            if (!seq->score()->tempomap())
                  return;

            if (int(pos.beats_per_minute) != int(60 * seq->curTempo() * seq->score()->tempomap()->relTempo())) {
                  if (MScore::debugMode)
                        qDebug()<<"JACK Transport tempo changed! JACK bpm: "<<(int)pos.beats_per_minute<<", current bpm: "<<int(60 * seq->curTempo() * seq->score()->tempomap()->relTempo());
                  if (60 * seq->curTempo() == 0.0)
                        return;
                  qreal newRelTempo = pos.beats_per_minute / (60* seq->curTempo());
                  seq->setRelTempo(newRelTempo);
                  // Update UI
                  if (mscore->getPlayPanel()) {
                        mscore->getPlayPanel()->setRelTempo(newRelTempo);
                        mscore->getPlayPanel()->setTempo(seq->curTempo() * newRelTempo);
                        }
                  }
            }
      }

//---------------------------------------------------------
//   seekTransport
//---------------------------------------------------------

void JackAudio::seekTransport(int utick)
      {
      if (MScore::debugMode)
            qDebug()<<"jack locate to utick: "<<utick<<", frame: "<<int(seq->score()->utick2utime(utick) * MScore::sampleRate);
      jack_transport_locate(client, seq->score()->utick2utime(utick) * MScore::sampleRate);
      }

//---------------------------------------------------------
//   setTimebaseCallback
//---------------------------------------------------------

void JackAudio::setTimebaseCallback()
      {
      int errCode = jack_set_timebase_callback(client, 0, timebase, this); // 0: force set timebase
      if (errCode == 0) {
            if (MScore::debugMode)
                  qDebug("Registered as JACK Timebase Master.");
            }
      else {
            preferences.jackTimebaseMaster = false;
            qDebug("Unable to take over JACK Timebase, error code: %i",errCode);
            }
      }

//---------------------------------------------------------
//   releaseTimebaseCallback
//---------------------------------------------------------

void JackAudio::releaseTimebaseCallback()
      {
      int errCode = jack_release_timebase(client);
      if (errCode == 0)
            qDebug("Unregistered as JACK Timebase Master");
      else
            qDebug("Unable to unregister as JACK Timebase Master (not a Timebase Master?), error code: %i", errCode);
      }

//---------------------------------------------------------
//   rememberAudioConnections
//---------------------------------------------------------

void JackAudio::rememberAudioConnections()
      {
      if (!preferences.rememberLastConnections)
            return;
      if (MScore::debugMode)
            qDebug("Saving audio connections...");
      QSettings settings;
      settings.setValue(QString("audio-0-connections"), 0);
      settings.setValue(QString("audio-1-connections"), 0);
      int port = 0;
      foreach(jack_port_t* mp, ports) {
            const char** cc = jack_port_get_connections(mp);
            const char** c = cc;
            int idx = 0;
            while (c) {
                  const char* p = *c++;
                  if (p == 0)
                        break;
                  settings.setValue(QString("audio-%1-%2").arg(port).arg(idx), p);
                  ++idx;
                  }
            settings.setValue(QString("audio-%1-connections").arg(port), idx);
            free((void*)cc);
            ++port;
            }
      }

//---------------------------------------------------------
//   restoreAudioConnections
//   Connect to the ports in Preferences->I/O
//---------------------------------------------------------

void JackAudio::restoreAudioConnections()
      {
      for (auto p : ports)
            jack_port_disconnect(client, p);

      QList<QString> portList = inputPorts();
      QList<QString>::iterator pi = portList.begin();

      QSettings settings;
      // Number of saved ports
      int n = settings.value(QString("audio-0-connections"), 0).toInt() + settings.value(QString("audio-1-connections"), 0).toInt();

      // Connecting to system ports
      if (!preferences.rememberLastConnections || n == 0) {
            if (MScore::debugMode)
                  qDebug("Connecting to system ports...");
            for (auto p : ports) {
                  const char* src = jack_port_name(p);
                  if (pi != portList.end()) {
                        connect(src, qPrintable(*pi));
                        ++pi;
                        }
                  }
            return;
            }
      if (MScore::debugMode)
            qDebug("Restoring audio connections...");
      // Connecting to saved ports
      int nPorts = ports.size();
      for (int i = 0; i < nPorts; ++i) {
            int n = settings.value(QString("audio-%1-connections").arg(i), 0).toInt();
            const char* src = jack_port_name(ports[i]);
            for (int k = 0; k < n; ++k) {
                  QString dst = settings.value(QString("audio-%1-%2").arg(i).arg(k), "").toString();
                  if (!dst.isEmpty()) {
                        if (jack_port_connected_to(ports[i], qPrintable(dst)))
                              qDebug()<<"Audio port "<<src<<" ("<<i<<") already connected to "<<qPrintable(dst);
                        else
                              connect(src, qPrintable(dst));
                        }
                  }
            }
      }

//---------------------------------------------------------
//   rememberMidiConnections
//---------------------------------------------------------

void JackAudio::rememberMidiConnections()
      {
      if (!preferences.rememberLastConnections)
            return;
      if (MScore::debugMode)
            qDebug("Saving midi connections...");
      QSettings settings;
      int port = 0;
      foreach(jack_port_t* mp, midiOutputPorts) {
            const char** cc = jack_port_get_connections(mp);
            const char** c = cc;
            int idx = 0;
            while (c) {
                  const char* p = *c++;
                  if (p == 0)
                        break;
                  settings.setValue(QString("midi-%1-%2").arg(port).arg(idx), p);
                  ++idx;
                  }
            settings.setValue(QString("midi-%1-connections").arg(port), idx);
            free((void*)cc);
            ++port;
            }

      port = 0;
      foreach(jack_port_t* mp, midiInputPorts) {
            const char** cc = jack_port_get_connections(mp);
            const char** c = cc;
            int idx = 0;
            while (c) {
                  const char* p = *c++;
                  if (p == 0)
                        break;
                  settings.setValue(QString("midiin-%1-%2").arg(idx).arg(port), p);
                  ++idx;
                  }
            settings.setValue(QString("midiin-%1-connections").arg(port), idx);
            free((void*)cc);
            ++port;
            }
      }

//---------------------------------------------------------
//   restoreMidiConnections
//   Connects to the ports from previous connection
//---------------------------------------------------------

void JackAudio::restoreMidiConnections()
      {
      if (!preferences.rememberLastConnections)
            return;
      if (MScore::debugMode)
            qDebug("Restoring midi connections...");
      QSettings settings;
      int nPorts = midiOutputPorts.size();
      for (int i = 0; i < nPorts; ++i) {
            int n = settings.value(QString("midi-%1-connections").arg(i), 0).toInt();
            const char* src = jack_port_name(midiOutputPorts[i]);
            for (int k = 0; k < n; ++k) {
                  QString dst = settings.value(QString("midi-%1-%2").arg(i).arg(k), "").toString();
                  if (!dst.isEmpty()) {
                        if (jack_port_connected_to(midiOutputPorts[i], qPrintable(dst)))
                              continue;
                        connect(src, qPrintable(dst));
                        }
                  }
            }
      nPorts = midiInputPorts.size();
      for (int i = 0; i < nPorts; ++i) {
            int n = settings.value(QString("midiin-%1-connections").arg(i), 0).toInt();
            const char* dst = jack_port_name(midiInputPorts[i]);
            for (int k = 0; k < n; ++k) {
                  QString src = settings.value(QString("midiin-%1-%2").arg(k).arg(i), "").toString();
                  if (!src.isEmpty()) {
                        if (jack_port_connected_to(midiInputPorts[i], qPrintable(src)))
                              continue;
                        connect(qPrintable(src), dst);
                        }
                  }
            }
      }

//---------------------------------------------------------
//   hotPlug
//   Change driver settings without unload
//---------------------------------------------------------

void JackAudio::hotPlug()
      {
      bool oldremember = preferences.rememberLastConnections;
      preferences.rememberLastConnections = true;
      // Remember connections before calling jack_deactivate() - it disconnects all ports
      rememberMidiConnections();
      if (ports.size() != 0)
            rememberAudioConnections();

      // We must set callbacks only on inactive client
      if (jack_deactivate(client))
            qDebug("cannot deactivate client");

      // Audio connections
      if (preferences.useJackAudio) {
            if (ports.size() == 0) {
                  registerPort("left", false, false);
                  registerPort("right", false, false);
                  }
            }
      else if (!preferences.useJackAudio) {
            foreach(jack_port_t* p, ports) {
                  unregisterPort(p);
                  ports.removeOne(p);
                  }
            }

      // Midi connections
      if (preferences.useJackMidi) {
            if (midiInputPorts.size() == 0)
                  registerPort(QString("mscore-midiin-1"), true, true);
            }
      else { // No midi
            updateOutPortCount(0);
            if (midiInputPorts.size() != 0) {
                  unregisterPort(midiInputPorts[0]);
                  midiInputPorts.removeOne(midiInputPorts[0]);
                  }
            }

      // Timebase Master callback
      if (preferences.jackTimebaseMaster)
            setTimebaseCallback();
      else
            releaseTimebaseCallback();

      preferences.rememberLastConnections = oldremember;
      }
}