boost::shared_ptr<Diskstream>
AudioTrack::create_diskstream ()
{
- AudioDiskstream::Flag dflags = AudioDiskstream::Flag (0);
-
- if (_flags & Auditioner) {
- dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Hidden);
- } else {
- dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Recordable);
- }
+ AudioDiskstream::Flag dflags = AudioDiskstream::Flag (AudioDiskstream::Recordable);
if (_mode == Destructive) {
dflags = AudioDiskstream::Flag (dflags | AudioDiskstream::Destructive);
}
_diskstream->set_record_enabled (false);
- _diskstream->request_jack_monitors_input (false);
+ _diskstream->request_input_monitoring (false);
DiskstreamChanged (); /* EMIT SIGNAL */
}
{
const XMLProperty *prop;
- if (Track::set_state (node, version)) {
- return -1;
- }
-
if ((prop = node.property (X_("mode"))) != 0) {
_mode = TrackMode (string_2_enum (prop->value(), _mode));
} else {
_mode = Normal;
}
+ if (Track::set_state (node, version)) {
+ return -1;
+ }
+
pending_state = const_cast<XMLNode*> (&node);
if (_session.state_of_the_state() & Session::Loading) {
{
XMLNode* fnode;
XMLProperty* prop;
- LocaleGuard lg (X_("POSIX"));
+ LocaleGuard lg (X_("C"));
/* This is called after all session state has been restored but before
have been made ports and connections are established.
Glib::Threads::RWLock::ReaderLock lm (_processor_lock, Glib::Threads::TRY_LOCK);
if (!lm.locked()) {
+ boost::shared_ptr<AudioDiskstream> diskstream = audio_diskstream();
+ framecnt_t playback_distance = diskstream->calculate_playback_distance(nframes);
+ if (can_internal_playback_seek(llabs(playback_distance))) {
+ /* TODO should declick */
+ internal_playback_seek(playback_distance);
+ }
return 0;
}
if (!_active) {
silence (nframes);
+ if (_meter_point == MeterInput && (_monitoring & MonitorInput || _diskstream->record_enabled())) {
+ _meter->reset();
+ }
return 0;
}
return dret;
}
+ if (_mute_control->list() && _mute_control->automation_playback()) {
+ bool valid = false;
+ const float mute = _mute_control->list()->rt_safe_eval(transport_frame, valid);
+ if (mute >= 0.5 && !muted()) {
+ _mute_control->set_value(1.0); // mute
+ } else if (mute < 0.5 && muted()) {
+ _mute_control->set_value(0.0); // unmute
+ }
+ }
+
_silent = false;
_amp->apply_gain_automation(false);
- BufferSet& bufs = _session.get_scratch_buffers (n_process_buffers ());
+ BufferSet& bufs = _session.get_route_buffers (n_process_buffers ());
fill_buffers_with_input (bufs, _input, nframes);
process_output_buffers (bufs, start_frame, end_frame, nframes, declick, (!diskstream->record_enabled() && _session.transport_rolling()));
+ for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
+ boost::shared_ptr<Delivery> d = boost::dynamic_pointer_cast<Delivery> (*i);
+ if (d) {
+ d->flush_buffers (nframes);
+ }
+ }
+
need_butler = diskstream->commit (playback_distance);
return 0;
int
AudioTrack::export_stuff (BufferSet& buffers, framepos_t start, framecnt_t nframes,
- boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export)
+ boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export, bool for_freeze)
{
boost::scoped_array<gain_t> gain_buffer (new gain_t[nframes]);
boost::scoped_array<Sample> mix_buffer (new Sample[nframes]);
}
}
- // If no processing is required, there's no need to go any further.
-
- if (!endpoint && !include_endpoint) {
- return 0;
- }
-
- for (ProcessorList::iterator i = _processors.begin(); i != _processors.end(); ++i) {
-
- if (!include_endpoint && (*i) == endpoint) {
- break;
- }
-
- /* if we're not exporting, stop processing if we come across a routing processor.
- */
-
- if (!for_export && (*i)->does_routing()) {
- break;
- }
-
- /* even for export, don't run any processor that does routing.
-
- oh, and don't bother with the peak meter either.
- */
-
- if (!(*i)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*i)) {
- (*i)->run (buffers, start, start+nframes, nframes, true);
- }
-
- if ((*i) == endpoint) {
- break;
- }
- }
+ bounce_process (buffers, start, nframes, endpoint, include_endpoint, for_export, for_freeze);
return 0;
}
boost::shared_ptr<Processor> endpoint, bool include_endpoint)
{
vector<boost::shared_ptr<Source> > srcs;
- return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false);
+ return _session.write_one_track (*this, start, end, false, srcs, itt, endpoint, include_endpoint, false, false);
}
void
boost::shared_ptr<Region> res;
- if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(), true, srcs, itt,
- main_outs(), false, false)) == 0) {
+ if ((res = _session.write_one_track (*this, _session.current_start_frame(), _session.current_end_frame(),
+ true, srcs, itt, main_outs(), false, false, true)) == 0) {
return;
}
for (ProcessorList::iterator r = _processors.begin(); r != _processors.end(); ++r) {
- if (!(*r)->does_routing() && !boost::dynamic_pointer_cast<PeakMeter>(*r)) {
+ if ((*r)->does_routing() && (*r)->active()) {
+ break;
+ }
+ if (!boost::dynamic_pointer_cast<PeakMeter>(*r)) {
FreezeRecordProcessorInfo* frii = new FreezeRecordProcessorInfo ((*r)->get_state(), (*r));
_freeze_record.processor_info.push_back (frii);
- /* now deactivate the processor */
-
- (*r)->deactivate ();
+ /* now deactivate the processor, */
+ if (!boost::dynamic_pointer_cast<Amp>(*r)) {
+ (*r)->deactivate ();
+ }
}
_session.set_dirty ();
/* reset stuff that has already been accounted for in the freeze process */
- set_gain (1.0, this);
+ set_gain (GAIN_COEFF_UNITY, this);
_amp->gain_control()->set_automation_state (Off);
/* XXX need to use _main_outs _panner->set_automation_state (Off); */
projects / ardour.git / blobdiff