#include "ardour/tempo.h"
#include "ardour/utils.h"
#include "ardour/graph.h"
-#include "ardour/vbap_speakers.h"
+#include "ardour/speakers.h"
+#include "ardour/operations.h"
#include "midi++/port.h"
#include "midi++/mmc.h"
PBD::Signal1<void,std::string> Session::Dialog;
PBD::Signal0<int> Session::AskAboutPendingState;
-PBD::Signal2<int,nframes_t,nframes_t> Session::AskAboutSampleRateMismatch;
+PBD::Signal2<int, framecnt_t, framecnt_t> Session::AskAboutSampleRateMismatch;
PBD::Signal0<void> Session::SendFeedback;
PBD::Signal3<int,Session*,std::string,DataType> Session::MissingFile;
, _total_free_4k_blocks (0)
, _bundles (new BundleList)
, _bundle_xml_node (0)
+ , _current_trans (0)
, _click_io ((IO*) 0)
, click_data (0)
, click_emphasis_data (0)
boost::shared_ptr<Playlist> playlist;
if ((playlist = track->playlist()) != 0) {
- playlist->LengthChanged.connect_same_thread (*this, boost::bind (&Session::update_session_range_location_marker, this));
- playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::update_session_range_location_marker, this));
+ playlist->RegionAdded.connect_same_thread (*this, boost::bind (&Session::playlist_region_added, this, _1));
+ playlist->RangesMoved.connect_same_thread (*this, boost::bind (&Session::playlist_ranges_moved, this, _1));
}
-
- update_session_range_location_marker ();
}
bool
void
Session::auto_punch_end_changed (Location* location)
{
- nframes_t when_to_stop = location->end();
+ framepos_t when_to_stop = location->end();
// when_to_stop += _worst_output_latency + _worst_input_latency;
replace_event (SessionEvent::PunchOut, when_to_stop);
}
void
Session::auto_punch_changed (Location* location)
{
- nframes_t when_to_stop = location->end();
+ framepos_t when_to_stop = location->end();
replace_event (SessionEvent::PunchIn, location->start());
//when_to_stop += _worst_output_latency + _worst_input_latency;
{
framepos_t ret;
framepos_t tf;
- nframes_t offset;
+ framecnt_t offset;
/* the first of these two possible settings for "offset"
mean that the audible frame is stationary until
}
void
-Session::set_frame_rate (nframes_t frames_per_second)
+Session::set_frame_rate (framecnt_t frames_per_second)
{
- /** \fn void Session::set_frame_size(nframes_t)
+ /** \fn void Session::set_frame_size(framecnt_t)
the AudioEngine object that calls this guarantees
that it will not be called while we are also in
::process(). Its fine to do things that block
sync_time_vars();
- Automatable::set_automation_interval ((jack_nframes_t) ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
+ Automatable::set_automation_interval (ceil ((double) frames_per_second * (0.001 * Config->get_automation_interval())));
clear_clicks ();
}
void
-Session::set_block_size (nframes_t nframes)
+Session::set_block_size (pframes_t nframes)
{
/* the AudioEngine guarantees
that it will not be called while we are also in
Session::set_default_fade (float /*steepness*/, float /*fade_msecs*/)
{
#if 0
- nframes_t fade_frames;
+ framecnt_t fade_frames;
/* Don't allow fade of less 1 frame */
} else {
- fade_frames = (nframes_t) floor (fade_msecs * _current_frame_rate * 0.001);
+ fade_frames = (framecnt_t) floor (fade_msecs * _current_frame_rate * 0.001);
}
/** Caller must not hold process lock */
RouteList
-Session::new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
+Session::new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many)
{
char bus_name[32];
uint32_t bus_id = 0;
bus->set_remote_control_id (control_id);
++control_id;
- if (aux) {
- bus->add_internal_return ();
- }
+ bus->add_internal_return ();
ret.push_back (bus);
}
picks up the configuration of the route. During session
loading this normally happens in a different way.
*/
+
+ Glib::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+
IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
change.after = route->input()->n_ports();
route->input()->changed (change, this);
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value (0.0);
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (0.0);
}
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value (1.0);
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value (1.0);
}
}
}
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<Send> s;
- /* only tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
- if ((s = (*i)->internal_send_for (dest)) != 0) {
- s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
- }
+ if ((s = (*i)->internal_send_for (dest)) != 0) {
+ s->amp()->gain_control()->set_value ((*i)->gain_control()->get_value());
}
}
}
+/** @param include_buses true to add sends to buses and tracks, false for just tracks */
void
-Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p)
+Session::globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool include_buses)
{
boost::shared_ptr<RouteList> r = routes.reader ();
boost::shared_ptr<RouteList> t (new RouteList);
- /* only send tracks */
-
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (boost::dynamic_pointer_cast<Track>(*i)) {
+ if (include_buses || boost::dynamic_pointer_cast<Track>(*i)) {
t->push_back (*i);
}
}
}
update_route_solo_state ();
- update_session_range_location_marker ();
// We need to disconnect the route's inputs and outputs
return boost::shared_ptr<Route> ((Route*) 0);
}
-/** If either end of the session range location marker lies inside the current
- * session extent, move it to the corresponding session extent.
+void
+Session::playlist_region_added (boost::weak_ptr<Region> w)
+{
+ boost::shared_ptr<Region> r = w.lock ();
+ if (!r) {
+ return;
+ }
+
+ /* These are the operations that are currently in progress... */
+ list<GQuark> curr = _current_trans_quarks;
+ curr.sort ();
+
+ /* ...and these are the operations during which we want to update
+ the session range location markers.
+ */
+ list<GQuark> ops;
+ ops.push_back (Operations::capture);
+ ops.push_back (Operations::paste);
+ ops.push_back (Operations::duplicate_region);
+ ops.push_back (Operations::insert_file);
+ ops.push_back (Operations::insert_region);
+ ops.push_back (Operations::drag_region_brush);
+ ops.push_back (Operations::region_drag);
+ ops.push_back (Operations::selection_grab);
+ ops.push_back (Operations::region_fill);
+ ops.push_back (Operations::fill_selection);
+ ops.push_back (Operations::create_region);
+ ops.sort ();
+
+ /* See if any of the current operations match the ones that we want */
+ list<GQuark> in;
+ set_intersection (_current_trans_quarks.begin(), _current_trans_quarks.end(), ops.begin(), ops.end(), back_inserter (in));
+
+ /* If so, update the session range markers */
+ if (!in.empty ()) {
+ maybe_update_session_range (r->position (), r->last_frame ());
+ }
+}
+
+/** Update the session range markers if a is before the current start or
+ * b is after the current end.
*/
void
-Session::update_session_range_location_marker ()
+Session::maybe_update_session_range (framepos_t a, framepos_t b)
{
if (_state_of_the_state & Loading) {
return;
}
- pair<framepos_t, framepos_t> const ext = get_extent ();
-
if (_session_range_location == 0) {
- /* we don't have a session range yet; use this one (provided it is valid) */
- if (ext.first != max_framepos) {
- add_session_range_location (ext.first, ext.second);
- }
+
+ add_session_range_location (a, b);
+
} else {
- /* update the existing session range */
- if (ext.first < _session_range_location->start()) {
- _session_range_location->set_start (ext.first);
- set_dirty ();
- }
- if (ext.second > _session_range_location->end()) {
- _session_range_location->set_end (ext.second);
- set_dirty ();
+ if (a < _session_range_location->start()) {
+ _session_range_location->set_start (a);
}
+ if (b > _session_range_location->end()) {
+ _session_range_location->set_end (b);
+ }
}
}
-/** @return Extent of the session's contents; if the session is empty, the first value of
- * the pair will equal max_framepos.
- */
-pair<framepos_t, framepos_t>
-Session::get_extent () const
+void
+Session::playlist_ranges_moved (list<Evoral::RangeMove<framepos_t> > const & ranges)
{
- pair<framepos_t, framepos_t> ext (max_framepos, 0);
-
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (!tr || tr->destructive()) {
- // ignore tape tracks when getting extents
- continue;
- }
-
- pair<framepos_t, framepos_t> e = tr->playlist()->get_extent ();
- if (e.first < ext.first) {
- ext.first = e.first;
- }
- if (e.second > ext.second) {
- ext.second = e.second;
- }
+ for (list<Evoral::RangeMove<framepos_t> >::const_iterator i = ranges.begin(); i != ranges.end(); ++i) {
+ maybe_update_session_range (i->to, i->to + i->length);
}
-
- return ext;
}
/* Region management */
boost::shared_ptr<AudioFileSource> fsource;
uint32_t x;
char buf[PATH_MAX+1];
- ChanCount nchans(track.n_channels());
+ ChanCount diskstream_channels (track.n_channels());
framepos_t position;
framecnt_t this_chunk;
framepos_t to_do;
framepos_t len = end - start;
bool need_block_size_reset = false;
string ext;
+ ChanCount const max_proc = track.max_processor_streams ();
if (end <= start) {
error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
- for (uint32_t chan_n=0; chan_n < nchans.n_audio(); ++chan_n) {
+ for (uint32_t chan_n = 0; chan_n < diskstream_channels.n_audio(); ++chan_n) {
for (x = 0; x < 99999; ++x) {
snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 "%s", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1, ext.c_str());
to_do = len;
/* create a set of reasonably-sized buffers */
- buffers.ensure_buffers(DataType::AUDIO, nchans.n_audio(), chunk_size);
- buffers.set_count(nchans);
+ buffers.ensure_buffers (DataType::AUDIO, max_proc.n_audio(), chunk_size);
+ buffers.set_count (max_proc);
- for (vector<boost::shared_ptr<Source> >::iterator src=srcs.begin(); src != srcs.end(); ++src) {
+ for (vector<boost::shared_ptr<Source> >::iterator src = srcs.begin(); src != srcs.end(); ++src) {
boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(*src);
if (afs)
afs->prepare_for_peakfile_writes ();
}
void
-Session::add_session_range_location (nframes_t start, nframes_t end)
+Session::add_session_range_location (framepos_t start, framepos_t end)
{
_session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
_locations->add (_session_range_location);
/* Update the auto loop range to match the session range
(unless the auto loop range has been changed by the user)
*/
-
+
Location* s = _locations->session_range_location ();
+ if (s == 0) {
+ return;
+ }
+
Location* l = _locations->auto_loop_location ();
if (l->start() == old) {
*/
Location* s = _locations->session_range_location ();
+ if (s == 0) {
+ return;
+ }
+
Location* l = _locations->auto_loop_location ();
if (l->end() == old) {
Speakers&
Session::get_speakers()
{
- if (!_speakers) {
- _speakers = new Speakers;
- }
-
return *_speakers;
}