#include <cassert>
#include <sigc++/bind.h>
-#include <pbd/xml++.h>
-#include <pbd/enumwriter.h>
-#include <pbd/stacktrace.h>
-#include <pbd/memento_command.h>
-
-#include <evoral/Curve.hpp>
-
-#include <ardour/timestamps.h>
-#include <ardour/audioengine.h>
-#include <ardour/route.h>
-#include <ardour/buffer.h>
-#include <ardour/processor.h>
-#include <ardour/plugin_insert.h>
-#include <ardour/port_insert.h>
-#include <ardour/send.h>
-#include <ardour/session.h>
-#include <ardour/utils.h>
-#include <ardour/configuration.h>
-#include <ardour/cycle_timer.h>
-#include <ardour/route_group.h>
-#include <ardour/port.h>
-#include <ardour/audio_port.h>
-#include <ardour/ladspa_plugin.h>
-#include <ardour/panner.h>
-#include <ardour/dB.h>
-#include <ardour/amp.h>
-#include <ardour/meter.h>
-#include <ardour/buffer_set.h>
-#include <ardour/mix.h>
-#include <ardour/profile.h>
+#include "pbd/xml++.h"
+#include "pbd/enumwriter.h"
+#include "pbd/stacktrace.h"
+#include "pbd/memento_command.h"
+
+#include "evoral/Curve.hpp"
+
+#include "ardour/timestamps.h"
+#include "ardour/audioengine.h"
+#include "ardour/route.h"
+#include "ardour/buffer.h"
+#include "ardour/processor.h"
+#include "ardour/plugin_insert.h"
+#include "ardour/port_insert.h"
+#include "ardour/send.h"
+#include "ardour/session.h"
+#include "ardour/utils.h"
+#include "ardour/configuration.h"
+#include "ardour/cycle_timer.h"
+#include "ardour/route_group.h"
+#include "ardour/port.h"
+#include "ardour/audio_port.h"
+#include "ardour/ladspa_plugin.h"
+#include "ardour/panner.h"
+#include "ardour/dB.h"
+#include "ardour/amp.h"
+#include "ardour/meter.h"
+#include "ardour/buffer_set.h"
+#include "ardour/mix.h"
+#include "ardour/profile.h"
#include "i18n.h"
Route::order_key (const char* name) const
{
OrderKeys::const_iterator i;
-
+
for (i = order_keys.begin(); i != order_keys.end(); ++i) {
if (!strcmp (name, i->first)) {
return i->second;
++i;
} else {
/* key exists - use it and reset all others (actually, itself included) */
- i = order_keys.begin();
key = i->second;
+ i = order_keys.begin();
}
for (; i != order_keys.end(); ++i) {
* @param start_frame Initial transport frame
* @param end_frame Final transport frame
* @param nframes Number of frames to output (to ports)
- * @param offset Output offset (of port buffers, for split cycles)
*
* Note that (end_frame - start_frame) may not be equal to nframes when the
* transport speed isn't 1.0 (eg varispeed).
*/
void
Route::process_output_buffers (BufferSet& bufs,
- nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset,
- bool with_processors, int declick, bool meter)
+ nframes_t start_frame, nframes_t end_frame, nframes_t nframes,
+ bool with_processors, int declick, bool meter)
{
// This is definitely very audio-only for now
assert(_default_type == DataType::AUDIO);
----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes);
}
if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
) {
- co->silence (nframes, offset);
+ co->silence (nframes);
} else {
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes);
}
}
for (BufferSet::audio_iterator i = bufs.audio_begin(); i != bufs.audio_end(); ++i) {
Sample* const sp = i->data();
- for (nframes_t nx = offset; nx < nframes + offset; ++nx) {
+ for (nframes_t nx = 0; nx < nframes; ++nx) {
sp[nx] += 1.0e-27f;
}
}
for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes);
break;
case PostFader:
post_fader_work = true;
for (i = _processors.begin(); i != _processors.end(); ++i) {
switch ((*i)->placement()) {
case PreFader:
- (*i)->silence (nframes, offset);
+ (*i)->silence (nframes);
break;
case PostFader:
post_fader_work = true;
----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterPreFader)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes);
}
) {
- co->silence (nframes, offset);
+ co->silence (nframes);
} else {
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes);
}
}
case PreFader:
break;
case PostFader:
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes);
break;
}
}
case PreFader:
break;
case PostFader:
- (*i)->silence (nframes, offset);
+ (*i)->silence (nframes);
break;
}
}
) {
- co->silence (nframes, offset);
+ co->silence (nframes);
} else {
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes);
}
}
} else if (no_monitor && record_enabled()
&& (!Config->get_auto_input() || _session.actively_recording())) {
- IO::silence (nframes, offset);
+ IO::silence (nframes);
} else {
peak_meter().reset();
}
- IO::silence (nframes, offset);
+ IO::silence (nframes);
} else {
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
+ deliver_output(bufs, start_frame, end_frame, nframes);
}
if ((_gain == 0 && !apply_gain_automation) || dmg == 0) {
_meter->reset();
} else {
- _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(output_buffers(), start_frame, end_frame, nframes);
}
}
}
* @param start_frame Initial transport frame
* @param end_frame Final transport frame
* @param nframes Number of frames to output (to ports)
- * @param offset Output offset (of port buffers, for split cycles)
*
* Note that (end_frame - start_frame) may not be equal to nframes when the
* transport speed isn't 1.0 (eg varispeed).
*/
void
Route::process_output_buffers (BufferSet& bufs,
- nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset,
- bool with_processors, int declick, bool meter)
+ nframes_t start_frame, nframes_t end_frame, nframes_t nframes,
+ bool with_processors, int declick, bool meter)
{
// This is definitely very audio-only for now
assert(_default_type == DataType::AUDIO);
{
Glib::RWLock::ReaderLock rm (_processor_lock, Glib::TRY_LOCK);
for (i = processors.begin(); i != processors.end(); ++i) {
- (*i)->run_in_place (bufs, start_frame, end_frame, nframes, offset);
+ (*i)->run_in_place (bufs, start_frame, end_frame, nframes);
}
}
----------------------------------------------------------------------------------------- */
if (meter && (_meter_point == MeterInput)) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes);
}
if (!_soloed && _mute_affects_pre_fader && (mute_gain != dmg)) {
) {
- co->silence (nframes, offset);
+ co->silence (nframes);
} else {
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes);
}
}
) {
- co->silence (nframes, offset);
+ co->silence (nframes);
} else {
- co->deliver_output (bufs, start_frame, end_frame, nframes, offset);
+ co->deliver_output (bufs, start_frame, end_frame, nframes);
}
}
} else if (no_monitor && record_enabled()
&& (!Config->get_auto_input() || _session.actively_recording())) {
- IO::silence (nframes, offset);
+ IO::silence (nframes);
} else {
peak_meter().reset();
}
- IO::silence (nframes, offset);
+ IO::silence (nframes);
} else {
- deliver_output(bufs, start_frame, end_frame, nframes, offset);
+ deliver_output(bufs, start_frame, end_frame, nframes);
}
}
void
-Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter_first)
+Route::passthru (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, int declick, bool meter_first)
{
BufferSet& bufs = _session.get_scratch_buffers(n_process_buffers());
_silent = false;
- collect_input (bufs, nframes, offset);
+ collect_input (bufs, nframes);
if (meter_first) {
- _meter->run_in_place(bufs, start_frame, end_frame, nframes, offset);
+ _meter->run_in_place(bufs, start_frame, end_frame, nframes);
meter_first = false;
} else {
meter_first = true;
}
- process_output_buffers (bufs, start_frame, end_frame, nframes, offset, true, declick, meter_first);
+ process_output_buffers (bufs, start_frame, end_frame, nframes, true, declick, meter_first);
}
void
-Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, nframes_t offset, int declick, bool meter)
+Route::passthru_silence (nframes_t start_frame, nframes_t end_frame, nframes_t nframes, int declick, bool meter)
{
- process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, offset, true, declick, meter);
+ process_output_buffers (_session.get_silent_buffers (n_process_buffers()), start_frame, end_frame, nframes, true, declick, meter);
}
void
child = *niter;
if (child->name() == IO::state_node_name && call_base) {
-
IO::set_state (*child);
break;
}
delete _control_outs;
_control_outs = new IO (_session, coutname);
+
+ /* fix up the control out name in the XML before setting it.
+ Otherwise track templates don't work because the control
+ outs end up with the stored template name, rather than
+ the new name of the track based on the template.
+ */
+
+ XMLProperty* prop = (*child->children().begin())->property ("name");
+ if (prop) {
+ prop->set_value (coutname);
+ }
+
_control_outs->set_state (**(child->children().begin()));
} else if (child->name() == X_("Comment")) {
}
void
-Route::silence (nframes_t nframes, nframes_t offset)
+Route::silence (nframes_t nframes)
{
if (!_silent) {
- IO::silence (nframes, offset);
+ IO::silence (nframes);
if (_control_outs) {
- _control_outs->silence (nframes, offset);
+ _control_outs->silence (nframes);
}
{
continue;
}
- (*i)->silence (nframes, offset);
+ (*i)->silence (nframes);
}
- if (nframes == _session.get_block_size() && offset == 0) {
+ if (nframes == _session.get_block_size()) {
// _silent = true;
}
}
}
int
-Route::no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
- bool session_state_changing, bool can_record, bool rec_monitors_input)
+Route::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_total() == 0) {
return 0;
}
if (session_state_changing || !_active) {
- silence (nframes, offset);
+ silence (nframes);
return 0;
}
apply_gain_automation = false;
if (n_inputs().n_total()) {
- passthru (start_frame, end_frame, nframes, offset, 0, false);
+ passthru (start_frame, end_frame, nframes, 0, false);
} else {
- silence (nframes, offset);
+ silence (nframes);
}
return 0;
}
nframes_t
-Route::check_initial_delay (nframes_t nframes, nframes_t& offset, nframes_t& transport_frame)
+Route::check_initial_delay (nframes_t nframes, nframes_t& transport_frame)
{
if (_roll_delay > nframes) {
_roll_delay -= nframes;
- silence (nframes, offset);
+ silence (nframes);
/* transport frame is not legal for caller to use */
return 0;
} else if (_roll_delay > 0) {
nframes -= _roll_delay;
-
- silence (_roll_delay, offset);
-
- offset += _roll_delay;
+ silence (_roll_delay);
+ /* we've written _roll_delay of samples into the
+ output ports, so make a note of that for
+ future reference.
+ */
+ increment_output_offset (_roll_delay);
transport_frame += _roll_delay;
_roll_delay = 0;
}
int
-Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset, int declick,
+Route::roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, int declick,
bool can_record, bool rec_monitors_input)
{
{
}
if ((n_outputs().n_total() == 0 && _processors.empty()) || n_inputs().n_total() == 0 || !_active) {
- silence (nframes, offset);
+ silence (nframes);
return 0;
}
nframes_t unused = 0;
- if ((nframes = check_initial_delay (nframes, offset, unused)) == 0) {
+ if ((nframes = check_initial_delay (nframes, unused)) == 0) {
return 0;
}
}
}
- passthru (start_frame, end_frame, nframes, offset, declick, false);
+ passthru (start_frame, end_frame, nframes, declick, false);
return 0;
}
int
-Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, nframes_t offset,
+Route::silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
bool can_record, bool rec_monitors_input)
{
- silence (nframes, offset);
+ silence (nframes);
return 0;
}
#endif
}
+
+
+int
+Route::save_as_template (const string& path, const string& name)
+{
+ XMLNode& node (state (false));
+ XMLTree tree;
+
+ IO::set_name_in_state (*node.children().front(), name);
+
+ tree.set_root (&node);
+ return tree.write (path.c_str());
+}
projects / ardour.git / blobdiff