#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/smf_source.h>
#include <ardour/destructive_filesource.h>
#include <ardour/send.h>
+#include <ardour/region_factory.h>
#include <ardour/midi_playlist.h>
#include <ardour/cycle_timer.h>
#include <ardour/midi_region.h>
+#include <ardour/midi_port.h>
#include "i18n.h"
#include <locale.h>
using namespace ARDOUR;
using namespace PBD;
-sigc::signal<void,list<SMFSource*>*> MidiDiskstream::DeleteSources;
-
MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
: Diskstream(sess, name, flag)
- , _playlist(NULL)
+ , _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)
+ , _capture_transition_buf(0)
+ , _last_flush_frame(0)
{
/* prevent any write sources from being created */
in_set_state = false;
- DiskstreamCreated (this); /* EMIT SIGNAL */
+ assert(!destructive());
}
MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
: Diskstream(sess, node)
- , _playlist(NULL)
+ , _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)
+ , _capture_transition_buf(0)
+ , _last_flush_frame(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 ();
- /* FIXME: this is now done before the above. OK? */
- /*pending_overwrite = false;
- overwrite_frame = 0;
- overwrite_queued = false;
- input_change_pending = NoChange;*/
+ //_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);
+
+ _n_channels = ChanCount(DataType::MIDI, 1);
- _n_channels = 1;
+ assert(recordable());
}
MidiDiskstream::~MidiDiskstream ()
{
Glib::Mutex::Lock lm (state_lock);
-
- if (_playlist)
- _playlist->unref ();
}
-/*
-void
-MidiDiskstream::handle_input_change (IOChange change, void *src)
-{
- Glib::Mutex::Lock lm (state_lock);
- if (!(input_change_pending & change)) {
- input_change_pending = IOChange (input_change_pending|change);
- _session.request_input_change_handling ();
- }
-}
-*/
void
MidiDiskstream::non_realtime_input_change ()
{
+ {
+ Glib::Mutex::Lock lm (state_lock);
+
+ if (input_change_pending == NoChange) {
+ return;
+ }
+
+ if (input_change_pending & ConfigurationChanged) {
+
+ assert(_io->n_inputs() == _n_channels);
+ }
+
+ get_input_sources ();
+ set_capture_offset ();
+
+ if (first_input_change) {
+ set_align_style (_persistent_alignment_style);
+ first_input_change = false;
+ } else {
+ set_align_style_from_io ();
+ }
+
+ input_change_pending = NoChange;
+ }
+
+ /* reset capture files */
+
+ reset_write_sources (false);
+
+ /* now refill channel buffers */
+
+ if (speed() != 1.0f || speed() != -1.0f) {
+ seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()));
+ }
+ else {
+ seek (_session.transport_frame());
+ }
+
+ _last_flush_frame = _session.transport_frame();
}
void
MidiDiskstream::get_input_sources ()
{
+ uint32_t ni = _io->n_inputs().get(DataType::MIDI);
+
+ if (ni == 0) {
+ return;
+ }
+
+ // This is all we do for now at least
+ assert(ni == 1);
+
+ _source_port = _io->midi_input(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);
+ }*/
}
int
{
assert(dynamic_cast<MidiPlaylist*>(playlist));
- {
- Glib::Mutex::Lock lm (state_lock);
-
- if (playlist == _playlist) {
- return 0;
- }
-
- plstate_connection.disconnect();
- plmod_connection.disconnect ();
- plgone_connection.disconnect ();
-
- if (_playlist) {
- _playlist->unref();
- }
-
- _playlist = dynamic_cast<MidiPlaylist*>(playlist);
- _playlist->ref();
-
- if (!in_set_state && recordable()) {
- reset_write_sources (false);
- }
-
- plstate_connection = _playlist->StateChanged.connect (mem_fun (*this, &MidiDiskstream::playlist_changed));
- plmod_connection = _playlist->Modified.connect (mem_fun (*this, &MidiDiskstream::playlist_modified));
- plgone_connection = _playlist->GoingAway.connect (mem_fun (*this, &MidiDiskstream::playlist_deleted));
- }
-
- if (!overwrite_queued) {
- _session.request_overwrite_buffer (this);
- overwrite_queued = true;
- }
-
- PlaylistChanged (); /* EMIT SIGNAL */
- _session.set_dirty ();
-
- return 0;
+ return Diskstream::use_playlist(playlist);
}
int
newname = Playlist::bump_name (_playlist->name(), _session);
- if ((playlist = new MidiPlaylist (*_playlist, newname)) != 0) {
+ if ((playlist = new MidiPlaylist (*midi_playlist(), newname)) != 0) {
playlist->set_orig_diskstream_id (id());
return use_playlist (playlist);
} else {
}
}
-
+/** Overloaded from parent to die horribly
+ */
void
-MidiDiskstream::playlist_deleted (Playlist* pl)
+MidiDiskstream::set_destructive (bool yn)
{
- /* this catches an ordering issue with session destruction. playlists
- are destroyed before diskstreams. we have to invalidate any handles
- we have to the playlist.
- */
-
- _playlist = 0;
+ assert( ! destructive());
+ assert( ! yn);
}
-
void
-MidiDiskstream::setup_destructive_playlist ()
-{
- /* a single full-sized region */
-
- //MidiRegion* region = new MidiRegion (srcs, 0, max_frames, _name);
- //_playlist->add_region (*region, 0);
-}
-
-void
-MidiDiskstream::use_destructive_playlist ()
+MidiDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
{
- /* use the sources associated with the single full-extent region */
+ // FIXME: waaay too much code to duplicate (AudioDiskstream)
- Playlist::RegionList* rl = _playlist->regions_at (0);
+ int possibly_recording;
+ int rolling;
+ int change;
+ const int transport_rolling = 0x4;
+ const int track_rec_enabled = 0x2;
+ const int global_rec_enabled = 0x1;
+
+ /* merge together the 3 factors that affect record status, and compute
+ what has changed.
+ */
+
+ rolling = _session.transport_speed() != 0.0f;
+ possibly_recording = (rolling << 2) | (record_enabled() << 1) | can_record;
+ change = possibly_recording ^ last_possibly_recording;
- if (rl->empty()) {
- reset_write_sources (false, true);
+ if (possibly_recording == last_possibly_recording) {
return;
}
- MidiRegion* region = dynamic_cast<MidiRegion*> (rl->front());
+ /* change state */
- if (region == 0) {
- throw failed_constructor();
- }
+ /* if per-track or global rec-enable turned on while the other was already on, we've started recording */
- delete rl;
+ 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 */
- /* the source list will never be reset for a destructive track */
-}
+ first_recordable_frame = transport_frame + _capture_offset;
+ last_recordable_frame = max_frames;
+ capture_start_frame = transport_frame;
-void
-MidiDiskstream::set_io (IO& io)
-{
- _io = &io;
- set_align_style_from_io ();
-}
+ if (!(last_possibly_recording & transport_rolling) && (possibly_recording & transport_rolling)) {
-void
-MidiDiskstream::non_realtime_set_speed ()
-{
- if (_buffer_reallocation_required)
- {
- Glib::Mutex::Lock lm (state_lock);
- allocate_temporary_buffers ();
+ /* was stopped, now rolling (and recording) */
- _buffer_reallocation_required = false;
- }
+ if (_alignment_style == ExistingMaterial) {
+ first_recordable_frame += _session.worst_output_latency();
+ } else {
+ first_recordable_frame += _roll_delay;
+ }
+
+ } else {
+
+ /* was rolling, but record state changed */
+
+ if (_alignment_style == ExistingMaterial) {
+
+
+ if (!Config->get_punch_in()) {
+
+ /* manual punch in happens at the correct transport frame
+ because the user hit a button. but to get alignment correct
+ we have to back up the position of the new region to the
+ appropriate spot given the roll delay.
+ */
+
+ capture_start_frame -= _roll_delay;
+
+ /* XXX paul notes (august 2005): i don't know why
+ this is needed.
+ */
+
+ first_recordable_frame += _capture_offset;
+
+ } else {
- if (_seek_required) {
- if (speed() != 1.0f || speed() != -1.0f) {
- seek ((jack_nframes_t) (_session.transport_frame() * (double) speed()), true);
+ /* autopunch toggles recording at the precise
+ transport frame, and then the DS waits
+ to start recording for a time that depends
+ on the output latency.
+ */
+
+ first_recordable_frame += _session.worst_output_latency();
+ }
+
+ } else {
+
+ if (Config->get_punch_in()) {
+ first_recordable_frame += _roll_delay;
+ } else {
+ capture_start_frame -= _roll_delay;
+ }
+ }
+
}
- else {
- seek (_session.transport_frame(), true);
+
+ 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;
+ }
}
- _seek_required = false;
+ } else if (!record_enabled() || !can_record) {
+
+ /* stop recording */
+
+ last_recordable_frame = transport_frame + _capture_offset;
+
+ if (_alignment_style == ExistingMaterial) {
+ last_recordable_frame += _session.worst_output_latency();
+ } else {
+ last_recordable_frame += _roll_delay;
+ }
}
-}
-void
-MidiDiskstream::check_record_status (jack_nframes_t transport_frame, jack_nframes_t nframes, bool can_record)
-{
+ last_possibly_recording = possibly_recording;
}
int
MidiDiskstream::process (jack_nframes_t transport_frame, jack_nframes_t nframes, jack_nframes_t offset, 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;*/
+
+ /* if we've already processed the frames corresponding to this call,
+ just return. this allows multiple routes that are taking input
+ from this diskstream to call our ::process() method, but have
+ this stuff only happen once. more commonly, it allows both
+ the AudioTrack that is using this AudioDiskstream *and* the Session
+ to call process() without problems.
+ */
+
+ if (_processed) {
+ return 0;
+ }
+
+ check_record_status (transport_frame, nframes, can_record);
+
+ nominally_recording = (can_record && re);
+
+ if (nframes == 0) {
+ _processed = true;
+ return 0;
+ }
+
+ /* This lock is held until the end of AudioDiskstream::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 we can't take the state lock return.
+ if (!state_lock.trylock()) {
+ return 1;
+ }
+
+ adjust_capture_position = 0;
+
+ if (nominally_recording || (_session.get_record_enabled() && Config->get_punch_in())) {
+ OverlapType ot;
+
+ ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
+
+ switch (ot) {
+ case OverlapNone:
+ rec_nframes = 0;
+ break;
+
+ case OverlapInternal:
+ /* ---------- recrange
+ |---| transrange
+ */
+ rec_nframes = nframes;
+ rec_offset = 0;
+ break;
+
+ case OverlapStart:
+ /* |--------| recrange
+ -----| transrange
+ */
+ rec_nframes = transport_frame + nframes - first_recordable_frame;
+ if (rec_nframes) {
+ rec_offset = first_recordable_frame - transport_frame;
+ }
+ break;
+
+ case OverlapEnd:
+ /* |--------| recrange
+ |-------- transrange
+ */
+ rec_nframes = last_recordable_frame - transport_frame;
+ rec_offset = 0;
+ break;
+
+ case OverlapExternal:
+ /* |--------| recrange
+ -------------- transrange
+ */
+ rec_nframes = last_recordable_frame - last_recordable_frame;
+ rec_offset = first_recordable_frame - transport_frame;
+ break;
+ }
+
+ if (rec_nframes && !was_recording) {
+ capture_captured = 0;
+ was_recording = true;
+ }
+ }
+
+
+ if (can_record && !_last_capture_regions.empty()) {
+ _last_capture_regions.clear ();
+ }
+
+ 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";
+ */
+ } else {
+
+ if (was_recording) {
+ finish_capture (rec_monitors_input);
+ }
+
+ }
+
+ if (rec_nframes) {
+
+ /* XXX XXX XXX XXX XXX XXX XXX XXX */
+ /* data will be written to disk */
+
+ 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;
+
+ } else {
+
+ collect_playback = true;
+ }
+
+ if (collect_playback) {
+
+ /* we're doing playback */
+
+ jack_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;
+ } else {
+ necessary_samples = nframes;
+ }
+
+ // XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX
+ // Write into playback buffer here, and whatnot
+
+ }
+
+ ret = 0;
+
+ _processed = true;
+
+ if (ret) {
+
+ /* we're exiting with failure, so ::commit will not
+ be called. unlock the state lock.
+ */
+
+ state_lock.unlock();
+ }
+
+ return ret;
+
+ _processed = true;
+
return 0;
}
bool
MidiDiskstream::commit (jack_nframes_t nframes)
{
- return 0;
+ bool need_butler = false;
+
+ if (_actual_speed < 0.0) {
+ playback_sample -= playback_distance;
+ } else {
+ 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;
+ }
+
+ state_lock.unlock();
+
+ _processed = false;
+
+ return need_butler;
}
void
int
MidiDiskstream::seek (jack_nframes_t frame, bool complete_refill)
{
- return 0;
+ Glib::Mutex::Lock lm (state_lock);
+ int ret = -1;
+
+ _playback_buf->reset();
+ _capture_buf->reset();
+
+ playback_sample = frame;
+ file_frame = frame;
+ _last_flush_frame = frame;
+
+ if (complete_refill) {
+ while ((ret = do_refill_with_alloc ()) > 0) ;
+ } else {
+ ret = do_refill_with_alloc ();
+ }
+
+ return ret;
}
int
MidiDiskstream::can_internal_playback_seek (jack_nframes_t distance)
{
- return 0;
+ if (_playback_buf->read_space() < distance) {
+ return false;
+ } else {
+ return true;
+ }
}
int
MidiDiskstream::internal_playback_seek (jack_nframes_t distance)
{
+ first_recordable_frame += distance;
+ playback_sample += distance;
+
return 0;
}
+/** @a start is set to the new frame position (TIME) read up to */
int
-MidiDiskstream::read (RawMidi* buf, RawMidi* mixdown_buffer, char * workbuf, jack_nframes_t& start, jack_nframes_t cnt, bool reversed)
-{
+MidiDiskstream::read (jack_nframes_t& start, jack_nframes_t dur, bool reversed)
+{
+ jack_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;
+ Location *loc = 0;
+
+ if (!reversed) {
+ /* Make the use of a Location atomic for this read operation.
+
+ Note: Locations don't get deleted, so all we care about
+ when I say "atomic" is that we are always pointing to
+ the same one and using a start/length values obtained
+ just once.
+ */
+
+ if ((loc = loop_location) != 0) {
+ loop_start = loc->start();
+ loop_end = loc->end();
+ loop_length = loop_end - loop_start;
+ }
+
+ /* if we are looping, ensure that the first frame we read is at the correct
+ position within the loop.
+ */
+
+ if (loc && start >= loop_end) {
+ //cerr << "start adjusted from " << start;
+ start = loop_start + ((start - loop_start) % loop_length);
+ //cerr << "to " << start << endl;
+ }
+ //cerr << "start is " << start << " loopstart: " << loop_start << " loopend: " << loop_end << endl;
+ }
+
+ while (dur) {
+
+ /* take any loop into account. we can't read past the end of the loop. */
+
+ if (loc && (loop_end - start < dur)) {
+ this_read = loop_end - start;
+ //cerr << "reloop true: thisread: " << this_read << " dur: " << dur << endl;
+ reloop = true;
+ } else {
+ reloop = false;
+ this_read = dur;
+ }
+
+ if (this_read == 0) {
+ break;
+ }
+
+ 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;
+ return -1;
+ }
+
+ _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
+
+ } else {
+
+ /* if we read to the end of the loop, go back to the beginning */
+
+ if (reloop) {
+ start = loop_start;
+ } else {
+ start += this_read;
+ }
+ }
+
+ dur -= this_read;
+ }
+
return 0;
}
int
-MidiDiskstream::do_refill (RawMidi* mixdown_buffer, float* gain_buffer, char * workbuf)
+MidiDiskstream::do_refill_with_alloc ()
{
- return 0;
-}
+ return do_refill();
+}
+
+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;
+
+ 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;
+ }
+
+ 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:
+ 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;
+ }
+
+ file_frame = file_frame_tmp;
+
+out:
+
+ return ret;
+}
+
+/** Flush pending data to disk.
+ *
+ * Important note: this function will write *AT MOST* disk_io_chunk_frames
+ * of data to disk. it will never write more than that. If it writes that
+ * much and there is more than that waiting to be written, it will return 1,
+ * otherwise 0 on success or -1 on failure.
+ *
+ * If there is less than disk_io_chunk_frames to be written, no data will be
+ * written at all unless @a force_flush is true.
+ */
int
-MidiDiskstream::do_flush (char * workbuf, bool force_flush)
+MidiDiskstream::do_flush (Session::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;
+
+ _write_data_count = 0;
+
+ if (_last_flush_frame > _session.transport_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";
+ goto out;
+ }
+
+ /* 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.
+
+ if we are forcing a flush, then if there is* any* extra
+ work, let the caller know.
+
+ if we are no longer recording and there is any extra work,
+ let the caller know too.
+ */
+
+ if (total >= 2 * disk_io_chunk_frames || ((force_flush || !was_recording) && total > disk_io_chunk_frames)) {
+ 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";
+ }
+
+ //(*chan).curr_capture_cnt += to_write;
+
+out:
+ //return ret;
return 0;
}
void
MidiDiskstream::transport_stopped (struct tm& when, time_t twhen, bool abort_capture)
{
+ uint32_t buffer_position;
+ bool more_work = true;
+ int err = 0;
+ boost::shared_ptr<MidiRegion> region;
+ jack_nframes_t total_capture;
+ MidiRegion::SourceList srcs;
+ MidiRegion::SourceList::iterator src;
+ vector<CaptureInfo*>::iterator ci;
+ bool mark_write_completed = false;
+
+ finish_capture (true);
+
+ /* butler is already stopped, but there may be work to do
+ to flush remaining data to disk.
+ */
+
+ while (more_work && !err) {
+ switch (do_flush (Session::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++;
+ }
+ }
+
+ /* XXX is there anything we can do if err != 0 ? */
+ Glib::Mutex::Lock lm (capture_info_lock);
+
+ if (capture_info.empty()) {
+ return;
+ }
+
+ if (abort_capture) {
+
+ if (_write_source) {
+
+ _write_source->mark_for_remove ();
+ _write_source->drop_references ();
+ _write_source.reset();
+ }
+
+ /* new source set up in "out" below */
+
+ } else {
+
+ assert(_write_source);
+
+ for (total_capture = 0, ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+ total_capture += (*ci)->frames;
+ }
+
+ /* figure out the name for this take */
+
+ boost::shared_ptr<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);
+
+ }
+
+ /* 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);
+
+ boost::shared_ptr<Region> rx (RegionFactory::create (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)));
+
+ region = boost::dynamic_pointer_cast<MidiRegion> (rx);
+ region->special_set_position (capture_info.front()->start);
+ }
+
+
+ catch (failed_constructor& err) {
+ error << string_compose(_("%1: could not create region for complete midi file"), _name) << endmsg;
+ /* XXX what now? */
+ }
+
+ _last_capture_regions.push_back (region);
+
+ // cerr << _name << ": there are " << capture_info.size() << " capture_info records\n";
+
+ 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) {
+
+ 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 {
+ 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 midi!") << endmsg;
+ continue; /* XXX is this OK? */
+ }
+
+ _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);
+ i_am_the_modifier--;
+
+ buffer_position += (*ci)->frames;
+ }
+
+ _playlist->thaw ();
+ XMLNode &after = _playlist->get_state();
+ _session.add_command (new MementoCommand<Playlist>(*_playlist, &before, &after));
+
+ mark_write_completed = true;
+
+ reset_write_sources (mark_write_completed);
+
+ }
+
+ for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
+ delete *ci;
+ }
+
+ capture_info.clear ();
+ capture_start_frame = 0;
}
void
MidiDiskstream::finish_capture (bool rec_monitors_input)
{
+ was_recording = false;
+
+ if (capture_captured == 0) {
+ return;
+ }
+
+ // Why must we destroy?
+ assert(!destructive());
+
+ CaptureInfo* ci = new CaptureInfo;
+
+ ci->start = capture_start_frame;
+ ci->frames = capture_captured;
+
+ /* XXX theoretical race condition here. Need atomic exchange ?
+ However, the circumstances when this is called right
+ now (either on record-disable or transport_stopped)
+ mean that no actual race exists. I think ...
+ We now have a capture_info_lock, but it is only to be used
+ to synchronize in the transport_stop and the capture info
+ accessors, so that invalidation will not occur (both non-realtime).
+ */
+
+ // cerr << "Finish capture, add new CI, " << ci->start << '+' << ci->frames << endl;
+
+ capture_info.push_back (ci);
+ capture_captured = 0;
+}
+
+void
+MidiDiskstream::set_record_enabled (bool yn)
+{
+ if (!recordable() || !_session.record_enabling_legal()) {
+ return;
+ }
+
+ assert(!destructive());
+
+ if (yn && _source_port == 0) {
+
+ /* pick up connections not initiated *from* the IO object
+ we're associated with.
+ */
+
+ get_input_sources ();
+ }
+
+ /* yes, i know that this not proof against race conditions, but its
+ good enough. i think.
+ */
+
+ if (record_enabled() != yn) {
+ if (yn) {
+ engage_record_enable ();
+ } else {
+ disengage_record_enable ();
+ }
+ }
}
void
-MidiDiskstream::set_record_enabled (bool yn, void* src)
+MidiDiskstream::engage_record_enable ()
{
+ bool rolling = _session.transport_speed() != 0.0f;
+
+ g_atomic_int_set (&_record_enabled, 1);
+
+ if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
+ _source_port->request_monitor_input (!(Config->get_auto_input() && rolling));
+ }
+
+ RecordEnableChanged (); /* EMIT SIGNAL */
+}
+
+void
+MidiDiskstream::disengage_record_enable ()
+{
+ g_atomic_int_set (&_record_enabled, 0);
+ if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
+ if (_source_port) {
+ _source_port->request_monitor_input (false);
+ }
+ }
+
+ RecordEnableChanged (); /* EMIT SIGNAL */
}
XMLNode&
node->add_property ("speed", buf);
node->add_property("name", _name);
- id().print(buf);
+ id().print(buf, sizeof(buf));
node->add_property("id", buf);
- if (!_capturing_sources.empty() && _session.get_record_enabled()) {
+ if (_write_source && _session.get_record_enabled()) {
XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
XMLNode* cs_grandchild;
- for (vector<SMFSource*>::iterator i = _capturing_sources.begin(); i != _capturing_sources.end(); ++i) {
- cs_grandchild = new XMLNode (X_("file"));
- cs_grandchild->add_property (X_("path"), (*i)->path());
- cs_child->add_child_nocopy (*cs_grandchild);
- }
+ cs_grandchild = new XMLNode (X_("file"));
+ cs_grandchild->add_property (X_("path"), _write_source->path());
+ cs_child->add_child_nocopy (*cs_grandchild);
/* store the location where capture will start */
Location* pi;
- if (_session.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
+ if (Config->get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
snprintf (buf, sizeof (buf), "%" PRIu32, pi->start());
} else {
snprintf (buf, sizeof (buf), "%" PRIu32, _session.transport_frame());
_playlist->set_orig_diskstream_id (_id);
}
- if (!destructive() && capture_pending_node) {
- /* destructive streams have one and only one source per channel,
- and so they never end up in pending capture in any useful
- sense.
- */
+ if (capture_pending_node) {
use_pending_capture_data (*capture_pending_node);
}
/* make sure this is clear before we do anything else */
- _capturing_sources.clear ();
+ // FIXME?
+ //_capturing_source = 0;
/* write sources are handled when we handle the input set
up of the IO that owns this DS (::non_realtime_input_change())
int
MidiDiskstream::use_new_write_source (uint32_t n)
{
+ if (!recordable()) {
+ return 1;
+ }
+
+ assert(n == 0);
+
+ if (_write_source) {
+
+ if (SMFSource::is_empty (_write_source->path())) {
+ _write_source->mark_for_remove ();
+ _write_source.reset();
+ } else {
+ _write_source.reset();
+ }
+ }
+
+ try {
+ _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.reset();
+ return -1;
+ }
+
+ _write_source->set_allow_remove_if_empty (true);
+
return 0;
}
void
MidiDiskstream::reset_write_sources (bool mark_write_complete, bool force)
{
+ if (!recordable()) {
+ return;
+ }
+
+ if (_write_source && mark_write_complete) {
+ _write_source->mark_streaming_write_completed ();
+ }
+
+ if (!_write_source) {
+ use_new_write_source ();
+ }
}
int
MidiDiskstream::rename_write_sources ()
{
+ if (_write_source != 0) {
+ _write_source->set_name (_name, destructive());
+ /* XXX what to do if this fails ? */
+ }
return 0;
}
void
MidiDiskstream::monitor_input (bool yn)
{
+ if (_source_port)
+ _source_port->request_monitor_input (yn);
+ else
+ cerr << "MidiDiskstream NO SOURCE PORT TO MONITOR\n";
}
void
MidiDiskstream::set_align_style_from_io ()
{
+ bool have_physical = false;
+
+ if (_io == 0) {
+ return;
+ }
+
+ get_input_sources ();
+
+ if (_source_port && _source_port->flags() & JackPortIsPhysical) {
+ have_physical = true;
+ }
+
+ if (have_physical) {
+ set_align_style (ExistingMaterial);
+ } else {
+ set_align_style (CaptureTime);
+ }
}
float
MidiDiskstream::playback_buffer_load () const
{
- return 0;
+ return (float) ((double) _playback_buf->read_space()/
+ (double) _playback_buf->capacity());
}
float
MidiDiskstream::capture_buffer_load () const
{
- return 0;
+ return (float) ((double) _capture_buf->write_space()/
+ (double) _capture_buf->capacity());
}
{
return 0;
}
+
+/** Writes playback events in the given range to dst, translating time stamps
+ * so that an event at start has time = 0
+ */
+void
+MidiDiskstream::get_playback(MidiBuffer& dst, jack_nframes_t start, jack_nframes_t end)
+{
+ dst.clear();
+ assert(dst.size() == 0);
+
+ // I think this happens with reverse varispeed? maybe?
+ if (end <= start) {
+ return;
+ }
+
+/*
+ cerr << "MIDI Diskstream pretending to read" << endl;
+
+ MidiEvent ev;
+ RawMidi data[4];
+
+ const char note = rand()%30 + 30;
+
+ ev.buffer = data;
+ ev.time = 0;
+ ev.size = 3;
+
+ data[0] = 0x90;
+ data[1] = note;
+ data[2] = 120;
+
+ dst.push_back(ev);
+
+ 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;
+
+ }
+}
projects / ardour.git / blobdiff