1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
//=========================================================
// MusE
// Linux Music Editor
// $Id: jackmidi.h,v 1.1.1.1 2010/01/27 09:06:43 terminator356 Exp $
// (C) Copyright 1999-2010 Werner Schweer (ws@seh.de)
//=========================================================
#ifndef __JACKMIDI_H__
#define __JACKMIDI_H__
//#include <config.h>
#include <map>
#include <jack/jack.h>
#include <jack/midiport.h>
#include "mididev.h"
#include "route.h"
class QString;
//class MidiFifo;
class MidiRecordEvent;
class MidiPlayEvent;
//class RouteList;
class Xml;
// Turn on to show multiple devices, work in progress,
// not working fully yet, can't seem to connect...
//#define JACK_MIDI_SHOW_MULTIPLE_DEVICES
// It appears one client port per remote port will be necessary.
// Jack doesn't seem to like manipulation of non-local ports buffers.
//#define JACK_MIDI_USE_MULTIPLE_CLIENT_PORTS
/* jack-midi channels */
//#define JACK_MIDI_CHANNELS 32
/* jack-midi buffer size */
//#define JACK_MIDI_BUFFER_SIZE 32
/*
typedef struct {
int give;
int take;
// 32 parallel midi events, where each event contains three
// midi-bytes and one busy-byte
char buffer[4 * JACK_MIDI_BUFFER_SIZE];
} muse_jack_midi_buffer;
*/
/*
struct JackMidiPort
{
jack_port_t* _jackPort;
QString _name;
int _flags; // 1 = writable, 2 = readable - do not mix
JackMidiPort(jack_port_t* jp, const QString& s, int f)
{
_jackPort = jp;
_name = QString(s);
_flags = f;
}
};
typedef std::map<jack_port_t*, JackMidiPort, std::less<jack_port_t*> >::iterator iJackMidiPort;
typedef std::map<jack_port_t*, JackMidiPort, std::less<jack_port_t*> >::const_iterator ciJackMidiPort;
class JackMidiPortList : public std::map<jack_port_t*, JackMidiPort, std::less<jack_port_t*> >
{
private:
static int _nextOutIdNum;
static int _nextInIdNum;
public:
JackMidiPortList();
~JackMidiPortList();
iJackMidiPort createClientPort(int flags);
bool removeClientPort(jack_port_t* port);
};
extern JackMidiPortList jackMidiClientPorts;
*/
//---------------------------------------------------------
// MidiJackDevice
//---------------------------------------------------------
class MidiJackDevice : public MidiDevice {
public:
//int adr;
private:
// fifo for midi events sent from gui
// direct to midi port:
//MidiFifo eventFifo; // Moved into MidiDevice p4.0.15
//static int _nextOutIdNum;
//static int _nextInIdNum;
//jack_port_t* _client_jackport;
// p3.3.55
jack_port_t* _in_client_jackport;
jack_port_t* _out_client_jackport;
//RouteList _routes;
virtual QString open();
virtual void close();
//bool putEvent(int*);
bool processEvent(const MidiPlayEvent&);
// Port is not midi port, it is the port(s) created for MusE.
bool queueEvent(const MidiPlayEvent&);
virtual bool putMidiEvent(const MidiPlayEvent&);
//bool sendEvent(const MidiPlayEvent&);
void eventReceived(jack_midi_event_t*);
public:
//MidiJackDevice() {} // p3.3.55 Removed.
//MidiJackDevice(const int&, const QString& name);
//MidiJackDevice(jack_port_t* jack_port, const QString& name);
//MidiJackDevice(jack_port_t* in_jack_port, jack_port_t* out_jack_port, const QString& name); // p3.3.55 In or out port can be null.
MidiJackDevice(const QString& name);
//static MidiDevice* createJackMidiDevice(QString /*name*/, int /*rwflags*/); // 1:Writable 2: Readable. Do not mix.
static MidiDevice* createJackMidiDevice(QString name = "", int rwflags = 3); // p3.3.55 1:Writable 2: Readable 3: Writable + Readable
virtual inline int deviceType() const { return JACK_MIDI; }
virtual void setName(const QString&);
virtual void processMidi();
virtual ~MidiJackDevice();
//virtual int selectRfd();
//virtual int selectWfd();
//virtual void processInput();
virtual void recordEvent(MidiRecordEvent&);
virtual bool putEvent(const MidiPlayEvent&);
virtual void collectMidiEvents();
//virtual jack_port_t* jackPort() { return _jackport; }
//virtual jack_port_t* clientJackPort() { return _client_jackport; }
//virtual void* clientPort() { return (void*)_client_jackport; }
// p3.3.55
virtual void* inClientPort() { return (void*) _in_client_jackport; }
virtual void* outClientPort() { return (void*) _out_client_jackport; }
//RouteList* routes() { return &_routes; }
//bool noRoute() const { return _routes.empty(); }
virtual void writeRouting(int, Xml&) const;
};
extern bool initMidiJack();
//extern int jackSelectRfd();
//extern int jackSelectWfd();
//extern void jackProcessMidiInput();
//extern void jackScanMidiPorts();
#endif
|
