midi_source.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2016 David Robillard <d@drobilla.net>
 * Copyright (C) 2007-2017 Paul Davis <paul@linuxaudiosystems.com>
 * Copyright (C) 2009-2012 Carl Hetherington <carl@carlh.net>
 * Copyright (C) 2016 Nick Mainsbridge <mainsbridge@gmail.com>
 * Copyright (C) 2018-2019 Ben Loftis <ben@harrisonconsoles.com>
 *
 * 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
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#pragma once
 
#include <string>
#include <time.h>
#include <glibmm/threads.h>
 
#include "pbd/stateful.h"
#include "pbd/xml++.h"
 
#include "evoral/Sequence.h"
 
#include "temporal/range.h"
 
#include "ardour/ardour.h"
#include "ardour/automation_list.h"
#include "ardour/buffer.h"
#include "ardour/midi_cursor.h"
#include "ardour/source.h"
 
namespace ARDOUR {
 
class MidiChannelFilter;
class MidiModel;
class MidiNoteTracker;
 
template<typename T> class MidiRingBuffer;
 
class LIBARDOUR_API MidiSource : virtual public Source
{
  public:
        typedef Temporal::Beats TimeType;
 
        MidiSource (Session& session, std::string name, Source::Flag flags = Source::Flag(0));
        MidiSource (Session& session, const XMLNode&);
        virtual ~MidiSource ();
 
        int write_to (const ReaderLock&             lock,
                      std::shared_ptr<MidiSource> newsrc,
                      Temporal::Beats               begin = Temporal::Beats(),
                      Temporal::Beats               end   = std::numeric_limits<Temporal::Beats>::max());
 
        int export_write_to (const ReaderLock&             lock,
                             std::shared_ptr<MidiSource> newsrc,
                             Temporal::Beats               begin,
                             Temporal::Beats               end);
 
        virtual timecnt_t midi_read (const ReaderLock&                  lock,
                                     Evoral::EventSink<samplepos_t>&    dst,
                                     timepos_t const &                  source_start,
                                     timepos_t const &                  start,
                                     timecnt_t const &                  cnt,
                                     Temporal::Range*                   loop_range,
                                     MidiCursor&                        cursor,
                                     MidiNoteTracker*                   tracker,
                                     MidiChannelFilter*                 filter,
                                     const std::set<Evoral::Parameter>& filtered);
        virtual void render (const ReaderLock& lock, Evoral::EventSink<Temporal::Beats>& dst) = 0;
 
        virtual timecnt_t midi_write (const WriterLock&              lock,
                                        MidiRingBuffer<samplepos_t>& source,
                                        timepos_t const &            source_start,
                                        timecnt_t const &            cnt);
 
        virtual void append_event_beats(const WriterLock& lock,
                                        const Evoral::Event<Temporal::Beats>& ev) = 0;
 
        virtual void append_event_samples(const WriterLock&                lock,
                                         const Evoral::Event<samplepos_t>& ev,
                                         samplepos_t                       source_start) = 0;
 
        virtual void mark_streaming_midi_write_started (const WriterLock& lock, NoteMode mode);
        virtual void mark_streaming_write_started (const WriterLock& lock);
        virtual void mark_streaming_write_completed (const WriterLock& lock, Temporal::timecnt_t const & duration);
 
        void mark_write_starting_now (timepos_t const & position, samplecnt_t capture_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 (
                const WriterLock&                                  lock,
                Evoral::Sequence<Temporal::Beats>::StuckNoteOption stuck_option,
                Temporal::timecnt_t const &                        when);
 
        virtual void session_saved();
 
        XMLNode& get_state () const;
        int set_state (const XMLNode&, int version);
 
        bool length_mutable() const { return true; }
 
        virtual void load_model(const WriterLock& lock, bool force_reload=false) = 0;
        virtual void destroy_model(const WriterLock& lock) = 0;
 
        void invalidate(const WriterLock& lock);
 
        mutable PBD::Signal<void(bool)> Invalidated;
 
        void set_note_mode(const WriterLock& lock, NoteMode mode);
 
        std::shared_ptr<MidiModel> model() { return _model; }
        void set_model(const WriterLock& lock, std::shared_ptr<MidiModel>);
        void drop_model(const WriterLock& lock);
 
        AutomationList::InterpolationStyle interpolation_of (Evoral::Parameter const&) const;
        void set_interpolation_of (Evoral::Parameter const&, AutomationList::InterpolationStyle);
        void copy_interpolation_from (std::shared_ptr<MidiSource>);
        void copy_interpolation_from (MidiSource *);
 
        AutoState automation_state_of (Evoral::Parameter const&) const;
        void set_automation_state_of (Evoral::Parameter const&, AutoState);
        void copy_automation_state_from (std::shared_ptr<MidiSource>);
        void copy_automation_state_from (MidiSource *);
 
        PBD::Signal<void()> ModelChanged;
        PBD::Signal<void(Evoral::Parameter, AutomationList::InterpolationStyle)> InterpolationChanged;
        PBD::Signal<void(Evoral::Parameter, AutoState)> AutomationStateChanged;
 
  protected:
        virtual void flush_midi(const WriterLock& lock) = 0;
 
        virtual timecnt_t read_unlocked (const ReaderLock&               lock,
                                         Evoral::EventSink<samplepos_t>& dst,
                                         timepos_t const &               position,
                                         timepos_t const &               start,
                                         timecnt_t const &               cnt,
                                         Temporal::Range*                loop_range,
                                         MidiNoteTracker*               tracker,
                                         MidiChannelFilter*              filter) const = 0;
 
        virtual timecnt_t write_unlocked (const WriterLock&            lock,
                                          MidiRingBuffer<samplepos_t>& source,
                                          timepos_t const &            position,
                                          timecnt_t const &            cnt) = 0;
 
        std::shared_ptr<MidiModel> _model;
        bool                         _writing;
 
        samplecnt_t _capture_length;
 
        typedef std::map<Evoral::Parameter, AutomationList::InterpolationStyle> InterpolationStyleMap;
        InterpolationStyleMap _interpolation_style;
 
        typedef std::map<Evoral::Parameter, AutoState> AutomationStateMap;
        AutomationStateMap  _automation_state;
};
 
}