#include "midi++/events.h"
#include "evoral/midi_util.h"
-#include "ardour/midi_track.h"
-#include "ardour/midi_diskstream.h"
-#include "ardour/session.h"
+#include "ardour/amp.h"
+#include "ardour/buffer_set.h"
+#include "ardour/delivery.h"
#include "ardour/io_processor.h"
+#include "ardour/meter.h"
+#include "ardour/midi_diskstream.h"
+#include "ardour/midi_playlist.h"
#include "ardour/midi_region.h"
#include "ardour/midi_source.h"
-#include "ardour/route_group_specialized.h"
-#include "ardour/processor.h"
-#include "ardour/midi_playlist.h"
+#include "ardour/midi_track.h"
#include "ardour/panner.h"
+#include "ardour/processor.h"
+#include "ardour/route_group_specialized.h"
+#include "ardour/session.h"
#include "ardour/utils.h"
-#include "ardour/buffer_set.h"
-#include "ardour/meter.h"
-
#include "i18n.h"
_freeze_record.state = NoFreeze;
_saved_meter_point = _meter_point;
_mode = mode;
-
- set_input_minimum(ChanCount(DataType::MIDI, 1));
- set_input_maximum(ChanCount(DataType::MIDI, 1));
- set_output_minimum(ChanCount(DataType::MIDI, 1));
- set_output_maximum(ChanCount(DataType::MIDI, 1));
-
- PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */
}
MidiTrack::MidiTrack (Session& sess, const XMLNode& node)
, _note_mode(Sustained)
{
_set_state(node, false);
-
- set_input_minimum(ChanCount(DataType::MIDI, 1));
- set_input_maximum(ChanCount(DataType::MIDI, 1));
- set_output_minimum(ChanCount(DataType::MIDI, 1));
- set_output_maximum(ChanCount(DataType::MIDI, 1));
-
- PortCountChanged(ChanCount(DataType::MIDI, 2)); /* EMIT SIGNAL */
}
MidiTrack::~MidiTrack ()
MidiTrack::set_diskstream (boost::shared_ptr<MidiDiskstream> ds)
{
_diskstream = ds;
- _diskstream->set_io (*this);
+ _diskstream->set_route (*this);
_diskstream->set_destructive (_mode == Destructive);
_diskstream->set_record_enabled (false);
//_diskstream->monitor_input (false);
ic_connection.disconnect();
- ic_connection = input_changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change));
+ ic_connection = _input->changed.connect (mem_fun (*_diskstream, &MidiDiskstream::handle_input_change));
DiskstreamChanged (); /* EMIT SIGNAL */
{
boost::shared_ptr<MidiDiskstream> dstream;
+ cerr << "\n\n\nMIDI use diskstream\n";
+
if ((dstream = boost::dynamic_pointer_cast<MidiDiskstream>(_session.diskstream_by_name (name))) == 0) {
error << string_compose(_("MidiTrack: midi diskstream \"%1\" not known by session"), name) << endmsg;
return -1;
}
+ cerr << "\n\n\nMIDI found DS\n";
return set_diskstream (dstream);
}
that means "you should create a new diskstream here, not look for
an old one.
*/
+
+ cerr << "\n\n\n\n MIDI track " << name() << " found DS id " << id << endl;
if (id == zero) {
use_new_diskstream ();
return;
}
-int
-MidiTrack::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
-{
- if (n_outputs().n_midi() == 0) {
- return 0;
- }
-
- if (!_active) {
- silence (nframes);
- }
-
- if (session_state_changing) {
-
- /* XXX is this safe to do against transport state changes? */
-
- passthru_silence (start_frame, end_frame, nframes, 0, false);
- return 0;
- }
-
- midi_diskstream()->check_record_status (start_frame, nframes, can_record);
-
- bool send_silence;
-
- if (_have_internal_generator) {
- /* since the instrument has no input streams,
- there is no reason to send any signal
- into the route.
- */
- send_silence = true;
- } else {
-
- if (Config->get_auto_input()) {
- if (Config->get_monitoring_model() == SoftwareMonitoring) {
- send_silence = false;
- } else {
- send_silence = true;
- }
- } else {
- if (_diskstream->record_enabled()) {
- if (Config->get_monitoring_model() == SoftwareMonitoring) {
- send_silence = false;
- } else {
- send_silence = true;
- }
- } else {
- send_silence = true;
- }
- }
- }
-
- apply_gain_automation = false;
-
- if (send_silence) {
-
- /* if we're sending silence, but we want the meters to show levels for the signal,
- meter right here.
- */
-
- if (_have_internal_generator) {
- passthru_silence (start_frame, end_frame, nframes, 0, true);
- } else {
- if (_meter_point == MeterInput) {
- just_meter_input (start_frame, end_frame, nframes);
- }
- passthru_silence (start_frame, end_frame, nframes, 0, false);
- }
-
- } else {
-
- /* we're sending signal, but we may still want to meter the input.
- */
-
- passthru (start_frame, end_frame, nframes, 0, (_meter_point == MeterInput));
- }
-
- flush_outputs (nframes);
-
- return 0;
-}
-
int
-MidiTrack::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, int declick,
+MidiTrack::roll (nframes_t nframes, sframes_t start_frame, sframes_t end_frame, int declick,
bool can_record, bool rec_monitors_input)
{
int dret;
boost::shared_ptr<MidiDiskstream> diskstream = midi_diskstream();
- prepare_inputs (nframes);
-
{
Glib::RWLock::ReaderLock lm (_processor_lock, Glib::TRY_LOCK);
if (lm.locked()) {
if ((dret = diskstream->process (transport_frame, nframes, can_record, rec_monitors_input)) != 0) {
silence (nframes);
-
return dret;
}
/* special condition applies */
if (_meter_point == MeterInput) {
- just_meter_input (start_frame, end_frame, nframes);
+ _input->process_input (_meter, start_frame, end_frame, nframes);
}
- if (diskstream->record_enabled() && !can_record && !Config->get_auto_input()) {
+ if (diskstream->record_enabled() && !can_record && !_session.config.get_auto_input()) {
/* not actually recording, but we want to hear the input material anyway,
at least potentially (depending on monitoring options)
*/
- passthru (start_frame, end_frame, nframes, 0, true);
+ passthru (start_frame, end_frame, nframes, 0);
} else {
/*
diskstream->get_playback(bufs.get_midi(0), start_frame, end_frame);
process_output_buffers (bufs, start_frame, end_frame, nframes,
- (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick, (_meter_point != MeterInput));
+ (!_session.get_record_enabled() || !Config->get_do_not_record_plugins()), declick);
}
- flush_outputs (nframes);
+ _main_outs->flush (nframes);
return 0;
}
-int
-MidiTrack::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
- bool can_record, bool rec_monitors_input)
-{
- if (n_outputs().n_midi() == 0 && _processors.empty()) {
- return 0;
- }
-
- if (!_active) {
- silence (nframes);
- return 0;
- }
-
- _silent = true;
- apply_gain_automation = false;
-
- silence (nframes);
-
- return midi_diskstream()->process (_session.transport_frame(), nframes, can_record, rec_monitors_input);
-}
-
-void
-MidiTrack::process_output_buffers (BufferSet& bufs,
- nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, bool with_processors, int declick,
- bool meter)
-{
- /* There's no such thing as a MIDI bus for the time being.
- * We'll do all the MIDI route work here for now, but the long-term goal is to have
- * Route::process_output_buffers handle everything */
-
- if (meter && (_meter_point == MeterInput || _meter_point == MeterPreFader)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes);
- }
-
- // Run all processors
- if (with_processors) {
- Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
- if (rm.locked()) {
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes);
- }
- }
- }
-
- if (meter && (_meter_point == MeterPostFader)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes);
- }
-
- // Main output stage
- if (muted()) {
- IO::silence (nframes);
- } else {
-
- // Write 'automation' controllers (e.g. CC events from a UI slider)
- write_controller_messages(bufs.get_midi(0), start_frame, end_frame, nframes);
-
- deliver_output(bufs, start_frame, end_frame, nframes);
- }
-}
-
void
-MidiTrack::write_controller_messages(MidiBuffer& output_buf, nframes_t start, nframes_t end, nframes_t nframes)
+MidiTrack::write_controller_messages(MidiBuffer& output_buf, sframes_t /*start*/, sframes_t /*end*/, nframes_t nframes)
{
// Append immediate events (UI controls)
}
int
-MidiTrack::export_stuff (BufferSet& bufs, nframes_t nframes, nframes_t end_frame)
+MidiTrack::export_stuff (BufferSet& /*bufs*/, nframes_t /*nframes*/, sframes_t /*end_frame*/)
{
return -1;
}
}
boost::shared_ptr<Region>
-MidiTrack::bounce (InterThreadInfo& itt)
+MidiTrack::bounce (InterThreadInfo& /*itt*/)
{
throw;
// vector<MidiSource*> srcs;
boost::shared_ptr<Region>
-MidiTrack::bounce_range (nframes_t start, nframes_t end, InterThreadInfo& itt, bool enable_processing)
+MidiTrack::bounce_range (nframes_t /*start*/, nframes_t /*end*/, InterThreadInfo& /*itt*/, bool /*enable_processing*/)
{
throw;
//vector<MidiSource*> srcs;
}
void
-MidiTrack::freeze (InterThreadInfo& itt)
+MidiTrack::freeze (InterThreadInfo& /*itt*/)
{
}
projects / ardour.git / blobdiff