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.
-
- $Id: diskstream.cc 567 2006-06-07 14:54:12Z trutkin $
*/
#include <fstream>
#include <sys/stat.h>
#include <sys/mman.h>
-#include <pbd/error.h>
-#include <pbd/basename.h>
+#include "pbd/error.h"
+#include "pbd/basename.h"
#include <glibmm/thread.h>
-#include <pbd/xml++.h>
-#include <pbd/memento_command.h>
-
-#include <ardour/ardour.h>
-#include <ardour/audioengine.h>
-#include <ardour/midi_diskstream.h>
-#include <ardour/utils.h>
-#include <ardour/configuration.h>
-#include <ardour/smf_source.h>
-#include <ardour/destructive_filesource.h>
-#include <ardour/send.h>
-#include <ardour/midi_playlist.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/midi_region.h>
-#include <ardour/midi_port.h>
+#include "pbd/xml++.h"
+#include "pbd/memento_command.h"
+#include "pbd/enumwriter.h"
+
+#include "ardour/ardour.h"
+#include "ardour/audioengine.h"
+#include "ardour/configuration.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/io.h"
+#include "ardour/midi_diskstream.h"
+#include "ardour/midi_playlist.h"
+#include "ardour/midi_port.h"
+#include "ardour/midi_region.h"
+#include "ardour/playlist_factory.h"
+#include "ardour/region_factory.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/smf_source.h"
+#include "ardour/utils.h"
+
+#include "midi++/types.h"
#include "i18n.h"
#include <locale.h>
using namespace ARDOUR;
using namespace PBD;
+nframes_t MidiDiskstream::midi_readahead = 4096;
+
MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
, _playback_buf(0)
, _capture_buf(0)
- //, _current_playback_buffer(0)
- //, _current_capture_buffer(0)
- //, _playback_wrap_buffer(0)
- //, _capture_wrap_buffer(0)
, _source_port(0)
- , _write_source(0)
- , _capture_transition_buf(0)
, _last_flush_frame(0)
+ , _note_mode(Sustained)
+ , _frames_written_to_ringbuffer(0)
+ , _frames_read_from_ringbuffer(0)
{
/* prevent any write sources from being created */
in_set_state = false;
assert(!destructive());
- DiskstreamCreated (this); /* EMIT SIGNAL */
}
MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
: Diskstream(sess, node)
, _playback_buf(0)
, _capture_buf(0)
- //, _current_playback_buffer(0)
- //, _current_capture_buffer(0)
- //, _playback_wrap_buffer(0)
- //, _capture_wrap_buffer(0)
, _source_port(0)
- , _write_source(0)
- , _capture_transition_buf(0)
, _last_flush_frame(0)
+ , _note_mode(Sustained)
+ , _frames_written_to_ringbuffer(0)
+ , _frames_read_from_ringbuffer(0)
{
in_set_state = true;
init (Recordable);
if (destructive()) {
use_destructive_playlist ();
}
-
- DiskstreamCreated (this); /* EMIT SIGNAL */
}
void
set_block_size (_session.get_block_size());
allocate_temporary_buffers ();
- //_playback_wrap_buffer = new RawMidi[wrap_buffer_size];
- //_capture_wrap_buffer = new RawMidi[wrap_buffer_size];
- _playback_buf = new MidiRingBuffer (_session.diskstream_buffer_size());
- _capture_buf = new MidiRingBuffer (_session.diskstream_buffer_size());
- _capture_transition_buf = new RingBufferNPT<CaptureTransition> (128);
+ const size_t size = _session.midi_diskstream_buffer_size();
+ _playback_buf = new MidiRingBuffer<nframes_t>(size);
+ _capture_buf = new MidiRingBuffer<nframes_t>(size);
_n_channels = ChanCount(DataType::MIDI, 1);
Glib::Mutex::Lock lm (state_lock);
}
+
+void
+MidiDiskstream::non_realtime_locate (nframes_t position)
+{
+ if (_write_source) {
+ _write_source->set_timeline_position (position);
+ }
+ seek(position, false);
+}
+
+
void
MidiDiskstream::non_realtime_input_change ()
{
}
if (input_change_pending & ConfigurationChanged) {
-
- assert(_io->n_inputs() == _n_channels);
+ if (_io->n_ports().n_midi() != _n_channels.n_midi()) {
+ error << "Can not feed IO " << _io->n_ports()
+ << " with diskstream " << _n_channels << endl;
+ }
}
get_input_sources ();
}
input_change_pending = NoChange;
+
+ /* implicit unlock */
}
/* reset capture files */
/* now refill channel buffers */
if (speed() != 1.0f || speed() != -1.0f) {
- seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()));
+ seek ((nframes_t) (_session.transport_frame() * (double) speed()));
}
else {
seek (_session.transport_frame());
void
MidiDiskstream::get_input_sources ()
{
- uint32_t ni = _io->n_inputs().get(DataType::MIDI);
+ uint32_t ni = _io->n_ports().n_midi();
if (ni == 0) {
return;
// This is all we do for now at least
assert(ni == 1);
- _source_port = _io->midi_input(0);
+ _source_port = _io->midi(0);
- /* I don't get it....
- const char **connections = _io->input(0)->get_connections ();
-
- if (connections == 0 || connections[0] == 0) {
-
- if (_source_port) {
- // _source_port->disable_metering ();
- }
-
- _source_port = 0;
-
- } else {
- _source_port = dynamic_cast<MidiPort*>(
- _session.engine().get_port_by_name (connections[0]) );
- }
-
- if (connections) {
- free (connections);
- }*/
+ // do... stuff?
}
int
MidiDiskstream::find_and_use_playlist (const string& name)
{
- Playlist* pl;
- MidiPlaylist* playlist;
+ boost::shared_ptr<MidiPlaylist> playlist;
- if ((pl = _session.playlist_by_name (name)) == 0) {
- playlist = new MidiPlaylist(_session, name);
- pl = playlist;
+ if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlist_by_name (name))) == 0) {
+ playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
}
- if ((playlist = dynamic_cast<MidiPlaylist*> (pl)) == 0) {
- error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't a midi playlist"), name) << endmsg;
+ if (!playlist) {
+ error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
return -1;
}
}
int
-MidiDiskstream::use_playlist (Playlist* playlist)
-{
- assert(dynamic_cast<MidiPlaylist*>(playlist));
+MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
+{
+ assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
- return Diskstream::use_playlist(playlist);
+ Diskstream::use_playlist(playlist);
+
+ return 0;
}
int
MidiDiskstream::use_new_playlist ()
-{
+{
string newname;
- MidiPlaylist* playlist;
+ boost::shared_ptr<MidiPlaylist> playlist;
if (!in_set_state && destructive()) {
return 0;
newname = Playlist::bump_name (_name, _session);
}
- if ((playlist = new MidiPlaylist (_session, newname, hidden())) != 0) {
+ if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
+ DataType::MIDI, _session, newname, hidden()))) != 0) {
+
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
+
} else {
return -1;
}
int
MidiDiskstream::use_copy_playlist ()
{
+ assert(midi_playlist());
+
if (destructive()) {
return 0;
}
}
string newname;
- MidiPlaylist* playlist;
+ boost::shared_ptr<MidiPlaylist> playlist;
newname = Playlist::bump_name (_playlist->name(), _session);
- if ((playlist = new MidiPlaylist (*midi_playlist(), newname)) != 0) {
+ if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
} else {
/** Overloaded from parent to die horribly
*/
-void
+int
MidiDiskstream::set_destructive (bool yn)
{
assert( ! destructive());
assert( ! yn);
+ return -1;
+}
+
+void
+MidiDiskstream::set_note_mode (NoteMode m)
+{
+ _note_mode = m;
+ midi_playlist()->set_note_mode(m);
+ if (_write_source && _write_source->model())
+ _write_source->model()->set_note_mode(m);
}
void
-MidiDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
+MidiDiskstream::check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record)
{
// FIXME: waaay too much code to duplicate (AudioDiskstream)
/* if per-track or global rec-enable turned on while the other was already on, we've started recording */
- if ((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record) ||
+ if (((change & track_rec_enabled) && record_enabled() && (!(change & global_rec_enabled) && can_record)) ||
((change & global_rec_enabled) && can_record && (!(change & track_rec_enabled) && record_enabled()))) {
/* starting to record: compute first+last frames */
} else {
first_recordable_frame += _roll_delay;
}
-
+
} else {
/* was rolling, but record state changed */
if (_alignment_style == ExistingMaterial) {
- if (!_session.get_punch_in()) {
+ if (!_session.config.get_punch_in()) {
/* manual punch in happens at the correct transport frame
because the user hit a button. but to get alignment correct
} else {
- if (_session.get_punch_in()) {
+ if (_session.config.get_punch_in()) {
first_recordable_frame += _roll_delay;
} else {
capture_start_frame -= _roll_delay;
}
- if (_flags & Recordable) {
- RingBufferNPT<CaptureTransition>::rw_vector transvec;
- _capture_transition_buf->get_write_vector(&transvec);
-
- if (transvec.len[0] > 0) {
- transvec.buf[0]->type = CaptureStart;
- transvec.buf[0]->capture_val = capture_start_frame;
- _capture_transition_buf->increment_write_ptr(1);
- } else {
- // bad!
- fatal << X_("programming error: capture_transition_buf is full on rec start! inconceivable!")
- << endmsg;
- }
- }
-
} else if (!record_enabled() || !can_record) {
/* stop recording */
last_possibly_recording = possibly_recording;
}
+#if 0
+static void
+trace_midi (ostream& o, MIDI::byte *msg, size_t len)
+{
+ using namespace MIDI;
+ eventType type;
+ const char trace_prefix = ':';
+
+ type = (eventType) (msg[0]&0xF0);
+
+ switch (type) {
+ case off:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " NoteOff NoteNum "
+ << (int) msg[1]
+ << " Vel "
+ << (int) msg[2]
+ << endl;
+ break;
+
+ case on:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " NoteOn NoteNum "
+ << (int) msg[1]
+ << " Vel "
+ << (int) msg[2]
+ << endl;
+ break;
+
+ case polypress:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " PolyPressure"
+ << (int) msg[1]
+ << endl;
+ break;
+
+ case MIDI::controller:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " Controller "
+ << (int) msg[1]
+ << " Value "
+ << (int) msg[2]
+ << endl;
+ break;
+
+ case program:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " Program Change ProgNum "
+ << (int) msg[1]
+ << endl;
+ break;
+
+ case chanpress:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " Channel Pressure "
+ << (int) msg[1]
+ << endl;
+ break;
+
+ case MIDI::pitchbend:
+ o << trace_prefix
+ << "Channel "
+ << (msg[0]&0xF)+1
+ << " Pitch Bend "
+ << ((msg[2]<<7)|msg[1])
+ << endl;
+ break;
+
+ case MIDI::sysex:
+ if (len == 1) {
+ switch (msg[0]) {
+ case 0xf8:
+ o << trace_prefix
+ << "Clock"
+ << endl;
+ break;
+ case 0xfa:
+ o << trace_prefix
+ << "Start"
+ << endl;
+ break;
+ case 0xfb:
+ o << trace_prefix
+ << "Continue"
+ << endl;
+ break;
+ case 0xfc:
+ o << trace_prefix
+ << "Stop"
+ << endl;
+ break;
+ case 0xfe:
+ o << trace_prefix
+ << "Active Sense"
+ << endl;
+ break;
+ case 0xff:
+ o << trace_prefix
+ << "System Reset"
+ << endl;
+ break;
+ default:
+ o << trace_prefix
+ << "System Exclusive (1 byte : " << hex << (int) *msg << dec << ')'
+ << endl;
+ break;
+ }
+ } else {
+ o << trace_prefix
+ << "System Exclusive (" << len << ") = [ " << hex;
+ for (unsigned int i = 0; i < len; ++i) {
+ o << (int) msg[i] << ' ';
+ }
+ o << dec << ']' << endl;
+
+ }
+ break;
+
+ case MIDI::song:
+ o << trace_prefix << "Song" << endl;
+ break;
+
+ case MIDI::tune:
+ o << trace_prefix << "Tune" << endl;
+ break;
+
+ case MIDI::eox:
+ o << trace_prefix << "End-of-System Exclusive" << endl;
+ break;
+
+ case MIDI::timing:
+ o << trace_prefix << "Timing" << endl;
+ break;
+
+ case MIDI::start:
+ o << trace_prefix << "Start" << endl;
+ break;
+
+ case MIDI::stop:
+ o << trace_prefix << "Stop" << endl;
+ break;
+
+ case MIDI::contineu:
+ o << trace_prefix << "Continue" << endl;
+ break;
+
+ case active:
+ o << trace_prefix << "Active Sense" << endl;
+ break;
+
+ default:
+ o << trace_prefix << "Unrecognized MIDI message" << endl;
+ break;
+ }
+}
+#endif
+
int
-MidiDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, bool can_record, bool rec_monitors_input)
+MidiDiskstream::process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input)
{
// FIXME: waay too much code to duplicate (AudioDiskstream::process)
- int ret = -1;
- jack_nframes_t rec_offset = 0;
- jack_nframes_t rec_nframes = 0;
- bool nominally_recording;
- bool re = record_enabled ();
- bool collect_playback = false;
-
- /*_current_capture_buffer = 0;
- _current_playback_buffer = 0;*/
+ int ret = -1;
+ nframes_t rec_offset = 0;
+ nframes_t rec_nframes = 0;
+ bool nominally_recording;
+ bool re = record_enabled ();
+ bool collect_playback = true;
/* if we've already processed the frames corresponding to this call,
just return. this allows multiple routes that are taking input
if (_processed) {
return 0;
}
+
+ commit_should_unlock = false;
check_record_status (transport_frame, nframes, can_record);
return 0;
}
- /* This lock is held until the end of AudioDiskstream::commit, so these two functions
+ /* This lock is held until the end of ::commit, so these two functions
must always be called as a pair. The only exception is if this function
returns a non-zero value, in which case, ::commit should not be called.
*/
if (!state_lock.trylock()) {
return 1;
}
-
+ commit_should_unlock = true;
adjust_capture_position = 0;
- if (nominally_recording || (_session.get_record_enabled() && _session.get_punch_in())) {
+ if (nominally_recording || (_session.get_record_enabled() && _session.config.get_punch_in())) {
OverlapType ot;
ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
if (nominally_recording || rec_nframes) {
- assert(_source_port);
-
- // Pump entire port buffer into the ring buffer (FIXME!)
- _capture_buf->write(_source_port->get_midi_buffer(), transport_frame);
-
- // FIXME: hackitty hack, don't come back
- //_write_source->ViewDataRangeReady (_write_source->length(), rec_nframes); /* EMIT SIGNAL */
- /*
- for (size_t i=0; i < _source_port->size(); ++i) {
- cerr << "DISKSTREAM GOT EVENT(1) " << i << "!!\n";
- }
-
- if (_source_port->size() == 0)
- cerr << "No events :/ (1)\n";
- */
+ // Pump entire port buffer into the ring buffer (FIXME: split cycles?)
+ MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
+ for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
+ const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
+ assert(ev.buffer());
+ _capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
+ }
+
} else {
if (was_recording) {
if (rec_nframes) {
- /* XXX XXX XXX XXX XXX XXX XXX XXX */
/* data will be written to disk */
+ if (rec_nframes == nframes && rec_offset == 0) {
+ playback_distance = nframes;
+ }
+
adjust_capture_position = rec_nframes;
} else if (nominally_recording) {
/* can't do actual capture yet - waiting for latency effects to finish before we start*/
- // Ummm.. well, I suppose we'll just hang out for a bit?
-
playback_distance = nframes;
+ collect_playback = false;
- } else {
-
- collect_playback = true;
}
if (collect_playback) {
/* we're doing playback */
- jack_nframes_t necessary_samples;
+ nframes_t necessary_samples;
/* no varispeed playback if we're recording, because the output .... TBD */
if (rec_nframes == 0 && _actual_speed != 1.0f) {
- necessary_samples = (jack_nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
+ necessary_samples = (nframes_t) floor ((nframes * fabs (_actual_speed))) + 1;
} else {
necessary_samples = nframes;
}
- // XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
- // Write into playback buffer here, and whatnot
-
+ // Pump entire port buffer into playback buffer (FIXME: split cycles?)
+ MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
+ for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
+ const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
+ assert(ev.buffer());
+ _playback_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
+ }
}
ret = 0;
be called. unlock the state lock.
*/
+ commit_should_unlock = false;
state_lock.unlock();
}
return ret;
-
- _processed = true;
-
- return 0;
}
bool
-MidiDiskstream::commit (jack_nframes_t nframes)
+MidiDiskstream::commit (nframes_t nframes)
{
bool need_butler = false;
playback_sample += playback_distance;
}
- /* XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX */
-
- /*
- _playback_buf->increment_read_ptr (playback_distance);
-
- if (adjust_capture_position) {
- _capture_buf->increment_write_ptr (adjust_capture_position);
- }
-*/
if (adjust_capture_position != 0) {
capture_captured += adjust_capture_position;
adjust_capture_position = 0;
}
- if (_slaved) {
- need_butler = _playback_buf->write_space() >= _playback_buf->capacity() / 2;
- } else {
- need_butler = _playback_buf->write_space() >= disk_io_chunk_frames
- || _capture_buf->read_space() >= disk_io_chunk_frames;
+ uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
+ uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
+ if ((frames_written - frames_read) + nframes < midi_readahead) {
+ need_butler = true;
}
+
+ /*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
+ " = " << frames_written - frames_read
+ << " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
- state_lock.unlock();
+ if (commit_should_unlock) {
+ state_lock.unlock();
+ }
_processed = false;
/* called from audio thread, so we can use the read ptr and playback sample as we wish */
pending_overwrite = yn;
-
+
overwrite_frame = playback_sample;
- //overwrite_offset = channels.front().playback_buf->get_read_ptr();
}
int
MidiDiskstream::overwrite_existing_buffers ()
{
+ //read(overwrite_frame, disk_io_chunk_frames, false);
+ overwrite_queued = false;
+ pending_overwrite = false;
+
return 0;
}
int
-MidiDiskstream::seek (jack_nframes_t frame, bool complete_refill)
+MidiDiskstream::seek (nframes_t frame, bool complete_refill)
{
Glib::Mutex::Lock lm (state_lock);
int ret = -1;
-
+
_playback_buf->reset();
_capture_buf->reset();
+ g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
+ g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
playback_sample = frame;
file_frame = frame;
- _last_flush_frame = frame;
if (complete_refill) {
while ((ret = do_refill_with_alloc ()) > 0) ;
}
int
-MidiDiskstream::can_internal_playback_seek (jack_nframes_t distance)
+MidiDiskstream::can_internal_playback_seek (nframes_t distance)
{
- if (_playback_buf->read_space() < distance) {
- return false;
- } else {
- return true;
- }
+ uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
+ uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
+ return ((frames_written - frames_read) < distance);
}
int
-MidiDiskstream::internal_playback_seek (jack_nframes_t distance)
+MidiDiskstream::internal_playback_seek (nframes_t distance)
{
+ cerr << "MDS: internal_playback_seek " << distance << endl;
+
first_recordable_frame += distance;
playback_sample += distance;
/** @a start is set to the new frame position (TIME) read up to */
int
-MidiDiskstream::read (jack_nframes_t& start, jack_nframes_t dur, bool reversed)
+MidiDiskstream::read (nframes_t& start, nframes_t dur, bool reversed)
{
- jack_nframes_t this_read = 0;
+ nframes_t this_read = 0;
bool reloop = false;
- jack_nframes_t loop_end = 0;
- jack_nframes_t loop_start = 0;
- jack_nframes_t loop_length = 0;
+ nframes_t loop_end = 0;
+ nframes_t loop_start = 0;
+ nframes_t loop_length = 0;
Location *loc = 0;
if (!reversed) {
position within the loop.
*/
- if (loc && start >= loop_end) {
+ if (loc && (start >= loop_end)) {
//cerr << "start adjusted from " << start;
start = loop_start + ((start - loop_start) % loop_length);
//cerr << "to " << start << endl;
this_read = min(dur,this_read);
if (midi_playlist()->read (*_playback_buf, start, this_read) != this_read) {
- error << string_compose(_("MidiDiskstream %1: cannot read %2 from playlist at frame %3"), _id, this_read,
- start) << endmsg;
+ error << string_compose(
+ _("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
+ _id, this_read, start) << endmsg;
return -1;
}
+
+ //cout << "MDS this read " << this_read << " start = " << start << endl;
+ g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
_read_data_count = _playlist->read_data_count();
if (reversed) {
- cerr << "Reversed MIDI.. that's just crazy talk." << endl;
- // Swap note ons with note offs here
+ // Swap note ons with note offs here. etc?
+ // Fully reversing MIDI requires look-ahead (well, behind) to find previous
+ // CC values etc. hard.
} else {
/* if we read to the end of the loop, go back to the beginning */
if (reloop) {
+ // Synthesize LoopEvent here, because the next events
+ // written will have non-monotonic timestamps.
+ _playback_buf->write(loop_end - 1, LoopEventType, 0, 0);
+ //cout << "Pushing LoopEvent ts=" << loop_end-1
+ // << " start+this_read " << start+this_read << endl;
+
start = loop_start;
} else {
start += this_read;
}
dur -= this_read;
+ //offset += this_read;
}
return 0;
int
MidiDiskstream::do_refill ()
{
- int32_t ret = 0;
- size_t write_space = _playback_buf->write_space();
-
- bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
+ int ret = 0;
+ size_t write_space = _playback_buf->write_space();
+ bool reversed = (_visible_speed * _session.transport_speed()) < 0.0f;
if (write_space == 0) {
return 0;
}
-
- /* if there are 2+ chunks of disk i/o possible for
- this track, let the caller know so that it can arrange
- for us to be called again, ASAP.
- */
-
- // FIXME: using disk_io_chunk_frames as an event count, not good
- if (_playback_buf->write_space() >= (_slaved?3:2) * disk_io_chunk_frames) {
- ret = 1;
- }
-
- /* if we're running close to normal speed and there isn't enough
- space to do disk_io_chunk_frames of I/O, then don't bother.
-
- at higher speeds, just do it because the sync between butler
- and audio thread may not be good enough.
- */
-
- if ((write_space < disk_io_chunk_frames) && fabs (_actual_speed) < 2.0f) {
- cerr << "No refill 1\n";
- return 0;
- }
-
- /* when slaved, don't try to get too close to the read pointer. this
- leaves space for the buffer reversal to have something useful to
- work with.
- */
-
- if (_slaved && write_space < (_playback_buf->capacity() / 2)) {
- cerr << "No refill 2\n";
- return 0;
- }
-
+
if (reversed) {
- cerr << "No refill 3 (reverse)\n";
return 0;
}
+ /* at end: nothing to do */
if (file_frame == max_frames) {
- //cerr << "No refill 4 (EOF)\n";
-
- /* at end: nothing to do */
-
return 0;
}
-#if 0
- // or this
- if (file_frame > max_frames - total_space) {
-
- /* to close to the end: read what we can, and zero fill the rest */
-
- zero_fill = total_space - (max_frames - file_frame);
- total_space = max_frames - file_frame;
-
- } else {
- zero_fill = 0;
- }
-#endif
-
- // At this point we:
+ // At this point we...
assert(_playback_buf->write_space() > 0); // ... have something to write to, and
assert(file_frame <= max_frames); // ... something to write
- // So (read it, then) write it:
-
- jack_nframes_t file_frame_tmp = file_frame;
- jack_nframes_t to_read = min(disk_io_chunk_frames, (max_frames - file_frame));
-
- // FIXME: read count?
- if (read (file_frame_tmp, to_read, reversed)) {
- ret = -1;
- goto out;
+ // now calculate how much time is in the ringbuffer.
+ // and lets write as much as we need to get this to be midi_readahead;
+ uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
+ uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
+ if ((frames_written - frames_read) >= midi_readahead) {
+ //cout << "MDS Nothing to do. all fine" << endl;
+ return 0;
}
- file_frame = file_frame_tmp;
+ nframes_t to_read = midi_readahead - (frames_written - frames_read);
-out:
+ //cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
+ // << frames_written - frames_read << endl;
+ to_read = min(to_read, (max_frames - file_frame));
+
+ if (read (file_frame, to_read, reversed)) {
+ ret = -1;
+ }
+
return ret;
}
* written at all unless @a force_flush is true.
*/
int
-MidiDiskstream::do_flush (Session::RunContext context, bool force_flush)
+MidiDiskstream::do_flush (RunContext context, bool force_flush)
{
uint32_t to_write;
int32_t ret = 0;
- // FIXME: I'd be lying if I said I knew what this thing was
- //RingBufferNPT<CaptureTransition>::rw_vector transvec;
- jack_nframes_t total;
+ nframes_t total;
_write_data_count = 0;
- if (_last_flush_frame > _session.transport_frame()) {
+ total = _session.transport_frame() - _last_flush_frame;
+
+ if (_last_flush_frame > _session.transport_frame()
+ || _last_flush_frame < capture_start_frame) {
_last_flush_frame = _session.transport_frame();
}
- total = _session.transport_frame() - _last_flush_frame;
-
-
- // FIXME: put this condition back in! (removed for testing)
- if (total == 0 || (total < disk_io_chunk_frames && !force_flush && was_recording)) {
- //cerr << "MDS - no flush 1\n";
+ if (total == 0 || _capture_buf->read_space() == 0
+ || (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
goto out;
}
ret = 1;
}
- //to_write = min (disk_io_chunk_frames, (jack_nframes_t) vector.len[0]);
to_write = disk_io_chunk_frames;
assert(!destructive());
- if ((!_write_source) || _write_source->write (*_capture_buf, to_write) != to_write) {
- //cerr << "MDS - no flush 2\n";
- error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
- return -1;
- } else {
- _last_flush_frame = _session.transport_frame();
- //cerr << "MDS - flushed\n";
+ if (record_enabled()
+ && ( (_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames)
+ || force_flush)) {
+ if ((!_write_source) || _write_source->midi_write (*_capture_buf, capture_start_frame, to_write) != to_write) {
+ error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
+ return -1;
+ } else {
+ _last_flush_frame = _session.transport_frame();
+ }
}
- //(*chan).curr_capture_cnt += to_write;
-
out:
- //return ret;
- return 0;
+ return ret;
}
void
uint32_t buffer_position;
bool more_work = true;
int err = 0;
- MidiRegion* region = 0;
- jack_nframes_t total_capture;
+ boost::shared_ptr<MidiRegion> region;
+ nframes_t total_capture;
MidiRegion::SourceList srcs;
MidiRegion::SourceList::iterator src;
vector<CaptureInfo*>::iterator ci;
*/
while (more_work && !err) {
- switch (do_flush (Session::TransportContext, true)) {
+ switch (do_flush (TransportContext, true)) {
case 0:
more_work = false;
break;
if (abort_capture) {
- list<Source*>* deletion_list = new list<Source*>;
-
if (_write_source) {
- _write_source->mark_for_remove ();
- _write_source->release ();
-
- deletion_list->push_back (_write_source);
- _write_source = 0;
+ _write_source->mark_for_remove ();
+ _write_source->drop_references ();
+ _write_source.reset();
}
/* new source set up in "out" below */
- if (!deletion_list->empty()) {
- DeleteSources (deletion_list);
- } else {
- delete deletion_list;
- }
-
} else {
assert(_write_source);
}
/* figure out the name for this take */
+
+ srcs.push_back (_write_source);
+ _write_source->set_timeline_position (capture_info.front()->start);
+ _write_source->set_captured_for (_name);
- SMFSource* s = _write_source;
-
- if (s) {
-
- srcs.push_back (s);
-
- cerr << "MidiDiskstream: updating source after capture\n";
- s->update_header (capture_info.front()->start, when, twhen);
-
- s->set_captured_for (_name);
-
- }
+ string whole_file_region_name;
+ whole_file_region_name = region_name_from_path (_write_source->name(), true);
/* Register a new region with the Session that
describes the entire source. Do this first
so that any sub-regions will obviously be
children of this one (later!)
*/
+
try {
- assert(_write_source);
- region = new MidiRegion (srcs, _write_source->last_capture_start_frame(), total_capture,
- region_name_from_path (_write_source->name()),
- 0, Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile));
+ boost::shared_ptr<Region> rx (RegionFactory::create (srcs, 0,
+ total_capture, whole_file_region_name, 0,
+ Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
+ region = boost::dynamic_pointer_cast<MidiRegion> (rx);
region->special_set_position (capture_info.front()->start);
}
XMLNode &before = _playlist->get_state();
_playlist->freeze ();
- for (buffer_position = _write_source->last_capture_start_frame(), ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+ for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
string region_name;
+
_session.region_name (region_name, _write_source->name(), false);
// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
try {
- region = new MidiRegion (srcs, buffer_position, (*ci)->frames, region_name);
+ boost::shared_ptr<Region> rx (RegionFactory::create (srcs, buffer_position, (*ci)->frames, region_name));
+ region = boost::dynamic_pointer_cast<MidiRegion> (rx);
}
catch (failed_constructor& err) {
- error << _("MidiDiskstream: could not create region for captured audio!") << endmsg;
+ error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
continue; /* XXX is this OK? */
}
+
+ region->GoingAway.connect (bind (mem_fun (*this, &Diskstream::remove_region_from_last_capture), boost::weak_ptr<Region>(region)));
_last_capture_regions.push_back (region);
// cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
i_am_the_modifier++;
- _playlist->add_region (*region, (*ci)->start);
+ _playlist->add_region (region, (*ci)->start);
i_am_the_modifier--;
buffer_position += (*ci)->frames;
_playlist->thaw ();
XMLNode &after = _playlist->get_state();
- _session.add_command (new MementoCommand<Playlist>(*_playlist, before, after));
+ _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
- mark_write_completed = true;
+ }
- reset_write_sources (mark_write_completed);
+ mark_write_completed = true;
- }
+ reset_write_sources (mark_write_completed);
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
delete *ci;
capture_start_frame = 0;
}
+void
+MidiDiskstream::transport_looped (nframes_t transport_frame)
+{
+ if (was_recording) {
+
+ // adjust the capture length knowing that the data will be recorded to disk
+ // only necessary after the first loop where we're recording
+ if (capture_info.size() == 0) {
+ capture_captured += _capture_offset;
+
+ if (_alignment_style == ExistingMaterial) {
+ capture_captured += _session.worst_output_latency();
+ } else {
+ capture_captured += _roll_delay;
+ }
+ }
+
+ finish_capture (true);
+
+ // the next region will start recording via the normal mechanism
+ // we'll set the start position to the current transport pos
+ // no latency adjustment or capture offset needs to be made, as that already happened the first time
+ capture_start_frame = transport_frame;
+ first_recordable_frame = transport_frame; // mild lie
+ last_recordable_frame = max_frames;
+ was_recording = true;
+ }
+}
+
void
MidiDiskstream::finish_capture (bool rec_monitors_input)
{
g_atomic_int_set (&_record_enabled, 1);
- if (Config->get_use_hardware_monitoring() && _source_port) {
- _source_port->request_monitor_input (!(_session.get_auto_input() && rolling));
+ if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
+ _source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
}
+ // FIXME: Why is this necessary? Isn't needed for AudioDiskstream...
+ if (!_write_source)
+ use_new_write_source();
+
+ _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
+
RecordEnableChanged (); /* EMIT SIGNAL */
}
MidiDiskstream::disengage_record_enable ()
{
g_atomic_int_set (&_record_enabled, 0);
- if (Config->get_use_hardware_monitoring()) {
+ if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
if (_source_port) {
_source_port->request_monitor_input (false);
}
snprintf (buf, sizeof(buf), "0x%x", _flags);
node->add_property ("flags", buf);
+ node->add_property("channel-mode", enum_2_string(get_channel_mode()));
+
+ snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
+ node->add_property("channel-mask", buf);
+
node->add_property ("playlist", _playlist->name());
snprintf (buf, sizeof(buf), "%f", _visible_speed);
node->add_property ("speed", buf);
node->add_property("name", _name);
- id().print(buf);
+ id().print(buf, sizeof(buf));
node->add_property("id", buf);
if (_write_source && _session.get_record_enabled()) {
Location* pi;
- if (_session.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
- snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
+ if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+ snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
} else {
snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
}
}
if ((prop = node.property ("flags")) != 0) {
- _flags = strtol (prop->value().c_str(), 0, 0);
+ _flags = Flag (string_2_enum (prop->value(), _flags));
}
+ ChannelMode channel_mode = AllChannels;
+ if ((prop = node.property ("channel-mode")) != 0) {
+ channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
+ }
+
+ unsigned int channel_mask = 0xFFFF;
+ if ((prop = node.property ("channel-mask")) != 0) {
+ sscanf (prop->value().c_str(), "0x%x", &channel_mask);
+ if (channel_mask & (~0xFFFF)) {
+ warning << _("MidiDiskstream: XML property channel-mask out of range") << endmsg;
+ }
+ }
+
+ set_channel_mode(channel_mode, channel_mask);
+
if ((prop = node.property ("channels")) != 0) {
nchans = atoi (prop->value().c_str());
}
if (_write_source) {
- if (SMFSource::is_empty (_write_source->path())) {
+ if (_write_source->is_empty ()) {
_write_source->mark_for_remove ();
- _write_source->release();
- delete _write_source;
+ _write_source.reset();
} else {
- _write_source->release();
- _write_source = 0;
+ _write_source.reset();
}
}
try {
- _write_source = dynamic_cast<SMFSource*>(_session.create_midi_source_for_session (*this));
+ _write_source = boost::dynamic_pointer_cast<SMFSource>(_session.create_midi_source_for_session (*this));
if (!_write_source) {
throw failed_constructor();
}
catch (failed_constructor &err) {
error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
- _write_source = 0;
+ _write_source.reset();
return -1;
}
- _write_source->use ();
_write_source->set_allow_remove_if_empty (true);
return 0;
_write_source->mark_streaming_write_completed ();
}
- if (!_write_source) {
- use_new_write_source ();
+ use_new_write_source (0);
+
+ if (record_enabled()) {
+ //_capturing_sources.push_back (_write_source);
}
}
MidiDiskstream::rename_write_sources ()
{
if (_write_source != 0) {
- _write_source->set_name (_name, destructive());
+ _write_source->set_source_name (_name, destructive());
/* XXX what to do if this fails ? */
}
return 0;
}
void
-MidiDiskstream::set_block_size (jack_nframes_t nframes)
+MidiDiskstream::set_block_size (nframes_t nframes)
{
}
MidiDiskstream::monitor_input (bool yn)
{
if (_source_port)
- _source_port->request_monitor_input (yn);
- else
- cerr << "MidiDiskstream NO SOURCE PORT TO MONITOR\n";
+ _source_port->ensure_monitor_input (yn);
}
void
(double) _capture_buf->capacity());
}
-
int
MidiDiskstream::use_pending_capture_data (XMLNode& node)
{
return 0;
}
-/** Writes playback events in the given range to dst, translating time stamps
- * so that an event at start has time = 0
+/** Writes playback events in the given range to \a dst, translating time stamps
+ * so that an event at \a start has time = 0
*/
void
-MidiDiskstream::get_playback(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end)
+MidiDiskstream::get_playback (MidiBuffer& dst, nframes_t start, nframes_t end)
{
dst.clear();
assert(dst.size() == 0);
- // I think this happens with reverse varispeed? maybe?
+ // Reverse. ... We just don't do reverse, ok? Back off.
if (end <= start) {
return;
}
-/*
- cerr << "MIDI Diskstream pretending to read" << endl;
-
- MidiEvent ev;
- RawMidi data[4];
-
- const char note = rand()%30 + 30;
+ // Check only events added this offset cycle
+ MidiBuffer::iterator this_cycle_start = dst.end();
- ev.buffer = data;
- ev.time = 0;
- ev.size = 3;
-
- data[0] = 0x90;
- data[1] = note;
- data[2] = 120;
-
- dst.push_back(ev);
+ // Translates stamps to be relative to start
+ #if 1
+ _playback_buf->read(dst, start, end);
+ #else
+ const size_t events_read = _playback_buf->read(dst, start, end);
+ cout << "MDS events read = " << events_read
+ << " start = " << start << " end = " << end
+ << " readspace " << _playback_buf->read_space()
+ << " writespace " << _playback_buf->write_space() << endl;
+ #endif
- ev.buffer = data;
- ev.time = (end - start) / 2;
- ev.size = 3;
-
- data[0] = 0x80;
- data[1] = note;
- data[2] = 64;
-*/
- _playback_buf->read(dst, start, end);
-
- // Translate time stamps to be relative to the start of this cycle
- for (size_t i=0; i < dst.size(); ++i) {
- assert(dst[i].time >= start);
- assert(dst[i].time <= end);
- cerr << "Translating event stamp " << dst[i].time << " to ";
- dst[i].time -= start;
- cerr << dst[i].time << endl;
-
+ gint32 frames_read = end - start;
+ g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
+
+ // Feed the data through the MidiStateTracker
+ // If it detects a LoopEvent it will add necessary note offs
+ if (_midi_state_tracker.track(this_cycle_start, dst.end())) {
+ _midi_state_tracker.resolve_notes(dst, end-start - 1);
}
}
+
projects / ardour.git / blobdiff