2008-06-02 17:41:35 -04:00
|
|
|
/*
|
2015-02-05 16:21:01 -05:00
|
|
|
Copyright (C) 2000 Paul Davis
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __ardour_session_h__
|
|
|
|
#define __ardour_session_h__
|
|
|
|
|
2011-03-10 21:55:52 -05:00
|
|
|
#include "libardour-config.h"
|
|
|
|
|
2015-09-05 07:16:26 -04:00
|
|
|
#include <exception>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <list>
|
|
|
|
#include <map>
|
|
|
|
#include <set>
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
2016-04-23 16:11:48 -04:00
|
|
|
#include <queue>
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <stdint.h>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <boost/dynamic_bitset.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
|
|
#include <boost/weak_ptr.hpp>
|
2009-02-16 22:49:32 -05:00
|
|
|
#include <boost/utility.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2012-07-25 13:48:55 -04:00
|
|
|
#include <glibmm/threads.h>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2014-01-14 12:22:18 -05:00
|
|
|
#include <ltc.h>
|
2013-10-26 10:58:14 -04:00
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
2011-10-20 14:50:29 -04:00
|
|
|
#include "pbd/event_loop.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/rcu.h"
|
2016-02-23 09:41:21 -05:00
|
|
|
#include "pbd/reallocpool.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/statefuldestructible.h"
|
2009-12-19 15:26:31 -05:00
|
|
|
#include "pbd/signals.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/undo.h"
|
|
|
|
|
2016-02-23 09:41:21 -05:00
|
|
|
#include "lua/luastate.h"
|
|
|
|
|
2015-10-05 13:58:35 -04:00
|
|
|
#include "evoral/Range.hpp"
|
2011-10-18 23:34:02 -04:00
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "midi++/types.h"
|
2014-10-22 17:06:53 -04:00
|
|
|
#include "midi++/mmc.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
|
2010-12-14 13:13:37 -05:00
|
|
|
#include "timecode/time.h"
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/chan_count.h"
|
2012-01-18 12:51:57 -05:00
|
|
|
#include "ardour/delivery.h"
|
2012-03-15 17:40:17 -04:00
|
|
|
#include "ardour/interthread_info.h"
|
2016-02-23 09:41:21 -05:00
|
|
|
#include "ardour/luascripting.h"
|
2016-01-08 08:20:58 -05:00
|
|
|
#include "ardour/location.h"
|
|
|
|
#include "ardour/monitor_processor.h"
|
2016-05-16 07:30:28 -04:00
|
|
|
#include "ardour/presentation_info.h"
|
2009-05-13 20:13:27 -04:00
|
|
|
#include "ardour/rc_configuration.h"
|
|
|
|
#include "ardour/session_configuration.h"
|
2009-12-03 21:15:12 -05:00
|
|
|
#include "ardour/session_event.h"
|
2009-06-09 20:03:47 -04:00
|
|
|
#include "ardour/interpolation.h"
|
2016-05-06 10:02:04 -04:00
|
|
|
#include "ardour/plugin.h"
|
2016-05-16 07:30:28 -04:00
|
|
|
#include "ardour/presentation_info.h"
|
2016-01-08 08:20:58 -05:00
|
|
|
#include "ardour/route.h"
|
2011-11-09 12:44:39 -05:00
|
|
|
#include "ardour/route_graph.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2012-10-21 10:07:10 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
class XMLTree;
|
|
|
|
class XMLNode;
|
2011-11-21 20:28:27 -05:00
|
|
|
struct _AEffect;
|
|
|
|
typedef struct _AEffect AEffect;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
namespace MIDI {
|
2015-02-05 16:21:01 -05:00
|
|
|
class Port;
|
|
|
|
class MachineControl;
|
|
|
|
class Parser;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace PBD {
|
2015-02-05 16:21:01 -05:00
|
|
|
class Controllable;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2016-02-23 09:41:21 -05:00
|
|
|
namespace luabridge {
|
|
|
|
class LuaRef;
|
|
|
|
}
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
namespace Evoral {
|
2015-02-05 16:21:01 -05:00
|
|
|
class Curve;
|
2009-01-30 15:18:31 -05:00
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
namespace ARDOUR {
|
|
|
|
|
2012-01-27 17:47:16 -05:00
|
|
|
class Amp;
|
2008-06-02 17:41:35 -04:00
|
|
|
class AudioEngine;
|
2009-01-30 15:18:31 -05:00
|
|
|
class AudioFileSource;
|
|
|
|
class AudioRegion;
|
2008-06-02 17:41:35 -04:00
|
|
|
class AudioSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class AudioTrack;
|
|
|
|
class Auditioner;
|
|
|
|
class AutomationList;
|
|
|
|
class AuxInput;
|
2008-06-02 17:41:35 -04:00
|
|
|
class BufferSet;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Bundle;
|
2009-10-30 11:30:22 -04:00
|
|
|
class Butler;
|
2011-10-18 23:34:02 -04:00
|
|
|
class Click;
|
2016-05-16 11:08:32 -04:00
|
|
|
class ControllableDescriptor;
|
2008-06-02 17:41:35 -04:00
|
|
|
class Diskstream;
|
2009-01-30 15:18:31 -05:00
|
|
|
class ExportHandler;
|
|
|
|
class ExportStatus;
|
2011-10-18 23:34:02 -04:00
|
|
|
class Graph;
|
2009-01-30 15:18:31 -05:00
|
|
|
class IO;
|
|
|
|
class IOProcessor;
|
2009-10-30 11:30:22 -04:00
|
|
|
class ImportStatus;
|
2012-01-27 08:22:55 -05:00
|
|
|
class MidiClockTicker;
|
2011-10-18 23:34:02 -04:00
|
|
|
class MidiControlUI;
|
2013-09-05 13:22:34 -04:00
|
|
|
class MidiPortManager;
|
|
|
|
class MidiPort;
|
2009-01-30 15:18:31 -05:00
|
|
|
class MidiRegion;
|
2008-06-02 17:41:35 -04:00
|
|
|
class MidiSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class MidiTrack;
|
2008-06-02 17:41:35 -04:00
|
|
|
class Playlist;
|
2009-01-30 15:18:31 -05:00
|
|
|
class PluginInsert;
|
2012-02-01 23:12:23 -05:00
|
|
|
class PluginInfo;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Port;
|
|
|
|
class PortInsert;
|
2010-04-13 16:48:33 -04:00
|
|
|
class ProcessThread;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Processor;
|
|
|
|
class Region;
|
2009-05-07 13:31:18 -04:00
|
|
|
class Return;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Route;
|
|
|
|
class RouteGroup;
|
2008-06-02 17:41:35 -04:00
|
|
|
class SMFSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Send;
|
2014-04-28 19:58:24 -04:00
|
|
|
class SceneChanger;
|
2008-06-02 17:41:35 -04:00
|
|
|
class SessionDirectory;
|
2008-09-17 04:44:51 -04:00
|
|
|
class SessionMetadata;
|
2009-12-04 14:09:08 -05:00
|
|
|
class SessionPlaylists;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Slave;
|
|
|
|
class Source;
|
2010-11-26 12:43:03 -05:00
|
|
|
class Speakers;
|
2009-01-30 15:18:31 -05:00
|
|
|
class TempoMap;
|
2010-04-21 16:42:22 -04:00
|
|
|
class Track;
|
2016-01-26 00:18:03 -05:00
|
|
|
class VCAManager;
|
2011-11-21 12:42:29 -05:00
|
|
|
class WindowsVSTPlugin;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-30 11:12:13 -05:00
|
|
|
extern void setup_enum_writer ();
|
|
|
|
|
2015-09-05 07:16:26 -04:00
|
|
|
class LIBARDOUR_API SessionException: public std::exception {
|
|
|
|
public:
|
|
|
|
explicit SessionException(const std::string msg) : _message(msg) {}
|
|
|
|
virtual ~SessionException() throw() {}
|
|
|
|
|
|
|
|
virtual const char* what() const throw() { return _message.c_str(); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
std::string _message;
|
|
|
|
};
|
|
|
|
|
2016-03-30 19:10:51 -04:00
|
|
|
/** Ardour Session */
|
2016-03-11 10:34:51 -05:00
|
|
|
class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
public:
|
2010-11-25 17:12:03 -05:00
|
|
|
enum RecordState {
|
2008-06-02 17:41:35 -04:00
|
|
|
Disabled = 0,
|
|
|
|
Enabled = 1,
|
|
|
|
Recording = 2
|
|
|
|
};
|
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
/* a new session might have non-empty mix_template, an existing session should always have an empty one.
|
|
|
|
the bus profile can be null if no master out bus is required.
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
Session (AudioEngine&,
|
2010-11-25 17:12:03 -05:00
|
|
|
const std::string& fullpath,
|
|
|
|
const std::string& snapshot_name,
|
|
|
|
BusProfile* bus_profile = 0,
|
2011-12-26 19:57:20 -05:00
|
|
|
std::string mix_template = "");
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
virtual ~Session ();
|
2010-11-25 17:12:03 -05:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format);
|
2015-11-19 21:11:39 -05:00
|
|
|
static std::string get_snapshot_from_instant (const std::string& session_dir);
|
2013-09-23 21:35:51 -04:00
|
|
|
|
2016-04-12 07:49:50 -04:00
|
|
|
/** a monotonic counter used for naming user-visible things uniquely
|
|
|
|
* (curently the sidechain port).
|
|
|
|
* Use sparingly to keep the numbers low, prefer PBD::ID for all
|
|
|
|
* internal, not user-visible IDs */
|
|
|
|
static unsigned int next_name_id ();
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string path() const { return _path; }
|
|
|
|
std::string name() const { return _name; }
|
|
|
|
std::string snap_name() const { return _current_snapshot_name; }
|
|
|
|
std::string raid_path () const;
|
2009-11-30 08:16:38 -05:00
|
|
|
bool path_is_within_session (const std::string&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-13 16:43:28 -04:00
|
|
|
bool writable() const { return _writable; }
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_dirty ();
|
|
|
|
void set_clean ();
|
|
|
|
bool dirty() const { return _state_of_the_state & Dirty; }
|
|
|
|
void set_deletion_in_progress ();
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
void clear_deletion_in_progress ();
|
2015-05-19 09:29:39 -04:00
|
|
|
bool reconnection_in_progress() const { return _reconnecting_routes_in_progress; }
|
2008-06-02 17:41:35 -04:00
|
|
|
bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
|
2015-05-08 16:04:15 -04:00
|
|
|
bool routes_deletion_in_progress() const { return _route_deletion_in_progress; }
|
2015-09-15 08:41:27 -04:00
|
|
|
bool peaks_cleanup_in_progres() const { return _state_of_the_state & PeakCleanup; }
|
2016-04-13 17:41:39 -04:00
|
|
|
bool loading () const { return _state_of_the_state & Loading; }
|
2015-05-08 16:04:15 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> DirtyChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal1<void,std::string> Dialog;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2015-04-30 11:58:33 -04:00
|
|
|
PBD::Signal0<void> BatchUpdateStart;
|
|
|
|
PBD::Signal0<void> BatchUpdateEnd;
|
|
|
|
|
2011-05-13 15:55:39 -04:00
|
|
|
int ensure_subdirs ();
|
|
|
|
|
2012-01-27 20:45:15 -05:00
|
|
|
std::string automation_dir () const; ///< Automation data
|
|
|
|
std::string analysis_dir () const; ///< Analysis data
|
|
|
|
std::string plugins_dir () const; ///< Plugin state
|
|
|
|
std::string externals_dir () const; ///< Links to external files
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-09-10 10:39:35 -04:00
|
|
|
std::string construct_peak_filepath (const std::string& audio_path, const bool in_session = false, const bool old_peak_name = false) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-20 14:12:12 -05:00
|
|
|
bool audio_source_name_is_unique (const std::string& name);
|
2014-07-08 00:53:06 -04:00
|
|
|
std::string format_audio_source_name (const std::string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists);
|
|
|
|
std::string new_audio_source_path_for_embedded (const std::string& existing_path);
|
2014-06-02 11:20:37 -04:00
|
|
|
std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool destructive, bool take_required);
|
|
|
|
std::string new_midi_source_path (const std::string&);
|
2016-04-12 05:06:35 -04:00
|
|
|
/** create a new track or bus from a template (XML path)
|
|
|
|
* @param how_many how many tracks or busses to create
|
|
|
|
* @param template_path path to xml template file
|
|
|
|
* @param name name (prefix) of the route to create
|
|
|
|
* @param pd Playlist disposition
|
|
|
|
* @return list of newly created routes
|
|
|
|
*/
|
2015-11-13 16:14:09 -05:00
|
|
|
RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name, PlaylistDisposition pd = NewPlaylist);
|
|
|
|
RouteList new_route_from_template (uint32_t how_many, XMLNode&, const std::string& name, PlaylistDisposition pd = NewPlaylist);
|
2014-06-02 11:20:37 -04:00
|
|
|
std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path, uint32_t channels);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2014-07-08 00:53:06 -04:00
|
|
|
int bring_all_sources_into_session (boost::function<void(uint32_t,uint32_t,std::string)> callback);
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
void process (pframes_t nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO);
|
2016-03-25 19:40:51 -04:00
|
|
|
BufferSet& get_noinplace_buffers (ChanCount count = ChanCount::ZERO);
|
|
|
|
BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
|
2013-07-30 10:55:33 -04:00
|
|
|
BufferSet& get_route_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
|
2008-06-02 17:41:35 -04:00
|
|
|
BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
bool have_rec_enabled_track () const;
|
2015-05-08 13:46:42 -04:00
|
|
|
bool have_rec_disabled_track () const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
bool have_captured() const { return _have_captured; }
|
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
void refill_all_track_buffers ();
|
2009-10-23 20:39:28 -04:00
|
|
|
Butler* butler() { return _butler; }
|
|
|
|
void butler_transport_work ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
void refresh_disk_space ();
|
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
int load_diskstreams_2X (XMLNode const &, int);
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
int load_routes (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<RouteList> get_routes() const {
|
|
|
|
return routes.reader ();
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2016-05-16 16:43:00 -04:00
|
|
|
/* because the set of Stripables consists of objects managed
|
|
|
|
* independently, in multiple containers within the Session (or objects
|
|
|
|
* owned by the session), we fill out a list in-place rather than
|
|
|
|
* return a pointer to a copy of the (RCU) managed list, as happens
|
|
|
|
* with get_routes()
|
|
|
|
*/
|
|
|
|
|
|
|
|
void get_stripables (StripableList&) const;
|
2014-07-09 11:29:26 -04:00
|
|
|
boost::shared_ptr<RouteList> get_tracks() const;
|
2009-11-18 23:25:46 -05:00
|
|
|
boost::shared_ptr<RouteList> get_routes_with_internal_returns() const;
|
2010-09-17 14:20:37 -04:00
|
|
|
boost::shared_ptr<RouteList> get_routes_with_regions_at (framepos_t const) const;
|
2009-11-29 07:47:59 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t nroutes() const { return routes.reader()->size(); }
|
|
|
|
uint32_t ntracks () const;
|
|
|
|
uint32_t nbusses () const;
|
|
|
|
|
2009-01-25 01:47:11 -05:00
|
|
|
boost::shared_ptr<BundleList> bundles () {
|
|
|
|
return _bundles.reader ();
|
|
|
|
}
|
|
|
|
|
2014-01-14 05:13:12 -05:00
|
|
|
struct LIBARDOUR_API RoutePublicOrderSorter {
|
2009-10-14 12:10:01 -04:00
|
|
|
bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
void notify_presentation_info_change ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2015-04-02 14:51:23 -04:00
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(Route&), bool sort = true);
|
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>), bool sort = true);
|
|
|
|
template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg, bool sort = true);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-12-08 22:06:58 -05:00
|
|
|
static char session_name_is_legal (const std::string&);
|
2016-05-16 07:30:28 -04:00
|
|
|
bool io_name_is_legal (const std::string&) const;
|
|
|
|
boost::shared_ptr<Route> route_by_name (std::string) const;
|
|
|
|
boost::shared_ptr<Route> route_by_id (PBD::ID) const;
|
2016-05-17 15:26:35 -04:00
|
|
|
boost::shared_ptr<Stripable> get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag) const;
|
|
|
|
boost::shared_ptr<Route> get_remote_nth_route (PresentationInfo::order_t n) const;
|
2016-05-16 07:30:28 -04:00
|
|
|
boost::shared_ptr<Route> route_by_selected_count (uint32_t cnt) const;
|
|
|
|
boost::shared_ptr<Track> track_by_diskstream_id (PBD::ID) const;
|
2015-02-05 16:21:01 -05:00
|
|
|
void routes_using_input_from (const std::string& str, RouteList& rl);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
bool route_name_unique (std::string) const;
|
|
|
|
bool route_name_internal (std::string) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2014-06-25 15:16:09 -04:00
|
|
|
uint32_t track_number_decimals () const {
|
|
|
|
return _track_number_decimals;
|
|
|
|
}
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
bool get_record_enabled() const {
|
2008-06-02 17:41:35 -04:00
|
|
|
return (record_status () >= Enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
RecordState record_status() const {
|
|
|
|
return (RecordState) g_atomic_int_get (&_record_status);
|
|
|
|
}
|
|
|
|
|
2011-05-02 18:21:59 -04:00
|
|
|
bool actively_recording () const {
|
2008-06-02 17:41:35 -04:00
|
|
|
return record_status() == Recording;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool record_enabling_legal () const;
|
|
|
|
void maybe_enable_record ();
|
|
|
|
void disable_record (bool rt_context, bool force = false);
|
|
|
|
void step_back_from_record ();
|
2016-01-26 00:18:03 -05:00
|
|
|
|
2016-01-19 15:00:03 -05:00
|
|
|
void set_all_tracks_record_enabled(bool);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void maybe_write_autosave ();
|
|
|
|
|
|
|
|
/* Emitted when all i/o connections are complete */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> IOConnectionsComplete;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2015-05-12 12:17:17 -04:00
|
|
|
/* Timecode status signals */
|
|
|
|
PBD::Signal1<void, bool> MTCSyncStateChanged;
|
2015-10-05 10:17:49 -04:00
|
|
|
PBD::Signal1<void, bool> LTCSyncStateChanged;
|
2015-05-25 20:56:03 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Record status signals */
|
|
|
|
|
2015-05-08 16:26:52 -04:00
|
|
|
PBD::Signal0<void> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
|
|
|
|
/* XXX may 2015: paul says: it isn't clear to me that this has semantics that cannot be inferrred
|
|
|
|
from the previous signal and session state.
|
|
|
|
*/
|
|
|
|
PBD::Signal0<void> RecordArmStateChanged; /* signals changes in recording arming */
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-05-08 20:56:10 -04:00
|
|
|
/* Emited when session is loaded */
|
|
|
|
PBD::Signal0<void> SessionLoaded;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Transport mechanism signals */
|
|
|
|
|
2011-04-19 21:24:34 -04:00
|
|
|
/** Emitted on the following changes in transport state:
|
|
|
|
* - stop (from the butler thread)
|
|
|
|
* - change in whether or not we are looping (from the process thread)
|
|
|
|
* - change in the play range (from the process thread)
|
|
|
|
* - start (from the process thread)
|
|
|
|
* - engine halted
|
2015-02-05 16:21:01 -05:00
|
|
|
*/
|
2011-04-19 21:24:34 -04:00
|
|
|
PBD::Signal0<void> TransportStateChange;
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2010-09-17 14:20:37 -04:00
|
|
|
PBD::Signal1<void,framepos_t> PositionChanged; /* sent after any non-sequential motion */
|
|
|
|
PBD::Signal1<void,framepos_t> Xrun;
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> TransportLooped;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 19:12:22 -05:00
|
|
|
/** emitted when a locate has occurred */
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> Located;
|
2009-02-16 19:12:22 -05:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,RouteList&> RouteAdded;
|
2011-09-07 07:56:23 -04:00
|
|
|
/** Emitted when a property of one of our route groups changes.
|
|
|
|
* The parameter is the RouteGroup that has changed.
|
|
|
|
*/
|
2016-01-19 14:16:49 -05:00
|
|
|
PBD::Signal1<void, RouteGroup *> RouteGroupPropertyChanged;
|
2011-09-07 07:56:23 -04:00
|
|
|
/** Emitted when a route is added to one of our route groups.
|
|
|
|
* First parameter is the RouteGroup, second is the route.
|
|
|
|
*/
|
|
|
|
PBD::Signal2<void, RouteGroup *, boost::weak_ptr<Route> > RouteAddedToRouteGroup;
|
|
|
|
/** Emitted when a route is removed from one of our route groups.
|
|
|
|
* First parameter is the RouteGroup, second is the route.
|
|
|
|
*/
|
|
|
|
PBD::Signal2<void, RouteGroup *, boost::weak_ptr<Route> > RouteRemovedFromRouteGroup;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
/* Step Editing status changed */
|
|
|
|
PBD::Signal1<void,bool> StepEditStatusChange;
|
2010-07-24 12:40:56 -04:00
|
|
|
|
2015-05-12 12:17:17 -04:00
|
|
|
/* Timecode state signals */
|
|
|
|
PBD::Signal0<void> MtcOrLtcInputPortChanged;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-12-07 18:51:46 -05:00
|
|
|
void queue_event (SessionEvent*);
|
|
|
|
|
2010-12-02 14:25:53 -05:00
|
|
|
void request_roll_at_and_return (framepos_t start, framepos_t return_to);
|
|
|
|
void request_bounded_roll (framepos_t start, framepos_t end);
|
2009-11-08 11:28:21 -05:00
|
|
|
void request_stop (bool abort = false, bool clear_state = false);
|
2010-12-02 14:25:53 -05:00
|
|
|
void request_locate (framepos_t frame, bool with_roll = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-30 14:14:25 -04:00
|
|
|
void request_play_loop (bool yn, bool leave_rolling = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
bool get_play_loop () const { return play_loop; }
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t last_transport_start () const { return _last_roll_location; }
|
2010-05-09 16:48:21 -04:00
|
|
|
void goto_end ();
|
|
|
|
void goto_start ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void use_rf_shuttle_speed ();
|
|
|
|
void allow_auto_play (bool yn);
|
2015-12-13 12:16:57 -05:00
|
|
|
void request_transport_speed (double speed, bool as_default = true);
|
2015-12-13 12:32:55 -05:00
|
|
|
void request_transport_speed_nonzero (double, bool as_default = true);
|
2010-04-21 16:42:22 -04:00
|
|
|
void request_overwrite_buffer (Track *);
|
2010-06-09 13:24:07 -04:00
|
|
|
void adjust_playback_buffering();
|
|
|
|
void adjust_capture_buffering();
|
2010-04-21 16:42:22 -04:00
|
|
|
void request_track_speed (Track *, double speed);
|
2008-06-02 17:41:35 -04:00
|
|
|
void request_input_change_handling ();
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
bool locate_pending() const { return static_cast<bool>(post_transport_work()&PostTransportLocate); }
|
2008-06-02 17:41:35 -04:00
|
|
|
bool transport_locked () const;
|
|
|
|
|
|
|
|
int wipe ();
|
|
|
|
|
2010-09-17 12:24:22 -04:00
|
|
|
framepos_t current_end_frame () const;
|
|
|
|
framepos_t current_start_frame () const;
|
2010-12-03 17:26:29 -05:00
|
|
|
/** "actual" sample rate of session, set by current audioengine rate, pullup/down etc. */
|
|
|
|
framecnt_t frame_rate () const { return _current_frame_rate; }
|
|
|
|
/** "native" sample rate of session, regardless of current audioengine rate, pullup/down etc */
|
|
|
|
framecnt_t nominal_frame_rate () const { return _nominal_frame_rate; }
|
|
|
|
framecnt_t frames_per_hour () const { return _frames_per_hour; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
double frames_per_timecode_frame() const { return _frames_per_timecode_frame; }
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t timecode_frames_per_hour() const { return _timecode_frames_per_hour; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
MIDI::byte get_mtc_timecode_bits() const {
|
|
|
|
return mtc_timecode_bits; /* encoding of SMTPE type for MTC */
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
|
|
|
|
2012-11-12 21:00:45 -05:00
|
|
|
double timecode_frames_per_second() const;
|
2009-10-26 10:38:58 -04:00
|
|
|
bool timecode_drop_frames() const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Locations */
|
|
|
|
|
2010-08-09 12:40:31 -04:00
|
|
|
Locations *locations() { return _locations; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,Location*> auto_loop_location_changed;
|
|
|
|
PBD::Signal1<void,Location*> auto_punch_location_changed;
|
|
|
|
PBD::Signal0<void> locations_modified;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_auto_punch_location (Location *);
|
|
|
|
void set_auto_loop_location (Location *);
|
2014-12-09 17:17:47 -05:00
|
|
|
void set_session_extents (framepos_t start, framepos_t end);
|
2016-07-12 11:19:15 -04:00
|
|
|
void set_end_is_free (bool);
|
2009-05-12 13:03:42 -04:00
|
|
|
int location_name(std::string& result, std::string base = std::string(""));
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
pframes_t get_block_size() const { return current_block_size; }
|
|
|
|
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; }
|
2011-03-09 00:19:44 -05:00
|
|
|
framecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; }
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-01-11 12:15:14 -05:00
|
|
|
struct SaveAs {
|
2015-01-14 17:53:23 -05:00
|
|
|
std::string new_parent_folder; /* parent folder where new session folder will be created */
|
|
|
|
std::string new_name; /* name of newly saved session */
|
|
|
|
bool switch_to; /* true if we should be working on newly saved session after save-as; false otherwise */
|
2015-05-07 22:35:35 -04:00
|
|
|
bool include_media; /* true if the newly saved session should contain references to media */
|
2015-01-14 17:53:23 -05:00
|
|
|
bool copy_media; /* true if media files (audio, media, etc) should be copied into newly saved session; false otherwise */
|
|
|
|
bool copy_external; /* true if external media should be consolidated into the newly saved session; false otherwise */
|
2015-05-07 22:35:35 -04:00
|
|
|
|
|
|
|
std::string final_session_folder_name; /* filled in by * Session::save_as(), provides full path to newly saved session */
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-01-14 17:53:23 -05:00
|
|
|
/* emitted as we make progress. 3 arguments passed to signal
|
|
|
|
* handler:
|
|
|
|
*
|
|
|
|
* 1: percentage complete measured as a fraction (0-1.0) of
|
|
|
|
* total data copying done.
|
|
|
|
* 2: number of files copied so far
|
|
|
|
* 3: total number of files to copy
|
|
|
|
*
|
|
|
|
* Handler should return true for save-as to continue, or false
|
|
|
|
* to stop (and remove all evidence of partial save-as).
|
|
|
|
*/
|
2015-01-11 12:15:14 -05:00
|
|
|
PBD::Signal3<bool,float,int64_t,int64_t> Progress;
|
2015-01-14 17:53:23 -05:00
|
|
|
|
|
|
|
/* if save_as() returns non-zero, this string will indicate the reason why.
|
|
|
|
*/
|
|
|
|
std::string failure_message;
|
2015-01-11 12:15:14 -05:00
|
|
|
};
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-01-11 12:15:14 -05:00
|
|
|
int save_as (SaveAs&);
|
2016-04-12 05:06:35 -04:00
|
|
|
/** save session
|
|
|
|
* @param snapshot_name name of the session (use an empty string for the current name)
|
|
|
|
* @param pending save a 'recovery', not full state (default: false)
|
|
|
|
* @param switch_to_snapshot switch to given snapshot after saving (default: false)
|
|
|
|
* @param template_only save a session template (default: false)
|
|
|
|
* @return zero on success
|
|
|
|
*/
|
2015-05-07 22:35:35 -04:00
|
|
|
int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false, bool template_only = false);
|
2008-09-10 11:03:30 -04:00
|
|
|
int restore_state (std::string snapshot_name);
|
2015-10-12 06:27:28 -04:00
|
|
|
int save_template (std::string template_name, bool replace_existing = false);
|
2008-09-10 11:03:30 -04:00
|
|
|
int save_history (std::string snapshot_name = "");
|
|
|
|
int restore_history (std::string snapshot_name);
|
|
|
|
void remove_state (std::string snapshot_name);
|
|
|
|
void rename_state (std::string old_name, std::string new_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_pending_capture_state ();
|
2015-05-07 12:06:49 -04:00
|
|
|
int rename (const std::string&);
|
2013-03-30 14:12:31 -04:00
|
|
|
bool get_nsm_state () const { return _under_nsm_control; }
|
|
|
|
void set_nsm_state (bool state) { _under_nsm_control = state; }
|
2014-06-29 09:45:08 -04:00
|
|
|
bool save_default_options ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,std::string> StateSaved;
|
|
|
|
PBD::Signal0<void> StateReady;
|
2015-01-24 19:06:31 -05:00
|
|
|
|
|
|
|
/* emitted when session needs to be saved due to some internal
|
|
|
|
* event or condition (i.e. not in response to a user request).
|
|
|
|
*
|
|
|
|
* Only one object should
|
|
|
|
* connect to this signal and take responsibility.
|
|
|
|
*
|
|
|
|
* Argument is the snapshot name to use when saving.
|
|
|
|
*/
|
2015-10-04 14:51:05 -04:00
|
|
|
PBD::Signal1<void,std::string> SaveSessionRequested;
|
2015-01-24 19:06:31 -05:00
|
|
|
|
|
|
|
/* emitted during a session save to allow other entities to add state, via
|
2015-10-04 14:51:05 -04:00
|
|
|
* extra XML, to the session state
|
2015-01-24 19:06:31 -05:00
|
|
|
*/
|
|
|
|
PBD::Signal0<void> SessionSaveUnderway;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2014-06-16 06:39:45 -04:00
|
|
|
std::vector<std::string> possible_states() const;
|
|
|
|
static std::vector<std::string> possible_states (std::string path);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
XMLNode& get_state();
|
2009-10-15 14:56:11 -04:00
|
|
|
int set_state(const XMLNode& node, int version); // not idempotent
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode& get_template();
|
|
|
|
|
|
|
|
/// The instant xml file is written to the session directory
|
2008-09-17 04:44:51 -04:00
|
|
|
void add_instant_xml (XMLNode&, bool write_to_config = true);
|
2009-02-16 21:11:49 -05:00
|
|
|
XMLNode* instant_xml (const std::string& str);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
enum StateOfTheState {
|
|
|
|
Clean = 0x0,
|
|
|
|
Dirty = 0x1,
|
|
|
|
CannotSave = 0x2,
|
|
|
|
Deletion = 0x4,
|
|
|
|
InitialConnecting = 0x8,
|
|
|
|
Loading = 0x10,
|
2015-09-15 08:41:27 -04:00
|
|
|
InCleanup = 0x20,
|
|
|
|
PeakCleanup = 0x40
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
|
|
|
|
|
2014-06-28 15:27:36 -04:00
|
|
|
class StateProtector {
|
2015-02-05 16:21:01 -05:00
|
|
|
public:
|
|
|
|
StateProtector (Session* s) : _session (s) {
|
|
|
|
g_atomic_int_inc (&s->_suspend_save);
|
|
|
|
}
|
|
|
|
~StateProtector () {
|
|
|
|
if (g_atomic_int_dec_and_test (&_session->_suspend_save)) {
|
|
|
|
while (_session->_save_queued) {
|
|
|
|
_session->_save_queued = false;
|
|
|
|
_session->save_state ("");
|
2014-06-28 15:27:36 -04:00
|
|
|
}
|
|
|
|
}
|
2015-02-05 16:21:01 -05:00
|
|
|
}
|
|
|
|
private:
|
|
|
|
Session * _session;
|
2014-06-28 15:27:36 -04:00
|
|
|
};
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
void add_route_group (RouteGroup *);
|
|
|
|
void remove_route_group (RouteGroup&);
|
2011-04-19 11:46:47 -04:00
|
|
|
void reorder_route_groups (std::list<RouteGroup*>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-08-26 19:25:44 -04:00
|
|
|
RouteGroup* route_group_by_name (std::string);
|
2010-11-25 17:12:03 -05:00
|
|
|
RouteGroup& all_route_group() const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,RouteGroup*> route_group_added;
|
|
|
|
PBD::Signal0<void> route_group_removed;
|
2011-04-19 11:46:47 -04:00
|
|
|
PBD::Signal0<void> route_groups_reordered;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
void foreach_route_group (boost::function<void(RouteGroup*)> f) {
|
2010-02-23 15:25:53 -05:00
|
|
|
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
|
2009-12-17 13:24:23 -05:00
|
|
|
f (*i);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-07 21:35:46 -05:00
|
|
|
std::list<RouteGroup*> const & route_groups () const {
|
|
|
|
return _route_groups;
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* fundamental operations. duh. */
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
std::list<boost::shared_ptr<AudioTrack> > new_audio_track (
|
2011-02-26 20:59:04 -05:00
|
|
|
int input_channels,
|
|
|
|
int output_channels,
|
2016-05-16 07:30:28 -04:00
|
|
|
RouteGroup* route_group,
|
|
|
|
uint32_t how_many,
|
|
|
|
std::string name_template,
|
|
|
|
PresentationInfo::order_t order,
|
|
|
|
TrackMode mode = Normal
|
2011-02-26 20:59:04 -05:00
|
|
|
);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
|
2012-06-21 21:45:16 -04:00
|
|
|
const ChanCount& input, const ChanCount& output,
|
2016-05-16 07:30:28 -04:00
|
|
|
boost::shared_ptr<PluginInfo> instrument,
|
2016-05-17 08:21:05 -04:00
|
|
|
Plugin::PresetRecord* pset,
|
2016-05-16 07:30:28 -04:00
|
|
|
RouteGroup* route_group, uint32_t how_many, std::string name_template,
|
|
|
|
PresentationInfo::order_t,
|
|
|
|
TrackMode mode = Normal
|
2009-06-20 11:40:26 -04:00
|
|
|
);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
RouteList new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, std::string name_template, PresentationInfo::Flag, PresentationInfo::order_t);
|
|
|
|
RouteList new_midi_route (RouteGroup* route_group, uint32_t how_many, std::string name_template, boost::shared_ptr<PluginInfo> instrument, Plugin::PresetRecord*, PresentationInfo::Flag, PresentationInfo::order_t);
|
2016-03-15 23:41:19 -04:00
|
|
|
|
2015-05-08 16:04:15 -04:00
|
|
|
void remove_routes (boost::shared_ptr<RouteList>);
|
|
|
|
void remove_route (boost::shared_ptr<Route>);
|
|
|
|
|
|
|
|
void resort_routes ();
|
|
|
|
void resort_routes_using (boost::shared_ptr<RouteList>);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
AudioEngine & engine() { return _engine; }
|
|
|
|
AudioEngine const & engine () const { return _engine; }
|
|
|
|
|
2015-05-19 15:54:52 -04:00
|
|
|
static std::string default_track_name_pattern (DataType);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Time */
|
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
framepos_t transport_frame () const {return _transport_frame; }
|
2014-09-07 11:33:47 -04:00
|
|
|
framepos_t record_location () const {return _last_record_location; }
|
2010-09-17 14:20:37 -04:00
|
|
|
framepos_t audible_frame () const;
|
|
|
|
framepos_t requested_return_frame() const { return _requested_return_frame; }
|
2014-07-03 13:25:35 -04:00
|
|
|
void set_requested_return_frame(framepos_t return_to);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
enum PullupFormat {
|
|
|
|
pullup_Plus4Plus1,
|
|
|
|
pullup_Plus4,
|
|
|
|
pullup_Plus4Minus1,
|
|
|
|
pullup_Plus1,
|
|
|
|
pullup_None,
|
|
|
|
pullup_Minus1,
|
|
|
|
pullup_Minus4Plus1,
|
|
|
|
pullup_Minus4,
|
|
|
|
pullup_Minus4Minus1
|
|
|
|
};
|
|
|
|
|
|
|
|
void sync_time_vars();
|
|
|
|
|
2010-12-14 13:13:37 -05:00
|
|
|
void bbt_time (framepos_t when, Timecode::BBT_Time&);
|
2010-12-01 12:51:17 -05:00
|
|
|
void timecode_to_sample(Timecode::Time& timecode, framepos_t& sample, bool use_offset, bool use_subframes) const;
|
|
|
|
void sample_to_timecode(framepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
|
2009-10-26 10:38:58 -04:00
|
|
|
void timecode_time (Timecode::Time &);
|
2010-12-03 17:26:29 -05:00
|
|
|
void timecode_time (framepos_t when, Timecode::Time&);
|
|
|
|
void timecode_time_subframes (framepos_t when, Timecode::Time&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-04 16:37:46 -04:00
|
|
|
void timecode_duration (framecnt_t, Timecode::Time&) const;
|
2015-02-05 16:21:01 -05:00
|
|
|
void timecode_duration_string (char *, size_t len, framecnt_t) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-30 10:45:48 -05:00
|
|
|
framecnt_t convert_to_frames (AnyTime const & position);
|
2011-06-01 12:50:12 -04:00
|
|
|
framecnt_t any_duration_to_frames (framepos_t position, AnyTime const & duration);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-10-07 14:33:20 -04:00
|
|
|
static PBD::Signal1<void, framepos_t> StartTimeChanged;
|
|
|
|
static PBD::Signal1<void, framepos_t> EndTimeChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-03 13:44:06 -05:00
|
|
|
void request_sync_source (Slave*);
|
2015-04-06 21:19:51 -04:00
|
|
|
bool synced_to_engine() const { return _slave && config.get_external_sync() && Config->get_sync_source() == Engine; }
|
2015-05-12 12:17:17 -04:00
|
|
|
bool synced_to_mtc () const { return config.get_external_sync() && Config->get_sync_source() == MTC && g_atomic_int_get (const_cast<gint*>(&_mtc_active)); }
|
2015-05-25 20:56:03 -04:00
|
|
|
bool synced_to_ltc () const { return config.get_external_sync() && Config->get_sync_source() == LTC && g_atomic_int_get (const_cast<gint*>(&_ltc_active)); }
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
double transport_speed() const { return _transport_speed; }
|
2016-06-24 20:23:56 -04:00
|
|
|
bool transport_stopped() const { return _transport_speed == 0.0; }
|
|
|
|
bool transport_rolling() const { return _transport_speed != 0.0; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool silent () { return _silent; }
|
|
|
|
|
2014-11-03 17:29:11 -05:00
|
|
|
TempoMap& tempo_map() { return *_tempo_map; }
|
|
|
|
const TempoMap& tempo_map() const { return *_tempo_map; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2015-04-28 21:09:17 -04:00
|
|
|
unsigned int get_xrun_count () const {return _xrun_count; }
|
|
|
|
void reset_xrun_count () {_xrun_count = 0; }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* region info */
|
|
|
|
|
2010-03-01 19:00:00 -05:00
|
|
|
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Region> XMLRegionFactory (const XMLNode&, bool full);
|
|
|
|
boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
|
|
|
|
boost::shared_ptr<MidiRegion> XMLMidiRegionFactory (const XMLNode&, bool full);
|
|
|
|
|
|
|
|
/* source management */
|
|
|
|
|
2012-06-09 11:04:11 -04:00
|
|
|
void import_files (ImportStatus&);
|
2009-05-12 13:03:42 -04:00
|
|
|
bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
|
|
|
|
std::string build_tmp_convert_name (std::string file);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
boost::shared_ptr<ExportHandler> get_export_handler ();
|
2008-09-28 07:11:38 -04:00
|
|
|
boost::shared_ptr<ExportStatus> get_export_status ();
|
2008-09-17 04:44:51 -04:00
|
|
|
|
2016-07-13 22:34:18 -04:00
|
|
|
int start_audio_export (framepos_t position, bool realtime = false);
|
2008-09-17 04:44:51 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
PBD::Signal1<int, framecnt_t> ProcessExport;
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal2<void,std::string, std::string> Exported;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void add_source (boost::shared_ptr<Source>);
|
|
|
|
void remove_source (boost::weak_ptr<Source>);
|
|
|
|
|
2015-09-15 08:41:27 -04:00
|
|
|
void cleanup_regions();
|
|
|
|
bool can_cleanup_peakfiles () const;
|
|
|
|
int cleanup_peakfiles ();
|
2009-10-30 11:30:22 -04:00
|
|
|
int cleanup_sources (CleanupReport&);
|
|
|
|
int cleanup_trash_sources (CleanupReport&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-06-23 16:14:07 -04:00
|
|
|
int destroy_sources (std::list<boost::shared_ptr<Source> >);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int remove_last_capture ();
|
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
/** handlers should return 0 for "everything OK", and any other value for
|
2013-09-09 13:17:53 -04:00
|
|
|
* "cannot setup audioengine".
|
|
|
|
*/
|
2015-02-05 16:21:01 -05:00
|
|
|
static PBD::Signal1<int,uint32_t> AudioEngineSetupRequired;
|
2013-09-09 13:17:53 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return -1 for "stop cleanup",
|
|
|
|
0 for "yes, delete this playlist",
|
|
|
|
1 for "no, don't delete this playlist".
|
2008-06-02 17:41:35 -04:00
|
|
|
*/
|
2009-12-20 11:50:41 -05:00
|
|
|
static PBD::Signal1<int,boost::shared_ptr<Playlist> > AskAboutPlaylistDeletion;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return 0 for "ignore the rate mismatch",
|
|
|
|
!0 for "do not use this session"
|
2008-06-02 17:41:35 -04:00
|
|
|
*/
|
2010-12-03 17:26:29 -05:00
|
|
|
static PBD::Signal2<int, framecnt_t, framecnt_t> AskAboutSampleRateMismatch;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-04-18 09:16:27 -04:00
|
|
|
/** non interactive message */
|
|
|
|
static PBD::Signal2<void, framecnt_t, framecnt_t> NotifyAboutSampleRateMismatch;
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return !0 for use pending state, 0 for ignore it.
|
2015-02-05 16:21:01 -05:00
|
|
|
*/
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<int> AskAboutPendingState;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (
|
2011-03-02 12:05:16 -05:00
|
|
|
size_t, std::string const &, uint32_t, bool destructive);
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2014-04-13 10:29:07 -04:00
|
|
|
boost::shared_ptr<MidiSource> create_midi_source_for_session (std::string const &);
|
|
|
|
boost::shared_ptr<MidiSource> create_midi_source_by_stealing_name (boost::shared_ptr<Track>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<Source> source_by_id (const PBD::ID&);
|
2014-05-29 16:27:33 -04:00
|
|
|
boost::shared_ptr<AudioFileSource> audio_source_by_path_and_channel (const std::string&, uint16_t) const;
|
|
|
|
boost::shared_ptr<MidiSource> midi_source_by_path (const std::string&) const;
|
2010-11-09 17:18:52 -05:00
|
|
|
uint32_t count_sources_by_origin (const std::string&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-09-26 04:29:30 -04:00
|
|
|
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Curves and AutomationLists (TODO when they go away) */
|
|
|
|
void add_automation_list(AutomationList*);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* auditioning */
|
|
|
|
|
|
|
|
boost::shared_ptr<Auditioner> the_auditioner() { return auditioner; }
|
|
|
|
void audition_playlist ();
|
|
|
|
void audition_region (boost::shared_ptr<Region>);
|
|
|
|
void cancel_audition ();
|
|
|
|
bool is_auditioning () const;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,bool> AuditionActive;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-02-23 09:41:21 -05:00
|
|
|
/* session script */
|
|
|
|
void register_lua_function (const std::string&, const std::string&, const LuaScriptParamList&);
|
|
|
|
void unregister_lua_function (const std::string& name);
|
|
|
|
std::vector<std::string> registered_lua_functions ();
|
|
|
|
uint32_t registered_lua_function_count () const { return _n_lua_scripts; }
|
|
|
|
void scripts_changed (); // called from lua, updates _n_lua_scripts
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* flattening stuff */
|
|
|
|
|
2014-12-17 21:48:09 -05:00
|
|
|
boost::shared_ptr<Region> write_one_track (Track&, framepos_t start, framepos_t end,
|
2015-02-05 16:21:01 -05:00
|
|
|
bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
|
|
|
|
boost::shared_ptr<Processor> endpoint,
|
|
|
|
bool include_endpoint, bool for_export, bool for_freeze);
|
2010-03-02 13:05:26 -05:00
|
|
|
int freeze_all (InterThreadInfo&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* session-wide solo/mute/rec-enable */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
bool soloing() const { return _non_soloed_outs_muted; }
|
2009-07-01 09:36:50 -04:00
|
|
|
bool listening() const { return _listen_cnt > 0; }
|
2010-11-25 17:12:03 -05:00
|
|
|
bool solo_isolated() const { return _solo_isolated_cnt > 0; }
|
2016-07-13 14:33:23 -04:00
|
|
|
void cancel_all_solo ();
|
2009-07-01 09:36:50 -04:00
|
|
|
|
2009-12-11 18:30:48 -05:00
|
|
|
static const SessionEvent::RTeventCallback rt_cleanup;
|
2009-12-10 12:45:18 -05:00
|
|
|
|
2015-10-06 14:05:38 -04:00
|
|
|
void clear_all_solo_state (boost::shared_ptr<RouteList>);
|
2016-04-08 16:49:47 -04:00
|
|
|
|
|
|
|
/* Control-based methods */
|
|
|
|
|
|
|
|
void set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition);
|
|
|
|
void set_control (boost::shared_ptr<AutomationControl>, double val, PBD::Controllable::GroupControlDisposition);
|
|
|
|
|
2016-01-21 11:03:14 -05:00
|
|
|
void set_exclusive_input_active (boost::shared_ptr<RouteList> rt, bool onoff, bool flip_others = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,bool> SoloActive;
|
|
|
|
PBD::Signal0<void> SoloChanged;
|
2010-11-25 17:12:03 -05:00
|
|
|
PBD::Signal0<void> IsolatedChanged;
|
2016-01-08 08:20:58 -05:00
|
|
|
PBD::Signal0<void> MonitorChanged;
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2015-05-08 20:30:30 -04:00
|
|
|
PBD::Signal0<void> session_routes_reconnected;
|
|
|
|
|
2012-01-17 20:30:44 -05:00
|
|
|
/* monitor/master out */
|
|
|
|
|
|
|
|
void add_monitor_section ();
|
2015-04-21 09:18:10 -04:00
|
|
|
void reset_monitor_section ();
|
2012-01-17 20:30:44 -05:00
|
|
|
void remove_monitor_section ();
|
2016-01-08 08:20:58 -05:00
|
|
|
bool monitor_active() const { return (_monitor_out && _monitor_out->monitor_control () && _monitor_out->monitor_control ()->monitor_active()); }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-03-22 17:35:35 -04:00
|
|
|
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Route> master_out() const { return _master_out; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-29 17:07:34 -05:00
|
|
|
void globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool);
|
2009-07-21 08:05:44 -04:00
|
|
|
void globally_set_send_gains_from_track (boost::shared_ptr<Route> dest);
|
|
|
|
void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
|
|
|
|
void globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest);
|
2009-07-14 20:47:34 -04:00
|
|
|
void add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders);
|
2012-01-30 13:09:54 -05:00
|
|
|
void add_internal_send (boost::shared_ptr<Route>, int, boost::shared_ptr<Route>);
|
|
|
|
void add_internal_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>, boost::shared_ptr<Route>);
|
2009-06-25 16:46:39 -04:00
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
static void set_disable_all_loaded_plugins (bool yn) {
|
2008-06-02 17:41:35 -04:00
|
|
|
_disable_all_loaded_plugins = yn;
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
static bool get_disable_all_loaded_plugins() {
|
2008-06-02 17:41:35 -04:00
|
|
|
return _disable_all_loaded_plugins;
|
|
|
|
}
|
2015-09-01 07:26:31 -04:00
|
|
|
static void set_bypass_all_loaded_plugins (bool yn) {
|
|
|
|
_bypass_all_loaded_plugins = yn;
|
|
|
|
}
|
|
|
|
static bool get_bypass_all_loaded_plugins() {
|
|
|
|
return _bypass_all_loaded_plugins;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
uint32_t next_send_id();
|
2012-01-18 12:51:57 -05:00
|
|
|
uint32_t next_aux_send_id();
|
2009-05-07 13:31:18 -04:00
|
|
|
uint32_t next_return_id();
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t next_insert_id();
|
|
|
|
void mark_send_id (uint32_t);
|
2012-01-18 12:51:57 -05:00
|
|
|
void mark_aux_send_id (uint32_t);
|
2009-05-07 13:31:18 -04:00
|
|
|
void mark_return_id (uint32_t);
|
2008-06-02 17:41:35 -04:00
|
|
|
void mark_insert_id (uint32_t);
|
2010-03-31 21:24:13 -04:00
|
|
|
void unmark_send_id (uint32_t);
|
2012-01-18 12:51:57 -05:00
|
|
|
void unmark_aux_send_id (uint32_t);
|
2010-03-31 21:24:13 -04:00
|
|
|
void unmark_return_id (uint32_t);
|
|
|
|
void unmark_insert_id (uint32_t);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* s/w "RAID" management */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2012-06-12 12:41:29 -04:00
|
|
|
boost::optional<framecnt_t> available_capture_duration();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* I/O bundles */
|
|
|
|
|
2015-03-08 17:38:55 -04:00
|
|
|
void add_bundle (boost::shared_ptr<Bundle>, bool emit_signal = true);
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_bundle (boost::shared_ptr<Bundle>);
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-03-08 17:38:55 -04:00
|
|
|
PBD::Signal0<void> BundleAddedOrRemoved;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-07-08 18:55:20 -04:00
|
|
|
void midi_panic ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* History (for editors, mixers, UIs etc.) */
|
|
|
|
|
|
|
|
/** Undo some transactions.
|
|
|
|
* @param n Number of transactions to undo.
|
|
|
|
*/
|
|
|
|
void undo (uint32_t n) {
|
|
|
|
_history.undo (n);
|
|
|
|
}
|
|
|
|
|
|
|
|
void redo (uint32_t n) {
|
|
|
|
_history.redo (n);
|
|
|
|
}
|
|
|
|
|
|
|
|
UndoHistory& history() { return _history; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t undo_depth() const { return _history.undo_depth(); }
|
|
|
|
uint32_t redo_depth() const { return _history.redo_depth(); }
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string next_undo() const { return _history.next_undo(); }
|
|
|
|
std::string next_redo() const { return _history.next_redo(); }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-04-12 18:07:28 -04:00
|
|
|
/** begin collecting undo information
|
|
|
|
*
|
|
|
|
* This call must always be followed by either
|
|
|
|
* begin_reversible_command() or commit_reversible_command()
|
|
|
|
*
|
|
|
|
* @param cmd_name human readable name for the undo operation
|
|
|
|
*/
|
2009-05-12 13:03:42 -04:00
|
|
|
void begin_reversible_command (const std::string& cmd_name);
|
2011-01-19 12:38:56 -05:00
|
|
|
void begin_reversible_command (GQuark);
|
2016-04-12 18:07:28 -04:00
|
|
|
/** abort an open undo command
|
|
|
|
* This must only be called after begin_reversible_command ()
|
|
|
|
*/
|
2015-02-05 07:32:57 -05:00
|
|
|
void abort_reversible_command ();
|
2016-04-12 18:07:28 -04:00
|
|
|
/** finalize an undo command and commit pending transactions
|
|
|
|
*
|
|
|
|
* This must only be called after begin_reversible_command ()
|
|
|
|
* @param cmd (additional) command to add
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
void commit_reversible_command (Command* cmd = 0);
|
|
|
|
|
2015-08-18 23:45:01 -04:00
|
|
|
void add_command (Command *const cmd);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-04-12 18:07:28 -04:00
|
|
|
/** create an StatefulDiffCommand from the given object and add it to the stack.
|
|
|
|
*
|
|
|
|
* This function must only be called after begin_reversible_command.
|
|
|
|
* Failing to do so may lead to a crash.
|
|
|
|
*
|
|
|
|
* @param sfd the object to diff
|
|
|
|
* @returns the allocated StatefulDiffCommand (already added via add_command)
|
|
|
|
*/
|
|
|
|
PBD::StatefulDiffCommand* add_stateful_diff_command (boost::shared_ptr<PBD::StatefulDestructible> sfd);
|
2016-04-09 19:45:41 -04:00
|
|
|
|
2011-01-19 12:38:56 -05:00
|
|
|
/** @return The list of operations that are currently in progress */
|
|
|
|
std::list<GQuark> const & current_operations () {
|
|
|
|
return _current_trans_quarks;
|
|
|
|
}
|
|
|
|
|
2012-06-13 12:46:59 -04:00
|
|
|
bool operation_in_progress (GQuark) const;
|
|
|
|
|
2010-08-25 21:44:11 -04:00
|
|
|
void add_commands (std::vector<Command*> const & cmds);
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
std::map<PBD::ID,PBD::StatefulDestructible*> registry;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
// these commands are implemented in libs/ardour/session_command.cc
|
|
|
|
Command* memento_command_factory(XMLNode* n);
|
2010-02-09 17:28:46 -05:00
|
|
|
Command* stateful_diff_command_factory (XMLNode *);
|
2009-12-17 13:24:23 -05:00
|
|
|
void register_with_memento_command_factory(PBD::ID, PBD::StatefulDestructible*);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* clicking */
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
boost::shared_ptr<IO> click_io() { return _click_io; }
|
2012-01-27 17:47:16 -05:00
|
|
|
boost::shared_ptr<Amp> click_gain() { return _click_gain; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* disk, buffer loads */
|
|
|
|
|
|
|
|
uint32_t playback_load ();
|
|
|
|
uint32_t capture_load ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* ranges */
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
void request_play_range (std::list<AudioRange>*, bool leave_rolling = false);
|
2014-07-02 18:34:49 -04:00
|
|
|
void request_cancel_play_range ();
|
2008-06-02 17:41:35 -04:00
|
|
|
bool get_play_range () const { return _play_range; }
|
|
|
|
|
2013-03-27 13:21:09 -04:00
|
|
|
void maybe_update_session_range (framepos_t, framepos_t);
|
|
|
|
|
2015-01-16 12:17:09 -05:00
|
|
|
/* temporary hacks to allow selection to be pushed from GUI into backend.
|
|
|
|
Whenever we move the selection object into libardour, these will go away.
|
|
|
|
*/
|
|
|
|
void set_range_selection (framepos_t start, framepos_t end);
|
|
|
|
void set_object_selection (framepos_t start, framepos_t end);
|
|
|
|
void clear_range_selection ();
|
|
|
|
void clear_object_selection ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* buffers for gain and pan */
|
|
|
|
|
2010-04-13 16:48:33 -04:00
|
|
|
gain_t* gain_automation_buffer () const;
|
2015-04-25 15:24:58 -04:00
|
|
|
gain_t* trim_automation_buffer () const;
|
2012-06-11 06:42:30 -04:00
|
|
|
gain_t* send_gain_automation_buffer () const;
|
2010-04-13 16:48:33 -04:00
|
|
|
pan_t** pan_automation_buffer () const;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* VST support */
|
|
|
|
|
2014-02-23 11:52:49 -05:00
|
|
|
static int vst_current_loading_id;
|
|
|
|
static const char* vst_can_do_strings[];
|
|
|
|
static const int vst_can_do_string_count;
|
|
|
|
|
2011-11-22 11:30:58 -05:00
|
|
|
static intptr_t vst_callback (
|
|
|
|
AEffect* effect,
|
|
|
|
int32_t opcode,
|
|
|
|
int32_t index,
|
|
|
|
intptr_t value,
|
|
|
|
void* ptr,
|
|
|
|
float opt
|
|
|
|
);
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<void> SendFeedback;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
/* Speakers */
|
2010-11-18 19:58:57 -05:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
boost::shared_ptr<Speakers> get_speakers ();
|
2010-11-18 19:58:57 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Controllables */
|
|
|
|
|
2016-02-20 14:22:40 -05:00
|
|
|
boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
|
2016-05-16 11:08:32 -04:00
|
|
|
boost::shared_ptr<PBD::Controllable> controllable_by_descriptor (const ARDOUR::ControllableDescriptor&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void add_controllable (boost::shared_ptr<PBD::Controllable>);
|
|
|
|
void remove_controllable (PBD::Controllable*);
|
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
boost::shared_ptr<PBD::Controllable> solo_cut_control() const;
|
2011-02-11 11:14:54 -05:00
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
SessionConfiguration config;
|
|
|
|
|
2016-08-15 16:16:08 -04:00
|
|
|
SessionConfiguration* cfg () { return &config; }
|
|
|
|
|
2009-09-01 16:13:23 -04:00
|
|
|
bool exporting () const {
|
|
|
|
return _exporting;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2014-05-26 00:17:49 -04:00
|
|
|
bool bounce_processing() const {
|
|
|
|
return _bounce_processing_active;
|
|
|
|
}
|
|
|
|
|
2009-11-30 11:12:13 -05:00
|
|
|
/* this is a private enum, but setup_enum_writer() needs it,
|
|
|
|
and i can't find a way to give that function
|
|
|
|
friend access. sigh.
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum PostTransportWork {
|
|
|
|
PostTransportStop = 0x1,
|
2011-06-26 08:56:40 -04:00
|
|
|
PostTransportDuration = 0x2,
|
|
|
|
PostTransportLocate = 0x4,
|
|
|
|
PostTransportRoll = 0x8,
|
|
|
|
PostTransportAbort = 0x10,
|
|
|
|
PostTransportOverWrite = 0x20,
|
|
|
|
PostTransportSpeed = 0x40,
|
|
|
|
PostTransportAudition = 0x80,
|
|
|
|
PostTransportReverse = 0x100,
|
|
|
|
PostTransportInputChange = 0x200,
|
|
|
|
PostTransportCurveRealloc = 0x400,
|
|
|
|
PostTransportClearSubstate = 0x800,
|
|
|
|
PostTransportAdjustPlaybackBuffering = 0x1000,
|
|
|
|
PostTransportAdjustCaptureBuffering = 0x2000
|
2009-11-30 11:12:13 -05:00
|
|
|
};
|
|
|
|
|
2009-12-02 16:26:26 -05:00
|
|
|
enum SlaveState {
|
|
|
|
Stopped,
|
|
|
|
Waiting,
|
|
|
|
Running
|
|
|
|
};
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2009-12-02 16:26:26 -05:00
|
|
|
SlaveState slave_state() const { return _slave_state; }
|
2015-02-05 16:21:01 -05:00
|
|
|
Slave* slave() const { return _slave; }
|
2009-11-30 11:12:13 -05:00
|
|
|
|
2009-12-04 14:09:08 -05:00
|
|
|
boost::shared_ptr<SessionPlaylists> playlists;
|
2009-12-03 16:52:10 -05:00
|
|
|
|
2010-09-17 14:20:37 -04:00
|
|
|
void send_mmc_locate (framepos_t);
|
2015-02-05 16:21:01 -05:00
|
|
|
void queue_full_time_code () { _send_timecode_update = true; }
|
|
|
|
void queue_song_position_pointer () { /* currently does nothing */ }
|
2010-07-04 21:13:36 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
bool step_editing() const { return (_step_editors > 0); }
|
2010-07-24 12:40:56 -04:00
|
|
|
|
2010-08-01 21:59:34 -04:00
|
|
|
void request_suspend_timecode_transmission ();
|
|
|
|
void request_resume_timecode_transmission ();
|
|
|
|
bool timecode_transmission_suspended () const;
|
|
|
|
|
2013-07-15 08:05:37 -04:00
|
|
|
std::vector<std::string> source_search_path(DataType) const;
|
2010-11-25 17:12:03 -05:00
|
|
|
void ensure_search_path_includes (const std::string& path, DataType type);
|
2014-07-08 00:53:06 -04:00
|
|
|
void remove_dir_from_search_path (const std::string& path, DataType type);
|
2010-11-25 17:12:03 -05:00
|
|
|
|
2010-11-26 18:30:48 -05:00
|
|
|
std::list<std::string> unknown_processors () const;
|
|
|
|
|
2011-11-09 12:44:39 -05:00
|
|
|
/** Emitted when a feedback cycle has been detected within Ardour's signal
|
|
|
|
processing path. Until it is fixed (by the user) some (unspecified)
|
|
|
|
routes will not be run.
|
|
|
|
*/
|
|
|
|
static PBD::Signal0<void> FeedbackDetected;
|
|
|
|
|
2011-11-11 08:52:27 -05:00
|
|
|
/** Emitted when a graph sort has successfully completed, which means
|
|
|
|
that it has no feedback cycles.
|
|
|
|
*/
|
|
|
|
static PBD::Signal0<void> SuccessfulGraphSort;
|
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
/* handlers can return an integer value:
|
|
|
|
0: config.set_audio_search_path() or config.set_midi_search_path() was used
|
|
|
|
to modify the search path and we should try to find it again.
|
|
|
|
1: quit entire session load
|
|
|
|
2: as 0, but don't ask about other missing files
|
|
|
|
3: don't ask about other missing files, and just mark this one missing
|
|
|
|
-1: just mark this one missing
|
|
|
|
any other value: as -1
|
|
|
|
*/
|
2010-11-09 01:03:51 -05:00
|
|
|
static PBD::Signal3<int,Session*,std::string,DataType> MissingFile;
|
|
|
|
|
2010-10-07 08:12:16 -04:00
|
|
|
/** Emitted when the session wants Ardour to quit */
|
|
|
|
static PBD::Signal0<void> Quit;
|
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
/** Emitted when Ardour is asked to load a session in an older session
|
2013-03-04 16:57:29 -05:00
|
|
|
* format, and makes a backup copy.
|
|
|
|
*/
|
2015-02-05 16:21:01 -05:00
|
|
|
static PBD::Signal2<void,std::string,std::string> VersionMismatch;
|
2013-03-04 16:57:29 -05:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
SceneChanger* scene_changer() const { return _scene_changer; }
|
|
|
|
|
2015-12-07 12:02:42 -05:00
|
|
|
/* asynchronous MIDI control ports */
|
2013-09-05 13:22:34 -04:00
|
|
|
|
2015-12-07 12:02:42 -05:00
|
|
|
boost::shared_ptr<Port> midi_input_port () const;
|
|
|
|
boost::shared_ptr<Port> midi_output_port () const;
|
|
|
|
boost::shared_ptr<Port> mmc_output_port () const;
|
|
|
|
boost::shared_ptr<Port> mmc_input_port () const;
|
|
|
|
boost::shared_ptr<Port> scene_input_port () const;
|
|
|
|
boost::shared_ptr<Port> scene_output_port () const;
|
2013-09-05 13:22:34 -04:00
|
|
|
|
2015-12-07 12:02:42 -05:00
|
|
|
/* synchronous MIDI ports used for synchronization */
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
boost::shared_ptr<MidiPort> midi_clock_output_port () const;
|
|
|
|
boost::shared_ptr<MidiPort> midi_clock_input_port () const;
|
|
|
|
boost::shared_ptr<MidiPort> mtc_output_port () const;
|
|
|
|
boost::shared_ptr<MidiPort> mtc_input_port () const;
|
2015-12-07 12:02:42 -05:00
|
|
|
boost::shared_ptr<Port> ltc_input_port() const;
|
|
|
|
boost::shared_ptr<Port> ltc_output_port() const;
|
|
|
|
|
|
|
|
boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
|
|
|
|
boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
|
2015-10-04 14:51:05 -04:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
MIDI::MachineControl& mmc() { return *_mmc; }
|
2013-09-05 13:22:34 -04:00
|
|
|
|
2015-05-08 15:03:06 -04:00
|
|
|
void reconnect_midi_scene_ports (bool);
|
2015-05-09 19:34:50 -04:00
|
|
|
void reconnect_mtc_ports ();
|
|
|
|
void reconnect_mmc_ports (bool);
|
2015-05-08 15:03:06 -04:00
|
|
|
|
2015-05-25 20:56:03 -04:00
|
|
|
void reconnect_ltc_input ();
|
|
|
|
void reconnect_ltc_output ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2016-01-26 00:18:03 -05:00
|
|
|
VCAManager& vca_manager() { return *_vca_manager; }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
protected:
|
|
|
|
friend class AudioEngine;
|
2010-12-03 17:26:29 -05:00
|
|
|
void set_block_size (pframes_t nframes);
|
|
|
|
void set_frame_rate (framecnt_t nframes);
|
2016-04-23 16:11:48 -04:00
|
|
|
#ifdef USE_TRACKS_CODE_FEATURES
|
2015-02-05 16:21:01 -05:00
|
|
|
void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true);
|
2016-04-23 16:11:48 -04:00
|
|
|
#endif
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
friend class Route;
|
|
|
|
void schedule_curve_reallocation ();
|
2011-03-14 16:33:47 -04:00
|
|
|
void update_latency_compensation (bool force = false);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
2010-05-09 16:48:21 -04:00
|
|
|
int create (const std::string& mix_template, BusProfile*);
|
2008-06-02 17:41:35 -04:00
|
|
|
void destroy ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2016-04-12 07:49:50 -04:00
|
|
|
static guint _name_id_counter;
|
|
|
|
static void init_name_id_counter (guint n);
|
|
|
|
static unsigned int name_id_counter ();
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
enum SubState {
|
2012-06-20 14:46:05 -04:00
|
|
|
PendingDeclickIn = 0x1, ///< pending de-click fade-in for start
|
|
|
|
PendingDeclickOut = 0x2, ///< pending de-click fade-out for stop
|
|
|
|
StopPendingCapture = 0x4,
|
|
|
|
PendingLoopDeclickIn = 0x8, ///< pending de-click fade-in at the start of a loop
|
|
|
|
PendingLoopDeclickOut = 0x10, ///< pending de-click fade-out at the end of a loop
|
|
|
|
PendingLocate = 0x20,
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* stuff used in process() should be close together to
|
|
|
|
maximise cache hits
|
|
|
|
*/
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
typedef void (Session::*process_function_type)(pframes_t);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
AudioEngine& _engine;
|
|
|
|
mutable gint processing_prohibited;
|
|
|
|
process_function_type process_function;
|
|
|
|
process_function_type last_process_function;
|
2014-05-26 00:17:49 -04:00
|
|
|
bool _bounce_processing_active;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool waiting_for_sync_offset;
|
2016-04-18 08:50:09 -04:00
|
|
|
framecnt_t _base_frame_rate; // sample-rate of the session at creation time, "native" SR
|
|
|
|
framecnt_t _nominal_frame_rate; // overridden by audioengine setting
|
|
|
|
framecnt_t _current_frame_rate; // this includes video pullup offset
|
2008-06-02 17:41:35 -04:00
|
|
|
int transport_sub_state;
|
|
|
|
mutable gint _record_status;
|
2010-12-01 15:49:32 -05:00
|
|
|
framepos_t _transport_frame;
|
2010-05-09 16:48:21 -04:00
|
|
|
Location* _session_range_location; ///< session range, or 0 if there is nothing in the session yet
|
2016-07-12 11:19:15 -04:00
|
|
|
bool _session_range_end_is_free;
|
2008-06-02 17:41:35 -04:00
|
|
|
Slave* _slave;
|
|
|
|
bool _silent;
|
2011-01-19 12:38:56 -05:00
|
|
|
|
2010-12-01 15:49:32 -05:00
|
|
|
// varispeed playback
|
|
|
|
double _transport_speed;
|
2012-06-22 10:45:44 -04:00
|
|
|
double _default_transport_speed;
|
2010-12-01 15:49:32 -05:00
|
|
|
double _last_transport_speed;
|
2015-03-10 05:46:24 -04:00
|
|
|
double _signalled_varispeed;
|
2010-12-01 15:49:32 -05:00
|
|
|
double _target_transport_speed;
|
|
|
|
CubicInterpolation interpolation;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool auto_play_legal;
|
2010-12-01 15:49:32 -05:00
|
|
|
framepos_t _last_slave_transport_frame;
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t maximum_output_latency;
|
2010-12-01 15:49:32 -05:00
|
|
|
framepos_t _requested_return_frame;
|
2010-12-03 17:26:29 -05:00
|
|
|
pframes_t current_block_size;
|
|
|
|
framecnt_t _worst_output_latency;
|
|
|
|
framecnt_t _worst_input_latency;
|
|
|
|
framecnt_t _worst_track_latency;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _have_captured;
|
2009-06-09 16:21:19 -04:00
|
|
|
bool _non_soloed_outs_muted;
|
2016-01-16 17:40:03 -05:00
|
|
|
bool _listening;
|
2009-07-01 09:36:50 -04:00
|
|
|
uint32_t _listen_cnt;
|
2010-05-06 14:40:37 -04:00
|
|
|
uint32_t _solo_isolated_cnt;
|
2009-10-13 16:43:28 -04:00
|
|
|
bool _writable;
|
2009-11-08 11:28:21 -05:00
|
|
|
bool _was_seamless;
|
2013-03-30 14:12:31 -04:00
|
|
|
bool _under_nsm_control;
|
2015-04-28 21:09:17 -04:00
|
|
|
unsigned int _xrun_count;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-05-12 12:17:17 -04:00
|
|
|
void mtc_status_changed (bool);
|
|
|
|
PBD::ScopedConnection mtc_status_connection;
|
2015-05-25 20:56:03 -04:00
|
|
|
void ltc_status_changed (bool);
|
|
|
|
PBD::ScopedConnection ltc_status_connection;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-09-21 13:28:13 -04:00
|
|
|
void initialize_latencies ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_worst_io_latencies ();
|
2011-03-14 16:33:47 -04:00
|
|
|
void set_worst_playback_latency ();
|
|
|
|
void set_worst_capture_latency ();
|
2009-07-21 11:55:17 -04:00
|
|
|
void set_worst_io_latencies_x (IOChange, void *) {
|
2008-06-02 17:41:35 -04:00
|
|
|
set_worst_io_latencies ();
|
|
|
|
}
|
2011-06-01 12:50:12 -04:00
|
|
|
void post_capture_latency ();
|
|
|
|
void post_playback_latency ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void update_latency_compensation_proxy (void* ignored);
|
|
|
|
|
2010-04-13 16:48:33 -04:00
|
|
|
void ensure_buffers (ChanCount howmany = ChanCount::ZERO);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
void process_scrub (pframes_t);
|
|
|
|
void process_without_events (pframes_t);
|
|
|
|
void process_with_events (pframes_t);
|
|
|
|
void process_audition (pframes_t);
|
2016-07-13 22:34:18 -04:00
|
|
|
void process_export (pframes_t);
|
|
|
|
void process_export_fw (pframes_t);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-04-16 12:02:25 -04:00
|
|
|
void block_processing() { g_atomic_int_set (&processing_prohibited, 1); }
|
|
|
|
void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
|
|
|
|
bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
|
|
|
|
|
2014-05-26 00:58:44 -04:00
|
|
|
static const framecnt_t bounce_chunk_size;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* slave tracking */
|
|
|
|
|
|
|
|
static const int delta_accumulator_size = 25;
|
|
|
|
int delta_accumulator_cnt;
|
2010-07-22 12:08:11 -04:00
|
|
|
int32_t delta_accumulator[delta_accumulator_size];
|
|
|
|
int32_t average_slave_delta;
|
2008-06-02 17:41:35 -04:00
|
|
|
int average_dir;
|
|
|
|
bool have_first_delta_accumulator;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-02 16:26:26 -05:00
|
|
|
SlaveState _slave_state;
|
2015-05-12 12:17:17 -04:00
|
|
|
gint _mtc_active;
|
2015-05-25 20:56:03 -04:00
|
|
|
gint _ltc_active;
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t slave_wait_end;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void reset_slave_state ();
|
2010-12-03 17:26:29 -05:00
|
|
|
bool follow_slave (pframes_t);
|
|
|
|
void calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta);
|
|
|
|
void track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t this_delta);
|
|
|
|
void follow_slave_silently (pframes_t nframes, float slave_speed);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
void switch_to_sync_source (SyncSource); /* !RT context */
|
|
|
|
void drop_sync_source (); /* !RT context */
|
|
|
|
void use_sync_source (Slave*); /* RT context */
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
bool post_export_sync;
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t post_export_position;
|
2008-09-28 07:11:38 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _exporting;
|
2009-12-27 17:09:40 -05:00
|
|
|
bool _export_rolling;
|
2016-07-13 22:34:18 -04:00
|
|
|
bool _realtime_export;
|
2016-02-29 07:50:56 -05:00
|
|
|
framepos_t _export_preroll;
|
2016-07-09 21:20:35 -04:00
|
|
|
framepos_t _export_latency;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
boost::shared_ptr<ExportHandler> export_handler;
|
2008-09-28 07:11:38 -04:00
|
|
|
boost::shared_ptr<ExportStatus> export_status;
|
|
|
|
|
|
|
|
int pre_export ();
|
|
|
|
int stop_audio_export ();
|
|
|
|
void finalize_audio_export ();
|
2012-12-06 14:56:33 -05:00
|
|
|
void finalize_export_internal (bool stop_freewheel);
|
2012-02-06 12:09:53 -05:00
|
|
|
bool _pre_export_mmc_enabled;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::ScopedConnection export_freewheel_connection;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
void get_track_statistics ();
|
2010-12-03 17:26:29 -05:00
|
|
|
int process_routes (pframes_t, bool& need_butler);
|
|
|
|
int silent_process_routes (pframes_t, bool& need_butler);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2012-06-20 14:45:58 -04:00
|
|
|
/** @return 1 if there is a pending declick fade-in,
|
2015-02-05 16:21:01 -05:00
|
|
|
-1 if there is a pending declick fade-out,
|
|
|
|
0 if there is no pending declick.
|
2012-06-20 14:45:58 -04:00
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
int get_transport_declick_required () {
|
|
|
|
if (transport_sub_state & PendingDeclickIn) {
|
|
|
|
transport_sub_state &= ~PendingDeclickIn;
|
|
|
|
return 1;
|
|
|
|
} else if (transport_sub_state & PendingDeclickOut) {
|
2012-06-20 14:46:05 -04:00
|
|
|
/* XXX: not entirely sure why we don't clear this */
|
2008-06-02 17:41:35 -04:00
|
|
|
return -1;
|
2012-06-20 14:46:05 -04:00
|
|
|
} else if (transport_sub_state & PendingLoopDeclickOut) {
|
|
|
|
/* Return the declick out first ... */
|
|
|
|
transport_sub_state &= ~PendingLoopDeclickOut;
|
|
|
|
return -1;
|
|
|
|
} else if (transport_sub_state & PendingLoopDeclickIn) {
|
|
|
|
/* ... then the declick in on the next call */
|
|
|
|
transport_sub_state &= ~PendingLoopDeclickIn;
|
|
|
|
return 1;
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
bool maybe_stop (framepos_t limit);
|
|
|
|
bool maybe_sync_start (pframes_t &);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void check_declick_out ();
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string _path;
|
|
|
|
std::string _name;
|
2010-11-25 17:12:03 -05:00
|
|
|
bool _is_new;
|
2011-01-03 18:55:00 -05:00
|
|
|
bool _send_qf_mtc;
|
2011-01-03 22:35:10 -05:00
|
|
|
/** Number of process frames since the last MTC output (when sending MTC); used to
|
|
|
|
* know when to send full MTC messages every so often.
|
|
|
|
*/
|
|
|
|
pframes_t _pframes_since_last_mtc;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool session_midi_feedback;
|
|
|
|
bool play_loop;
|
|
|
|
bool loop_changing;
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t last_loopend;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
boost::scoped_ptr<SessionDirectory> _session_dir;
|
|
|
|
|
2010-03-22 17:35:35 -04:00
|
|
|
void hookup_io ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void graph_reordered ();
|
|
|
|
|
2011-05-04 07:32:35 -04:00
|
|
|
/** current snapshot name, without the .ardour suffix */
|
2015-11-19 21:10:57 -05:00
|
|
|
void set_snapshot_name (const std::string &);
|
|
|
|
void save_snapshot_name (const std::string &);
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string _current_snapshot_name;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-15 14:56:11 -04:00
|
|
|
XMLTree* state_tree;
|
|
|
|
bool state_was_pending;
|
2008-06-02 17:41:35 -04:00
|
|
|
StateOfTheState _state_of_the_state;
|
|
|
|
|
2014-06-28 15:27:36 -04:00
|
|
|
friend class StateProtector;
|
|
|
|
gint _suspend_save; /* atomic */
|
|
|
|
volatile bool _save_queued;
|
2014-07-09 10:18:28 -04:00
|
|
|
Glib::Threads::Mutex save_state_lock;
|
2015-09-15 08:41:27 -04:00
|
|
|
Glib::Threads::Mutex peak_cleanup_lock;
|
2014-06-28 15:27:36 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int load_options (const XMLNode&);
|
2009-05-12 13:03:42 -04:00
|
|
|
int load_state (std::string snapshot_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t _last_roll_location;
|
2012-06-25 21:40:34 -04:00
|
|
|
/** the session frame time at which we last rolled, located, or changed transport direction */
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t _last_roll_or_reversal_location;
|
|
|
|
framepos_t _last_record_location;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
bool pending_locate_roll;
|
2010-12-03 17:26:29 -05:00
|
|
|
framepos_t pending_locate_frame;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool pending_locate_flush;
|
|
|
|
bool pending_abort;
|
|
|
|
bool pending_auto_loop;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2016-02-23 09:41:21 -05:00
|
|
|
PBD::ReallocPool _mempool;
|
|
|
|
LuaState lua;
|
|
|
|
Glib::Threads::Mutex lua_lock;
|
|
|
|
luabridge::LuaRef * _lua_run;
|
|
|
|
luabridge::LuaRef * _lua_add;
|
|
|
|
luabridge::LuaRef * _lua_del;
|
|
|
|
luabridge::LuaRef * _lua_list;
|
|
|
|
luabridge::LuaRef * _lua_load;
|
|
|
|
luabridge::LuaRef * _lua_save;
|
|
|
|
luabridge::LuaRef * _lua_cleanup;
|
|
|
|
uint32_t _n_lua_scripts;
|
|
|
|
|
|
|
|
void setup_lua ();
|
|
|
|
void try_run_lua (pframes_t);
|
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
Butler* _butler;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
static const PostTransportWork ProcessCannotProceedMask =
|
2009-01-30 15:18:31 -05:00
|
|
|
PostTransportWork (
|
2015-02-05 16:21:01 -05:00
|
|
|
PostTransportInputChange|
|
|
|
|
PostTransportSpeed|
|
|
|
|
PostTransportReverse|
|
|
|
|
PostTransportCurveRealloc|
|
|
|
|
PostTransportAudition|
|
|
|
|
PostTransportLocate|
|
|
|
|
PostTransportStop|
|
|
|
|
PostTransportClearSubstate);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
gint _post_transport_work; /* accessed only atomic ops */
|
2015-02-05 16:21:01 -05:00
|
|
|
PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (const_cast<gint*>(&_post_transport_work)); }
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_post_transport_work (PostTransportWork ptw) { g_atomic_int_set (&_post_transport_work, (gint) ptw); }
|
|
|
|
void add_post_transport_work (PostTransportWork ptw);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
void schedule_playback_buffering_adjustment ();
|
|
|
|
void schedule_capture_buffering_adjustment ();
|
2010-06-09 13:24:07 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t cumulative_rf_motion;
|
|
|
|
uint32_t rf_scale;
|
|
|
|
|
|
|
|
void set_rf_speed (float speed);
|
2010-12-03 17:26:29 -05:00
|
|
|
void reset_rf_scale (framecnt_t frames_moved);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-08-09 12:40:31 -04:00
|
|
|
Locations* _locations;
|
2015-02-05 16:21:01 -05:00
|
|
|
void location_added (Location*);
|
|
|
|
void location_removed (Location*);
|
|
|
|
void locations_changed ();
|
|
|
|
void _locations_changed (const Locations::LocationList&);
|
|
|
|
|
|
|
|
void update_skips (Location*, bool consolidate);
|
|
|
|
void update_marks (Location* loc);
|
|
|
|
void consolidate_skips (Location*);
|
|
|
|
void sync_locations_to_skips ();
|
|
|
|
void _sync_locations_to_skips ();
|
2015-10-04 14:51:05 -04:00
|
|
|
|
2015-02-17 11:10:29 -05:00
|
|
|
PBD::ScopedConnectionList skip_update_connections;
|
2015-02-07 14:36:47 -05:00
|
|
|
bool _ignore_skips_updates;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
PBD::ScopedConnectionList punch_connections;
|
2008-06-02 17:41:35 -04:00
|
|
|
void auto_punch_start_changed (Location *);
|
|
|
|
void auto_punch_end_changed (Location *);
|
|
|
|
void auto_punch_changed (Location *);
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
PBD::ScopedConnectionList loop_connections;
|
2008-06-02 17:41:35 -04:00
|
|
|
void auto_loop_changed (Location *);
|
2012-06-20 14:46:05 -04:00
|
|
|
void auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2016-04-26 06:56:52 -04:00
|
|
|
int ensure_engine (uint32_t desired_sample_rate, bool);
|
2013-09-10 15:41:19 -04:00
|
|
|
void pre_engine_init (std::string path);
|
|
|
|
int post_engine_init ();
|
2015-02-05 16:21:01 -05:00
|
|
|
int immediately_post_engine ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_empty_sounds ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-05-08 20:56:10 -04:00
|
|
|
void session_loaded ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void setup_midi_control ();
|
|
|
|
int midi_read (MIDI::Port *);
|
|
|
|
|
|
|
|
void enable_record ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-09-17 12:24:22 -04:00
|
|
|
void increment_transport_position (framecnt_t val) {
|
|
|
|
if (max_framepos - val < _transport_frame) {
|
|
|
|
_transport_frame = max_framepos;
|
2008-06-02 17:41:35 -04:00
|
|
|
} else {
|
|
|
|
_transport_frame += val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-17 12:24:22 -04:00
|
|
|
void decrement_transport_position (framecnt_t val) {
|
2008-06-02 17:41:35 -04:00
|
|
|
if (val < _transport_frame) {
|
|
|
|
_transport_frame -= val;
|
|
|
|
} else {
|
|
|
|
_transport_frame = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void post_transport_motion ();
|
|
|
|
static void *session_loader_thread (void *arg);
|
|
|
|
|
|
|
|
void *do_work();
|
|
|
|
|
2015-04-28 16:18:30 -04:00
|
|
|
/* Signal Forwarding */
|
2015-04-30 11:58:33 -04:00
|
|
|
void emit_route_signals ();
|
2015-04-28 16:18:30 -04:00
|
|
|
void emit_thread_run ();
|
|
|
|
static void *emit_thread (void *);
|
|
|
|
void emit_thread_start ();
|
|
|
|
void emit_thread_terminate ();
|
|
|
|
|
|
|
|
pthread_t _rt_emit_thread;
|
|
|
|
bool _rt_thread_active;
|
|
|
|
|
|
|
|
pthread_mutex_t _rt_emit_mutex;
|
|
|
|
pthread_cond_t _rt_emit_cond;
|
|
|
|
bool _rt_emit_pending;
|
|
|
|
|
2016-04-23 16:11:48 -04:00
|
|
|
/* Auto Connect Thread */
|
|
|
|
static void *auto_connect_thread (void *);
|
|
|
|
void auto_connect_thread_run ();
|
|
|
|
void auto_connect_thread_start ();
|
|
|
|
void auto_connect_thread_terminate ();
|
|
|
|
|
|
|
|
pthread_t _auto_connect_thread;
|
|
|
|
bool _ac_thread_active;
|
|
|
|
pthread_mutex_t _auto_connect_mutex;
|
|
|
|
pthread_cond_t _auto_connect_cond;
|
|
|
|
|
|
|
|
struct AutoConnectRequest {
|
|
|
|
public:
|
|
|
|
AutoConnectRequest (boost::shared_ptr <Route> r, bool ci,
|
|
|
|
const ChanCount& is,
|
|
|
|
const ChanCount& os,
|
|
|
|
const ChanCount& io,
|
|
|
|
const ChanCount& oo)
|
|
|
|
: route (boost::weak_ptr<Route> (r))
|
|
|
|
, connect_inputs (ci)
|
|
|
|
, input_start (is)
|
|
|
|
, output_start (os)
|
|
|
|
, input_offset (io)
|
|
|
|
, output_offset (oo)
|
|
|
|
{}
|
|
|
|
|
|
|
|
boost::weak_ptr <Route> route;
|
|
|
|
bool connect_inputs;
|
|
|
|
ChanCount input_start;
|
|
|
|
ChanCount output_start;
|
|
|
|
ChanCount input_offset;
|
|
|
|
ChanCount output_offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef std::queue<AutoConnectRequest> AutoConnectQueue;
|
|
|
|
Glib::Threads::Mutex _auto_connect_queue_lock;
|
|
|
|
AutoConnectQueue _auto_connect_queue;
|
2016-07-09 11:42:58 -04:00
|
|
|
guint _latency_recompute_pending;
|
2016-04-23 16:11:48 -04:00
|
|
|
|
|
|
|
void auto_connect (const AutoConnectRequest&);
|
2016-07-09 11:42:58 -04:00
|
|
|
void queue_latency_recompute ();
|
2015-04-28 16:18:30 -04:00
|
|
|
|
2009-12-03 21:15:12 -05:00
|
|
|
/* SessionEventManager interface */
|
|
|
|
|
|
|
|
void process_event (SessionEvent*);
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_next_event ();
|
2009-12-03 21:15:12 -05:00
|
|
|
void cleanup_event (SessionEvent*,int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* MIDI Machine Control */
|
|
|
|
|
2012-04-11 16:21:00 -04:00
|
|
|
void spp_start ();
|
|
|
|
void spp_continue ();
|
|
|
|
void spp_stop ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void mmc_deferred_play (MIDI::MachineControl &);
|
|
|
|
void mmc_stop (MIDI::MachineControl &);
|
|
|
|
void mmc_step (MIDI::MachineControl &, int);
|
|
|
|
void mmc_pause (MIDI::MachineControl &);
|
|
|
|
void mmc_record_pause (MIDI::MachineControl &);
|
|
|
|
void mmc_record_strobe (MIDI::MachineControl &);
|
|
|
|
void mmc_record_exit (MIDI::MachineControl &);
|
|
|
|
void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
|
|
|
|
void mmc_fast_forward (MIDI::MachineControl &);
|
|
|
|
void mmc_rewind (MIDI::MachineControl &);
|
|
|
|
void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
|
|
|
|
void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
|
|
|
|
void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
|
|
|
|
|
|
|
|
struct timeval last_mmc_step;
|
|
|
|
double step_speed;
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
typedef boost::function<bool()> MidiTimeoutCallback;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::list<MidiTimeoutCallback> MidiTimeoutList;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
MidiTimeoutList midi_timeouts;
|
|
|
|
bool mmc_step_timeout ();
|
2014-10-22 17:06:53 -04:00
|
|
|
void send_immediate_mmc (MIDI::MachineControlCommand);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
MIDI::byte mtc_msg[16];
|
2009-10-26 10:38:58 -04:00
|
|
|
MIDI::byte mtc_timecode_bits; /* encoding of SMTPE type for MTC */
|
2008-06-02 17:41:35 -04:00
|
|
|
MIDI::byte midi_msg[16];
|
2013-03-02 17:52:39 -05:00
|
|
|
double outbound_mtc_timecode_frame;
|
2009-10-26 10:38:58 -04:00
|
|
|
Timecode::Time transmitting_timecode_time;
|
2008-06-02 17:41:35 -04:00
|
|
|
int next_quarter_frame_to_send;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
double _frames_per_timecode_frame; /* has to be floating point because of drop frame */
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t _frames_per_hour;
|
|
|
|
framecnt_t _timecode_frames_per_hour;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* cache the most-recently requested time conversions. This helps when we
|
|
|
|
* have multiple clocks showing the same time (e.g. the transport frame) */
|
2010-12-03 17:26:29 -05:00
|
|
|
bool last_timecode_valid;
|
|
|
|
framepos_t last_timecode_when;
|
|
|
|
Timecode::Time last_timecode;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
bool _send_timecode_update; ///< Flag to send a full frame (Timecode) MTC message this cycle
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-01-03 18:54:36 -05:00
|
|
|
int send_midi_time_code_for_cycle (framepos_t, framepos_t, pframes_t nframes);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2012-10-21 10:07:10 -04:00
|
|
|
LTCEncoder* ltc_encoder;
|
|
|
|
ltcsnd_sample_t* ltc_enc_buf;
|
|
|
|
|
|
|
|
Timecode::TimecodeFormat ltc_enc_tcformat;
|
|
|
|
int32_t ltc_buf_off;
|
|
|
|
int32_t ltc_buf_len;
|
2012-10-23 19:32:39 -04:00
|
|
|
|
2012-10-21 10:07:10 -04:00
|
|
|
double ltc_speed;
|
2012-10-23 19:32:39 -04:00
|
|
|
int32_t ltc_enc_byte;
|
|
|
|
framepos_t ltc_enc_pos;
|
|
|
|
double ltc_enc_cnt;
|
|
|
|
framepos_t ltc_enc_off;
|
2012-11-09 02:48:04 -05:00
|
|
|
bool restarting;
|
2013-08-04 10:13:43 -04:00
|
|
|
framepos_t ltc_prev_cycle;
|
2012-10-21 10:07:10 -04:00
|
|
|
|
2012-11-13 15:29:28 -05:00
|
|
|
framepos_t ltc_timecode_offset;
|
|
|
|
bool ltc_timecode_negative_offset;
|
|
|
|
|
2013-07-25 12:36:54 -04:00
|
|
|
LatencyRange ltc_out_latency;
|
2012-10-26 07:39:13 -04:00
|
|
|
|
2012-10-21 10:07:10 -04:00
|
|
|
void ltc_tx_initialize();
|
|
|
|
void ltc_tx_cleanup();
|
|
|
|
void ltc_tx_reset();
|
2012-10-28 06:48:06 -04:00
|
|
|
void ltc_tx_resync_latency();
|
2012-10-23 19:32:39 -04:00
|
|
|
void ltc_tx_recalculate_position();
|
2012-11-13 15:29:28 -05:00
|
|
|
void ltc_tx_parse_offset();
|
2012-10-25 23:11:10 -04:00
|
|
|
void ltc_tx_send_time_code_for_cycle (framepos_t, framepos_t, double, double, pframes_t nframes);
|
2012-10-21 10:07:10 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void reset_record_status ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
int no_roll (pframes_t nframes);
|
|
|
|
int fail_roll (pframes_t nframes);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work()); }
|
|
|
|
bool process_can_proceed() const { return !(post_transport_work() & ProcessCannotProceedMask); }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-08 22:05:14 -05:00
|
|
|
MidiControlUI* midi_control_ui;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int start_midi_thread ();
|
2009-12-08 22:05:14 -05:00
|
|
|
|
2014-04-17 09:47:06 -04:00
|
|
|
void set_play_loop (bool yn, double speed);
|
2009-11-08 11:28:21 -05:00
|
|
|
void unset_play_loop ();
|
2010-04-21 16:42:22 -04:00
|
|
|
void overwrite_some_buffers (Track *);
|
2008-06-02 17:41:35 -04:00
|
|
|
void flush_all_inserts ();
|
2010-12-03 17:26:29 -05:00
|
|
|
int micro_locate (framecnt_t distance);
|
2010-11-25 17:12:03 -05:00
|
|
|
void locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true);
|
2015-09-24 13:40:55 -04:00
|
|
|
void start_locate (framepos_t, bool with_roll, bool with_flush, bool for_loop_enabled=false, bool force=false);
|
2010-09-17 14:20:37 -04:00
|
|
|
void force_locate (framepos_t frame, bool with_roll = false);
|
2010-04-21 16:42:22 -04:00
|
|
|
void set_track_speed (Track *, double speed);
|
2015-02-05 16:21:01 -05:00
|
|
|
void set_transport_speed (double speed, framepos_t destination_frame, bool abort = false, bool clear_state = false, bool as_default = false);
|
2009-11-08 11:28:21 -05:00
|
|
|
void stop_transport (bool abort = false, bool clear_state = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
void start_transport ();
|
2009-11-08 11:28:21 -05:00
|
|
|
void realtime_stop (bool abort, bool clear_state);
|
2011-05-30 17:37:58 -04:00
|
|
|
void realtime_locate ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void non_realtime_start_scrub ();
|
|
|
|
void non_realtime_set_speed ();
|
|
|
|
void non_realtime_locate ();
|
|
|
|
void non_realtime_stop (bool abort, int entry_request_count, bool& finished);
|
|
|
|
void non_realtime_overwrite (int entry_request_count, bool& finished);
|
|
|
|
void post_transport ();
|
|
|
|
void engine_halted ();
|
|
|
|
void xrun_recovery ();
|
2015-02-13 15:27:53 -05:00
|
|
|
void set_track_loop (bool);
|
2015-01-16 12:17:09 -05:00
|
|
|
bool select_playhead_priority_target (framepos_t&);
|
|
|
|
void follow_playhead_priority ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
/* These are synchronous and so can only be called from within the process
|
|
|
|
* cycle
|
|
|
|
*/
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
int send_full_time_code (framepos_t, pframes_t nframes);
|
|
|
|
void send_song_position_pointer (framepos_t);
|
2013-08-08 19:31:10 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
TempoMap *_tempo_map;
|
2010-02-19 13:09:08 -05:00
|
|
|
void tempo_map_changed (const PBD::PropertyChange&);
|
2015-12-29 08:39:10 -05:00
|
|
|
void gui_tempo_map_changed ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* edit/mix groups */
|
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
int load_route_groups (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
std::list<RouteGroup *> _route_groups;
|
2010-11-25 17:12:03 -05:00
|
|
|
RouteGroup* _all_route_group;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* routes stuff */
|
|
|
|
|
2011-11-09 12:44:39 -05:00
|
|
|
boost::shared_ptr<Graph> _process_graph;
|
2010-06-03 15:50:22 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
SerializedRCUManager<RouteList> routes;
|
|
|
|
|
2016-05-16 07:30:28 -04:00
|
|
|
void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t);
|
|
|
|
void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t);
|
2015-02-05 16:21:01 -05:00
|
|
|
bool _adding_routes_in_progress;
|
2015-05-08 20:30:30 -04:00
|
|
|
bool _reconnecting_routes_in_progress;
|
2015-05-08 16:04:15 -04:00
|
|
|
bool _route_deletion_in_progress;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t destructive_index;
|
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
|
2010-04-21 16:42:22 -04:00
|
|
|
boost::shared_ptr<Route> XMLRouteFactory_2X (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-30 18:16:28 -05:00
|
|
|
void route_processors_changed (RouteProcessorChange);
|
|
|
|
|
2015-05-12 10:43:37 -04:00
|
|
|
bool find_route_name (std::string const &, uint32_t& id, std::string& name, bool);
|
2011-03-15 15:32:21 -04:00
|
|
|
void count_existing_track_channels (ChanCount& in, ChanCount& out);
|
2016-04-23 16:11:48 -04:00
|
|
|
void auto_connect_route (boost::shared_ptr<Route>, bool, const ChanCount&, const ChanCount&, const ChanCount& io = ChanCount(), const ChanCount& oo = ChanCount());
|
2011-06-01 12:50:12 -04:00
|
|
|
void midi_output_change_handler (IOChange change, void* /*src*/, boost::weak_ptr<Route> midi_track);
|
2010-02-23 17:45:07 -05:00
|
|
|
|
2014-06-25 15:16:09 -04:00
|
|
|
/* track numbering */
|
|
|
|
|
|
|
|
void reassign_track_numbers ();
|
|
|
|
uint32_t _track_number_decimals;
|
|
|
|
|
2016-03-11 10:34:51 -05:00
|
|
|
/* solo/mute/notifications */
|
2016-03-09 13:11:53 -05:00
|
|
|
|
2016-03-11 10:34:51 -05:00
|
|
|
void route_listen_changed (PBD::Controllable::GroupControlDisposition, boost::weak_ptr<Route>);
|
|
|
|
void route_mute_changed ();
|
|
|
|
void route_solo_changed (bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route>);
|
|
|
|
void route_solo_isolated_changed (boost::weak_ptr<Route>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-10 14:10:07 -04:00
|
|
|
void update_route_solo_state (boost::shared_ptr<RouteList> r = boost::shared_ptr<RouteList>());
|
2009-07-01 09:36:50 -04:00
|
|
|
|
|
|
|
void listen_position_changed ();
|
|
|
|
void solo_control_mode_changed ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* REGION MANAGEMENT */
|
|
|
|
|
2012-07-25 13:48:55 -04:00
|
|
|
mutable Glib::Threads::Mutex region_lock;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int load_regions (const XMLNode& node);
|
2011-05-22 12:11:00 -04:00
|
|
|
int load_compounds (const XMLNode& node);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-09-07 07:56:23 -04:00
|
|
|
void route_added_to_route_group (RouteGroup *, boost::weak_ptr<Route>);
|
|
|
|
void route_removed_from_route_group (RouteGroup *, boost::weak_ptr<Route>);
|
2016-01-19 14:16:49 -05:00
|
|
|
void route_group_property_changed (RouteGroup *);
|
2009-06-20 09:41:55 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* SOURCES */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2012-07-25 13:48:55 -04:00
|
|
|
mutable Glib::Threads::Mutex source_lock;
|
2010-07-14 08:27:37 -04:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
public:
|
2008-06-02 17:41:35 -04:00
|
|
|
typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
|
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
private:
|
2015-04-06 21:18:52 -04:00
|
|
|
void reset_write_sources (bool mark_write_complete, bool force = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
SourceMap sources;
|
|
|
|
|
2015-04-06 21:18:52 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
int load_sources (const XMLNode& node);
|
|
|
|
XMLNode& get_sources_as_xml ();
|
|
|
|
|
|
|
|
boost::shared_ptr<Source> XMLSourceFactory (const XMLNode&);
|
|
|
|
|
|
|
|
/* PLAYLISTS */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_playlist (boost::weak_ptr<Playlist>);
|
2010-04-21 16:42:22 -04:00
|
|
|
void track_playlist_changed (boost::weak_ptr<Track>);
|
2011-01-19 12:38:56 -05:00
|
|
|
void playlist_region_added (boost::weak_ptr<Region>);
|
|
|
|
void playlist_ranges_moved (std::list<Evoral::RangeMove<framepos_t> > const &);
|
2011-03-01 11:23:31 -05:00
|
|
|
void playlist_regions_extended (std::list<Evoral::Range<framepos_t> > const &);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* CURVES and AUTOMATION LISTS */
|
|
|
|
std::map<PBD::ID, AutomationList*> automation_lists;
|
|
|
|
|
|
|
|
/* DEFAULT FADE CURVES */
|
|
|
|
|
|
|
|
float default_fade_steepness;
|
|
|
|
float default_fade_msecs;
|
|
|
|
|
|
|
|
/* AUDITIONING */
|
|
|
|
|
|
|
|
boost::shared_ptr<Auditioner> auditioner;
|
|
|
|
void set_audition (boost::shared_ptr<Region>);
|
|
|
|
void non_realtime_set_audition ();
|
|
|
|
boost::shared_ptr<Region> pending_audition_region;
|
|
|
|
|
|
|
|
/* EXPORT */
|
|
|
|
|
|
|
|
/* FLATTEN */
|
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
int flatten_one_track (AudioTrack&, framepos_t start, framecnt_t cnt);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* INSERT AND SEND MANAGEMENT */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> send_bitset;
|
2012-01-18 12:51:57 -05:00
|
|
|
boost::dynamic_bitset<uint32_t> aux_send_bitset;
|
2009-05-07 13:31:18 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> return_bitset;
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> insert_bitset;
|
|
|
|
|
|
|
|
/* S/W RAID */
|
|
|
|
|
|
|
|
struct space_and_path {
|
2012-06-12 12:41:29 -04:00
|
|
|
uint32_t blocks; ///< 4kB blocks
|
|
|
|
bool blocks_unknown; ///< true if blocks is unknown
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string path;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2012-06-12 12:41:29 -04:00
|
|
|
space_and_path ()
|
|
|
|
: blocks (0)
|
|
|
|
, blocks_unknown (true)
|
|
|
|
{}
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct space_and_path_ascending_cmp {
|
2009-01-30 15:18:31 -05:00
|
|
|
bool operator() (space_and_path a, space_and_path b) {
|
2012-06-12 12:41:29 -04:00
|
|
|
if (a.blocks_unknown != b.blocks_unknown) {
|
|
|
|
return !a.blocks_unknown;
|
|
|
|
}
|
2009-01-30 15:18:31 -05:00
|
|
|
return a.blocks > b.blocks;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void setup_raid_path (std::string path);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<space_and_path> session_dirs;
|
|
|
|
std::vector<space_and_path>::iterator last_rr_session_dir;
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t _total_free_4k_blocks;
|
2012-06-12 12:41:29 -04:00
|
|
|
/** If this is true, _total_free_4k_blocks is not definite,
|
|
|
|
as one or more of the session directories' filesystems
|
|
|
|
could not report free space.
|
|
|
|
*/
|
|
|
|
bool _total_free_4k_blocks_uncertain;
|
2012-07-25 13:48:55 -04:00
|
|
|
Glib::Threads::Mutex space_lock;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
bool no_questions_about_missing_files;
|
2010-11-09 01:03:51 -05:00
|
|
|
|
2014-06-02 11:20:37 -04:00
|
|
|
std::string get_best_session_directory_for_new_audio ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
mutable gint _playback_load;
|
|
|
|
mutable gint _capture_load;
|
|
|
|
|
|
|
|
/* I/O bundles */
|
|
|
|
|
2009-01-25 01:47:11 -05:00
|
|
|
SerializedRCUManager<BundleList> _bundles;
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode* _bundle_xml_node;
|
|
|
|
int load_bundles (XMLNode const &);
|
|
|
|
|
2011-01-19 12:38:46 -05:00
|
|
|
UndoHistory _history;
|
|
|
|
/** current undo transaction, or 0 */
|
|
|
|
UndoTransaction* _current_trans;
|
2011-01-19 12:38:56 -05:00
|
|
|
/** GQuarks to describe the reversible commands that are currently in progress.
|
|
|
|
* These may be nested, in which case more recently-started commands are toward
|
|
|
|
* the front of the list.
|
|
|
|
*/
|
|
|
|
std::list<GQuark> _current_trans_quarks;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
int backend_sync_callback (TransportState, framepos_t);
|
2013-08-09 12:15:37 -04:00
|
|
|
|
2009-12-07 16:37:35 -05:00
|
|
|
void process_rtop (SessionEvent*);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
void update_latency (bool playback);
|
2011-02-15 14:55:14 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode& state(bool);
|
|
|
|
|
|
|
|
/* click track */
|
2011-10-18 23:34:02 -04:00
|
|
|
typedef std::list<Click*> Clicks;
|
2012-01-27 17:47:16 -05:00
|
|
|
Clicks clicks;
|
|
|
|
bool _clicking;
|
|
|
|
boost::shared_ptr<IO> _click_io;
|
|
|
|
boost::shared_ptr<Amp> _click_gain;
|
|
|
|
Sample* click_data;
|
|
|
|
Sample* click_emphasis_data;
|
|
|
|
framecnt_t click_length;
|
|
|
|
framecnt_t click_emphasis_length;
|
2012-07-25 13:48:55 -04:00
|
|
|
mutable Glib::Threads::RWLock click_lock;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
static const Sample default_click[];
|
|
|
|
static const framecnt_t default_click_length;
|
|
|
|
static const Sample default_click_emphasis[];
|
|
|
|
static const framecnt_t default_click_emphasis_length;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
Click *get_click();
|
2012-01-11 09:36:46 -05:00
|
|
|
framepos_t _clicks_cleared;
|
2008-06-02 17:41:35 -04:00
|
|
|
void setup_click_sounds (int which);
|
2011-02-17 15:25:09 -05:00
|
|
|
void setup_click_sounds (Sample**, Sample const *, framecnt_t*, framecnt_t, std::string const &);
|
2008-06-02 17:41:35 -04:00
|
|
|
void clear_clicks ();
|
2010-12-03 17:26:29 -05:00
|
|
|
void click (framepos_t start, framecnt_t nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<Route*> master_outs;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* range playback */
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::list<AudioRange> current_audio_range;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _play_range;
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_play_range (std::list<AudioRange>&, bool leave_rolling);
|
|
|
|
void unset_play_range ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2015-01-16 12:17:09 -05:00
|
|
|
/* temporary hacks to allow selection to be pushed from GUI into backend
|
|
|
|
Whenever we move the selection object into libardour, these will go away.
|
|
|
|
*/
|
|
|
|
Evoral::Range<framepos_t> _range_selection;
|
|
|
|
Evoral::Range<framepos_t> _object_selection;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* main outs */
|
|
|
|
uint32_t main_outs;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Route> _master_out;
|
2010-03-22 17:35:35 -04:00
|
|
|
boost::shared_ptr<Route> _monitor_out;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2012-01-17 20:30:44 -05:00
|
|
|
void auto_connect_master_bus ();
|
|
|
|
|
2011-11-21 12:42:29 -05:00
|
|
|
/* Windows VST support */
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-11-21 12:42:29 -05:00
|
|
|
long _windows_vst_callback (
|
|
|
|
WindowsVSTPlugin*,
|
|
|
|
long opcode,
|
|
|
|
long index,
|
|
|
|
long value,
|
|
|
|
void* ptr,
|
|
|
|
float opt
|
|
|
|
);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int find_all_sources (std::string path, std::set<std::string>& result);
|
|
|
|
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
|
|
|
|
|
|
|
|
typedef std::set<boost::shared_ptr<PBD::Controllable> > Controllables;
|
2012-07-25 13:48:55 -04:00
|
|
|
Glib::Threads::Mutex controllables_lock;
|
2008-06-02 17:41:35 -04:00
|
|
|
Controllables controllables;
|
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
boost::shared_ptr<PBD::Controllable> _solo_cut_control;
|
2011-02-11 11:14:54 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void reset_native_file_format();
|
|
|
|
bool first_file_data_format_reset;
|
|
|
|
bool first_file_header_format_reset;
|
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
void config_changed (std::string, bool);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
XMLNode& get_control_protocol_state ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_history_depth (uint32_t depth);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
static bool _disable_all_loaded_plugins;
|
2015-09-01 07:26:31 -04:00
|
|
|
static bool _bypass_all_loaded_plugins;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
mutable bool have_looped; ///< Used in ::audible_frame(*)
|
2009-04-29 13:30:35 -04:00
|
|
|
|
2014-09-19 09:45:01 -04:00
|
|
|
void update_route_record_state ();
|
2010-04-21 16:42:22 -04:00
|
|
|
gint _have_rec_enabled_track;
|
2014-09-19 09:45:01 -04:00
|
|
|
gint _have_rec_disabled_track;
|
2009-12-10 12:45:18 -05:00
|
|
|
|
2009-12-20 11:50:41 -05:00
|
|
|
static int ask_about_playlist_deletion (boost::shared_ptr<Playlist>);
|
|
|
|
|
2009-12-10 12:45:18 -05:00
|
|
|
/* realtime "apply to set of routes" operations */
|
2011-10-20 14:50:29 -04:00
|
|
|
template<typename T> SessionEvent*
|
2016-01-21 11:03:14 -05:00
|
|
|
get_rt_event (boost::shared_ptr<RouteList> rl, T targ, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override,
|
|
|
|
void (Session::*method) (boost::shared_ptr<RouteList>, T, PBD::Controllable::GroupControlDisposition)) {
|
2011-10-20 14:50:29 -04:00
|
|
|
SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
|
|
|
|
ev->rt_slot = boost::bind (method, this, rl, targ, group_override);
|
|
|
|
ev->rt_return = after;
|
|
|
|
ev->event_loop = PBD::EventLoop::get_event_loop_for_thread ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2011-10-20 14:50:29 -04:00
|
|
|
return ev;
|
|
|
|
}
|
2009-12-10 12:45:18 -05:00
|
|
|
|
2016-03-08 10:42:20 -05:00
|
|
|
/* specialized version realtime "apply to set of routes" operations */
|
|
|
|
template<typename T1, typename T2> SessionEvent*
|
|
|
|
get_rt_event (boost::shared_ptr<RouteList> rl, T1 t1arg, T2 t2arg, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override,
|
|
|
|
void (Session::*method) (boost::shared_ptr<RouteList>, T1, T2, PBD::Controllable::GroupControlDisposition)) {
|
|
|
|
SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
|
|
|
|
ev->rt_slot = boost::bind (method, this, rl, t1arg, t2arg, group_override);
|
|
|
|
ev->rt_return = after;
|
|
|
|
ev->event_loop = PBD::EventLoop::get_event_loop_for_thread ();
|
|
|
|
|
|
|
|
return ev;
|
|
|
|
}
|
|
|
|
|
2016-04-08 16:49:47 -04:00
|
|
|
/* specialized version realtime "apply to set of controls" operations */
|
|
|
|
SessionEvent* get_rt_event (boost::shared_ptr<ControlList> cl, double arg, PBD::Controllable::GroupControlDisposition group_override) {
|
|
|
|
SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
|
|
|
|
ev->rt_slot = boost::bind (&Session::rt_set_controls, this, cl, arg, group_override);
|
|
|
|
ev->rt_return = Session::rt_cleanup;
|
|
|
|
ev->event_loop = PBD::EventLoop::get_event_loop_for_thread ();
|
|
|
|
|
|
|
|
return ev;
|
|
|
|
}
|
|
|
|
|
|
|
|
void rt_set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition group_override);
|
2016-01-21 11:03:14 -05:00
|
|
|
void rt_clear_all_solo_state (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
|
2010-04-21 16:42:22 -04:00
|
|
|
|
|
|
|
/** temporary list of Diskstreams used only during load of 2.X sessions */
|
|
|
|
std::list<boost::shared_ptr<Diskstream> > _diskstreams_2X;
|
2010-05-09 16:48:21 -04:00
|
|
|
|
2015-05-13 10:16:16 -04:00
|
|
|
void set_session_range_location (framepos_t, framepos_t);
|
2010-06-09 13:24:07 -04:00
|
|
|
|
2010-06-29 09:47:53 -04:00
|
|
|
void setup_midi_machine_control ();
|
2010-07-20 22:17:57 -04:00
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
void step_edit_status_change (bool);
|
|
|
|
uint32_t _step_editors;
|
2010-08-01 21:59:34 -04:00
|
|
|
|
|
|
|
/** true if timecode transmission by the transport is suspended, otherwise false */
|
|
|
|
mutable gint _suspend_timecode_transmission;
|
2010-08-09 12:40:31 -04:00
|
|
|
|
2014-10-24 12:18:40 -04:00
|
|
|
void update_locations_after_tempo_map_change (const Locations::LocationList &);
|
2010-10-07 14:33:20 -04:00
|
|
|
|
|
|
|
void start_time_changed (framepos_t);
|
|
|
|
void end_time_changed (framepos_t);
|
2010-11-18 19:58:57 -05:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
void set_track_monitor_input_status (bool);
|
2011-05-02 18:21:59 -04:00
|
|
|
framepos_t compute_stop_limit () const;
|
2011-03-05 18:16:32 -05:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
boost::shared_ptr<Speakers> _speakers;
|
2011-05-26 08:24:04 -04:00
|
|
|
void load_nested_sources (const XMLNode& node);
|
2011-11-09 12:44:39 -05:00
|
|
|
|
|
|
|
/** The directed graph of routes that is currently being used for audio processing
|
|
|
|
and solo/mute computations.
|
|
|
|
*/
|
|
|
|
GraphEdges _current_route_graph;
|
2012-01-17 20:30:44 -05:00
|
|
|
|
2016-06-02 11:47:19 -04:00
|
|
|
void ensure_route_presentation_info_gap (PresentationInfo::order_t, uint32_t gap_size);
|
2012-01-17 20:30:44 -05:00
|
|
|
bool ignore_route_processor_changes;
|
2012-01-27 08:22:55 -05:00
|
|
|
|
|
|
|
MidiClockTicker* midi_clock;
|
2012-10-25 15:46:23 -04:00
|
|
|
|
2015-02-05 16:21:01 -05:00
|
|
|
boost::shared_ptr<IO> _ltc_input;
|
|
|
|
boost::shared_ptr<IO> _ltc_output;
|
2012-10-25 15:46:23 -04:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
/* Scene Changing */
|
|
|
|
SceneChanger* _scene_changer;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
/* persistent, non-track related MIDI ports */
|
|
|
|
MidiPortManager* _midi_ports;
|
|
|
|
MIDI::MachineControl* _mmc;
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
void setup_ltc ();
|
|
|
|
void setup_click ();
|
|
|
|
void setup_click_state (const XMLNode*);
|
|
|
|
void setup_bundles ();
|
2015-10-05 10:17:49 -04:00
|
|
|
|
2015-01-14 17:53:23 -05:00
|
|
|
void save_as_bring_callback (uint32_t, uint32_t, std::string);
|
|
|
|
|
2014-04-28 19:58:24 -04:00
|
|
|
static int get_session_info_from_path (XMLTree& state_tree, const std::string& xmlpath);
|
2015-05-13 10:39:24 -04:00
|
|
|
static const uint32_t session_end_shift;
|
2015-12-19 08:46:15 -05:00
|
|
|
|
|
|
|
std::string _template_state_dir;
|
2016-01-26 00:18:03 -05:00
|
|
|
|
|
|
|
VCAManager* _vca_manager;
|
2016-05-16 07:30:28 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<Route> get_midi_nth_route_by_id (PresentationInfo::order_t n) const;
|
2016-06-01 16:27:55 -04:00
|
|
|
|
|
|
|
std::string created_with;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
2014-06-28 15:27:36 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
} // namespace ARDOUR
|
|
|
|
|
|
|
|
#endif /* __ardour_session_h__ */
|