int existing = 0;
int capture = 0;
+ int automatic = 0;
+ int styles = 0;
+ boost::shared_ptr<Track> first_track;
+
TrackSelection const & s = _editor.get_selection().tracks;
for (TrackSelection::const_iterator i = s.begin(); i != s.end(); ++i) {
RouteTimeAxisView* r = dynamic_cast<RouteTimeAxisView*> (*i);
if (!r || !r->is_track ()) {
continue;
}
-
- switch (r->track()->alignment_style()) {
- case ExistingMaterial:
- ++existing;
- break;
- case CaptureTime:
- ++capture;
- break;
- }
+
+ if (!first_track) {
+ first_track = r->track();
+ }
+
+ switch (r->track()->alignment_choice()) {
+ case Automatic:
+ ++automatic;
+ styles |= 0x1;
+ switch (r->track()->alignment_style()) {
+ case ExistingMaterial:
+ ++existing;
+ break;
+ case CaptureTime:
+ ++capture;
+ break;
+ }
+ break;
+ case UseExistingMaterial:
+ ++existing;
+ styles |= 0x2;
+ break;
+ case UseCaptureTime:
+ ++capture;
+ styles |= 0x4;
+ break;
+ }
}
-
- alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material")));
- RadioMenuItem* i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
- i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), ExistingMaterial, true));
- i->set_active (existing != 0 && capture == 0);
- i->set_inconsistent (existing != 0 && capture != 0);
-
- alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time")));
- i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
- i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_style), CaptureTime, true));
- i->set_active (existing == 0 && capture != 0);
- i->set_inconsistent (existing != 0 && capture != 0);
-
- items.push_back (MenuElem (_("Alignment"), *alignment_menu));
+
+ bool inconsistent;
+ switch (styles) {
+ case 1:
+ case 2:
+ case 4:
+ inconsistent = false;
+ break;
+ default:
+ inconsistent = true;
+ break;
+ }
+
+ RadioMenuItem* i;
+
+ if (!inconsistent && first_track) {
+
+ alignment_items.push_back (RadioMenuElem (align_group, _("Automatic (based on I/O connections)")));
+ i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
+ i->set_active (automatic != 0 && existing == 0 && capture == 0);
+ i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, Automatic, true));
+
+ switch (first_track->alignment_choice()) {
+ case Automatic:
+ switch (first_track->alignment_style()) {
+ case ExistingMaterial:
+ alignment_items.push_back (MenuElem (_("(Currently: Existing Material)")));
+ break;
+ case CaptureTime:
+ alignment_items.push_back (MenuElem (_("(Currently: Capture Time)")));
+ break;
+ }
+ break;
+ default:
+ break;
+ }
+
+ alignment_items.push_back (RadioMenuElem (align_group, _("Align With Existing Material")));
+ i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
+ i->set_active (existing != 0 && capture == 0 && automatic == 0);
+ i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseExistingMaterial, true));
+
+ alignment_items.push_back (RadioMenuElem (align_group, _("Align With Capture Time")));
+ i = dynamic_cast<RadioMenuItem*> (&alignment_items.back());
+ i->set_active (existing == 0 && capture != 0 && automatic == 0);
+ i->signal_activate().connect (sigc::bind (sigc::mem_fun(*this, &RouteTimeAxisView::set_align_choice), i, UseCaptureTime, true));
+
+ items.push_back (MenuElem (_("Alignment"), *alignment_menu));
+
+ } else {
+ /* show nothing */
+ }
Menu* mode_menu = manage (new Menu);
MenuList& mode_items = mode_menu->items ();
}
void
-RouteTimeAxisView::set_align_style (AlignStyle style, bool apply_to_selection)
+RouteTimeAxisView::set_align_choice (RadioMenuItem* mitem, AlignChoice choice, bool apply_to_selection)
{
+ /* this is one of the two calls made when these radio menu items change status. this one
+ is for the item that became inactive, and we want to ignore it.
+ */
+
+ if (!mitem->get_active()) {
+ return;
+ }
+
if (apply_to_selection) {
- _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_align_style, _1, style, false));
+ _editor.get_selection().tracks.foreach_route_time_axis (boost::bind (&RouteTimeAxisView::set_align_choice, _1, mitem, choice, false));
} else {
if (track ()) {
- track()->set_align_style (style);
+ track()->set_align_choice (choice);
}
}
}
boost::shared_ptr<Track> track = boost::dynamic_pointer_cast<Track>(*i);
if (!track) {
- std::cerr << "route " << (*i)->name() << " is not a Track" << std::endl;
continue;
}
virtual void append_extra_display_menu_items () {}
void build_display_menu ();
- void set_align_style (ARDOUR::AlignStyle, bool apply_to_selection = false);
+ void set_align_choice (Gtk::RadioMenuItem*, ARDOUR::AlignChoice, bool apply_to_selection = false);
void playlist_click ();
void show_playlist_selector ();
void set_flag (Flag f) { _flags = Flag (_flags | f); }
void unset_flag (Flag f) { _flags = Flag (_flags & ~f); }
- AlignStyle alignment_style() const { return _alignment_style; }
+ AlignStyle alignment_style() const { return _alignment_style; }
+ AlignChoice alignment_choice() const { return _alignment_choice; }
void set_align_style (AlignStyle);
- void set_persistent_align_style (AlignStyle a) { _persistent_alignment_style = a; }
+ void set_align_choice (AlignChoice a);
framecnt_t roll_delay() const { return _roll_delay; }
void set_roll_delay (framecnt_t);
framepos_t last_recordable_frame;
int last_possibly_recording;
AlignStyle _alignment_style;
+ AlignChoice _alignment_choice;
bool _scrubbing;
bool _slaved;
Location* loop_location;
uint32_t _write_data_count;
bool in_set_state;
- AlignStyle _persistent_alignment_style;
- bool first_input_change;
Glib::Mutex state_lock;
framecnt_t worst_output_latency () const { return _worst_output_latency; }
framecnt_t worst_input_latency () const { return _worst_input_latency; }
framecnt_t worst_track_latency () const { return _worst_track_latency; }
+ framecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; }
#ifdef HAVE_JACK_SESSION
void jack_session_event (jack_session_event_t* event);
ChanCount n_channels ();
framepos_t get_capture_start_frame (uint32_t n = 0) const;
AlignStyle alignment_style () const;
+ AlignChoice alignment_choice () const;
framepos_t current_capture_start () const;
framepos_t current_capture_end () const;
void playlist_modified ();
int use_playlist (boost::shared_ptr<Playlist>);
void set_align_style (AlignStyle);
+ void set_align_choice (AlignChoice);
int use_copy_playlist ();
int use_new_playlist ();
void adjust_playback_buffering ();
ExistingMaterial
};
+ enum AlignChoice {
+ UseCaptureTime,
+ UseExistingMaterial,
+ Automatic
+ };
+
enum MeterPoint {
MeterInput,
MeterPreFader,
get_input_sources ();
set_capture_offset ();
-
- if (first_input_change) {
- set_align_style (_persistent_alignment_style);
- first_input_change = false;
- } else {
- set_align_style_from_io ();
- }
+ set_align_style_from_io ();
input_change_pending = IOChange::NoChange;
capture_captured += _capture_offset;
if (_alignment_style == ExistingMaterial) {
- capture_captured += _session.worst_output_latency();
+ capture_captured += _session.worst_playback_latency();
} else {
capture_captured += _roll_delay;
}
{
bool have_physical = false;
+ if (_alignment_choice != Automatic) {
+ return;
+ }
+
if (_io == 0) {
return;
}
#include <sys/mman.h>
+#include <glibmm/thread.h>
+
#include "pbd/error.h"
#include "pbd/basename.h"
-#include <glibmm/thread.h>
-#include "pbd/xml++.h"
#include "pbd/memento_command.h"
+#include "pbd/xml++.h"
#include "ardour/ardour.h"
#include "ardour/audioengine.h"
, last_recordable_frame (max_framepos)
, last_possibly_recording (0)
, _alignment_style (ExistingMaterial)
+ , _alignment_choice (Automatic)
, _scrubbing (false)
, _slaved (false)
, loop_location (0)
, _read_data_count (0)
, _write_data_count (0)
, in_set_state (false)
- , _persistent_alignment_style (ExistingMaterial)
- , first_input_change (true)
, _flags (flag)
, deprecated_io_node (0)
{
, last_recordable_frame (max_framepos)
, last_possibly_recording (0)
, _alignment_style (ExistingMaterial)
+ , _alignment_choice (Automatic)
, _scrubbing (false)
, _slaved (false)
, loop_location (0)
, _read_data_count (0)
, _write_data_count (0)
, in_set_state (false)
- , _persistent_alignment_style (ExistingMaterial)
- , first_input_change (true)
, _flags (Recordable)
, deprecated_io_node (0)
{
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)
{
}
}
+void
+Diskstream::set_align_choice (AlignChoice a)
+{
+ if (record_enabled() && _session.actively_recording()) {
+ return;
+ }
+
+ if (a != _alignment_choice) {
+ _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)
{
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);
_flags = Flag (string_2_enum (prop->value(), _flags));
}
+ if ((prop = node.property (X_("capture-alignment"))) != 0) {
+ _alignment_choice = AlignChoice (string_2_enum (prop->value(), _alignment_choice));
+ } else {
+ _alignment_choice = Automatic;
+ }
+
if ((prop = node.property ("playlist")) == 0) {
return -1;
}
last_recordable_frame = max_framepos;
capture_start_frame = transport_frame;
- DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 basic FRF = %2 LRF = %3 CSF = %4 CO = %5, WLO = %6\n",
+ DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("%1: @ %7 basic FRF = %2 LRF = %3 CSF = %4 CO = %5, WPL = %6\n",
name(), first_recordable_frame, last_recordable_frame, capture_start_frame,
_capture_offset,
- _session.worst_output_latency(),
+ _session.worst_playback_latency(),
transport_frame));
if (_alignment_style == ExistingMaterial) {
- /* audio played by ardour will take (up to) _session.worst_output_latency() ("WOL") to
+ /* audio played by ardour will take (up to) _session.worst_playback_latency() ("WOL") to
appear at the speakers; audio played at the time when it does appear at
the speakers will take _capture_offset to arrive back here. we've
already added _capture_offset, so now add WOL.
*/
- first_recordable_frame += _session.worst_output_latency();
+ first_recordable_frame += _session.worst_playback_latency();
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tROLL: shift FRF by delta between WOL %1\n",
first_recordable_frame));
} else {
if (_alignment_style == ExistingMaterial) {
/* see comment in ExistingMaterial block above */
- first_recordable_frame += _session.worst_output_latency();
+ first_recordable_frame += _session.worst_playback_latency();
DEBUG_TRACE (DEBUG::CaptureAlignment, string_compose ("\tMANUAL PUNCH: shift FRF by delta between WOL and CO to %1\n",
first_recordable_frame));
} else {
OverlapType _OverlapType;
AlignStyle _AlignStyle;
+ AlignChoice _AlignChoice;
MeterPoint _MeterPoint;
TrackMode _TrackMode;
NoteMode _NoteMode;
REGISTER_ENUM (ExistingMaterial);
REGISTER (_AlignStyle);
+ REGISTER_ENUM (UseCaptureTime);
+ REGISTER_ENUM (UseExistingMaterial);
+ REGISTER_ENUM (Automatic);
+ REGISTER (_AlignChoice);
+
REGISTER_ENUM (MeterInput);
REGISTER_ENUM (MeterPreFader);
REGISTER_ENUM (MeterPostFader);
get_input_sources ();
set_capture_offset ();
-
- if (first_input_change) {
- set_align_style (_persistent_alignment_style);
- first_input_change = false;
- } else {
- set_align_style_from_io ();
- }
+ set_align_style_from_io ();
input_change_pending.type = IOChange::NoChange;
capture_captured += _capture_offset;
if (_alignment_style == ExistingMaterial) {
- capture_captured += _session.worst_output_latency();
+ capture_captured += _session.worst_playback_latency();
} else {
capture_captured += _roll_delay;
}
{
bool have_physical = false;
+ if (_alignment_choice != Automatic) {
+ return;
+ }
+
if (_io == 0) {
return;
}
frames. Also compensate for audio latency.
*/
- mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_output_latency();
+ mtc_frame += (long) (1.75 * session.frames_per_timecode_frame()) + session.worst_playback_latency();
if (now) {
in the absence of any plugin latency compensation
*/
- offset = _worst_output_latency;
+ offset = worst_playback_latency ();
if (offset > current_block_size) {
offset -= current_block_size;
}
// Compensate for audio latency
- outbound_mtc_timecode_frame += _worst_output_latency;
+ outbound_mtc_timecode_frame += worst_playback_latency();
next_quarter_frame_to_send = 0;
// Sync slave to the same Timecode time as we are on
past that point to pick up delayed input (and/or to delick)
*/
- if (_worst_output_latency > current_block_size) {
+ if (worst_playback_latency() > current_block_size) {
/* we rolled past the stop point to pick up data that had
not yet arrived. move back to where the stop occured.
*/
- decrement_transport_position (current_block_size + (_worst_output_latency - current_block_size));
+ decrement_transport_position (current_block_size + (worst_playback_latency() - current_block_size));
} else {
decrement_transport_position (current_block_size);
}
return;
}
- if (actively_recording() && !(transport_sub_state & StopPendingCapture) && _worst_output_latency > current_block_size) {
+ if (actively_recording() && !(transport_sub_state & StopPendingCapture) && worst_playback_latency() > current_block_size) {
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
*/
SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
- _transport_frame + _worst_output_latency - current_block_size,
- 0, 0, abort);
+ _transport_frame + _worst_input_latency - current_block_size,
+ 0, 0, abort);
merge_event (ev);
transport_sub_state |= StopPendingCapture;
return _diskstream->alignment_style ();
}
+AlignChoice
+Track::alignment_choice () const
+{
+ return _diskstream->alignment_choice ();
+}
+
framepos_t
Track::current_capture_start () const
{
_diskstream->set_align_style (s);
}
+void
+Track::set_align_choice (AlignChoice s)
+{
+ _diskstream->set_align_choice (s);
+}
+
uint32_t
Track::write_data_count () const
{
projects / ardour.git / commitdiff