X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fmidi_source.h;h=3564fff4fcc4fa38d9e752311447629263f0704d;hb=355183f1abea75d8fab0926cd7e7130796574cb0;hp=1c002890033270706779ff9be583e3273ea8b175;hpb=30c08ba655330232767554c48bda1975bfb5628c;p=ardour.git diff --git a/libs/ardour/ardour/midi_source.h b/libs/ardour/ardour/midi_source.h index 1c00289003..3564fff4fc 100644 --- a/libs/ardour/ardour/midi_source.h +++ b/libs/ardour/ardour/midi_source.h @@ -1,6 +1,6 @@ /* - Copyright (C) 2006 Paul Davis - Written by Dave Robillard, 2006 + Copyright (C) 2006 Paul Davis + Author: David Robillard 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 @@ -21,61 +21,159 @@ #define __ardour_midi_source_h__ #include - #include - #include - -#include - -#include -#include -#include -#include - -using std::string; +#include +#include "pbd/stateful.h" +#include "pbd/xml++.h" +#include "evoral/Sequence.hpp" +#include "ardour/ardour.h" +#include "ardour/buffer.h" +#include "ardour/source.h" +#include "ardour/beats_frames_converter.h" namespace ARDOUR { -/** Source for raw MIDI data */ -class MidiSource : public Source +class MidiStateTracker; +class MidiModel; +template class MidiRingBuffer; + +/** Source for MIDI data */ +class MidiSource : virtual public Source, public boost::enable_shared_from_this { public: - MidiSource (string name); - MidiSource (const XMLNode&); + typedef double TimeType; + + MidiSource (Session& session, std::string name, Source::Flag flags = Source::Flag(0)); + MidiSource (Session& session, const XMLNode&); virtual ~MidiSource (); - virtual jack_nframes_t read (RawMidi *dst, jack_nframes_t start, jack_nframes_t cnt) const; - virtual jack_nframes_t write (RawMidi *src, jack_nframes_t cnt); + boost::shared_ptr clone (Evoral::MusicalTime begin = Evoral::MinMusicalTime, + Evoral::MusicalTime end = Evoral::MaxMusicalTime); + + /** Read the data in a given time range from the MIDI source. + * All time stamps in parameters are in audio frames (even if the source has tempo time). + * \param dst Ring buffer where read events are written + * \param source_start Start position of the SOURCE in this read context + * \param start Start of range to be read + * \param cnt Length of range to be read (in audio frames) + * \param tracker an optional pointer to MidiStateTracker object, for note on/off tracking + */ + virtual framecnt_t midi_read (Evoral::EventSink& dst, + framepos_t source_start, + framepos_t start, framecnt_t cnt, + MidiStateTracker*, + std::set const &) const; - virtual void mark_for_remove() = 0; - virtual void mark_streaming_write_completed () {} + virtual framecnt_t midi_write (MidiRingBuffer& src, + framepos_t source_start, + framecnt_t cnt); - string captured_for() const { return _captured_for; } - void set_captured_for (string str) { _captured_for = str; } + virtual void append_event_unlocked_beats(const Evoral::Event& ev) = 0; - uint32_t read_data_count() const { return _read_data_count; } - uint32_t write_data_count() const { return _write_data_count; } + virtual void append_event_unlocked_frames(const Evoral::Event& ev, + framepos_t source_start) = 0; + + virtual bool empty () const; + virtual framecnt_t length (framepos_t pos) const; + virtual void update_length (framepos_t pos, framecnt_t cnt); + + virtual void mark_streaming_midi_write_started (NoteMode mode); + virtual void mark_streaming_write_started (); + virtual void mark_streaming_write_completed (); + void mark_write_starting_now (); + + /* like ::mark_streaming_write_completed() but with more arguments to + * allow control over MIDI-specific behaviour. Expected to be used only + * when recording actual MIDI input, rather then when importing files + * etc. + */ + virtual void mark_midi_streaming_write_completed (Evoral::Sequence::StuckNoteOption, Evoral::MusicalTime when = 0); + + virtual void session_saved(); + + std::string captured_for() const { return _captured_for; } + void set_captured_for (std::string str) { _captured_for = str; } + + framepos_t last_write_end() const { return _last_write_end; } + void set_last_write_end (framepos_t pos) { _last_write_end = pos; } + + static PBD::Signal1 MidiSourceCreated; - static sigc::signal MidiSourceCreated; - - mutable sigc::signal PeaksReady; - mutable sigc::signal PeakRangeReady; - XMLNode& get_state (); - int set_state (const XMLNode&); + int set_state (const XMLNode&, int version); + + bool length_mutable() const { return true; } + + void set_length_beats(double l) { _length_beats = l; } + double length_beats() const { return _length_beats; } + + virtual void load_model(bool lock=true, bool force_reload=false) = 0; + virtual void destroy_model() = 0; + + /** This must be called with the source lock held whenever the + * source/model contents have been changed (reset iterators/cache/etc). + */ + void invalidate(); + + void set_note_mode(NoteMode mode); + + boost::shared_ptr model() { return _model; } + void set_model (boost::shared_ptr); + void drop_model(); + + Evoral::ControlList::InterpolationStyle interpolation_of (Evoral::Parameter) const; + void set_interpolation_of (Evoral::Parameter, Evoral::ControlList::InterpolationStyle); + void copy_interpolation_from (boost::shared_ptr); + void copy_interpolation_from (MidiSource *); + + AutoState automation_state_of (Evoral::Parameter) const; + void set_automation_state_of (Evoral::Parameter, AutoState); + void copy_automation_state_from (boost::shared_ptr); + void copy_automation_state_from (MidiSource *); + + /** Emitted when a different MidiModel is set */ + PBD::Signal0 ModelChanged; + /** Emitted when a parameter's interpolation style is changed */ + PBD::Signal2 InterpolationChanged; + /** Emitted when a parameter's automation state is changed */ + PBD::Signal2 AutomationStateChanged; protected: - virtual jack_nframes_t read_unlocked (RawMidi* dst, jack_nframes_t start, jack_nframes_t cn) const = 0; - virtual jack_nframes_t write_unlocked (RawMidi* dst, jack_nframes_t cnt) = 0; - - mutable Glib::Mutex _lock; - string _captured_for; - mutable uint32_t _read_data_count; ///< modified in read() - mutable uint32_t _write_data_count; ///< modified in write() - - private: - bool file_changed (string path); + virtual void flush_midi() = 0; + + virtual framepos_t read_unlocked (Evoral::EventSink& dst, + framepos_t position, + framepos_t start, framecnt_t cnt, + MidiStateTracker* tracker) const = 0; + + virtual framepos_t write_unlocked (MidiRingBuffer& dst, + framepos_t position, + framecnt_t cnt) = 0; + + std::string _captured_for; + + boost::shared_ptr _model; + bool _writing; + + mutable Evoral::Sequence::const_iterator _model_iter; + mutable bool _model_iter_valid; + + mutable double _length_beats; + mutable framepos_t _last_read_end; + framepos_t _last_write_end; + + /** Map of interpolation styles to use for Parameters; if they are not in this map, + * the correct interpolation style can be obtained from EventTypeMap::interpolation_of () + */ + typedef std::map InterpolationStyleMap; + InterpolationStyleMap _interpolation_style; + + /** Map of automation states to use for Parameters; if they are not in this map, + * the correct automation state is Off. + */ + typedef std::map AutomationStateMap; + AutomationStateMap _automation_state; }; }