JackPortMonitor.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream 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 have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */
#ifndef JACKPORTMANAGER_H_
#define JACKPORTMANAGER_H_

#include "JackBase.H"

#define JACK_PORT_MONITOR_CLIENT_NAME "Jack Port Monitor" 

#include "Thread.H"

class JackPortMonitor : virtual public JackBase, public WaitingThread {

    void init(bool monitorPorts);

    void init(bool monitorPorts, bool autoConnectNetClientsIn);

    void connectPortMonitoringCallbacks(void);

    static void jackPortConnectCallback(jack_port_id_t a, jack_port_id_t b, int connect, void *arg) {
        //cout<<"\njackPortConnectCallback\n"<<endl;
        static_cast<JackPortMonitor*>(arg)->jackPortConnected(a, b, connect);
    }

    static void jackPortRegistrationCallback(jack_port_id_t port, int reg, void *arg) {
        //cout<<"\njackPortRegistrationCallback\n"<<endl;
        static_cast<JackPortMonitor*>(arg)->jackPortRegistered(port, reg);
    }

    static void jackPortRenameCallback(jack_port_id_t port, const char *oldName, const char *newName, void *arg) {
        //cout<<"\njackPortRenameCallback\n"<<endl;
        static_cast<JackPortMonitor*>(arg)->jackPortRenamed(port, oldName, newName);
    }

    virtual void breakDownPortsToClients(vector<jack_port_t *> &ports);

    void reSyncPorts(JackPortFlags flags);


    virtual int disconnect(void);


    virtual int connect(string clientName_){return JackBase::connect(clientName_);}

    virtual int connect(const string &clientName_, const string &serverName);

    virtual void *threadMain(void);

protected:

    struct CompareStrings : unary_function<string,bool> {
    public:
        string cn; 

        CompareStrings(string cn_) : cn(cn_) {}

        bool operator()(JackBaseWithPortNames *cl) {
            return cl->getClientName()==cn;
        }
    };

    vector<JackBaseWithPortNames *> knownClients; 

    bool autoConnectNetClients; 

    virtual void autoConnectNetClientsPorts(void);

    virtual void reSyncPorts(void);

    virtual void reSyncConnections(void);

    virtual void jackPortConnected(jack_port_id_t a, jack_port_id_t b, int connect) {
        reSyncConnections();
        this->print(cout);
    }

    virtual void jackPortRegistered(jack_port_id_t port, int reg) {
        if (autoConnectNetClients){
            //autoConnectNetClientsPorts(); // can't connect ports in a critical server thread.
            // Instruct the network port manager thread to connect the net ports.
            cond.lock(); // lock the mutex and wake the thread.
            cond.signal(); // Wake the WaitingThread
            cond.unLock(); // Unlock so the WaitingThread can continue.
        }
        reSyncPorts();
        reSyncConnections();
        this->print(cout);
    }

    virtual void jackPortRenamed(jack_port_id_t port, const char *oldName, const char *newName) {
        reSyncPorts();
        reSyncConnections();
            this->print(cout);
    }

public:
    JackPortMonitor();

    JackPortMonitor(bool monitorPorts);


    JackPortMonitor(bool monitorPorts, bool autoConnectNetClientsIn);

    JackPortMonitor(string clientName_);

    JackPortMonitor(string clientName_, bool monitorPorts);

    JackPortMonitor(string clientName_, bool monitorPorts, bool autoConnectNetClientsIn);

    JackPortMonitor(string clientName_, string serverName);

    JackPortMonitor(string clientName_, string serverName, bool monitorPorts);

    JackPortMonitor(string clientName_, string serverName, bool monitorPorts, bool autoConnectNetClients);

    JackPortMonitor(JackBase &jb);

    virtual ~JackPortMonitor() {}

    virtual void print(ostream &os);

    void connectPortRenameCallback(void);

    void connectPortRegistrationCallback(void);

    void connectPortConnectCallback(void);


//    /** Allow printing of port information to an ostream.
//    \param os The ostream to output to.
//    \param jpm The JackPortMonitor to print out.
//    */
//    friend ostream &operator<<(ostream &os, JackPortMonitor &jpm);
};

//ostream &operator<<(ostream &os, JackPortMonitor &jpm){
//    jpm.print(os);
//    return os;
//}

#endif // JACKPORTMANAGER_H_