X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fmidi%2B%2B2%2Fmidi%2B%2B%2Fchannel.h;h=6bd08073b371c9518a5d21e715ae2d2abf2535bd;hb=22fd92f97c5ff2bb1890a3b88085bed5c035498e;hp=f8dbb6e194381348350d4941723fecc5eb7a3af3;hpb=79986643c0c904f6574bb5323e2233a43a9e622e;p=ardour.git diff --git a/libs/midi++2/midi++/channel.h b/libs/midi++2/midi++/channel.h index f8dbb6e194..6bd08073b3 100644 --- a/libs/midi++2/midi++/channel.h +++ b/libs/midi++2/midi++/channel.h @@ -1,5 +1,5 @@ /* - Copyright (C) 1998-99 Paul Barton-Davis + Copyright (C) 1998-99 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 @@ -15,133 +15,158 @@ along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - $Id$ */ #ifndef __midichannel_h__ #define __midichannel_h__ #include +#include -#include - -#include -#include +#include "pbd/signals.h" +#include "midi++/parser.h" namespace MIDI { class Port; -class Channel : public sigc::trackable { +/** Stateful MIDI channel class. + * + * This remembers various useful information about the current 'state' of a + * MIDI channel (eg current pitch bend value). + */ +class LIBMIDIPP_API Channel : public PBD::ScopedConnectionList { public: Channel (byte channel_number, Port &); - Port &midi_port() { return port; } - byte channel() { return channel_number; } - byte program() { return program_number; } - byte bank() { return bank_number; } - byte pressure () { return chanpress; } - byte poly_pressure (byte n) { return polypress[n]; } + Port &midi_port() { return _port; } + byte channel() { return _channel_number; } + byte program() { return _program_number; } + unsigned short bank() { return _bank_number; } + byte pressure () { return _chanpress; } + byte poly_pressure (byte n) { return _polypress[n]; } - byte last_note_on () { + byte last_note_on () { return _last_note_on; } - byte last_on_velocity () { + byte last_on_velocity () { return _last_on_velocity; } - byte last_note_off () { + byte last_note_off () { return _last_note_off; } - byte last_off_velocity () { + byte last_off_velocity () { return _last_off_velocity; } - pitchbend_t pitchbend () { - return pitch_bend; + pitchbend_t pitchbend () { + return _pitch_bend; } - controller_value_t controller_value (byte n) { - return controller_val[n%128]; + controller_value_t controller_value (byte n) { + return _controller_val[n%128]; } controller_value_t *controller_addr (byte n) { - return &controller_val[n%128]; + return &_controller_val[n%128]; } void set_controller (byte n, byte val) { - controller_val[n%128] = val; + _controller_val[n%128] = val; } - int channel_msg (byte id, byte val1, byte val2); + controller_value_t rpn_value (uint16_t rpn_id); + controller_value_t nrpn_value (uint16_t rpn_id); - int all_notes_off () { - return channel_msg (MIDI::controller, 123, 0); + bool channel_msg (byte id, byte val1, byte val2, timestamp_t timestamp); + bool all_notes_off (timestamp_t timestamp) { + return channel_msg (MIDI::controller, 123, 0, timestamp); } - - int control (byte id, byte value) { - return channel_msg (MIDI::controller, id, value); + + bool control (byte id, byte value, timestamp_t timestamp) { + return channel_msg (MIDI::controller, id, value, timestamp); } - - int note_on (byte note, byte velocity) { - return channel_msg (MIDI::on, note, velocity); + + bool note_on (byte note, byte velocity, timestamp_t timestamp) { + return channel_msg (MIDI::on, note, velocity, timestamp); } - - int note_off (byte note, byte velocity) { - return channel_msg (MIDI::off, note, velocity); + + bool note_off (byte note, byte velocity, timestamp_t timestamp) { + return channel_msg (MIDI::off, note, velocity, timestamp); } - - int aftertouch (byte value) { - return channel_msg (MIDI::chanpress, value, 0); + + bool aftertouch (byte value, timestamp_t timestamp) { + return channel_msg (MIDI::chanpress, value, 0, timestamp); } - int poly_aftertouch (byte note, byte value) { - return channel_msg (MIDI::polypress, note, value); + bool poly_aftertouch (byte note, byte value, timestamp_t timestamp) { + return channel_msg (MIDI::polypress, note, value, timestamp); } - int program_change (byte value) { - return channel_msg (MIDI::program, value, 0); + bool program_change (byte value, timestamp_t timestamp) { + return channel_msg (MIDI::program, value, 0, timestamp); } - int pitchbend (byte msb, byte lsb) { - return channel_msg (MIDI::pitchbend, lsb, msb); + bool pitchbend (byte msb, byte lsb, timestamp_t timestamp) { + return channel_msg (MIDI::pitchbend, lsb, msb, timestamp); } + float rpn_value (uint16_t rpn) const; + float nrpn_value (uint16_t nrpn) const; + float rpn_value_absolute (uint16_t rpn) const; + float nrpn_value_absolute (uint16_t nrpn) const; + protected: friend class Port; - void connect_input_signals (); - void connect_output_signals (); + void connect_signals (); private: - Port &port; + Port& _port; + + enum RPNState { + HaveLSB = 0x1, + HaveMSB = 0x2, + HaveValue = 0x4 + }; /* Current channel values */ + byte _channel_number; + unsigned short _bank_number; + byte _program_number; + byte _rpn_msb; + byte _rpn_lsb; + byte _rpn_val_msb; + byte _rpn_val_lsb; + byte _nrpn_msb; + byte _nrpn_lsb; + byte _nrpn_val_lsb; + byte _nrpn_val_msb; + RPNState _rpn_state; + RPNState _nrpn_state; + byte _chanpress; + byte _polypress[128]; + bool _controller_14bit[128]; + controller_value_t _controller_val[128]; + byte _controller_msb[128]; + byte _controller_lsb[128]; + byte _last_note_on; + byte _last_on_velocity; + byte _last_note_off; + byte _last_off_velocity; + pitchbend_t _pitch_bend; + bool _omni; + bool _poly; + bool _mono; + size_t _notes_on; + + typedef std::map RPNList; + + RPNList rpns; + RPNList nrpns; + + void reset (timestamp_t timestamp, framecnt_t nframes, bool notes_off = true); - byte channel_number; - byte bank_number; - byte program_number; - byte rpn_msb; - byte rpn_lsb; - byte nrpn_msb; - byte nrpn_lsb; - byte chanpress; - byte polypress[128]; - bool controller_14bit[128]; - controller_value_t controller_val[128]; - byte controller_msb[128]; - byte controller_lsb[128]; - byte _last_note_on; - byte _last_on_velocity; - byte _last_note_off; - byte _last_off_velocity; - pitchbend_t pitch_bend; - bool _omni; - bool _poly; - bool _mono; - size_t _notes_on; - - void reset (bool notes_off = true); - void process_note_off (Parser &, EventTwoBytes *); void process_note_on (Parser &, EventTwoBytes *); void process_controller (Parser &, EventTwoBytes *); @@ -150,6 +175,14 @@ class Channel : public sigc::trackable { void process_chanpress (Parser &, byte); void process_pitchbend (Parser &, pitchbend_t); void process_reset (Parser &); + bool maybe_process_rpns (Parser&, EventTwoBytes *); + + void rpn_reset (); + void nrpn_reset (); + + static const RPNState RPN_READY_FOR_VALUE; + static const RPNState RPN_VALUE_READY; + }; } // namespace MIDI