*/
-#define __STDC_LIMIT_MACROS
#include <stdint.h>
#include <algorithm>
#include <glibmm/miscutils.h>
#include <glibmm/fileutils.h>
+#include <boost/algorithm/string/erase.hpp>
+
#include "pbd/error.h"
#include "pbd/boost_debug.h"
#include "pbd/pathscanner.h"
PBD::Signal0<void> Session::SendFeedback;
PBD::Signal0<void> Session::TimecodeOffsetChanged;
-PBD::Signal0<void> Session::StartTimeChanged;
-PBD::Signal0<void> Session::EndTimeChanged;
+PBD::Signal1<void, framepos_t> Session::StartTimeChanged;
+PBD::Signal1<void, framepos_t> Session::EndTimeChanged;
PBD::Signal0<void> Session::AutoBindingOn;
PBD::Signal0<void> Session::AutoBindingOff;
PBD::Signal2<void,std::string, std::string> Session::Exported;
PBD::Signal1<int,boost::shared_ptr<Playlist> > Session::AskAboutPlaylistDeletion;
+PBD::Signal0<void> Session::Quit;
static void clean_up_session_event (SessionEvent* ev) { delete ev; }
const SessionEvent::RTeventCallback Session::rt_cleanup (clean_up_session_event);
BusProfile* bus_profile,
string mix_template)
- : _engine (eng),
- _target_transport_speed (0.0),
- _requested_return_frame (-1),
- _session_dir (new SessionDirectory(fullpath)),
- state_tree (0),
- _butler (new Butler (*this)),
- _post_transport_work (0),
- _send_timecode_update (false),
- route_graph (new Graph(*this)),
- routes (new RouteList),
- _total_free_4k_blocks (0),
- _bundles (new BundleList),
- _bundle_xml_node (0),
- _click_io ((IO*) 0),
- click_data (0),
- click_emphasis_data (0),
- main_outs (0),
- _metadata (new SessionMetadata()),
- _have_rec_enabled_track (false)
-
-{
+ : _engine (eng)
+ , _target_transport_speed (0.0)
+ , _requested_return_frame (-1)
+ , _session_dir (new SessionDirectory(fullpath))
+ , state_tree (0)
+ , _state_of_the_state (Clean)
+ , _butler (new Butler (*this))
+ , _post_transport_work (0)
+ , _send_timecode_update (false)
+ , _all_route_group (new RouteGroup (*this, "all"))
+ , route_graph (new Graph(*this))
+ , routes (new RouteList)
+ , _total_free_4k_blocks (0)
+ , _bundles (new BundleList)
+ , _bundle_xml_node (0)
+ , _click_io ((IO*) 0)
+ , click_data (0)
+ , click_emphasis_data (0)
+ , main_outs (0)
+ , _metadata (new SessionMetadata())
+ , _have_rec_enabled_track (false)
+ , _suspend_timecode_transmission (0)
+{
+ _locations = new Locations (*this);
+
playlists.reset (new SessionPlaylists);
-
+
+ _all_route_group->set_active (true, this);
+
interpolation.add_channel_to (0, 0);
if (!eng.connected()) {
throw failed_constructor();
}
- n_physical_outputs = _engine.n_physical_outputs(DataType::AUDIO);
- n_physical_inputs = _engine.n_physical_inputs(DataType::AUDIO);
+ n_physical_outputs = _engine.n_physical_outputs ();
+ n_physical_inputs = _engine.n_physical_inputs ();
first_stage_init (fullpath, snapshot_name);
DirtyChanged (); /* EMIT SIGNAL */
}
+ StartTimeChanged.connect_same_thread (*this, boost::bind (&Session::start_time_changed, this, _1));
+ EndTimeChanged.connect_same_thread (*this, boost::bind (&Session::end_time_changed, this, _1));
+
_is_new = false;
}
delete state_tree;
+ /* remove all stubfiles that might still be lurking */
+
+ cleanup_stubfiles ();
+
/* reset dynamic state version back to default */
Stateful::loading_state_version = 0;
_butler->drop_references ();
delete _butler;
delete midi_control_ui;
+ delete _all_route_group;
if (click_data != default_click) {
delete [] click_data;
boost_debug_list_ptrs ();
+ delete _locations;
+
DEBUG_TRACE (DEBUG::Destruction, "Session::destroy() done\n");
}
/* default state for Click: dual-mono to first 2 physical outputs */
- for (int physport = 0; physport < 2; ++physport) {
- string physical_output = _engine.get_nth_physical_output (DataType::AUDIO, physport);
-
- if (physical_output.length()) {
- if (_click_io->add_port (physical_output, this)) {
- // relax, even though its an error
- }
- }
- }
+ vector<string> outs;
+ _engine.get_physical_outputs (DataType::AUDIO, outs);
- if (_click_io->n_ports () > ChanCount::ZERO) {
- _clicking = Config->get_clicking ();
- }
+ for (uint32_t physport = 0; physport < 2; ++physport) {
+ if (outs.size() > physport) {
+ if (_click_io->add_port (outs[physport], this)) {
+ // relax, even though its an error
+ }
+ }
+ }
+
+ if (_click_io->n_ports () > ChanCount::ZERO) {
+ _clicking = Config->get_clicking ();
+ }
}
}
-
+
catch (failed_constructor& err) {
error << _("cannot setup Click I/O") << endmsg;
}
BootMessage (_("Set up standard connections"));
+ vector<string> inputs[DataType::num_types];
+ vector<string> outputs[DataType::num_types];
+ for (uint32_t i = 0; i < DataType::num_types; ++i) {
+ _engine.get_physical_inputs (DataType (DataType::Symbol (i)), inputs[i]);
+ _engine.get_physical_outputs (DataType (DataType::Symbol (i)), outputs[i]);
+ }
+
/* Create a set of Bundle objects that map
to the physical I/O currently available. We create both
mono and stereo bundles, so that the common cases of mono
/* mono output bundles */
- for (uint32_t np = 0; np < n_physical_outputs; ++np) {
+ for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); ++np) {
char buf[32];
snprintf (buf, sizeof (buf), _("out %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("mono"), DataType::AUDIO);
- c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+ c->set_port (0, outputs[DataType::AUDIO][np]);
add_bundle (c);
}
/* stereo output bundles */
- for (uint32_t np = 0; np < n_physical_outputs; np += 2) {
- if (np + 1 < n_physical_outputs) {
+ for (uint32_t np = 0; np < outputs[DataType::AUDIO].size(); np += 2) {
+ if (np + 1 < outputs[DataType::AUDIO].size()) {
char buf[32];
snprintf (buf, sizeof(buf), _("out %" PRIu32 "+%" PRIu32), np + 1, np + 2);
shared_ptr<Bundle> c (new Bundle (buf, true));
c->add_channel (_("L"), DataType::AUDIO);
- c->set_port (0, _engine.get_nth_physical_output (DataType::AUDIO, np));
+ c->set_port (0, outputs[DataType::AUDIO][np]);
c->add_channel (_("R"), DataType::AUDIO);
- c->set_port (1, _engine.get_nth_physical_output (DataType::AUDIO, np + 1));
+ c->set_port (1, outputs[DataType::AUDIO][np + 1]);
add_bundle (c);
}
/* mono input bundles */
- for (uint32_t np = 0; np < n_physical_inputs; ++np) {
+ for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); ++np) {
char buf[32];
snprintf (buf, sizeof (buf), _("in %" PRIu32), np+1);
shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("mono"), DataType::AUDIO);
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ c->set_port (0, inputs[DataType::AUDIO][np]);
add_bundle (c);
}
/* stereo input bundles */
- for (uint32_t np = 0; np < n_physical_inputs; np += 2) {
- if (np + 1 < n_physical_inputs) {
+ for (uint32_t np = 0; np < inputs[DataType::AUDIO].size(); np += 2) {
+ if (np + 1 < inputs[DataType::AUDIO].size()) {
char buf[32];
snprintf (buf, sizeof(buf), _("in %" PRIu32 "+%" PRIu32), np + 1, np + 2);
shared_ptr<Bundle> c (new Bundle (buf, false));
c->add_channel (_("L"), DataType::AUDIO);
- c->set_port (0, _engine.get_nth_physical_input (DataType::AUDIO, np));
+ c->set_port (0, inputs[DataType::AUDIO][np]);
c->add_channel (_("R"), DataType::AUDIO);
- c->set_port (1, _engine.get_nth_physical_input (DataType::AUDIO, np + 1));
+ c->set_port (1, inputs[DataType::AUDIO][np + 1]);
add_bundle (c);
}
}
+ /* MIDI input bundles */
+
+ for (uint32_t np = 0; np < inputs[DataType::MIDI].size(); ++np) {
+ string n = inputs[DataType::MIDI][np];
+ boost::erase_first (n, X_("alsa_pcm:"));
+
+ shared_ptr<Bundle> c (new Bundle (n, false));
+ c->add_channel ("", DataType::MIDI);
+ c->set_port (0, inputs[DataType::MIDI][np]);
+ add_bundle (c);
+ }
+
+ /* MIDI output bundles */
+
+ for (uint32_t np = 0; np < outputs[DataType::MIDI].size(); ++np) {
+ string n = outputs[DataType::MIDI][np];
+ boost::erase_first (n, X_("alsa_pcm:"));
+
+ shared_ptr<Bundle> c (new Bundle (n, true));
+ c->add_channel ("", DataType::MIDI);
+ c->set_port (0, outputs[DataType::MIDI][np]);
+ add_bundle (c);
+ }
+
BootMessage (_("Setup signal flow and plugins"));
hookup_io ();
for (uint32_t n = 0; n < limit; ++n) {
Port* p = _master_out->output()->nth (n);
- string connect_to = _engine.get_nth_physical_output (DataType (p->type()), n);
+ string connect_to;
+ if (outputs[p->type()].size() > n) {
+ connect_to = outputs[p->type()][n];
+ }
if (!connect_to.empty() && p->connected_to (connect_to) == false) {
if (_master_out->output()->connect (p, connect_to, this)) {
} else {
for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
- uint32_t mod = _engine.n_physical_outputs (*t);
+ uint32_t mod = n_physical_outputs.get (*t);
uint32_t limit = _monitor_out->n_outputs().get(*t);
for (uint32_t n = 0; n < limit; ++n) {
Port* p = _monitor_out->output()->ports().port(*t, n);
- string connect_to = _engine.get_nth_physical_output (*t, (n % mod));
+ string connect_to;
+ if (outputs[*t].size() > (n % mod)) {
+ connect_to = outputs[*t][n % mod];
+ }
if (!connect_to.empty()) {
if (_monitor_out->output()->connect (p, connect_to, this)) {
{
Location* existing;
- if ((existing = _locations.auto_punch_location()) != 0 && existing != location) {
+ if ((existing = _locations->auto_punch_location()) != 0 && existing != location) {
punch_connections.drop_connections();
existing->set_auto_punch (false, this);
remove_event (existing->start(), SessionEvent::PunchIn);
{
Location* existing;
- if ((existing = _locations.auto_loop_location()) != 0 && existing != location) {
+ if ((existing = _locations->auto_loop_location()) != 0 && existing != location) {
loop_connections.drop_connections ();
existing->set_auto_loop (false, this);
remove_event (existing->end(), SessionEvent::AutoLoop);
void
Session::locations_changed ()
{
- _locations.apply (*this, &Session::handle_locations_changed);
+ _locations->apply (*this, &Session::handle_locations_changed);
}
void
void
Session::maybe_enable_record ()
{
+ if (_step_editors > 0) {
+ return;
+ }
+
g_atomic_int_set (&_record_status, Enabled);
- /* this function is currently called from somewhere other than an RT thread.
- this save_state() call therefore doesn't impact anything.
+ /* This function is currently called from somewhere other than an RT thread.
+ This save_state() call therefore doesn't impact anything. Doing it here
+ means that we save pending state of which sources the next record will use,
+ which gives us some chance of recovering from a crash during the record.
*/
-
+
save_state ("", true);
-
+
if (_transport_speed) {
if (!config.get_punch_in()) {
enable_record ();
set_dirty();
}
-nframes64_t
+framepos_t
Session::audible_frame () const
{
- nframes64_t ret;
- nframes64_t tf;
+ framepos_t ret;
+ framepos_t tf;
nframes_t offset;
/* the first of these two possible settings for "offset"
return false;
}
+/** Count the total ins and outs of all non-hidden routes in the session and return them in in and out */
void
Session::count_existing_route_channels (ChanCount& in, ChanCount& out)
{
shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->is_hidden()) {
- in += (*i)->n_inputs();
- out += (*i)->n_outputs();
+ in += (*i)->n_inputs();
+ out += (*i)->n_outputs();
}
}
}
goto failed;
}
- auto_connect_route (track, existing_inputs, existing_outputs);
+ auto_connect_route (track.get(), existing_inputs, existing_outputs);
track->non_realtime_input_change();
return ret;
}
+/** @param connect_inputs true to connect inputs as well as outputs, false to connect just outputs.
+ * @param input_start Where to start from when auto-connecting inputs; e.g. if this is 0, auto-connect starting from input 0.
+ * @param output_start As \a input_start, but for outputs.
+ */
void
-Session::auto_connect_route (boost::shared_ptr<Route> route,
- ChanCount& existing_inputs, ChanCount& existing_outputs)
+Session::auto_connect_route (
+ Route* route, ChanCount& existing_inputs, ChanCount& existing_outputs, bool connect_inputs, ChanCount input_start, ChanCount output_start
+ )
{
/* If both inputs and outputs are auto-connected to physical ports,
use the max of input and output offsets to ensure auto-connected
port number). Otherwise just use the lowest input or output
offset possible.
*/
+
const bool in_out_physical =
(Config->get_input_auto_connect() & AutoConnectPhysical)
- && (Config->get_output_auto_connect() & AutoConnectPhysical);
+ && (Config->get_output_auto_connect() & AutoConnectPhysical)
+ && connect_inputs;
const ChanCount in_offset = in_out_physical
? ChanCount::max(existing_inputs, existing_outputs)
_engine.get_physical_outputs (*t, physoutputs);
_engine.get_physical_inputs (*t, physinputs);
- if (!physinputs.empty()) {
+ if (!physinputs.empty() && connect_inputs) {
uint32_t nphysical_in = physinputs.size();
- for (uint32_t i = 0; i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
+ for (uint32_t i = input_start.get(*t); i < route->n_inputs().get(*t) && i < nphysical_in; ++i) {
string port;
if (Config->get_input_auto_connect() & AutoConnectPhysical) {
if (!physoutputs.empty()) {
uint32_t nphysical_out = physoutputs.size();
- for (uint32_t i = 0; i < route->n_outputs().get(*t); ++i) {
+ for (uint32_t i = output_start.get(*t); i < route->n_outputs().get(*t); ++i) {
string port;
if (Config->get_output_auto_connect() & AutoConnectPhysical) {
goto failed;
}
- auto_connect_route (track, existing_inputs, existing_outputs);
+ auto_connect_route (track.get(), existing_inputs, existing_outputs);
if (route_group) {
route_group->add (track);
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (MixerOrdered == m) {
- long order = (*i)->order_key(N_("signal"));
+ int32_t order = (*i)->order_key(N_("signal"));
(*i)->set_remote_control_id (order+1, false);
emit_signal = true;
} else if (EditorOrdered == m) {
- long order = (*i)->order_key(N_("editor"));
+ int32_t order = (*i)->order_key(N_("editor"));
(*i)->set_remote_control_id (order+1, false);
emit_signal = true;
} else if (UserOrdered == m) {
goto failure;
}
- auto_connect_route (bus, existing_inputs, existing_outputs);
+ auto_connect_route (bus.get(), existing_inputs, existing_outputs, false);
if (route_group) {
route_group->add (bus);
picks up the configuration of the route. During session
loading this normally happens in a different way.
*/
- route->input()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
- route->output()->changed (IOChange (ConfigurationChanged|ConnectionsChanged), this);
+ IOChange change (IOChange::Type (IOChange::ConfigurationChanged | IOChange::ConnectionsChanged));
+ change.after = route->input()->n_ports();
+ route->input()->changed (change, this);
+ change.after = route->output()->n_ports();
+ route->output()->changed (change, this);
}
route->set_remote_control_id (control_id);
r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
+ r->order_key_changed.connect_same_thread (*this, boost::bind (&Session::route_order_key_changed, this));
if (r->is_master()) {
_master_out = r;
tr->PlaylistChanged.connect_same_thread (*this, boost::bind (&Session::track_playlist_changed, this, boost::weak_ptr<Track> (tr)));
track_playlist_changed (boost::weak_ptr<Track> (tr));
tr->RecordEnableChanged.connect_same_thread (*this, boost::bind (&Session::update_have_rec_enabled_track, this));
+
+ boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (tr);
+ if (mt) {
+ mt->StepEditStatusChange.connect_same_thread (*this, boost::bind (&Session::step_edit_status_change, this, _1));
+ }
}
}
return;
}
+ route->set_solo (false, this);
+
{
RCUWriter<RouteList> writer (routes);
shared_ptr<RouteList> rs = writer.get_copy ();
}
}
+ boost::shared_ptr<MidiTrack> mt = boost::dynamic_pointer_cast<MidiTrack> (route);
+ if (mt && mt->step_editing()) {
+ if (_step_editors > 0) {
+ _step_editors--;
+ }
+ }
+
update_latency_compensation (false, false);
set_dirty();
return;
}
- pair<nframes_t, nframes_t> const ext = get_extent ();
+ 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_frames) {
+ if (ext.first != max_framepos) {
add_session_range_location (ext.first, ext.second);
}
} else {
}
/** @return Extent of the session's contents; if the session is empty, the first value of
- * the pair will equal max_frames.
+ * the pair will equal max_framepos.
*/
-pair<nframes_t, nframes_t>
+pair<framepos_t, framepos_t>
Session::get_extent () const
{
- pair<nframes_t, nframes_t> ext (max_frames, 0);
+ 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) {
continue;
}
- pair<nframes_t, nframes_t> e = tr->playlist()->get_extent ();
+ pair<framepos_t, framepos_t> e = tr->playlist()->get_extent ();
if (e.first < ext.first) {
ext.first = e.first;
}
Glib::Mutex::Lock lm (source_lock);
if ((i = sources.find (source->id())) != sources.end()) {
+ cerr << "Removing source " << source->name() << endl;
sources.erase (i);
}
}
}
boost::shared_ptr<Source>
-Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
+Session::source_by_path_and_channel (const string& path, uint16_t chn)
{
Glib::Mutex::Lock lm (source_lock);
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
- cerr << "comparing " << path << " with " << i->second->name() << endl;
boost::shared_ptr<AudioFileSource> afs
= boost::dynamic_pointer_cast<AudioFileSource>(i->second);
the task here is to replace NAME with the new name.
*/
- /* find last slash */
-
string dir;
string prefix;
- string::size_type slash;
string::size_type dash;
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
+ dir = Glib::path_get_dirname (path);
+ path = Glib::path_get_basename (path);
/* '-' is not a legal character for the NAME part of the path */
return "";
}
- prefix = path.substr (slash+1, dash-(slash+1));
+ prefix = path.substr (0, dash);
- path = dir;
path += prefix;
path += '-';
path += new_legalized;
- path += ".wav"; /* XXX gag me with a spoon */
+ path += native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
+
+ path = Glib::build_filename (dir, path);
} else {
string dir;
string suffix;
- string::size_type slash;
string::size_type dash;
string::size_type postfix;
- /* find last slash */
-
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
+ dir = Glib::path_get_dirname (path);
+ path = Glib::path_get_basename (path);
/* '-' is not a legal character for the NAME part of the path */
for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
- snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
+ snprintf (buf, sizeof(buf), "%s-%u%s", newname.c_str(), cnt, suffix.c_str());
- if (access (buf, F_OK) != 0) {
- path = buf;
+ if (!matching_unsuffixed_filename_exists_in (dir, buf)) {
+ path = Glib::build_filename (dir, buf);
break;
}
+
path = "";
}
- if (path == "") {
- error << "FATAL ERROR! Could not find a " << endl;
+ if (path.empty()) {
+ fatal << string_compose (_("FATAL ERROR! Could not find a suitable version of %1 for a rename"),
+ newname) << endl;
+ /*NOTREACHED*/
}
-
}
return path;
* (e.g. as returned by new_*_source_name)
*/
string
-Session::new_source_path_from_name (DataType type, const string& name)
+Session::new_source_path_from_name (DataType type, const string& name, bool as_stub)
{
assert(name.find("/") == string::npos);
sys::path p;
if (type == DataType::AUDIO) {
- p = sdir.sound_path();
+ p = (as_stub ? sdir.sound_stub_path() : sdir.sound_path());
} else if (type == DataType::MIDI) {
- p = sdir.midi_path();
+ p = (as_stub ? sdir.midi_stub_path() : sdir.midi_path());
} else {
error << "Unknown source type, unable to create file path" << endmsg;
return "";
return p.to_string();
}
-Glib::ustring
-Session::peak_path (Glib::ustring base) const
+string
+Session::peak_path (string base) const
{
sys::path peakfile_path(_session_dir->peak_path());
- peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
+ peakfile_path /= base + peakfile_suffix;
return peakfile_path.to_string();
}
string
Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
{
- string spath;
uint32_t cnt;
char buf[PATH_MAX+1];
const uint32_t limit = 10000;
string legalized;
+ string ext = native_header_format_extension (config.get_native_file_header_format(), DataType::AUDIO);
buf[0] = '\0';
legalized = legalize_for_path (base);
for (i = session_dirs.begin(); i != session_dirs.end(); ++i) {
- SessionDirectory sdir((*i).path);
-
- spath = sdir.sound_path().to_string();
-
if (destructive) {
if (nchan < 2) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
- spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "T%04d-%s%s",
+ cnt, legalized.c_str(), ext.c_str());
} else if (nchan == 2) {
if (chan == 0) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav",
- spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "T%04d-%s%%L%s",
+ cnt, legalized.c_str(), ext.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav",
- spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "T%04d-%s%%R%s",
+ cnt, legalized.c_str(), ext.c_str());
}
} else if (nchan < 26) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav",
- spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
+ snprintf (buf, sizeof(buf), "T%04d-%s%%%c%s",
+ cnt, legalized.c_str(), 'a' + chan, ext.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
- spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "T%04d-%s%s",
+ cnt, legalized.c_str(), ext.c_str());
}
} else {
- spath += '/';
- spath += legalized;
-
if (nchan < 2) {
- snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
} else if (nchan == 2) {
if (chan == 0) {
- snprintf (buf, sizeof(buf), "%s-%u%%L.wav", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u%%L%s", legalized.c_str(), cnt, ext.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s-%u%%R.wav", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u%%R%s", legalized.c_str(), cnt, ext.c_str());
}
} else if (nchan < 26) {
- snprintf (buf, sizeof(buf), "%s-%u%%%c.wav", spath.c_str(), cnt, 'a' + chan);
+ snprintf (buf, sizeof(buf), "%s-%u%%%c%s", legalized.c_str(), cnt, 'a' + chan, ext.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s-%u.wav", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u%s", legalized.c_str(), cnt, ext.c_str());
}
}
- if (sys::exists(buf)) {
- existing++;
- }
+ SessionDirectory sdir((*i).path);
+
+ string spath = sdir.sound_path().to_string();
+ string spath_stubs = sdir.sound_stub_path().to_string();
+
+ /* note that we search *without* the extension so that
+ we don't end up both "Audio 1-1.wav" and "Audio 1-1.caf"
+ in the event that this new name is required for
+ a file format change.
+ */
+ if (matching_unsuffixed_filename_exists_in (spath, buf) ||
+ matching_unsuffixed_filename_exists_in (spath_stubs, buf)) {
+ existing++;
+ break;
+ }
}
if (existing == 0) {
throw failed_constructor();
}
}
-
- return Glib::path_get_basename(buf);
+
+ return Glib::path_get_basename (buf);
}
/** Create a new within-session audio source */
boost::shared_ptr<AudioFileSource>
-Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive)
+Session::create_audio_source_for_session (size_t n_chans, string const & n, uint32_t chan, bool destructive, bool as_stub)
{
const string name = new_audio_source_name (n, n_chans, chan, destructive);
- const string path = new_source_path_from_name(DataType::AUDIO, name);
+ const string path = new_source_path_from_name(DataType::AUDIO, name, as_stub);
return boost::dynamic_pointer_cast<AudioFileSource> (
SourceFactory::createWritable (DataType::AUDIO, *this, path, destructive, frame_rate()));
/** Create a new within-session MIDI source */
boost::shared_ptr<MidiSource>
-Session::create_midi_source_for_session (Track* track, string const & n)
+Session::create_midi_source_for_session (Track* track, string const & n, bool as_stub)
{
/* try to use the existing write source for the track, to keep numbering sane
*/
}
const string name = new_midi_source_name (n);
- const string path = new_source_path_from_name (DataType::MIDI, name);
+ const string path = new_source_path_from_name (DataType::MIDI, name, as_stub);
return boost::dynamic_pointer_cast<SMFSource> (
SourceFactory::createWritable (
return a->order_key(N_("signal")) < b->order_key(N_("signal"));
}
-void
-Session::remove_empty_sounds ()
-{
- vector<string> audio_filenames;
-
- get_files_in_directory (_session_dir->sound_path(), audio_filenames);
-
- Glib::Mutex::Lock lm (source_lock);
-
- TapeFileMatcher tape_file_matcher;
-
- remove_if (audio_filenames.begin(), audio_filenames.end(),
- boost::bind (&TapeFileMatcher::matches, &tape_file_matcher, _1));
-
- for (vector<string>::iterator i = audio_filenames.begin(); i != audio_filenames.end(); ++i) {
-
- sys::path audio_file_path (_session_dir->sound_path());
-
- audio_file_path /= *i;
-
- if (AudioFileSource::is_empty (*this, audio_file_path.to_string())) {
-
- try
- {
- sys::remove (audio_file_path);
- const string peakfile = peak_path (audio_file_path.to_string());
- sys::remove (peakfile);
- }
- catch (const sys::filesystem_error& err)
- {
- error << err.what() << endmsg;
- }
- }
- }
-}
-
bool
Session::is_auditioning () const
{
}
}
-nframes_t
+framecnt_t
Session::available_capture_duration ()
{
float sample_bytes_on_disk = 4.0; // keep gcc happy
double scale = 4096.0 / sample_bytes_on_disk;
- if (_total_free_4k_blocks * scale > (double) max_frames) {
- return max_frames;
+ if (_total_free_4k_blocks * scale > (double) max_framecnt) {
+ return max_framecnt;
}
-
- return (nframes_t) floor (_total_free_4k_blocks * scale);
+
+ return (framecnt_t) floor (_total_free_4k_blocks * scale);
}
void
playlists->update_after_tempo_map_change ();
+ _locations->apply (*this, &Session::update_locations_after_tempo_map_change);
+
set_dirty ();
}
+void
+Session::update_locations_after_tempo_map_change (Locations::LocationList& loc)
+{
+ for (Locations::LocationList::iterator i = loc.begin(); i != loc.end(); ++i) {
+ (*i)->recompute_frames_from_bbt ();
+ }
+}
+
/** Ensures that all buffers (scratch, send, silent, etc) are allocated for
* the given count with the current block size.
*/
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr) {
+ /* don't save state as we do this, there's no point
+ */
+
+ _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
tr->reset_write_sources (false);
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
}
}
}
}
boost::shared_ptr<Region>
-Session::write_one_track (AudioTrack& track, nframes_t start, nframes_t end,
+Session::write_one_track (AudioTrack& track, framepos_t start, framepos_t end,
bool /*overwrite*/, vector<boost::shared_ptr<Source> >& srcs,
InterThreadInfo& itt, bool enable_processing)
{
uint32_t x;
char buf[PATH_MAX+1];
ChanCount nchans(track.n_channels());
- nframes_t position;
- nframes_t this_chunk;
- nframes_t to_do;
+ framepos_t position;
+ framecnt_t this_chunk;
+ framepos_t to_do;
BufferSet buffers;
SessionDirectory sdir(get_best_session_directory_for_new_source ());
const string sound_dir = sdir.sound_path().to_string();
- nframes_t len = end - start;
+ framepos_t len = end - start;
+ bool need_block_size_reset = false;
+ string ext;
if (end <= start) {
error << string_compose (_("Cannot write a range where end <= start (e.g. %1 <= %2)"),
return result;
}
- const nframes_t chunk_size = (256 * 1024)/4;
+ const framecnt_t chunk_size = (256 * 1024)/4;
// block all process callback handling
goto out;
}
+ 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 (x = 0; x < 99999; ++x) {
- snprintf (buf, sizeof(buf), "%s/%s-%d-bounce-%" PRIu32 ".wav", sound_dir.c_str(), playlist->name().c_str(), chan_n, x+1);
+ 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());
if (access (buf, F_OK) != 0) {
break;
}
srcs.push_back (fsource);
}
+ /* tell redirects that care that we are about to use a much larger blocksize */
+
+ need_block_size_reset = true;
+ track.set_block_size (chunk_size);
+
/* XXX need to flush all redirects */
position = start;
}
}
+
+ if (need_block_size_reset) {
+ track.set_block_size (get_block_size());
+ }
+
unblock_processing ();
return result;
}
boost::shared_ptr<RouteList>
-Session::get_routes_with_regions_at (nframes64_t const p) const
+Session::get_routes_with_regions_at (framepos_t const p) const
{
shared_ptr<RouteList> r = routes.reader ();
shared_ptr<RouteList> rl (new RouteList);
}
}
+framepos_t
+Session::current_start_frame () const
+{
+ return _session_range_location ? _session_range_location->start() : 0;
+}
+
+framepos_t
+Session::current_end_frame () const
+{
+ return _session_range_location ? _session_range_location->end() : 0;
+}
+
void
-Session::set_session_start (nframes_t start)
+Session::add_session_range_location (nframes_t start, nframes_t end)
{
- if (_session_range_location) {
- _session_range_location->set_start (start);
- } else {
- add_session_range_location (start, start);
- }
+ _session_range_location = new Location (*this, start, end, _("session"), Location::IsSessionRange);
+ _locations->add (_session_range_location);
}
-
+
+/** Called when one of our routes' order keys has changed */
void
-Session::set_session_end (nframes_t end)
+Session::route_order_key_changed ()
{
- if (_session_range_location) {
- _session_range_location->set_end (end);
- } else {
- add_session_range_location (end, end);
- }
+ RouteOrderKeyChanged (); /* EMIT SIGNAL */
}
-nframes_t
-Session::current_start_frame () const
+void
+Session::step_edit_status_change (bool yn)
{
- return _session_range_location ? _session_range_location->start() : 0;
+ bool send = false;
+
+ bool val = false;
+ if (yn) {
+ send = (_step_editors == 0);
+ val = true;
+
+ _step_editors++;
+ } else {
+ send = (_step_editors == 1);
+ val = false;
+
+ if (_step_editors > 0) {
+ _step_editors--;
+ }
+ }
+
+ if (send) {
+ StepEditStatusChange (val);
+ }
}
-nframes_t
-Session::current_end_frame () const
+
+void
+Session::start_time_changed (framepos_t old)
{
- return _session_range_location ? _session_range_location->end() : 0;
+ /* 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 ();
+ Location* l = _locations->auto_loop_location ();
+
+ if (l->start() == old) {
+ l->set_start (s->start(), true);
+ }
}
void
-Session::add_session_range_location (nframes_t start, nframes_t end)
+Session::end_time_changed (framepos_t old)
{
- _session_range_location = new Location (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 ();
+ Location* l = _locations->auto_loop_location ();
+
+ if (l->end() == old) {
+ l->set_end (s->end(), true);
+ }
}
projects / ardour.git / blobdiff