midi++2/midi++/port.h

Go to the documentation of this file.

/*
 * Copyright (C) 1998-2017 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2006-2012 David Robillard <d@drobilla.net>
 * Copyright (C) 2010 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2013 John Emmas <john@creativepost.co.uk>
 *
 * This program 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.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <string>
#include <iostream>
 
#include <pthread.h>
 
#include "pbd/xml++.h"
#ifndef PLATFORM_WINDOWS
#include "pbd/crossthread.h"
#endif
#include "pbd/signals.h"
#include "pbd/ringbuffer.h"
 
#include "midi++/libmidi_visibility.h"
#include "midi++/types.h"
#include "midi++/parser.h"
 
namespace MIDI {
 
class Channel;
class PortRequest;
 
class LIBMIDIPP_API Port {
  public:
        enum Flags {
                IsInput = 0x1,  /* MUST MATCH JACK's JackPortIsInput */
                IsOutput = 0x2, /* MUST MATCH JACK's JackPortIsOutput */
        };
 
        Port (std::string const &, Flags);
        Port (const XMLNode&);
        virtual ~Port ();
 
        virtual XMLNode& get_state () const;
        virtual void set_state (const XMLNode&);
 
        virtual int write (const byte *msg, size_t msglen, timestamp_t timestamp) = 0;
 
        virtual int read (byte *buf, size_t bufsize) = 0;
 
        virtual void drain (int /* check_interval_usecs */, int /* total_usecs_to_wait */) {}
 
        int midimsg (byte *msg, size_t len, timestamp_t timestamp) {
                return !(write (msg, len, timestamp) == (int) len);
        }
 
        virtual void parse (samplecnt_t timestamp) = 0;
 
        bool clock (timestamp_t timestamp);
 
        /* select(2)/poll(2)-based I/O */
 
        virtual int selectable () const = 0;
 
        Channel *channel (channel_t chn) {
                return _channel[chn&0x7F];
        }
 
        Parser* parser () {
                return _parser;
        }
 
        const char *name () const   { return _tagname.c_str(); }
        bool   ok ()   const        { return _ok; }
 
        virtual bool centrally_parsed() const;
        void set_centrally_parsed (bool yn) { _centrally_parsed = yn; }
 
        bool receives_input () const {
                return _flags == IsInput;
        }
 
        bool sends_output () const {
                return _flags == IsOutput;
        }
 
        struct Descriptor {
            std::string tag;
            Flags flags;
 
            Descriptor (const XMLNode&);
            XMLNode& get_state() const;
        };
 
        static std::string state_node_name;
 
  protected:
        bool              _ok;
        std::string       _tagname;
        Channel*          _channel[16];
        Parser*           _parser;
        Flags             _flags;
        bool              _centrally_parsed;
 
        void init (std::string const &, Flags);
};
 
struct LIBMIDIPP_API PortSet {
    PortSet (std::string str) : owner (str) { }
 
    std::string owner;
    std::list<XMLNode> ports;
};
 
std::ostream & operator << (std::ostream& os, const Port& port);
 
} // namespace MIDI