summaryrefslogtreecommitdiff
path: root/libs/ardour/ardour/midi_playlist.h
blob: f784b7317723d89bb9e57f2ee1548b830823278e (plain)
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
/*
    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
    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., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __ardour_midi_playlist_h__
#define __ardour_midi_playlist_h__

#include <vector>
#include <list>

#include <boost/utility.hpp>

#include "ardour/ardour.h"
#include "ardour/midi_cursor.h"
#include "ardour/midi_model.h"
#include "ardour/midi_state_tracker.h"
#include "ardour/note_fixer.h"
#include "ardour/playlist.h"
#include "evoral/Note.hpp"
#include "evoral/Parameter.hpp"

namespace Evoral {
template<typename Time> class EventSink;
class                         Beats;
}

namespace ARDOUR
{

class BeatsSamplesConverter;
class MidiChannelFilter;
class MidiRegion;
class Session;
class Source;

template<typename T> class MidiRingBuffer;

class LIBARDOUR_API MidiPlaylist : public ARDOUR::Playlist
{
public:
	MidiPlaylist (Session&, const XMLNode&, bool hidden = false);
	MidiPlaylist (Session&, std::string name, bool hidden = false);
	MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other, std::string name, bool hidden = false);

	/** This constructor does NOT notify others (session) */
	MidiPlaylist (boost::shared_ptr<const MidiPlaylist> other,
	              samplepos_t                            start,
	              samplecnt_t                            cnt,
	              std::string                           name,
	              bool                                  hidden = false);

	~MidiPlaylist ();

	/** Read a range from the playlist into an event sink.
	 *
	 * @param buf Destination for events.
	 * @param start First sample of read range.
	 * @param cnt Number of samples in read range.
	 * @param loop_range If non-null, all event times will be mapped into this loop range.
	 * @param chan_n Must be 0 (this is the audio-style "channel", where each
	 * channel is backed by a separate region, not MIDI channels, which all
	 * exist in the same region and are not handled here).
	 * @return The number of samples read (time, not an event count).
	 */
	samplecnt_t read (Evoral::EventSink<samplepos_t>& buf,
	                 samplepos_t                     start,
	                 samplecnt_t                     cnt,
	                 Evoral::Range<samplepos_t>*     loop_range,
	                 uint32_t                       chan_n = 0,
	                 MidiChannelFilter*             filter = NULL);

	int set_state (const XMLNode&, int version);

	bool destroy_region (boost::shared_ptr<Region>);
	void _split_region (boost::shared_ptr<Region>, const MusicSample& position);

	void set_note_mode (NoteMode m) { _note_mode = m; }

	std::set<Evoral::Parameter> contained_automation();

	/** Handle a region edit during read.
	 *
	 * This must be called before the command is applied to the model.  Events
	 * are injected into the playlist output to compensate for edits to active
	 * notes and maintain coherent output and tracker state.
	 */
	void region_edited(boost::shared_ptr<Region>         region,
	                   const MidiModel::NoteDiffCommand* cmd);

	/** Clear all note trackers. */
	void reset_note_trackers ();

	/** Resolve all pending notes and clear all note trackers.
	 *
	 * @param dst Sink to write note offs to.
	 * @param time Time stamp of all written note offs.
	 */
	void resolve_note_trackers (Evoral::EventSink<samplepos_t>& dst, samplepos_t time);

protected:
	void remove_dependents (boost::shared_ptr<Region> region);
	void region_going_away (boost::weak_ptr<Region> region);

private:
	typedef Evoral::Note<Temporal::Beats> Note;
	typedef Evoral::Event<samplepos_t>   Event;

	struct RegionTracker : public boost::noncopyable {
		MidiCursor       cursor;   ///< Cursor (iterator and read state)
		MidiStateTracker tracker;  ///< Active note tracker
		NoteFixer        fixer;    ///< Edit compensation
	};

	typedef std::map< Region*, boost::shared_ptr<RegionTracker> > NoteTrackers;

	void dump () const;

	NoteTrackers _note_trackers;
	NoteMode     _note_mode;
	samplepos_t   _read_end;
};

} /* namespace ARDOUR */

#endif	/* __ardour_midi_playlist_h__ */