Remove non-JACK midi++ ports.

git-svn-id: svn://localhost/ardour2/branches/3.0@7377 d708f5d6-7413-0410-9779-e7cbd77b26cf

1 files changed, 62 insertions, 78 deletions

diff --git a/libs/midi++2/midi++/port.h b/libs/midi++2/midi++/port.h
index c45f5ba2fc..8c875a6615 100644
--- a/libs/midi++2/midi++/port.h
+++ b/libs/midi++2/midi++/port.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 1998-99 Paul Barton-Davis 
+    Copyright (C) 1998-2010 Paul Barton-Davis 
     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
@@ -22,7 +22,15 @@
 #include <string>
 #include <iostream>
 
+#include <jack/types.h>
+
 #include "pbd/xml++.h"
+#include "pbd/crossthread.h"
+#include "pbd/signals.h"
+#include "pbd/ringbuffer.h"
+
+#include "evoral/Event.hpp"
+#include "evoral/EventRingBuffer.hpp"
 
 #include "midi++/types.h"
 #include "midi++/parser.h"
@@ -34,29 +42,18 @@ class PortRequest;
 
 class Port {
   public:
-	enum Type {
-		Unknown,
-		JACK_Midi,
-		ALSA_RawMidi,
-		ALSA_Sequencer,
-		CoreMidi_MidiPort,
-		Null,
-		FIFO
-	};
-
+	Port (const XMLNode&, jack_client_t *);
+	~Port ();
 
-	Port (const XMLNode&);
-	virtual ~Port ();
-
-	virtual XMLNode& get_state () const;
-	virtual void set_state (const XMLNode&);
+	XMLNode& get_state () const;
+	void set_state (const XMLNode&);
 
 	// FIXME: make Manager a friend of port so these can be hidden?
 
 	/* Only for use by MidiManager.  Don't ever call this. */
-	virtual void cycle_start(nframes_t nframes);
+	void cycle_start(nframes_t nframes);
 	/* Only for use by MidiManager.  Don't ever call this. */
-	virtual void cycle_end();
+	void cycle_end();
 
 	/** Write a message to port.
 	 * @param msg Raw MIDI message to send
@@ -64,14 +61,14 @@ class Port {
 	 * @param timestamp Time stamp in frames of this message (relative to cycle start)
 	 * @return number of bytes successfully written
 	 */
-	virtual int write (byte *msg, size_t msglen, timestamp_t timestamp) = 0;	
+	int write (byte *msg, size_t msglen, timestamp_t timestamp);
 
 	/** Read raw bytes from a port.
 	 * @param buf memory to store read data in
 	 * @param bufsize size of @a buf
 	 * @return number of bytes successfully read, negative if error
 	 */
-	virtual int read (byte *buf, size_t bufsize) = 0;
+	int read (byte *buf, size_t bufsize);
 
 	void parse (nframes_t timestamp);
 	
@@ -83,103 +80,90 @@ class Port {
 		return !(write (msg, len, timestamp) == (int) len);
 	} 
 
-	int three_byte_msg (byte a, byte b, byte c, timestamp_t timestamp) {
-		byte msg[3];
-
-		msg[0] = a;
-		msg[1] = b;
-		msg[2] = c;
-
-		return !(write (msg, 3, timestamp) == 3);
-	} 
-	
 	bool clock (timestamp_t timestamp);
-	
-	/* slowdown i/o to a loop of single byte emissions
-	   interspersed with a busy loop of 10000 * this value.
-
-	   This may be ignored by a particular instance
-	   of this virtual class. See FD_MidiPort for an 
-	   example of where it used.  
-	*/
-
-	void set_slowdown (size_t n) { slowdown = n; }
 
 	/* select(2)/poll(2)-based I/O */
 
 	/** Get the file descriptor for port.
 	 * @return File descriptor, or -1 if not selectable. 
 	 */
-	virtual int selectable() const = 0;
-	virtual bool must_drain_selectable() const { return false; }
+	int selectable () const {
+		return xthread.selectable();
+	}
 
-	static void gtk_read_callback (void *ptr, int fd, int cond);
-	static void write_callback (byte *msg, unsigned int len, void *);
-	
 	Channel *channel (channel_t chn) { 
 		return _channel[chn&0x7F];
 	}
 	
 	Parser *input()     { return input_parser; }
 	Parser *output()    { return output_parser; }
-
-	void iostat (int *written, int *read, 
-		     const size_t **in_counts,
-		     const size_t **out_counts) {
-
-		*written = bytes_written;
-		*read = bytes_read;
-		if (input_parser) {
-			*in_counts = input_parser->message_counts();
-		} else {
-			*in_counts = 0;
-		}
-		if (output_parser) {
-			*out_counts = output_parser->message_counts();
-		} else {
-			*out_counts = 0;
-		}
-	}
 	
-	const char *device () const { return _devname.c_str(); }
 	const char *name () const   { return _tagname.c_str(); }
-	Type   type () const        { return _type; }
 	int    mode () const        { return _mode; }
 	bool   ok ()   const        { return _ok; }
 
 	struct Descriptor {
 	    std::string tag;
-	    std::string device;
 	    int mode;
-	    Port::Type type;
 
 	    Descriptor (const XMLNode&);
 	    XMLNode& get_state();
 	};
 
-	virtual void reestablish (void *) {}
-	virtual void reconnect () {}
+	nframes_t nframes_this_cycle() const {	return _nframes_this_cycle; }
 
-  protected:
+	void reestablish (void *);
+	void reconnect ();
+
+	static void set_process_thread (pthread_t);
+	static pthread_t get_process_thread () { return _process_thread; }
+	static bool is_process_thread();
+	
+	static PBD::Signal0<void> MakeConnections;
+	static PBD::Signal0<void> JackHalted;
+
+private:	
 	bool             _ok;
 	bool             _currently_in_cycle;
 	nframes_t        _nframes_this_cycle;
-	Type             _type;
-	std::string      _devname;
 	std::string      _tagname;
 	int              _mode;
 	size_t           _number;
 	Channel          *_channel[16];
-	unsigned int     bytes_written;
-	unsigned int     bytes_read;
 	Parser           *input_parser;
 	Parser           *output_parser;
-	size_t           slowdown;
-
-	virtual std::string get_typestring () const = 0;
 
-  private:
 	static size_t nports;
+
+	int create_ports(const XMLNode&);
+	int create_ports ();
+
+	jack_client_t* _jack_client;
+	std::string    _jack_input_port_name; /// input port name, or empty if there isn't one
+	jack_port_t*   _jack_input_port;
+	std::string    _jack_output_port_name; /// output port name, or empty if there isn't one
+	jack_port_t*   _jack_output_port;
+	nframes_t      _last_read_index;
+	timestamp_t    _last_write_timestamp;
+
+	/** Channel used to signal to the MidiControlUI that input has arrived */
+	CrossThreadChannel xthread;
+	
+	std::string    _inbound_connections;
+	std::string    _outbound_connections;
+	PBD::ScopedConnection connect_connection;
+	PBD::ScopedConnection halt_connection;
+	void flush (void* jack_port_buffer);
+	void jack_halted ();
+	void make_connections();
+
+	static pthread_t _process_thread;
+
+	RingBuffer< Evoral::Event<double> > output_fifo;
+	Evoral::EventRingBuffer<timestamp_t> input_fifo;
+
+	Glib::Mutex output_fifo_lock;
+	
 };
 
 struct PortSet {