2 Copyright (C) 2009-2016 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include "pbd/debug.h"
21 #include "pbd/error.h"
23 #include "ardour/audioplaylist.h"
24 #include "ardour/butler.h"
25 #include "ardour/debug.h"
26 #include "ardour/disk_io.h"
27 #include "ardour/disk_reader.h"
28 #include "ardour/disk_writer.h"
29 #include "ardour/location.h"
30 #include "ardour/midi_ring_buffer.h"
31 #include "ardour/midi_playlist.h"
32 #include "ardour/playlist.h"
33 #include "ardour/playlist_factory.h"
34 #include "ardour/rc_configuration.h"
35 #include "ardour/session.h"
36 #include "ardour/session_playlists.h"
40 using namespace ARDOUR;
44 const string DiskIOProcessor::state_node_name = X_("DiskIOProcessor");
46 // PBD::Signal0<void> DiskIOProcessor::DiskOverrun;
47 // PBD::Signal0<void> DiskIOProcessor::DiskUnderrun;
49 DiskIOProcessor::DiskIOProcessor (Session& s, string const & str, Flag f)
52 , i_am_the_modifier (false)
53 , _seek_required (false)
55 , in_set_state (false)
57 , _need_butler (false)
58 , channels (new ChannelList)
59 , _midi_buf (new MidiRingBuffer<samplepos_t> (s.butler()->midi_diskstream_buffer_size()))
60 , _samples_written_to_ringbuffer (0)
61 , _samples_read_from_ringbuffer (0)
63 set_display_to_user (false);
66 DiskIOProcessor::~DiskIOProcessor ()
69 RCUWriter<ChannelList> writer (channels);
70 boost::shared_ptr<ChannelList> c = writer.get_copy();
72 for (ChannelList::iterator chan = c->begin(); chan != c->end(); ++chan) {
84 DiskIOProcessor::init ()
86 set_block_size (_session.get_block_size());
90 DiskIOProcessor::set_buffering_parameters (BufferingPreset bp)
92 samplecnt_t read_chunk_size;
93 samplecnt_t read_buffer_size;
94 samplecnt_t write_chunk_size;
95 samplecnt_t write_buffer_size;
97 if (!get_buffering_presets (bp, read_chunk_size, read_buffer_size, write_chunk_size, write_buffer_size)) {
101 DiskReader::set_chunk_samples (read_chunk_size);
102 DiskWriter::set_chunk_samples (write_chunk_size);
104 Config->set_audio_capture_buffer_seconds (write_buffer_size);
105 Config->set_audio_playback_buffer_seconds (read_buffer_size);
109 DiskIOProcessor::get_buffering_presets (BufferingPreset bp,
110 samplecnt_t& read_chunk_size,
111 samplecnt_t& read_buffer_size,
112 samplecnt_t& write_chunk_size,
113 samplecnt_t& write_buffer_size)
117 read_chunk_size = 65536; /* samples */
118 write_chunk_size = 65536; /* samples */
119 read_buffer_size = 5; /* seconds */
120 write_buffer_size = 5; /* seconds */
124 read_chunk_size = 262144; /* samples */
125 write_chunk_size = 131072; /* samples */
126 read_buffer_size = 10; /* seconds */
127 write_buffer_size = 10; /* seconds */
131 read_chunk_size = 524288; /* samples */
132 write_chunk_size = 131072; /* samples */
133 read_buffer_size = 20; /* seconds */
134 write_buffer_size = 20; /* seconds */
145 DiskIOProcessor::can_support_io_configuration (const ChanCount& in, ChanCount& out)
147 if (in.n_midi() != 0 && in.n_midi() != 1) {
148 /* we only support zero or 1 MIDI stream */
152 /* currently no way to deliver different channels that we receive */
159 DiskIOProcessor::configure_io (ChanCount in, ChanCount out)
161 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("Configuring %1 for in:%2 out:%3\n", name(), in, out));
163 bool changed = false;
166 RCUWriter<ChannelList> writer (channels);
167 boost::shared_ptr<ChannelList> c = writer.get_copy();
169 uint32_t n_audio = in.n_audio();
171 if (n_audio > c->size()) {
172 add_channel_to (c, n_audio - c->size());
174 } else if (n_audio < c->size()) {
175 remove_channel_from (c, c->size() - n_audio);
179 /* writer leaves scope, actual channel list is updated */
182 if (in.n_midi() > 0 && !_midi_buf) {
183 const size_t size = _session.butler()->midi_diskstream_buffer_size();
184 _midi_buf = new MidiRingBuffer<samplepos_t>(size);
189 seek (_session.transport_sample());
192 return Processor::configure_io (in, out);
196 DiskIOProcessor::set_block_size (pframes_t nframes)
202 DiskIOProcessor::non_realtime_locate (samplepos_t location)
204 /* now refill channel buffers */
206 seek (location, true);
210 DiskIOProcessor::non_realtime_speed_change ()
212 if (_seek_required) {
213 seek (_session.transport_sample(), true);
214 _seek_required = false;
219 DiskIOProcessor::realtime_speed_change ()
225 DiskIOProcessor::set_state (const XMLNode& node, int version)
227 XMLProperty const * prop;
229 Processor::set_state (node, version);
231 if ((prop = node.property ("flags")) != 0) {
232 _flags = Flag (string_2_enum (prop->value(), _flags));
239 DiskIOProcessor::add_channel (uint32_t how_many)
241 RCUWriter<ChannelList> writer (channels);
242 boost::shared_ptr<ChannelList> c = writer.get_copy();
244 return add_channel_to (c, how_many);
248 DiskIOProcessor::remove_channel_from (boost::shared_ptr<ChannelList> c, uint32_t how_many)
250 while (how_many-- && !c->empty()) {
259 DiskIOProcessor::remove_channel (uint32_t how_many)
261 RCUWriter<ChannelList> writer (channels);
262 boost::shared_ptr<ChannelList> c = writer.get_copy();
264 return remove_channel_from (c, how_many);
268 DiskIOProcessor::playlist_deleted (boost::weak_ptr<Playlist> wpl)
270 boost::shared_ptr<Playlist> pl (wpl.lock());
276 for (uint32_t n = 0; n < DataType::num_types; ++n) {
277 if (pl == _playlists[n]) {
279 /* this catches an ordering issue with session destruction. playlists
280 are destroyed before disk readers. we have to invalidate any handles
281 we have to the playlist.
283 _playlists[n].reset ();
289 boost::shared_ptr<AudioPlaylist>
290 DiskIOProcessor::audio_playlist () const
292 return boost::dynamic_pointer_cast<AudioPlaylist> (_playlists[DataType::AUDIO]);
295 boost::shared_ptr<MidiPlaylist>
296 DiskIOProcessor::midi_playlist () const
298 return boost::dynamic_pointer_cast<MidiPlaylist> (_playlists[DataType::MIDI]);
302 DiskIOProcessor::use_playlist (DataType dt, boost::shared_ptr<Playlist> playlist)
308 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: set to use playlist %2 (%3)\n", name(), playlist->name(), dt.to_string()));
310 if (playlist == _playlists[dt]) {
311 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1: already using that playlist\n", name()));
315 playlist_connections.drop_connections ();
317 if (_playlists[dt]) {
318 _playlists[dt]->release();
321 _playlists[dt] = playlist;
324 playlist->ContentsChanged.connect_same_thread (playlist_connections, boost::bind (&DiskIOProcessor::playlist_modified, this));
325 playlist->LayeringChanged.connect_same_thread (playlist_connections, boost::bind (&DiskIOProcessor::playlist_modified, this));
326 playlist->DropReferences.connect_same_thread (playlist_connections, boost::bind (&DiskIOProcessor::playlist_deleted, this, boost::weak_ptr<Playlist>(playlist)));
327 playlist->RangesMoved.connect_same_thread (playlist_connections, boost::bind (&DiskIOProcessor::playlist_ranges_moved, this, _1, _2));
329 DEBUG_TRACE (DEBUG::DiskIO, string_compose ("%1 now using playlist %1 (%2)\n", name(), playlist->name(), playlist->id()));
334 DiskIOProcessor::ChannelInfo::ChannelInfo (samplecnt_t bufsize)
337 , capture_transition_buf (0)
338 , curr_capture_cnt (0)
342 DiskIOProcessor::ChannelInfo::~ChannelInfo ()
346 delete capture_transition_buf;
349 capture_transition_buf = 0;
353 DiskIOProcessor::drop_route ()
359 DiskIOProcessor::set_route (boost::shared_ptr<Route> r)
364 _route->DropReferences.connect_same_thread (*this, boost::bind (&DiskIOProcessor::drop_route, this));
368 /** Get the start, end, and length of a location "atomically".
370 * Note: Locations don't get deleted, so all we care about when I say "atomic"
371 * is that we are always pointing to the same one and using start/length values
372 * obtained just once. Use this function to achieve this since location being
373 * a parameter achieves this.
376 DiskIOProcessor::get_location_times(const Location* location,
382 *start = location->start();
383 *end = location->end();
384 *length = *end - *start;