X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fdiskstream.cc;h=a359f228e8d68c7818d46141578cfb696e2bd8a9;hb=3566fa2d8ef069805c70e39101a129c35419ded7;hp=40a2714dc0735e9ea865109d5bbf9797d41e236f;hpb=061a85191c301ac18f2e8ca59d43127a4499ba96;p=ardour.git diff --git a/libs/ardour/diskstream.cc b/libs/ardour/diskstream.cc index 40a2714dc0..a359f228e8 100644 --- a/libs/ardour/diskstream.cc +++ b/libs/ardour/diskstream.cc @@ -31,27 +31,20 @@ #include #include +#include #include "pbd/error.h" #include "pbd/basename.h" -#include -#include "pbd/xml++.h" #include "pbd/memento_command.h" +#include "pbd/xml++.h" +#include "pbd/stacktrace.h" -#include "ardour/ardour.h" -#include "ardour/audioengine.h" #include "ardour/debug.h" #include "ardour/diskstream.h" -#include "ardour/utils.h" -#include "ardour/configuration.h" -#include "ardour/audiofilesource.h" -#include "ardour/send.h" +#include "ardour/io.h" +#include "ardour/pannable.h" #include "ardour/playlist.h" -#include "ardour/cycle_timer.h" -#include "ardour/region.h" -#include "ardour/panner.h" #include "ardour/session.h" -#include "ardour/io.h" #include "ardour/track.h" #include "i18n.h" @@ -66,7 +59,7 @@ using namespace PBD; * default from configuration_vars.h). 0 is not a good value for * allocating buffer sizes.. */ -ARDOUR::nframes_t Diskstream::disk_io_chunk_frames = 1024 * 256; +ARDOUR::framecnt_t Diskstream::disk_io_chunk_frames = 1024 * 256 / sizeof (Sample); PBD::Signal0 Diskstream::DiskOverrun; PBD::Signal0 Diskstream::DiskUnderrun; @@ -80,42 +73,32 @@ Diskstream::Diskstream (Session &sess, const string &name, Flag flag) , _actual_speed (1.0f) , _buffer_reallocation_required (false) , _seek_required (false) - , force_refill (false) , capture_start_frame (0) , capture_captured (0) , was_recording (false) , adjust_capture_position (0) , _capture_offset (0) , _roll_delay (0) - , first_recordable_frame (max_frames) - , last_recordable_frame (max_frames) + , first_recordable_frame (max_framepos) + , last_recordable_frame (max_framepos) , last_possibly_recording (0) , _alignment_style (ExistingMaterial) - , _scrubbing (false) + , _alignment_choice (Automatic) , _slaved (false) , loop_location (0) , overwrite_frame (0) , overwrite_offset (0) , _pending_overwrite (false) , overwrite_queued (false) - , input_change_pending (NoChange) , wrap_buffer_size (0) , speed_buffer_size (0) , _speed (1.0) , _target_speed (_speed) , file_frame (0) , playback_sample (0) - , playback_distance (0) - , _read_data_count (0) - , _write_data_count (0) , in_set_state (false) - , _persistent_alignment_style (ExistingMaterial) - , first_input_change (true) - , scrub_start (0) - , scrub_buffer_size (0) - , scrub_offset (0) , _flags (flag) - + , deprecated_io_node (0) { } @@ -128,41 +111,32 @@ Diskstream::Diskstream (Session& sess, const XMLNode& /*node*/) , _actual_speed (1.0f) , _buffer_reallocation_required (false) , _seek_required (false) - , force_refill (false) , capture_start_frame (0) , capture_captured (0) , was_recording (false) , adjust_capture_position (0) , _capture_offset (0) , _roll_delay (0) - , first_recordable_frame (max_frames) - , last_recordable_frame (max_frames) + , first_recordable_frame (max_framepos) + , last_recordable_frame (max_framepos) , last_possibly_recording (0) , _alignment_style (ExistingMaterial) - , _scrubbing (false) + , _alignment_choice (Automatic) , _slaved (false) , loop_location (0) , overwrite_frame (0) , overwrite_offset (0) , _pending_overwrite (false) , overwrite_queued (false) - , input_change_pending (NoChange) , wrap_buffer_size (0) , speed_buffer_size (0) , _speed (1.0) , _target_speed (_speed) , file_frame (0) , playback_sample (0) - , playback_distance (0) - , _read_data_count (0) - , _write_data_count (0) , in_set_state (false) - , _persistent_alignment_style (ExistingMaterial) - , first_input_change (true) - , scrub_start (0) - , scrub_buffer_size (0) - , scrub_offset (0) , _flags (Recordable) + , deprecated_io_node (0) { } @@ -173,6 +147,8 @@ Diskstream::~Diskstream () if (_playlist) { _playlist->release (); } + + delete deprecated_io_node; } void @@ -184,9 +160,10 @@ Diskstream::set_track (Track* t) ic_connection.disconnect(); _io->changed.connect_same_thread (ic_connection, boost::bind (&Diskstream::handle_input_change, this, _1, _2)); - input_change_pending = ConfigurationChanged; - non_realtime_input_change (); - set_align_style_from_io (); + if (_io->n_ports() != ChanCount::ZERO) { + input_change_pending.type = IOChange::Type (IOChange::ConfigurationChanged|IOChange::ConnectionsChanged); + non_realtime_input_change (); + } _track->Destroyed.connect_same_thread (*this, boost::bind (&Diskstream::route_going_away, this)); } @@ -194,12 +171,21 @@ Diskstream::set_track (Track* t) void Diskstream::handle_input_change (IOChange change, void * /*src*/) { - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); - if (!(input_change_pending & change)) { - input_change_pending = IOChange (input_change_pending|change); - _session.request_input_change_handling (); - } + if (change.type & (IOChange::ConfigurationChanged|IOChange::ConnectionsChanged)) { + + /* rather than handle this here on a DS-by-DS basis we defer to the + session transport/butler thread, and let it tackle + as many diskstreams as need it in one shot. this avoids many repeated + takings of the audioengine process lock. + */ + + if (!(input_change_pending.type & change.type)) { + input_change_pending.type = IOChange::Type (input_change_pending.type | change.type); + _session.request_input_change_handling (); + } + } } void @@ -207,7 +193,7 @@ Diskstream::non_realtime_set_speed () { if (_buffer_reallocation_required) { - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); allocate_temporary_buffers (); _buffer_reallocation_required = false; @@ -215,7 +201,7 @@ Diskstream::non_realtime_set_speed () if (_seek_required) { if (speed() != 1.0f || speed() != -1.0f) { - seek ((nframes_t) (_session.transport_frame() * (double) speed()), true); + seek ((framepos_t) (_session.transport_frame() * (double) speed()), true); } else { seek (_session.transport_frame(), true); @@ -238,8 +224,8 @@ Diskstream::realtime_set_speed (double sp, bool global) if (new_speed != _actual_speed) { - nframes_t required_wrap_size = (nframes_t) floor (_session.get_block_size() * - fabs (new_speed)) + 1; + framecnt_t required_wrap_size = (framecnt_t) ceil (_session.get_block_size() * + fabs (new_speed)) + 2; if (required_wrap_size > wrap_buffer_size) { _buffer_reallocation_required = true; @@ -268,21 +254,47 @@ Diskstream::set_capture_offset () } _capture_offset = _io->latency(); + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: using IO latency, capture offset set to %2\n", name(), _capture_offset)); } + void -Diskstream::set_align_style (AlignStyle a) +Diskstream::set_align_style (AlignStyle a, bool force) { if (record_enabled() && _session.actively_recording()) { return; } - if (a != _alignment_style) { + if ((a != _alignment_style) || force) { _alignment_style = a; AlignmentStyleChanged (); } } +void +Diskstream::set_align_choice (AlignChoice a, bool force) +{ + if (record_enabled() && _session.actively_recording()) { + return; + } + + if ((a != _alignment_choice) || force) { + _alignment_choice = a; + + switch (_alignment_choice) { + case Automatic: + set_align_style_from_io (); + break; + case UseExistingMaterial: + set_align_style (ExistingMaterial); + break; + case UseCaptureTime: + set_align_style (CaptureTime); + break; + } + } +} + int Diskstream::set_loop (Location *location) { @@ -295,38 +307,41 @@ Diskstream::set_loop (Location *location) loop_location = location; - LoopSet (location); /* EMIT SIGNAL */ + LoopSet (location); /* EMIT SIGNAL */ return 0; } -ARDOUR::nframes_t -Diskstream::get_capture_start_frame (uint32_t n) +/** Get the start position (in session frames) of the nth capture in the current pass */ +ARDOUR::framepos_t +Diskstream::get_capture_start_frame (uint32_t n) const { - Glib::Mutex::Lock lm (capture_info_lock); + Glib::Threads::Mutex::Lock lm (capture_info_lock); if (capture_info.size() > n) { + /* this is a completed capture */ return capture_info[n]->start; - } - else { + } else { + /* this is the currently in-progress capture */ return capture_start_frame; } } -ARDOUR::nframes_t -Diskstream::get_captured_frames (uint32_t n) +ARDOUR::framecnt_t +Diskstream::get_captured_frames (uint32_t n) const { - Glib::Mutex::Lock lm (capture_info_lock); + Glib::Threads::Mutex::Lock lm (capture_info_lock); if (capture_info.size() > n) { + /* this is a completed capture */ return capture_info[n]->frames; - } - else { + } else { + /* this is the currently in-progress capture */ return capture_captured; } } void -Diskstream::set_roll_delay (ARDOUR::nframes_t nframes) +Diskstream::set_roll_delay (ARDOUR::framecnt_t nframes) { _roll_delay = nframes; } @@ -341,7 +356,7 @@ Diskstream::use_playlist (boost::shared_ptr playlist) bool prior_playlist = false; { - Glib::Mutex::Lock lm (state_lock); + Glib::Threads::Mutex::Lock lm (state_lock); if (playlist == _playlist) { return 0; @@ -363,7 +378,7 @@ Diskstream::use_playlist (boost::shared_ptr playlist) _playlist->ContentsChanged.connect_same_thread (playlist_connections, boost::bind (&Diskstream::playlist_modified, this)); _playlist->DropReferences.connect_same_thread (playlist_connections, boost::bind (&Diskstream::playlist_deleted, this, boost::weak_ptr(_playlist))); - _playlist->RangesMoved.connect_same_thread (playlist_connections, boost::bind (&Diskstream::playlist_ranges_moved, this, _1)); + _playlist->RangesMoved.connect_same_thread (playlist_connections, boost::bind (&Diskstream::playlist_ranges_moved, this, _1, _2)); } /* don't do this if we've already asked for it *or* if we are setting up @@ -421,35 +436,90 @@ Diskstream::set_name (const string& str) if (_name != str) { assert(playlist()); playlist()->set_name (str); - SessionObject::set_name(str); + } + return true; +} - if (!in_set_state && recordable()) { - /* rename existing capture files so that they have the correct name */ - return rename_write_sources (); - } else { - return false; - } +XMLNode& +Diskstream::get_state () +{ + XMLNode* node = new XMLNode ("Diskstream"); + char buf[64]; + LocaleGuard lg (X_("POSIX")); + + node->add_property ("flags", enum_2_string (_flags)); + node->add_property ("playlist", _playlist->name()); + node->add_property("name", _name); + id().print (buf, sizeof (buf)); + node->add_property("id", buf); + snprintf (buf, sizeof(buf), "%f", _visible_speed); + node->add_property ("speed", buf); + node->add_property ("capture-alignment", enum_2_string (_alignment_choice)); + + if (_extra_xml) { + node->add_child_copy (*_extra_xml); } - return true; + return *node; } -void -Diskstream::remove_region_from_last_capture (boost::weak_ptr wregion) +int +Diskstream::set_state (const XMLNode& node, int /*version*/) { - boost::shared_ptr region (wregion.lock()); + const XMLProperty* prop; - if (!region) { - return; + if ((prop = node.property ("name")) != 0) { + _name = prop->value(); } - _last_capture_regions.remove (region); + if (deprecated_io_node) { + set_id (*deprecated_io_node); + } else { + set_id (node); + } + + if ((prop = node.property ("flags")) != 0) { + _flags = Flag (string_2_enum (prop->value(), _flags)); + } + + if ((prop = node.property (X_("capture-alignment"))) != 0) { + set_align_choice (AlignChoice (string_2_enum (prop->value(), _alignment_choice)), true); + } else { + set_align_choice (Automatic, true); + } + + if ((prop = node.property ("playlist")) == 0) { + return -1; + } + + if (find_and_use_playlist (prop->value())) { + return -1; + } + + if ((prop = node.property ("speed")) != 0) { + double sp = atof (prop->value().c_str()); + + if (realtime_set_speed (sp, false)) { + non_realtime_set_speed (); + } + } + + return 0; } void -Diskstream::playlist_ranges_moved (list< Evoral::RangeMove > const & movements_frames) +Diskstream::playlist_ranges_moved (list< Evoral::RangeMove > const & movements_frames, bool from_undo) { + /* If we're coming from an undo, it will have handled + automation undo (it must, since automation-follows-regions + can lose automation data). Hence we can do nothing here. + */ + + if (from_undo) { + return; + } + if (!_track || Config->get_automation_follows_regions () == false) { return; } @@ -464,16 +534,23 @@ Diskstream::playlist_ranges_moved (list< Evoral::RangeMove > const & } /* move panner automation */ - boost::shared_ptr p = _track->main_outs()->panner (); - if (p) { - for (uint32_t i = 0; i < p->npanners (); ++i) { - boost::shared_ptr pan_alist = p->streampanner(i).pan_control()->alist(); - XMLNode & before = pan_alist->get_state (); - pan_alist->move_ranges (movements); - _session.add_command (new MementoCommand ( - *pan_alist.get(), &before, &pan_alist->get_state ())); - } - } + boost::shared_ptr pannable = _track->pannable(); + Evoral::ControlSet::Controls& c (pannable->controls()); + + for (Evoral::ControlSet::Controls::iterator ci = c.begin(); ci != c.end(); ++ci) { + boost::shared_ptr ac = boost::dynamic_pointer_cast(ci->second); + if (!ac) { + continue; + } + boost::shared_ptr alist = ac->alist(); + + XMLNode & before = alist->get_state (); + bool const things_moved = alist->move_ranges (movements); + if (things_moved) { + _session.add_command (new MementoCommand ( + *alist.get(), &before, &alist->get_state ())); + } + } /* move processor automation */ _track->foreach_processor (boost::bind (&Diskstream::move_processor_automation, this, _1, movements_frames)); @@ -488,8 +565,7 @@ Diskstream::move_processor_automation (boost::weak_ptr p, list< Evora } list< Evoral::RangeMove > movements; - for (list< Evoral::RangeMove >::const_iterator i = movements_frames.begin(); - i != movements_frames.end(); ++i) { + for (list< Evoral::RangeMove >::const_iterator i = movements_frames.begin(); i != movements_frames.end(); ++i) { movements.push_back(Evoral::RangeMove(i->from, i->length, i->to)); } @@ -498,17 +574,19 @@ Diskstream::move_processor_automation (boost::weak_ptr p, list< Evora for (set::iterator i = a.begin (); i != a.end (); ++i) { boost::shared_ptr al = processor->automation_control(*i)->alist(); XMLNode & before = al->get_state (); - al->move_ranges (movements); - _session.add_command ( - new MementoCommand ( - *al.get(), &before, &al->get_state () - ) - ); + bool const things_moved = al->move_ranges (movements); + if (things_moved) { + _session.add_command ( + new MementoCommand ( + *al.get(), &before, &al->get_state () + ) + ); + } } } void -Diskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes*/, bool can_record) +Diskstream::check_record_status (framepos_t transport_frame, bool can_record) { int possibly_recording; int rolling; @@ -529,75 +607,36 @@ Diskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes* if (possibly_recording == last_possibly_recording) { return; } + + framecnt_t existing_material_offset = _session.worst_playback_latency(); + if (possibly_recording == fully_rec_enabled) { if (last_possibly_recording == fully_rec_enabled) { return; } - /* we transitioned to recording. lets see if its transport based or a punch */ - - first_recordable_frame = transport_frame + _capture_offset; - last_recordable_frame = max_frames; - capture_start_frame = transport_frame; - - if (change & transport_rolling) { - - /* transport-change (started rolling) */ - - if (_alignment_style == ExistingMaterial) { - - /* there are two delays happening: - - 1) inbound, represented by _capture_offset - 2) outbound, represented by _session.worst_output_latency() - - the first sample to record occurs when the larger of these - two has elapsed, since they occur in parallel. - - since we've already added _capture_offset, just add the - difference if _session.worst_output_latency() is larger. - */ - - if (_capture_offset < _session.worst_output_latency()) { - first_recordable_frame += (_session.worst_output_latency() - _capture_offset); - } - } else { - first_recordable_frame += _roll_delay; - } - - } else { - - /* punch in */ - - if (_alignment_style == ExistingMaterial) { - - /* There are two kinds of punch: - - 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. - - 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. - - XXX: BUT THIS CODE DOESN'T DIFFERENTIATE !!! - - */ - - if (_capture_offset < _session.worst_output_latency()) { - /* see comment in ExistingMaterial block above */ - first_recordable_frame += (_session.worst_output_latency() - _capture_offset); - } - - } else { - capture_start_frame -= _roll_delay; - } + capture_start_frame = _session.transport_frame(); + first_recordable_frame = capture_start_frame + _capture_offset; + last_recordable_frame = max_framepos; + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 (%9) FRF = %2 CSF = %4 CO = %5, EMO = %6 RD = %8 WOL %10 WTL %11\n", + name(), first_recordable_frame, last_recordable_frame, capture_start_frame, + _capture_offset, + existing_material_offset, + transport_frame, + _roll_delay, + _session.transport_frame(), + _session.worst_output_latency(), + _session.worst_track_latency())); + + + if (_alignment_style == ExistingMaterial) { + first_recordable_frame += existing_material_offset; + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tshift FRF by EMO %1\n", + first_recordable_frame)); } - + prepare_record_status (capture_start_frame); } else { @@ -605,21 +644,21 @@ Diskstream::check_record_status (nframes_t transport_frame, nframes_t /*nframes* if (last_possibly_recording == fully_rec_enabled) { /* we were recording last time */ - + if (change & transport_rolling) { - /* transport-change (stopped rolling): last_recordable_frame was set in ::prepare_to_stop() */ - + + /* transport-change (stopped rolling): last_recordable_frame was set in ::prepare_to_stop(). We + had to set it there because we likely rolled past the stopping point to declick out, + and then backed up. + */ + } else { /* punch out */ - - last_recordable_frame = transport_frame + _capture_offset; - + + last_recordable_frame = _session.transport_frame() + _capture_offset; + if (_alignment_style == ExistingMaterial) { - if (_session.worst_output_latency() > _capture_offset) { - last_recordable_frame += (_session.worst_output_latency() - _capture_offset); - } - } else { - last_recordable_frame += _roll_delay; + last_recordable_frame += existing_material_offset; } } } @@ -635,15 +674,15 @@ Diskstream::route_going_away () } void -Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nframes_t nframes, - nframes_t& rec_nframes, nframes_t& rec_offset) +Diskstream::calculate_record_range (Evoral::OverlapType ot, framepos_t transport_frame, framecnt_t nframes, + framecnt_t & rec_nframes, framecnt_t & rec_offset) { switch (ot) { - case OverlapNone: + case Evoral::OverlapNone: rec_nframes = 0; break; - case OverlapInternal: + case Evoral::OverlapInternal: /* ---------- recrange |---| transrange */ @@ -651,7 +690,7 @@ Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nf rec_offset = 0; break; - case OverlapStart: + case Evoral::OverlapStart: /* |--------| recrange -----| transrange */ @@ -661,7 +700,7 @@ Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nf } break; - case OverlapEnd: + case Evoral::OverlapEnd: /* |--------| recrange |-------- transrange */ @@ -669,7 +708,7 @@ Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nf rec_offset = 0; break; - case OverlapExternal: + case Evoral::OverlapExternal: /* |--------| recrange -------------- transrange */ @@ -677,6 +716,10 @@ Diskstream::calculate_record_range(OverlapType ot, sframes_t transport_frame, nf rec_offset = first_recordable_frame - transport_frame; break; } + + DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1 rec? %2 @ %3 (for %4) FRF %5 LRF %6 : rf %7 @ %8\n", + _name, enum_2_string (ot), transport_frame, nframes, + first_recordable_frame, last_recordable_frame, rec_nframes, rec_offset)); } void @@ -684,3 +727,16 @@ Diskstream::prepare_to_stop (framepos_t pos) { last_recordable_frame = pos + _capture_offset; } + +void +Diskstream::engage_record_enable () +{ + g_atomic_int_set (&_record_enabled, 1); +} + +void +Diskstream::disengage_record_enable () +{ + g_atomic_int_set (&_record_enabled, 0); +} +