2008-06-02 17:41:35 -04:00
|
|
|
/*
|
2009-10-14 12:10:01 -04:00
|
|
|
Copyright (C) 2000-2003 Paul Davis
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <fstream>
|
|
|
|
#include <cstdio>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <cmath>
|
|
|
|
#include <cerrno>
|
|
|
|
#include <string>
|
|
|
|
#include <climits>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <cstdlib>
|
|
|
|
#include <ctime>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <sys/mman.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/basename.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <glibmm/thread.h>
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/xml++.h"
|
|
|
|
#include "pbd/memento_command.h"
|
|
|
|
#include "pbd/enumwriter.h"
|
2010-03-02 13:05:26 -05:00
|
|
|
#include "pbd/stateful_diff_command.h"
|
2011-04-09 10:59:22 -04:00
|
|
|
#include "pbd/stacktrace.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/audioengine.h"
|
2009-10-23 20:39:28 -04:00
|
|
|
#include "ardour/butler.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/configuration.h"
|
|
|
|
#include "ardour/cycle_timer.h"
|
2009-10-25 10:42:46 -04:00
|
|
|
#include "ardour/debug.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#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"
|
2009-12-04 14:09:08 -05:00
|
|
|
#include "ardour/session_playlists.h"
|
2010-04-21 16:42:22 -04:00
|
|
|
#include "ardour/route.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
#include "midi++/types.h"
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
#include "i18n.h"
|
|
|
|
#include <locale.h>
|
|
|
|
|
|
|
|
using namespace std;
|
|
|
|
using namespace ARDOUR;
|
|
|
|
using namespace PBD;
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t MidiDiskstream::midi_readahead = 4096;
|
2008-10-12 13:40:37 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
MidiDiskstream::MidiDiskstream (Session &sess, const string &name, Diskstream::Flag flag)
|
|
|
|
: Diskstream(sess, name, flag)
|
|
|
|
, _playback_buf(0)
|
|
|
|
, _capture_buf(0)
|
|
|
|
, _source_port(0)
|
|
|
|
, _last_flush_frame(0)
|
|
|
|
, _note_mode(Sustained)
|
2008-10-12 13:40:37 -04:00
|
|
|
, _frames_written_to_ringbuffer(0)
|
|
|
|
, _frames_read_from_ringbuffer(0)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
/* prevent any write sources from being created */
|
|
|
|
|
|
|
|
in_set_state = true;
|
|
|
|
|
2010-03-31 21:24:13 -04:00
|
|
|
init ();
|
2008-06-02 17:41:35 -04:00
|
|
|
use_new_playlist ();
|
2010-12-20 16:50:46 -05:00
|
|
|
use_new_write_source (0);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
in_set_state = false;
|
|
|
|
|
|
|
|
assert(!destructive());
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
MidiDiskstream::MidiDiskstream (Session& sess, const XMLNode& node)
|
|
|
|
: Diskstream(sess, node)
|
|
|
|
, _playback_buf(0)
|
|
|
|
, _capture_buf(0)
|
|
|
|
, _source_port(0)
|
|
|
|
, _last_flush_frame(0)
|
|
|
|
, _note_mode(Sustained)
|
2008-10-12 13:40:37 -04:00
|
|
|
, _frames_written_to_ringbuffer(0)
|
|
|
|
, _frames_read_from_ringbuffer(0)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
in_set_state = true;
|
2010-06-26 09:45:59 -04:00
|
|
|
|
2010-03-31 21:24:13 -04:00
|
|
|
init ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-15 14:56:11 -04:00
|
|
|
if (set_state (node, Stateful::loading_state_version)) {
|
2008-06-02 17:41:35 -04:00
|
|
|
in_set_state = false;
|
|
|
|
throw failed_constructor();
|
|
|
|
}
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
use_new_write_source (0);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-06-26 09:45:59 -04:00
|
|
|
in_set_state = false;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-03-31 21:24:13 -04:00
|
|
|
MidiDiskstream::init ()
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
/* there are no channels at this point, so these
|
|
|
|
two calls just get speed_buffer_size and wrap_buffer
|
|
|
|
size setup without duplicating their code.
|
|
|
|
*/
|
|
|
|
|
|
|
|
set_block_size (_session.get_block_size());
|
|
|
|
allocate_temporary_buffers ();
|
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
const size_t size = _session.butler()->midi_diskstream_buffer_size();
|
2010-12-03 17:26:29 -05:00
|
|
|
_playback_buf = new MidiRingBuffer<framepos_t>(size);
|
|
|
|
_capture_buf = new MidiRingBuffer<framepos_t>(size);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
_n_channels = ChanCount(DataType::MIDI, 1);
|
|
|
|
|
|
|
|
assert(recordable());
|
|
|
|
}
|
|
|
|
|
|
|
|
MidiDiskstream::~MidiDiskstream ()
|
|
|
|
{
|
|
|
|
Glib::Mutex::Lock lm (state_lock);
|
|
|
|
}
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::non_realtime_locate (framepos_t position)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
if (_write_source) {
|
|
|
|
_write_source->set_timeline_position (position);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
seek(position, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::non_realtime_input_change ()
|
|
|
|
{
|
2009-10-14 12:10:01 -04:00
|
|
|
{
|
2008-06-02 17:41:35 -04:00
|
|
|
Glib::Mutex::Lock lm (state_lock);
|
|
|
|
|
2010-08-30 18:34:21 -04:00
|
|
|
if (input_change_pending.type == IOChange::NoChange) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-30 18:34:21 -04:00
|
|
|
if (input_change_pending.type & IOChange::ConfigurationChanged) {
|
2011-04-09 10:59:22 -04:00
|
|
|
uint32_t ni = _io->n_ports().n_midi();
|
|
|
|
|
|
|
|
if (ni != _n_channels.n_midi()) {
|
2011-04-04 19:00:48 -04:00
|
|
|
error << string_compose (_("%1: I/O configuration change %4 requested to use %2, but channel setup is %3"),
|
|
|
|
name(),
|
|
|
|
_io->n_ports(),
|
|
|
|
_n_channels, input_change_pending.type)
|
|
|
|
<< endmsg;
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
}
|
2011-04-09 10:59:22 -04:00
|
|
|
|
|
|
|
if (ni == 0) {
|
|
|
|
_source_port = 0;
|
|
|
|
} else {
|
|
|
|
_source_port = _io->midi(0);
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-04-04 19:00:48 -04:00
|
|
|
if (input_change_pending.type & IOChange::ConnectionsChanged) {
|
|
|
|
set_capture_offset ();
|
|
|
|
set_align_style_from_io ();
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-08-30 18:34:21 -04:00
|
|
|
input_change_pending.type = IOChange::NoChange;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* implicit unlock */
|
|
|
|
}
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
/* 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.
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* now refill channel buffers */
|
|
|
|
|
|
|
|
if (speed() != 1.0f || speed() != -1.0f) {
|
2010-09-17 12:24:22 -04:00
|
|
|
seek ((framepos_t) (_session.transport_frame() * (double) speed()));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
seek (_session.transport_frame());
|
|
|
|
}
|
|
|
|
|
|
|
|
_last_flush_frame = _session.transport_frame();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::find_and_use_playlist (const string& name)
|
|
|
|
{
|
|
|
|
boost::shared_ptr<MidiPlaylist> playlist;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-04 14:09:08 -05:00
|
|
|
if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (_session.playlists->by_name (name))) == 0) {
|
2008-06-02 17:41:35 -04:00
|
|
|
playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (DataType::MIDI, _session, name));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!playlist) {
|
|
|
|
error << string_compose(_("MidiDiskstream: Playlist \"%1\" isn't an midi playlist"), name) << endmsg;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return use_playlist (playlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::use_playlist (boost::shared_ptr<Playlist> playlist)
|
2009-10-14 12:10:01 -04:00
|
|
|
{
|
2008-06-02 17:41:35 -04:00
|
|
|
assert(boost::dynamic_pointer_cast<MidiPlaylist>(playlist));
|
|
|
|
|
|
|
|
Diskstream::use_playlist(playlist);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::use_new_playlist ()
|
2009-10-14 12:10:01 -04:00
|
|
|
{
|
2008-06-02 17:41:35 -04:00
|
|
|
string newname;
|
|
|
|
boost::shared_ptr<MidiPlaylist> playlist;
|
|
|
|
|
|
|
|
if (!in_set_state && destructive()) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_playlist) {
|
|
|
|
newname = Playlist::bump_name (_playlist->name(), _session);
|
|
|
|
} else {
|
|
|
|
newname = Playlist::bump_name (_name, _session);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist> (PlaylistFactory::create (
|
|
|
|
DataType::MIDI, _session, newname, hidden()))) != 0) {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
playlist->set_orig_diskstream_id (id());
|
|
|
|
return use_playlist (playlist);
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
} else {
|
2008-06-02 17:41:35 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::use_copy_playlist ()
|
|
|
|
{
|
|
|
|
assert(midi_playlist());
|
|
|
|
|
|
|
|
if (destructive()) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_playlist == 0) {
|
|
|
|
error << string_compose(_("MidiDiskstream %1: there is no existing playlist to make a copy of!"), _name) << endmsg;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
string newname;
|
|
|
|
boost::shared_ptr<MidiPlaylist> playlist;
|
|
|
|
|
|
|
|
newname = Playlist::bump_name (_playlist->name(), _session);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if ((playlist = boost::dynamic_pointer_cast<MidiPlaylist>(PlaylistFactory::create (midi_playlist(), newname))) != 0) {
|
|
|
|
playlist->set_orig_diskstream_id (id());
|
|
|
|
return use_playlist (playlist);
|
2009-10-14 12:10:01 -04:00
|
|
|
} else {
|
2008-06-02 17:41:35 -04:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Overloaded from parent to die horribly
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
MidiDiskstream::set_destructive (bool yn)
|
|
|
|
{
|
|
|
|
assert( ! destructive());
|
|
|
|
assert( ! yn);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
#if 0
|
2009-05-13 17:34:09 -04:00
|
|
|
static void
|
|
|
|
trace_midi (ostream& o, MIDI::byte *msg, size_t len)
|
|
|
|
{
|
|
|
|
using namespace MIDI;
|
|
|
|
eventType type;
|
|
|
|
const char trace_prefix = ':';
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
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;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case on:
|
|
|
|
o << trace_prefix
|
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
|
|
|
<< " NoteOn NoteNum "
|
|
|
|
<< (int) msg[1]
|
|
|
|
<< " Vel "
|
|
|
|
<< (int) msg[2]
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case polypress:
|
|
|
|
o << trace_prefix
|
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
|
|
|
<< " PolyPressure"
|
|
|
|
<< (int) msg[1]
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::controller:
|
|
|
|
o << trace_prefix
|
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
|
|
|
<< " Controller "
|
|
|
|
<< (int) msg[1]
|
|
|
|
<< " Value "
|
|
|
|
<< (int) msg[2]
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case program:
|
2009-10-14 12:10:01 -04:00
|
|
|
o << trace_prefix
|
2009-05-13 17:34:09 -04:00
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
2010-05-15 19:57:41 -04:00
|
|
|
<< " Program Change ProgNum "
|
2009-05-13 17:34:09 -04:00
|
|
|
<< (int) msg[1]
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case chanpress:
|
2009-10-14 12:10:01 -04:00
|
|
|
o << trace_prefix
|
2009-05-13 17:34:09 -04:00
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
|
|
|
<< " Channel Pressure "
|
|
|
|
<< (int) msg[1]
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::pitchbend:
|
|
|
|
o << trace_prefix
|
|
|
|
<< "Channel "
|
|
|
|
<< (msg[0]&0xF)+1
|
|
|
|
<< " Pitch Bend "
|
|
|
|
<< ((msg[2]<<7)|msg[1])
|
|
|
|
<< endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
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 << ')'
|
2009-10-14 12:10:01 -04:00
|
|
|
<< endl;
|
2009-05-13 17:34:09 -04:00
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2009-05-13 17:34:09 -04:00
|
|
|
} else {
|
|
|
|
o << trace_prefix
|
|
|
|
<< "System Exclusive (" << len << ") = [ " << hex;
|
|
|
|
for (unsigned int i = 0; i < len; ++i) {
|
|
|
|
o << (int) msg[i] << ' ';
|
|
|
|
}
|
|
|
|
o << dec << ']' << endl;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
}
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::song:
|
|
|
|
o << trace_prefix << "Song" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::tune:
|
|
|
|
o << trace_prefix << "Tune" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::eox:
|
|
|
|
o << trace_prefix << "End-of-System Exclusive" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::timing:
|
|
|
|
o << trace_prefix << "Timing" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::start:
|
|
|
|
o << trace_prefix << "Start" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::stop:
|
|
|
|
o << trace_prefix << "Stop" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case MIDI::contineu:
|
|
|
|
o << trace_prefix << "Continue" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
case active:
|
|
|
|
o << trace_prefix << "Active Sense" << endl;
|
|
|
|
break;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-13 17:34:09 -04:00
|
|
|
default:
|
|
|
|
o << trace_prefix << "Unrecognized MIDI message" << endl;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-06-09 16:21:19 -04:00
|
|
|
#endif
|
2009-05-13 17:34:09 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int
|
2010-12-03 17:26:29 -05:00
|
|
|
MidiDiskstream::process (framepos_t transport_frame, pframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
int ret = -1;
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t rec_offset = 0;
|
|
|
|
framecnt_t rec_nframes = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool nominally_recording;
|
|
|
|
bool re = record_enabled ();
|
|
|
|
|
2011-02-25 12:40:19 -05:00
|
|
|
playback_distance = 0;
|
|
|
|
|
2010-10-01 20:06:11 -04:00
|
|
|
check_record_status (transport_frame, can_record);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
nominally_recording = (can_record && re);
|
|
|
|
|
|
|
|
if (nframes == 0) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-04-09 10:59:22 -04:00
|
|
|
if (_source_port == 0) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
Glib::Mutex::Lock sm (state_lock, Glib::TRY_LOCK);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
if (!sm.locked()) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return 1;
|
|
|
|
}
|
2010-03-27 10:41:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
adjust_capture_position = 0;
|
|
|
|
|
2010-08-17 09:10:42 -04:00
|
|
|
if (nominally_recording || (re && was_recording && _session.get_record_enabled() && _session.config.get_punch_in())) {
|
2009-10-19 22:14:53 -04:00
|
|
|
OverlapType ot = coverage (first_recordable_frame, last_recordable_frame, transport_frame, transport_frame + nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-19 22:14:53 -04:00
|
|
|
calculate_record_range(ot, transport_frame, nframes, rec_nframes, rec_offset);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
if (rec_nframes && !was_recording) {
|
2011-02-28 21:03:52 -05:00
|
|
|
_write_source->mark_write_starting_now ();
|
2008-06-02 17:41:35 -04:00
|
|
|
capture_captured = 0;
|
|
|
|
was_recording = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-06-23 16:14:07 -04:00
|
|
|
if (can_record && !_last_capture_sources.empty()) {
|
|
|
|
_last_capture_sources.clear ();
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (nominally_recording || rec_nframes) {
|
2011-04-09 10:59:22 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
// Pump entire port buffer into the ring buffer (FIXME: split cycles?)
|
2009-04-23 13:48:37 -04:00
|
|
|
MidiBuffer& buf = _source_port->get_midi_buffer(nframes);
|
2009-02-01 16:04:12 -05:00
|
|
|
for (MidiBuffer::iterator i = buf.begin(); i != buf.end(); ++i) {
|
2009-02-01 21:36:05 -05:00
|
|
|
const Evoral::MIDIEvent<MidiBuffer::TimeType> ev(*i, false);
|
2008-06-02 17:41:35 -04:00
|
|
|
assert(ev.buffer());
|
2008-09-22 12:28:02 -04:00
|
|
|
_capture_buf->write(ev.time() + transport_frame, ev.type(), ev.size(), ev.buffer());
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-10-08 10:54:16 -04:00
|
|
|
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());
|
|
|
|
}
|
2010-12-20 16:50:46 -05:00
|
|
|
|
2010-10-08 10:54:16 -04:00
|
|
|
DataRecorded (copy, _write_source); /* EMIT SIGNAL */
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
|
|
|
|
|
|
|
if (was_recording) {
|
|
|
|
finish_capture (rec_monitors_input);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rec_nframes) {
|
2011-02-25 12:40:19 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* data will be written to disk */
|
2011-02-25 12:40:19 -05:00
|
|
|
|
|
|
|
if (rec_nframes == nframes && rec_offset == 0) {
|
|
|
|
playback_distance = nframes;
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
adjust_capture_position = rec_nframes;
|
2011-02-25 12:40:19 -05:00
|
|
|
|
|
|
|
} else if (nominally_recording) {
|
|
|
|
|
|
|
|
/* XXXX do this for MIDI !!!
|
|
|
|
can't do actual capture yet - waiting for latency effects to finish before we start
|
|
|
|
*/
|
|
|
|
|
|
|
|
playback_distance = nframes;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* XXX: should be doing varispeed stuff here, similar to the code in AudioDiskstream::process */
|
|
|
|
|
|
|
|
playback_distance = nframes;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2011-02-25 12:40:19 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
ret = 0;
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
if (commit (nframes)) {
|
|
|
|
need_butler = true;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
2010-12-03 17:26:29 -05:00
|
|
|
MidiDiskstream::commit (framecnt_t nframes)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
bool need_butler = false;
|
|
|
|
|
|
|
|
if (_actual_speed < 0.0) {
|
2011-02-25 12:40:19 -05:00
|
|
|
playback_sample -= playback_distance;
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
2011-02-25 12:40:19 -05:00
|
|
|
playback_sample += playback_distance;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (adjust_capture_position != 0) {
|
|
|
|
capture_captured += adjust_capture_position;
|
|
|
|
adjust_capture_position = 0;
|
|
|
|
}
|
|
|
|
|
2008-10-12 13:40:37 -04:00
|
|
|
uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
|
|
|
|
uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
|
2009-05-01 13:32:48 -04:00
|
|
|
if ((frames_written - frames_read) + nframes < midi_readahead) {
|
2008-10-12 13:40:37 -04:00
|
|
|
need_butler = true;
|
2009-05-01 13:32:48 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*cerr << "MDS written: " << frames_written << " - read: " << frames_read <<
|
|
|
|
" = " << frames_written - frames_read
|
|
|
|
<< " + " << nframes << " < " << midi_readahead << " = " << need_butler << ")" << endl;*/
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
return need_butler;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::set_pending_overwrite (bool yn)
|
|
|
|
{
|
|
|
|
/* called from audio thread, so we can use the read ptr and playback sample as we wish */
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
_pending_overwrite = yn;
|
2008-06-02 17:41:35 -04:00
|
|
|
overwrite_frame = playback_sample;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::overwrite_existing_buffers ()
|
|
|
|
{
|
2010-12-12 16:36:40 -05:00
|
|
|
/* 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);
|
2010-12-20 16:50:46 -05:00
|
|
|
|
2010-09-17 12:24:22 -04:00
|
|
|
read (overwrite_frame, disk_io_chunk_frames, false);
|
2011-04-04 19:00:48 -04:00
|
|
|
file_frame = overwrite_frame; // it was adjusted by ::read()
|
2008-06-02 17:41:35 -04:00
|
|
|
overwrite_queued = false;
|
2010-04-21 16:42:22 -04:00
|
|
|
_pending_overwrite = false;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::seek (framepos_t frame, bool complete_refill)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
Glib::Mutex::Lock lm (state_lock);
|
|
|
|
int ret = -1;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
_playback_buf->reset();
|
|
|
|
_capture_buf->reset();
|
2008-10-12 13:40:37 -04:00
|
|
|
g_atomic_int_set(&_frames_read_from_ringbuffer, 0);
|
|
|
|
g_atomic_int_set(&_frames_written_to_ringbuffer, 0);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
playback_sample = frame;
|
|
|
|
file_frame = frame;
|
|
|
|
|
|
|
|
if (complete_refill) {
|
|
|
|
while ((ret = do_refill_with_alloc ()) > 0) ;
|
|
|
|
} else {
|
|
|
|
ret = do_refill_with_alloc ();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::can_internal_playback_seek (framecnt_t distance)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2009-05-01 13:32:48 -04:00
|
|
|
uint32_t frames_read = g_atomic_int_get(&_frames_read_from_ringbuffer);
|
2008-10-12 13:40:37 -04:00
|
|
|
uint32_t frames_written = g_atomic_int_get(&_frames_written_to_ringbuffer);
|
2009-05-01 13:32:48 -04:00
|
|
|
return ((frames_written - frames_read) < distance);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::internal_playback_seek (framecnt_t distance)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
first_recordable_frame += distance;
|
|
|
|
playback_sample += distance;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** @a start is set to the new frame position (TIME) read up to */
|
|
|
|
int
|
2010-12-03 17:26:29 -05:00
|
|
|
MidiDiskstream::read (framepos_t& start, framecnt_t dur, bool reversed)
|
2009-10-14 12:10:01 -04:00
|
|
|
{
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t this_read = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool reloop = false;
|
2010-09-17 12:24:22 -04:00
|
|
|
framepos_t loop_end = 0;
|
|
|
|
framepos_t loop_start = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
Location *loc = 0;
|
|
|
|
|
|
|
|
if (!reversed) {
|
2010-02-23 15:25:53 -05:00
|
|
|
|
2010-09-17 12:24:22 -04:00
|
|
|
framecnt_t loop_length = 0;
|
2010-02-23 15:25:53 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Make the use of a Location atomic for this read operation.
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
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.
|
|
|
|
*/
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if ((loc = loop_location) != 0) {
|
|
|
|
loop_start = loc->start();
|
|
|
|
loop_end = loc->end();
|
|
|
|
loop_length = loop_end - loop_start;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* if we are looping, ensure that the first frame we read is at the correct
|
|
|
|
position within the loop.
|
|
|
|
*/
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-10-09 20:39:29 -04:00
|
|
|
if (loc && (start >= loop_end)) {
|
2008-06-02 17:41:35 -04:00
|
|
|
//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) {
|
2009-05-01 13:32:48 -04:00
|
|
|
error << string_compose(
|
|
|
|
_("MidiDiskstream %1: cannot read %2 from playlist at frame %3"),
|
|
|
|
_id, this_read, start) << endmsg;
|
2008-06-02 17:41:35 -04:00
|
|
|
return -1;
|
|
|
|
}
|
2009-09-15 21:08:51 -04:00
|
|
|
|
2008-10-12 13:40:37 -04:00
|
|
|
g_atomic_int_add(&_frames_written_to_ringbuffer, this_read);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
_read_data_count = _playlist->read_data_count();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (reversed) {
|
|
|
|
|
|
|
|
// Swap note ons with note offs here. etc?
|
2009-05-01 13:32:48 -04:00
|
|
|
// Fully reversing MIDI requires look-ahead (well, behind) to find previous
|
2008-06-02 17:41:35 -04:00
|
|
|
// CC values etc. hard.
|
|
|
|
|
|
|
|
} else {
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* if we read to the end of the loop, go back to the beginning */
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (reloop) {
|
2008-10-09 20:39:29 -04:00
|
|
|
// Synthesize LoopEvent here, because the next events
|
|
|
|
// written will have non-monotonic timestamps.
|
2010-09-17 12:24:22 -04:00
|
|
|
_playback_buf->write(loop_end - 1, LoopEventType, sizeof (framepos_t), (uint8_t *) &loop_start);
|
2008-06-02 17:41:35 -04:00
|
|
|
start = loop_start;
|
|
|
|
} else {
|
|
|
|
start += this_read;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
dur -= this_read;
|
|
|
|
//offset += this_read;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::do_refill_with_alloc ()
|
|
|
|
{
|
|
|
|
return do_refill();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::do_refill ()
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (reversed) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* at end: nothing to do */
|
2010-09-17 12:24:22 -04:00
|
|
|
if (file_frame == max_framepos) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// At this point we...
|
|
|
|
assert(_playback_buf->write_space() > 0); // ... have something to write to, and
|
2010-09-17 12:24:22 -04:00
|
|
|
assert(file_frame <= max_framepos); // ... something to write
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-10-12 13:40:37 -04:00
|
|
|
// 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);
|
2009-05-01 13:32:48 -04:00
|
|
|
if ((frames_written - frames_read) >= midi_readahead) {
|
2008-10-12 13:40:37 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t to_read = midi_readahead - (frames_written - frames_read);
|
2008-10-12 13:40:37 -04:00
|
|
|
|
2009-05-01 13:32:48 -04:00
|
|
|
//cout << "MDS read for midi_readahead " << to_read << " rb_contains: "
|
|
|
|
// << frames_written - frames_read << endl;
|
2008-10-12 13:40:37 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
to_read = (framecnt_t) min ((framecnt_t) to_read, (framecnt_t) (max_framepos - file_frame));
|
2011-04-04 17:44:56 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (read (file_frame, to_read, reversed)) {
|
|
|
|
ret = -1;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
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.
|
2009-10-14 12:10:01 -04:00
|
|
|
*
|
2008-06-02 17:41:35 -04:00
|
|
|
* 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
|
2009-07-21 11:55:17 -04:00
|
|
|
MidiDiskstream::do_flush (RunContext /*context*/, bool force_flush)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
uint32_t to_write;
|
|
|
|
int32_t ret = 0;
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t total;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
_write_data_count = 0;
|
|
|
|
|
2009-02-19 20:20:03 -05:00
|
|
|
total = _session.transport_frame() - _last_flush_frame;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-10-08 10:54:16 -04:00
|
|
|
if (_last_flush_frame > _session.transport_frame() || _last_flush_frame < capture_start_frame) {
|
2008-06-02 17:41:35 -04:00
|
|
|
_last_flush_frame = _session.transport_frame();
|
|
|
|
}
|
|
|
|
|
2009-02-19 20:20:03 -05:00
|
|
|
if (total == 0 || _capture_buf->read_space() == 0
|
|
|
|
|| (!force_flush && (total < disk_io_chunk_frames && was_recording))) {
|
2008-06-02 17:41:35 -04:00
|
|
|
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;
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
to_write = disk_io_chunk_frames;
|
|
|
|
|
|
|
|
assert(!destructive());
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
if (record_enabled() &&
|
2011-03-14 21:16:24 -04:00
|
|
|
((_session.transport_frame() - _last_flush_frame > disk_io_chunk_frames) ||
|
|
|
|
force_flush)) {
|
2010-10-08 10:54:16 -04:00
|
|
|
if ((!_write_source) || _write_source->midi_write (*_capture_buf, get_capture_start_frame (0), to_write) != to_write) {
|
2008-06-02 17:41:35 -04:00
|
|
|
error << string_compose(_("MidiDiskstream %1: cannot write to disk"), _id) << endmsg;
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
_last_flush_frame = _session.transport_frame();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-04-21 16:42:22 -04:00
|
|
|
MidiDiskstream::transport_stopped_wallclock (struct tm& /*when*/, time_t /*twhen*/, bool abort_capture)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
bool more_work = true;
|
|
|
|
int err = 0;
|
|
|
|
boost::shared_ptr<MidiRegion> region;
|
|
|
|
MidiRegion::SourceList srcs;
|
|
|
|
MidiRegion::SourceList::iterator src;
|
|
|
|
vector<CaptureInfo*>::iterator ci;
|
|
|
|
bool mark_write_completed = false;
|
|
|
|
|
|
|
|
finish_capture (true);
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
/* butler is already stopped, but there may be work to do
|
2008-06-02 17:41:35 -04:00
|
|
|
to flush remaining data to disk.
|
|
|
|
*/
|
|
|
|
|
|
|
|
while (more_work && !err) {
|
2009-01-30 15:18:31 -05:00
|
|
|
switch (do_flush (TransportContext, true)) {
|
2010-12-20 16:50:46 -05:00
|
|
|
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++;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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 ();
|
2011-02-28 21:04:50 -05:00
|
|
|
_write_source->drop_references ();
|
2008-06-02 17:41:35 -04:00
|
|
|
_write_source.reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* new source set up in "out" below */
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
assert(_write_source);
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t total_capture = 0;
|
2010-02-23 15:25:53 -05:00
|
|
|
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
|
2008-06-02 17:41:35 -04:00
|
|
|
total_capture += (*ci)->frames;
|
|
|
|
}
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
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);
|
|
|
|
|
|
|
|
_write_source->set_timeline_position (capture_info.front()->start);
|
|
|
|
_write_source->set_captured_for (_name);
|
|
|
|
|
|
|
|
/* flush to disk: this step differs from the audio path,
|
|
|
|
where all the data is already on disk.
|
|
|
|
*/
|
|
|
|
|
|
|
|
_write_source->mark_streaming_write_completed ();
|
|
|
|
|
2010-12-20 19:04:58 -05:00
|
|
|
/* set length in beats to entire capture length */
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
|
|
|
|
|
|
|
|
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_sources.insert (_last_capture_sources.end(), srcs.begin(), srcs.end());
|
|
|
|
|
|
|
|
_playlist->clear_changes ();
|
|
|
|
_playlist->freeze ();
|
2010-06-23 21:37:24 -04:00
|
|
|
|
2010-10-08 10:54:16 -04:00
|
|
|
/* 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;
|
|
|
|
}
|
2010-06-23 21:37:24 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
|
|
|
|
|
|
|
|
string region_name;
|
2010-06-23 21:37:24 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
RegionFactory::region_name (region_name, _write_source->name(), false);
|
2010-06-23 21:37:24 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
// cerr << _name << ": based on ci of " << (*ci)->start << " for " << (*ci)->frames << " add a region\n";
|
2010-06-23 21:37:24 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
try {
|
|
|
|
PropertyList plist;
|
2010-10-08 10:54:16 -04:00
|
|
|
|
|
|
|
/* start of this region is the offset between the start of its capture and the start of the whole pass */
|
2010-12-20 16:50:46 -05:00
|
|
|
plist.add (Properties::start, (*ci)->start - initial_capture);
|
|
|
|
plist.add (Properties::length, (*ci)->frames);
|
2010-12-20 19:53:18 -05:00
|
|
|
plist.add (Properties::length_beats, converter.from((*ci)->frames));
|
2010-12-20 16:50:46 -05:00
|
|
|
plist.add (Properties::name, region_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
boost::shared_ptr<Region> rx (RegionFactory::create (srcs, plist));
|
|
|
|
region = boost::dynamic_pointer_cast<MidiRegion> (rx);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
catch (failed_constructor& err) {
|
|
|
|
error << _("MidiDiskstream: could not create region for captured midi!") << endmsg;
|
|
|
|
continue; /* XXX is this OK? */
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
// cerr << "add new region, buffer position = " << buffer_position << " @ " << (*ci)->start << endl;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
i_am_the_modifier++;
|
|
|
|
_playlist->add_region (region, (*ci)->start);
|
|
|
|
i_am_the_modifier--;
|
|
|
|
}
|
|
|
|
|
|
|
|
_playlist->thaw ();
|
|
|
|
_session.add_command (new StatefulDiffCommand(_playlist));
|
2011-02-28 21:04:57 -05:00
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* No data was recorded, so this capture will
|
|
|
|
effectively be aborted; do the same as we
|
|
|
|
do for an explicit abort.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (_write_source) {
|
|
|
|
_write_source->mark_for_remove ();
|
|
|
|
_write_source->drop_references ();
|
|
|
|
_write_source.reset();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
mark_write_completed = true;
|
2010-06-26 09:45:59 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
use_new_write_source (0);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
for (ci = capture_info.begin(); ci != capture_info.end(); ++ci) {
|
|
|
|
delete *ci;
|
|
|
|
}
|
|
|
|
|
2009-10-25 10:42:46 -04:00
|
|
|
if (_playlist) {
|
|
|
|
midi_playlist()->clear_note_trackers ();
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
capture_info.clear ();
|
|
|
|
capture_start_frame = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::transport_looped (framepos_t transport_frame)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
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) {
|
2011-03-10 21:55:52 -05:00
|
|
|
capture_captured += _session.worst_output_latency();
|
2008-06-02 17:41:35 -04:00
|
|
|
} 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
|
2010-09-17 12:24:22 -04:00
|
|
|
last_recordable_frame = max_framepos;
|
2008-06-02 17:41:35 -04:00
|
|
|
was_recording = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
MidiDiskstream::finish_capture (bool /*rec_monitors_input*/)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
was_recording = false;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (capture_captured == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Why must we destroy?
|
|
|
|
assert(!destructive());
|
|
|
|
|
|
|
|
CaptureInfo* ci = new CaptureInfo;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
ci->start = capture_start_frame;
|
|
|
|
ci->frames = capture_captured;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
|
|
|
/* XXX theoretical race condition here. Need atomic exchange ?
|
|
|
|
However, the circumstances when this is called right
|
2008-06-02 17:41:35 -04:00
|
|
|
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());
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* 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::engage_record_enable ()
|
|
|
|
{
|
2010-10-04 20:27:26 -04:00
|
|
|
bool const rolling = _session.transport_speed() != 0.0f;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
g_atomic_int_set (&_record_enabled, 1);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (_source_port && Config->get_monitoring_model() == HardwareMonitoring) {
|
2009-05-13 20:13:27 -04:00
|
|
|
_source_port->request_monitor_input (!(_session.config.get_auto_input() && rolling));
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
RecordEnableChanged (); /* EMIT SIGNAL */
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::disengage_record_enable ()
|
|
|
|
{
|
|
|
|
g_atomic_int_set (&_record_enabled, 0);
|
|
|
|
RecordEnableChanged (); /* EMIT SIGNAL */
|
|
|
|
}
|
|
|
|
|
|
|
|
XMLNode&
|
|
|
|
MidiDiskstream::get_state ()
|
|
|
|
{
|
2011-03-08 15:12:40 -05:00
|
|
|
XMLNode& node (Diskstream::get_state());
|
2008-06-02 17:41:35 -04:00
|
|
|
char buf[64];
|
|
|
|
LocaleGuard lg (X_("POSIX"));
|
|
|
|
|
2011-03-08 15:12:40 -05:00
|
|
|
node.add_property("channel-mode", enum_2_string(get_channel_mode()));
|
2008-06-02 17:41:35 -04:00
|
|
|
snprintf (buf, sizeof(buf), "0x%x", get_channel_mask());
|
2011-03-08 15:12:40 -05:00
|
|
|
node.add_property("channel-mask", buf);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
if (_write_source && _session.get_record_enabled()) {
|
|
|
|
|
|
|
|
XMLNode* cs_child = new XMLNode (X_("CapturingSources"));
|
|
|
|
XMLNode* 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;
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
if (_session.config.get_punch_in() && ((pi = _session.locations()->auto_punch_location()) != 0)) {
|
2009-07-17 18:12:21 -04:00
|
|
|
snprintf (buf, sizeof (buf), "%" PRId64, pi->start());
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
2009-11-08 11:28:21 -05:00
|
|
|
snprintf (buf, sizeof (buf), "%" PRId64, _session.transport_frame());
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
cs_child->add_property (X_("at"), buf);
|
2011-03-08 15:12:40 -05:00
|
|
|
node.add_child_nocopy (*cs_child);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2011-03-08 15:12:40 -05:00
|
|
|
return node;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-03-08 15:12:40 -05:00
|
|
|
MidiDiskstream::set_state (const XMLNode& node, int version)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
const XMLProperty* prop;
|
|
|
|
XMLNodeList nlist = node.children();
|
|
|
|
XMLNodeIterator niter;
|
|
|
|
XMLNode* capture_pending_node = 0;
|
|
|
|
LocaleGuard lg (X_("POSIX"));
|
|
|
|
|
2011-03-08 15:12:40 -05:00
|
|
|
/* prevent write sources from being created */
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
in_set_state = true;
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
|
|
|
|
assert ((*niter)->name() != IO::state_node_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
if ((*niter)->name() == X_("CapturingSources")) {
|
|
|
|
capture_pending_node = *niter;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-03-14 21:16:24 -04:00
|
|
|
if (Diskstream::set_state (node, version)) {
|
|
|
|
return -1;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
ChannelMode channel_mode = AllChannels;
|
|
|
|
if ((prop = node.property ("channel-mode")) != 0) {
|
|
|
|
channel_mode = ChannelMode (string_2_enum(prop->value(), channel_mode));
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-03-14 21:16:24 -04:00
|
|
|
if (capture_pending_node) {
|
|
|
|
use_pending_capture_data (*capture_pending_node);
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-03-08 15:12:40 -05:00
|
|
|
set_channel_mode (channel_mode, channel_mask);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
in_set_state = false;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
MidiDiskstream::use_new_write_source (uint32_t n)
|
|
|
|
{
|
2010-06-29 16:40:52 -04:00
|
|
|
if (!_session.writable() || !recordable()) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(n == 0);
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
_write_source.reset();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
try {
|
2010-07-16 10:55:11 -04:00
|
|
|
_write_source = boost::dynamic_pointer_cast<SMFSource>(
|
2011-03-02 12:05:16 -05:00
|
|
|
_session.create_midi_source_for_session (0, name ()));
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
if (!_write_source) {
|
|
|
|
throw failed_constructor();
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
catch (failed_constructor &err) {
|
|
|
|
error << string_compose (_("%1:%2 new capture file not initialized correctly"), _name, n) << endmsg;
|
|
|
|
_write_source.reset();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
list<boost::shared_ptr<Source> >
|
2010-06-23 21:37:24 -04:00
|
|
|
MidiDiskstream::steal_write_sources()
|
|
|
|
{
|
2010-12-20 16:50:46 -05:00
|
|
|
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.
|
|
|
|
*/
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
boost::dynamic_pointer_cast<MidiSource>(_write_source)->session_saved ();
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
/* never let it go away */
|
|
|
|
_write_source->mark_nonremovable ();
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
ret.push_back (_write_source);
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
/* get a new one */
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
use_new_write_source (0);
|
2010-07-16 10:55:11 -04:00
|
|
|
|
2010-12-20 16:50:46 -05:00
|
|
|
return ret;
|
2010-06-23 21:37:24 -04:00
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void
|
2009-07-21 11:55:17 -04:00
|
|
|
MidiDiskstream::reset_write_sources (bool mark_write_complete, bool /*force*/)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2009-10-23 00:49:25 -04:00
|
|
|
if (!_session.writable() || !recordable()) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_write_source && mark_write_complete) {
|
|
|
|
_write_source->mark_streaming_write_completed ();
|
2010-12-20 16:50:46 -05:00
|
|
|
}
|
|
|
|
use_new_write_source (0);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-12-03 17:26:29 -05:00
|
|
|
MidiDiskstream::set_block_size (pframes_t /*nframes*/)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::allocate_temporary_buffers ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::monitor_input (bool yn)
|
|
|
|
{
|
|
|
|
if (_source_port)
|
2009-05-04 17:26:46 -04:00
|
|
|
_source_port->ensure_monitor_input (yn);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
MidiDiskstream::set_align_style_from_io ()
|
|
|
|
{
|
2011-03-14 21:16:24 -04:00
|
|
|
if (_alignment_choice != Automatic) {
|
|
|
|
return;
|
|
|
|
}
|
2011-03-09 00:19:44 -05:00
|
|
|
|
2011-04-09 10:59:22 -04:00
|
|
|
/* XXX Not sure what, if anything we can do with MIDI
|
|
|
|
as far as capture alignment etc.
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-04-09 10:59:22 -04:00
|
|
|
set_align_style (ExistingMaterial);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
float
|
|
|
|
MidiDiskstream::playback_buffer_load () const
|
|
|
|
{
|
|
|
|
return (float) ((double) _playback_buf->read_space()/
|
|
|
|
(double) _playback_buf->capacity());
|
|
|
|
}
|
|
|
|
|
|
|
|
float
|
|
|
|
MidiDiskstream::capture_buffer_load () const
|
|
|
|
{
|
|
|
|
return (float) ((double) _capture_buf->write_space()/
|
|
|
|
(double) _capture_buf->capacity());
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-07-21 11:55:17 -04:00
|
|
|
MidiDiskstream::use_pending_capture_data (XMLNode& /*node*/)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
return 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
|
2010-09-17 12:24:22 -04:00
|
|
|
MidiDiskstream::get_playback (MidiBuffer& dst, framepos_t start, framepos_t end)
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
2009-04-23 13:48:37 -04:00
|
|
|
dst.clear();
|
|
|
|
assert(dst.size() == 0);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
// Reverse. ... We just don't do reverse, ok? Back off.
|
|
|
|
if (end <= start) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-04-04 19:00:48 -04:00
|
|
|
// Translate stamps to be relative to start
|
2009-08-28 12:06:08 -04:00
|
|
|
|
2009-09-15 21:08:51 -04:00
|
|
|
|
2009-10-25 10:42:46 -04:00
|
|
|
#ifndef NDEBUG
|
2011-04-04 19:00:48 -04:00
|
|
|
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
|
|
|
|
"%1 MDS pre-read read from %2 write to %3\n", _name,
|
|
|
|
_playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
|
2011-04-04 17:44:56 -04:00
|
|
|
// cerr << "================\n";
|
|
|
|
// _playback_buf->dump (cerr);
|
|
|
|
// cerr << "----------------\n";
|
|
|
|
|
2009-08-28 12:06:08 -04:00
|
|
|
const size_t events_read = _playback_buf->read(dst, start, end);
|
2011-04-04 19:00:48 -04:00
|
|
|
DEBUG_TRACE (DEBUG::MidiDiskstreamIO, string_compose (
|
|
|
|
"%1 MDS events read %2 range %3 .. %4 rspace %5 wspace %6 r@%7 w@%8\n",
|
|
|
|
_name, events_read, start, end,
|
|
|
|
_playback_buf->read_space(), _playback_buf->write_space(),
|
|
|
|
_playback_buf->get_read_ptr(), _playback_buf->get_write_ptr()));
|
2009-10-25 10:42:46 -04:00
|
|
|
#else
|
|
|
|
_playback_buf->read(dst, start, end);
|
2009-08-28 12:06:08 -04:00
|
|
|
#endif
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-02-09 16:11:32 -05:00
|
|
|
gint32 frames_read = end - start;
|
2009-02-02 03:50:36 -05:00
|
|
|
g_atomic_int_add(&_frames_read_from_ringbuffer, frames_read);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
2009-02-15 15:31:05 -05:00
|
|
|
|