X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fardour%2Fmidi_source.h;h=ba50102ec915b7ed89ee8c2aeda1be73db05317b;hb=e3329000557015ce54691235769db8821e75666b;hp=c418559d6eeffe222a7119e19c8c8207627f986b;hpb=a196405da9fab534b5ece4d165e871d02d671b36;p=ardour.git diff --git a/libs/ardour/ardour/midi_source.h b/libs/ardour/ardour/midi_source.h index c418559d6e..ba50102ec9 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 + 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 @@ -22,7 +22,8 @@ #include #include -#include +#include +#include #include "pbd/stateful.h" #include "pbd/xml++.h" #include "evoral/Sequence.hpp" @@ -35,10 +36,11 @@ namespace ARDOUR { class MidiStateTracker; class MidiModel; + template class MidiRingBuffer; /** Source for MIDI data */ -class MidiSource : virtual public Source +class LIBARDOUR_API MidiSource : virtual public Source, public boost::enable_shared_from_this { public: typedef double TimeType; @@ -47,8 +49,9 @@ class MidiSource : virtual public Source MidiSource (Session& session, const XMLNode&); virtual ~MidiSource (); - boost::shared_ptr clone (Evoral::MusicalTime begin = Evoral::MinMusicalTime, - Evoral::MusicalTime end = Evoral::MaxMusicalTime); + boost::shared_ptr clone (const std::string& path, + 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). @@ -56,49 +59,75 @@ class MidiSource : virtual public Source * \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 stamp_offset Offset to add to event times written to dst - * \param negative_stamp_offset Offset to subtract from event times written to dst * \param tracker an optional pointer to MidiStateTracker object, for note on/off tracking */ - virtual nframes_t midi_read (Evoral::EventSink& dst, - sframes_t source_start, - sframes_t start, nframes_t cnt, - sframes_t stamp_offset, sframes_t negative_stamp_offset, MidiStateTracker*) const; - - virtual nframes_t midi_write (MidiRingBuffer& src, - sframes_t source_start, - nframes_t cnt); + virtual framecnt_t midi_read (Evoral::EventSink& dst, + framepos_t source_start, + framepos_t start, + framecnt_t cnt, + MidiStateTracker* tracker, + std::set const &) const; + + /** Write data from a MidiRingBuffer to this source. + * @param source Source to read from. + * @param source_start This source's start position in session frames. + * @param cnt The length of time to write. + */ + virtual framecnt_t midi_write (MidiRingBuffer& src, + framepos_t source_start, + framecnt_t cnt); virtual void append_event_unlocked_beats(const Evoral::Event& ev) = 0; - virtual void append_event_unlocked_frames(const Evoral::Event& ev, - sframes_t source_start) = 0; + virtual void append_event_unlocked_frames(const Evoral::Event& ev, + framepos_t source_start) = 0; - virtual sframes_t length (sframes_t pos) const; - virtual void update_length (sframes_t pos, sframes_t cnt); + virtual bool empty () const; + virtual framecnt_t length (framepos_t pos) const; + virtual void update_length (framecnt_t); - virtual void mark_streaming_midi_write_started (NoteMode mode, sframes_t start_time); + virtual void mark_streaming_midi_write_started (NoteMode mode); virtual void mark_streaming_write_started (); virtual void mark_streaming_write_completed (); + /** Mark write starting with the given time parameters. + * + * This is called by MidiDiskStream::process before writing to the capture + * buffer which will be later read by midi_read(). + * + * @param position The timeline position the source now starts at. + * @param capture_length The current length of the capture, which may not + * be zero if record is armed while rolling. + * @param loop_length The loop length if looping, otherwise zero. + */ + void mark_write_starting_now (framecnt_t position, + framecnt_t capture_length, + framecnt_t loop_length); + + /* 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 stuck_option, + 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; } - uint32_t read_data_count() const { return _read_data_count; } - uint32_t write_data_count() const { return _write_data_count; } - static PBD::Signal1 MidiSourceCreated; - // Signal a range of recorded data is available for reading from model() - mutable PBD::Signal2 ViewDataRangeReady; - XMLNode& get_state (); 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; @@ -110,25 +139,45 @@ class MidiSource : virtual public Source void set_note_mode(NoteMode mode); boost::shared_ptr model() { return _model; } - void set_model(boost::shared_ptr m) { _model = m; } + 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 void flush_midi() = 0; - virtual nframes_t read_unlocked (Evoral::EventSink& dst, - sframes_t position, - sframes_t start, nframes_t cnt, - sframes_t stamp_offset, sframes_t negative_stamp_offset, - MidiStateTracker* tracker) const = 0; + virtual framecnt_t read_unlocked (Evoral::EventSink& dst, + framepos_t position, + framepos_t start, + framecnt_t cnt, + MidiStateTracker* tracker) const = 0; - virtual nframes_t write_unlocked (MidiRingBuffer& dst, - sframes_t position, - nframes_t cnt) = 0; + /** Write data to this source from a MidiRingBuffer. + * @param source Buffer to read from. + * @param position This source's start position in session frames. + * @param cnt The duration of this block to write for. + */ + virtual framecnt_t write_unlocked (MidiRingBuffer& source, + framepos_t position, + framecnt_t cnt) = 0; - std::string _captured_for; - mutable uint32_t _read_data_count; ///< modified in read() - mutable uint32_t _write_data_count; ///< modified in write() + std::string _captured_for; boost::shared_ptr _model; bool _writing; @@ -136,9 +185,26 @@ class MidiSource : virtual public Source mutable Evoral::Sequence::const_iterator _model_iter; mutable bool _model_iter_valid; - mutable double _length_beats; - mutable sframes_t _last_read_end; - sframes_t _last_write_end; + mutable double _length_beats; + mutable framepos_t _last_read_end; + + /** The total duration of the current capture. */ + framepos_t _capture_length; + + /** Length of transport loop during current capture, or zero. */ + framepos_t _capture_loop_length; + + /** 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; }; }