using namespace ARDOUR;
using namespace PBD;
-nframes_t MidiDiskstream::midi_readahead = 4096;
+framecnt_t MidiDiskstream::midi_readahead = 4096;
MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
init ();
use_new_playlist ();
- use_new_write_source (0);
+ use_new_write_source (0);
in_set_state = false;
throw failed_constructor();
}
- use_new_write_source (0);
+ use_new_write_source (0);
in_set_state = false;
}
allocate_temporary_buffers ();
const size_t size = _session.butler()->midi_diskstream_buffer_size();
- _playback_buf = new MidiRingBuffer<nframes_t>(size);
- _capture_buf = new MidiRingBuffer<nframes_t>(size);
+ _playback_buf = new MidiRingBuffer<framepos_t>(size);
+ _capture_buf = new MidiRingBuffer<framepos_t>(size);
_n_channels = ChanCount(DataType::MIDI, 1);
/* implicit unlock */
}
- /* unlike with audio, there is never any need to reset write sources
- based on input configuration changes because ... a MIDI track
- has just 1 MIDI port as input, always.
- */
+ /* unlike with audio, there is never any need to reset write sources
+ based on input configuration changes because ... a MIDI track
+ has just 1 MIDI port as input, always.
+ */
/* now refill channel buffers */
#endif
int
-MidiDiskstream::process (framepos_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
+MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
{
int ret = -1;
- nframes_t rec_offset = 0;
- nframes_t rec_nframes = 0;
+ framecnt_t rec_offset = 0;
+ framecnt_t rec_nframes = 0;
bool nominally_recording;
bool re = record_enabled ();
- playback_distance = 0;
+ playback_distance = 0;
- check_record_status (transport_frame, nframes, can_record);
+ check_record_status (transport_frame, can_record);
nominally_recording = (can_record && re);
return 0;
}
- Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
+ Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
- if (!sm.locked()) {
+ if (!sm.locked()) {
return 1;
}
_capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
}
+ if (buf.size() != 0) {
+ /* Make a copy of this data and emit it for the GUI to see */
+ boost::shared_ptr<MidiBuffer> copy (new MidiBuffer (buf.capacity ()));
+ for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
+ copy->push_back ((*i).time() + transport_frame, (*i).size(), (*i).buffer());
+ }
+
+ DataRecorded (copy, _write_source); /* EMIT SIGNAL */
+ }
+
} else {
if (was_recording) {
ret = 0;
- if (commit (nframes)) {
- need_butler = true;
- }
+ if (commit (nframes)) {
+ need_butler = true;
+ }
return ret;
}
bool
-MidiDiskstream::commit (nframes_t nframes)
+MidiDiskstream::commit (framecnt_t nframes)
{
bool need_butler = false;
int
MidiDiskstream::overwrite_existing_buffers ()
{
+ /* This is safe as long as the butler thread is suspended, which it should be */
+ _playback_buf->reset ();
+
+ g_atomic_int_set (&_frames_read_from_ringbuffer, 0);
+ g_atomic_int_set (&_frames_written_to_ringbuffer, 0);
+
read (overwrite_frame, disk_io_chunk_frames, false);
overwrite_queued = false;
_pending_overwrite = false;
/** @a start is set to the new frame position (TIME) read up to */
int
-MidiDiskstream::read (framepos_t& start, nframes_t dur, bool reversed)
+MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
{
- nframes_t this_read = 0;
+ framecnt_t this_read = 0;
bool reloop = false;
framepos_t loop_end = 0;
framepos_t loop_start = 0;
// Synthesize LoopEvent here, because the next events
// written will have non-monotonic timestamps.
_playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
- cout << "Pushing LoopEvent ts=" << loop_end-1
- << " start+this_read " << start+this_read << endl;
-
start = loop_start;
} else {
start += this_read;
return 0;
}
- nframes_t to_read = midi_readahead - (frames_written - frames_read);
+ framecnt_t to_read = midi_readahead - (frames_written - frames_read);
//cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
// << frames_written - frames_read << endl;
- to_read = (nframes_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
+ to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
if (read (file_frame, to_read, reversed)) {
ret = -1;
{
uint32_t to_write;
int32_t ret = 0;
- nframes_t total;
+ framecnt_t total;
_write_data_count = 0;
total = _session.transport_frame() - _last_flush_frame;
- if (_last_flush_frame > _session.transport_frame()
- || _last_flush_frame < capture_start_frame) {
+ if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) {
_last_flush_frame = _session.transport_frame();
}
assert(!destructive());
- if (record_enabled() &&
- ((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
+ 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) {
+ if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
return -1;
} else {
while (more_work && !err) {
switch (do_flush (TransportContext, true)) {
- case 0:
- more_work = false;
- break;
- case 1:
- break;
- case -1:
- error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
- err++;
+ case 0:
+ more_work = false;
+ break;
+ case 1:
+ break;
+ case -1:
+ error << string_compose(_("MidiDiskstream \"%1\": cannot flush captured data to disk!"), _name) << endmsg;
+ err++;
}
}
if (abort_capture) {
if (_write_source) {
-
_write_source->mark_for_remove ();
_write_source.reset();
}
assert(_write_source);
- nframes_t total_capture = 0;
+ framecnt_t total_capture = 0;
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
total_capture += (*ci)->frames;
}
- if (_write_source->length (capture_info.front()->start) != 0) {
-
- /* phew, we have data */
-
- /* figure out the name for this take */
-
- srcs.push_back (_write_source);
+ if (_write_source->length (capture_info.front()->start) != 0) {
- _write_source->set_timeline_position (capture_info.front()->start);
- _write_source->set_captured_for (_name);
+ /* phew, we have data */
- /* flush to disk: this step differs from the audio path,
- where all the data is already on disk.
- */
+ /* figure out the name for this take */
- _write_source->mark_streaming_write_completed ();
-
- /* make it not a stub anymore */
+ srcs.push_back (_write_source);
- _write_source->unstubify ();
+ _write_source->set_timeline_position (capture_info.front()->start);
+ _write_source->set_captured_for (_name);
- /* we will want to be able to keep (over)writing the source
- but we don't want it to be removable. this also differs
- from the audio situation, where the source at this point
- must be considered immutable. luckily, we can rely on
- MidiSource::mark_streaming_write_completed() to have
- already done the necessary work for that.
- */
+ /* flush to disk: this step differs from the audio path,
+ where all the data is already on disk.
+ */
- 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 {
- PropertyList plist;
+ _write_source->mark_streaming_write_completed ();
- plist.add (Properties::name, whole_file_region_name);
- plist.add (Properties::whole_file, true);
- plist.add (Properties::automatic, true);
- plist.add (Properties::start, 0);
- plist.add (Properties::length, total_capture);
- plist.add (Properties::layer, 0);
+ /* set length in beats to entire capture length */
- boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+ BeatsFramesConverter converter (_session.tempo_map(), capture_info.front()->start);
+ const double total_capture_beats = converter.from(total_capture);
+ _write_source->set_length_beats(total_capture_beats);
- region = boost::dynamic_pointer_cast<MidiRegion> (rx);
- region->special_set_position (capture_info.front()->start);
- }
+ /* make it not a stub anymore */
+ _write_source->unstubify ();
- catch (failed_constructor& err) {
- error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
- /* XXX what now? */
- }
+ /* we will want to be able to keep (over)writing the source
+ but we don't want it to be removable. this also differs
+ from the audio situation, where the source at this point
+ must be considered immutable. luckily, we can rely on
+ MidiSource::mark_streaming_write_completed() to have
+ already done the necessary work for that.
+ */
- _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
+ string whole_file_region_name;
+ whole_file_region_name = region_name_from_path (_write_source->name(), true);
- _playlist->clear_changes ();
- _playlist->freeze ();
+ /* 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!)
+ */
- uint32_t buffer_position = 0;
- for (buffer_position = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+ try {
+ PropertyList plist;
- string region_name;
+ plist.add (Properties::name, whole_file_region_name);
+ plist.add (Properties::whole_file, true);
+ plist.add (Properties::automatic, true);
+ plist.add (Properties::start, 0);
+ plist.add (Properties::length, total_capture);
+ plist.add (Properties::layer, 0);
- RegionFactory::region_name (region_name, _write_source->name(), false);
+ boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+
+ region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+ region->special_set_position (capture_info.front()->start);
+ }
- // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
- try {
- PropertyList plist;
-
- plist.add (Properties::start, buffer_position);
- plist.add (Properties::length, (*ci)->frames);
- plist.add (Properties::name, region_name);
-
- boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
- region = boost::dynamic_pointer_cast<MidiRegion> (rx);
- }
+ catch (failed_constructor& err) {
+ error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
+ /* XXX what now? */
+ }
- catch (failed_constructor& err) {
- error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
- continue; /* XXX is this OK? */
- }
+ _last_capture_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
- // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
+ _playlist->clear_changes ();
+ _playlist->freeze ();
- i_am_the_modifier++;
- _playlist->add_region (region, (*ci)->start);
- i_am_the_modifier--;
+ /* Session frame time of the initial capture in this pass, which is where the source starts */
+ framepos_t initial_capture = 0;
+ if (!capture_info.empty()) {
+ initial_capture = capture_info.front()->start;
+ }
- buffer_position += (*ci)->frames;
- }
+ for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
- _playlist->thaw ();
- _session.add_command (new StatefulDiffCommand(_playlist));
- }
+ string region_name;
- mark_write_completed = true;
+ RegionFactory::region_name (region_name, _write_source->name(), false);
+
+ // cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
+
+ try {
+ PropertyList plist;
+
+ /* start of this region is the offset between the start of its capture and the start of the whole pass */
+ plist.add (Properties::start, (*ci)->start - initial_capture);
+ plist.add (Properties::length, (*ci)->frames);
+ plist.add (Properties::length_beats, converter.from((*ci)->frames));
+ plist.add (Properties::name, region_name);
+
+ boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
+ region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+ }
+
+ catch (failed_constructor& err) {
+ error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
+ continue; /* XXX is this OK? */
+ }
+
+ // cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
+
+ i_am_the_modifier++;
+ _playlist->add_region (region, (*ci)->start);
+ i_am_the_modifier--;
+ }
+
+ _playlist->thaw ();
+ _session.add_command (new StatefulDiffCommand(_playlist));
+ }
+
+ mark_write_completed = true;
}
- use_new_write_source (0);
+ use_new_write_source (0);
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
delete *ci;
void
MidiDiskstream::engage_record_enable ()
{
- bool rolling = _session.transport_speed() != 0.0f;
+ bool const rolling = _session.transport_speed() != 0.0f;
g_atomic_int_set (&_record_enabled, 1);
_source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
}
- _write_source->mark_streaming_midi_write_started (_note_mode, _session.transport_frame());
-
RecordEnableChanged (); /* EMIT SIGNAL */
}
assert(n == 0);
- _write_source.reset();
+ _write_source.reset();
try {
- /* file starts off as a stub file, it will be converted
- when we're done with a capture pass, or when "stolen"
- by the GUI.
- */
+ /* file starts off as a stub file, it will be converted
+ when we're done with a capture pass, or when "stolen"
+ by the GUI.
+ */
_write_source = boost::dynamic_pointer_cast<SMFSource>(
- _session.create_midi_source_for_session (0, name (), true));
+ _session.create_midi_source_for_session (0, name (), true));
if (!_write_source) {
throw failed_constructor();
return 0;
}
-list<boost::shared_ptr<Source> >
+list<boost::shared_ptr<Source> >
MidiDiskstream::steal_write_sources()
{
- list<boost::shared_ptr<Source> > ret;
+ list<boost::shared_ptr<Source> > ret;
- /* put some data on the disk, even if its just a header for an empty file.
- XXX should we not have a more direct method for doing this? Maybe not
- since we don't want to mess around with the model/disk relationship
- that the Source has to pay attention to.
- */
-
- boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
+ /* put some data on the disk, even if its just a header for an empty file.
+ XXX should we not have a more direct method for doing this? Maybe not
+ since we don't want to mess around with the model/disk relationship
+ that the Source has to pay attention to.
+ */
+
+ boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
- /* make it visible/present */
- _write_source->unstubify ();
- /* never let it go away */
- _write_source->mark_nonremovable ();
+ /* make it visible/present */
+ _write_source->unstubify ();
+ /* never let it go away */
+ _write_source->mark_nonremovable ();
- ret.push_back (_write_source);
+ ret.push_back (_write_source);
- /* get a new one */
+ /* get a new one */
- use_new_write_source (0);
+ use_new_write_source (0);
- return ret;
+ return ret;
}
void
if (_write_source && mark_write_complete) {
_write_source->mark_streaming_write_completed ();
- }
- use_new_write_source (0);
+ }
+ use_new_write_source (0);
}
int
}
void
-MidiDiskstream::set_block_size (nframes_t /*nframes*/)
+MidiDiskstream::set_block_size (pframes_t /*nframes*/)
{
}