2008-06-02 17:41:35 -04:00
|
|
|
/*
|
2008-08-04 18:37:24 -04:00
|
|
|
Copyright (C) 2000 Paul Davis
|
2008-06-02 17:41:35 -04: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.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __ardour_session_h__
|
|
|
|
#define __ardour_session_h__
|
|
|
|
|
2011-03-10 21:55:52 -05:00
|
|
|
#include "libardour-config.h"
|
|
|
|
|
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>
|
|
|
|
#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
|
|
|
|
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"
|
|
|
|
#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"
|
|
|
|
|
2011-10-18 23:34:02 -04:00
|
|
|
#include "evoral/types.hpp"
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "midi++/types.h"
|
|
|
|
|
2010-12-14 13:13:37 -05:00
|
|
|
#include "timecode/time.h"
|
2012-12-14 11:18:47 -05:00
|
|
|
#include "ltc/ltc.h"
|
2010-12-14 13:13:37 -05:00
|
|
|
|
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"
|
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-02-25 13:26:51 -05:00
|
|
|
#include "ardour/location.h"
|
2009-06-09 20:03:47 -04:00
|
|
|
#include "ardour/interpolation.h"
|
2011-11-09 12:44:39 -05:00
|
|
|
#include "ardour/route_graph.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-04-02 14:54:33 -04:00
|
|
|
#ifdef HAVE_JACK_SESSION
|
|
|
|
#include <jack/session.h>
|
|
|
|
#endif
|
|
|
|
|
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 {
|
|
|
|
class Port;
|
2010-06-29 09:47:53 -04:00
|
|
|
class MachineControl;
|
|
|
|
class Parser;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace PBD {
|
|
|
|
class Controllable;
|
2009-12-31 18:43:47 -05:00
|
|
|
class ControllableDescriptor;
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
namespace Evoral {
|
|
|
|
class Curve;
|
|
|
|
}
|
|
|
|
|
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;
|
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;
|
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;
|
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;
|
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 ();
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
class 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
|
|
|
|
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
|
|
|
|
|
|
|
void set_snap_name ();
|
2009-10-14 12:10:01 -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 ();
|
2008-06-02 17:41:35 -04:00
|
|
|
bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
|
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
|
|
|
|
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
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
std::string peak_path (std::string) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2010-07-21 22:27:06 -04:00
|
|
|
std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string peak_path_from_audio_path (std::string) const;
|
|
|
|
std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
|
|
|
|
std::string new_midi_source_name (const std::string&);
|
2011-03-02 12:05:16 -05:00
|
|
|
std::string new_source_path_from_name (DataType type, const std::string&);
|
2013-04-01 20:45:57 -04:00
|
|
|
RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
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);
|
2013-07-31 18:35:24 -04:00
|
|
|
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;
|
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
|
|
|
|
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 ();
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
struct 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
|
|
|
|
2012-07-19 18:35:43 -04:00
|
|
|
void notify_remote_id_change ();
|
2012-06-25 08:46:13 -04:00
|
|
|
void sync_order_keys (RouteSortOrderKey);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
|
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
|
|
|
|
template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
|
|
|
|
|
2011-12-08 22:06:58 -05:00
|
|
|
static char session_name_is_legal (const std::string&);
|
2010-11-25 17:12:03 -05:00
|
|
|
bool io_name_is_legal (const std::string&);
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Route> route_by_name (std::string);
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Route> route_by_id (PBD::ID);
|
|
|
|
boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
|
2011-12-10 14:20:15 -05:00
|
|
|
boost::shared_ptr<Track> track_by_diskstream_id (PBD::ID);
|
2012-11-12 21:19:04 -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
|
|
|
|
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 ();
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Record status signals */
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> RecordStateChanged;
|
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
|
|
|
|
*/
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
PBD::Signal1<void, RouteGroup *> RouteGroupPropertyChanged;
|
|
|
|
/** 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
|
|
|
|
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);
|
2012-06-22 10:45:44 -04:00
|
|
|
void request_transport_speed (double speed, bool as_default = false);
|
|
|
|
void request_transport_speed_nonzero (double, bool as_default = false);
|
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 *);
|
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; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2011-06-01 12:50:12 -04:00
|
|
|
#ifdef HAVE_JACK_SESSION
|
2010-04-02 14:54:33 -04:00
|
|
|
void jack_session_event (jack_session_event_t* event);
|
|
|
|
#endif
|
2010-04-20 22:24:38 -04:00
|
|
|
int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false);
|
2008-09-10 11:03:30 -04:00
|
|
|
int restore_state (std::string snapshot_name);
|
|
|
|
int save_template (std::string template_name);
|
|
|
|
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 ();
|
2011-07-14 13:41:06 -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; }
|
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;
|
2013-04-08 13:51:00 -04:00
|
|
|
PBD::Signal0<void> SaveSession;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -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,
|
|
|
|
InCleanup = 0x20
|
|
|
|
};
|
|
|
|
|
|
|
|
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
|
|
|
|
|
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,
|
|
|
|
TrackMode mode = Normal,
|
|
|
|
RouteGroup* route_group = 0,
|
|
|
|
uint32_t how_many = 1,
|
|
|
|
std::string name_template = ""
|
2009-06-20 11:40:26 -04:00
|
|
|
);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2011-02-26 20:59:04 -05:00
|
|
|
RouteList new_audio_route (
|
|
|
|
int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, std::string name_template = ""
|
|
|
|
);
|
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,
|
2012-02-01 23:12:23 -05:00
|
|
|
boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>(),
|
|
|
|
TrackMode mode = Normal,
|
|
|
|
RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
|
2009-06-20 11:40:26 -04:00
|
|
|
);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
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; }
|
|
|
|
|
|
|
|
/* Time */
|
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
framepos_t transport_frame () const {return _transport_frame; }
|
2010-09-17 14:20:37 -04:00
|
|
|
framepos_t audible_frame () const;
|
|
|
|
framepos_t requested_return_frame() const { return _requested_return_frame; }
|
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;
|
2010-09-17 12:24:22 -04:00
|
|
|
void timecode_duration_string (char *, 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*);
|
2012-10-10 23:10:18 -04:00
|
|
|
bool synced_to_jack() const { return config.get_external_sync() && Config->get_sync_source() == JACK; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
double transport_speed() const { return _transport_speed; }
|
|
|
|
bool transport_stopped() const { return _transport_speed == 0.0f; }
|
|
|
|
bool transport_rolling() const { return _transport_speed != 0.0f; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_silent (bool yn);
|
|
|
|
bool silent () { return _silent; }
|
|
|
|
|
|
|
|
TempoMap& tempo_map() { return *_tempo_map; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
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;
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string path_from_region_name (DataType type, std::string name, std::string identifier);
|
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
|
|
|
|
2012-06-08 17:06:49 -04:00
|
|
|
int start_audio_export (framepos_t position);
|
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>);
|
|
|
|
|
2011-02-14 16:49:43 -05:00
|
|
|
void cleanup_regions();
|
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 ();
|
|
|
|
|
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
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return !0 for use pending state, 0 for ignore it.
|
2008-06-02 17:41:35 -04: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
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
boost::shared_ptr<MidiSource> create_midi_source_for_session (
|
2011-03-02 12:05:16 -05:00
|
|
|
Track*, std::string const &);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<Source> source_by_id (const PBD::ID&);
|
2010-09-14 11:45:21 -04:00
|
|
|
boost::shared_ptr<Source> source_by_path_and_channel (const std::string&, uint16_t);
|
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
|
|
|
|
|
|
|
/* flattening stuff */
|
|
|
|
|
2010-08-16 15:58:34 -04:00
|
|
|
boost::shared_ptr<Region> write_one_track (AudioTrack&, framepos_t start, framepos_t end,
|
2012-03-15 17:40:17 -04:00
|
|
|
bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
|
|
|
|
boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export);
|
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; }
|
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
|
|
|
|
2009-12-11 18:30:48 -05:00
|
|
|
void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
|
|
|
void set_just_one_solo (boost::shared_ptr<Route>, bool, SessionEvent::RTeventCallback after = rt_cleanup);
|
2012-01-25 16:19:48 -05:00
|
|
|
void cancel_solo_after_disconnect (boost::shared_ptr<Route>, bool upstream, SessionEvent::RTeventCallback after = rt_cleanup);
|
2009-12-11 18:30:48 -05:00
|
|
|
void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
|
|
|
void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
2010-07-24 12:40:56 -04:00
|
|
|
void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
2010-11-25 17:12:03 -05:00
|
|
|
void set_solo_isolated (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
2011-10-20 14:50:29 -04:00
|
|
|
void set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
2012-11-12 21:19:04 -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;
|
2011-06-01 12:50:12 -04:00
|
|
|
|
2012-01-17 20:30:44 -05:00
|
|
|
/* monitor/master out */
|
|
|
|
|
|
|
|
void add_monitor_section ();
|
|
|
|
void remove_monitor_section ();
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
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 */
|
|
|
|
|
|
|
|
void add_bundle (boost::shared_ptr<Bundle>);
|
|
|
|
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
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleAdded;
|
|
|
|
PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleRemoved;
|
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
|
|
|
|
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);
|
2008-06-02 17:41:35 -04:00
|
|
|
void commit_reversible_command (Command* cmd = 0);
|
|
|
|
|
|
|
|
void add_command (Command *const cmd) {
|
2011-01-19 12:38:46 -05:00
|
|
|
assert (_current_trans);
|
|
|
|
_current_trans->add_command (cmd);
|
2008-06-02 17:41:35 -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);
|
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);
|
|
|
|
|
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;
|
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 */
|
|
|
|
|
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
|
|
|
|
);
|
2011-09-20 16:29:47 -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 */
|
|
|
|
|
|
|
|
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
|
2009-12-31 18:43:47 -05:00
|
|
|
boost::shared_ptr<PBD::Controllable> controllable_by_descriptor (const PBD::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;
|
|
|
|
|
2009-09-01 16:13:23 -04:00
|
|
|
bool exporting () const {
|
|
|
|
return _exporting;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
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; }
|
2012-10-12 18:04:21 -04: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);
|
2013-08-07 22:22:11 -04:00
|
|
|
int send_full_time_code (framepos_t, pframes_t nframes);
|
2013-07-28 18:18:30 -04:00
|
|
|
void send_song_position_pointer (framepos_t);
|
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;
|
|
|
|
|
2010-11-25 17:12:03 -05:00
|
|
|
std::string source_search_path(DataType) const;
|
|
|
|
void ensure_search_path_includes (const std::string& path, DataType type);
|
|
|
|
|
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;
|
|
|
|
|
2013-03-04 16:57:29 -05:00
|
|
|
/** Emitted when Ardour is asked to load a session in an older session
|
|
|
|
* format, and makes a backup copy.
|
|
|
|
*/
|
|
|
|
static PBD::Signal2<void,std::string,std::string> VersionMismatch;
|
|
|
|
|
2012-10-25 15:46:23 -04:00
|
|
|
boost::shared_ptr<Port> ltc_input_port() const;
|
|
|
|
boost::shared_ptr<Port> ltc_output_port() const;
|
2012-10-26 07:39:10 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
|
|
|
|
boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
|
2012-10-25 15:46:23 -04:00
|
|
|
|
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);
|
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
|
|
|
|
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;
|
|
|
|
bool waiting_for_sync_offset;
|
2010-12-03 17:26:29 -05:00
|
|
|
framecnt_t _base_frame_rate;
|
|
|
|
framecnt_t _current_frame_rate; //this includes video pullup offset
|
|
|
|
framecnt_t _nominal_frame_rate; //ignores audioengine setting, "native" SR
|
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
|
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;
|
|
|
|
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;
|
|
|
|
float _meter_hold;
|
|
|
|
float _meter_falloff;
|
2009-06-09 16:21:19 -04:00
|
|
|
bool _non_soloed_outs_muted;
|
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;
|
2008-06-02 17:41:35 -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);
|
2012-12-06 14:56:33 -05:00
|
|
|
int process_export (pframes_t);
|
2010-12-03 17:26:29 -05:00
|
|
|
int 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); }
|
|
|
|
|
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;
|
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;
|
2012-10-17 18:33:02 -04:00
|
|
|
bool _export_started;
|
2009-12-27 17:09:40 -05:00
|
|
|
bool _export_rolling;
|
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,
|
|
|
|
-1 if there is a pending declick fade-out,
|
|
|
|
0 if there is no pending declick.
|
|
|
|
*/
|
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 ();
|
|
|
|
void when_engine_running ();
|
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 */
|
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;
|
|
|
|
|
|
|
|
void auto_save();
|
|
|
|
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
|
|
|
|
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 (
|
|
|
|
PostTransportInputChange|
|
|
|
|
PostTransportSpeed|
|
|
|
|
PostTransportReverse|
|
|
|
|
PostTransportCurveRealloc|
|
|
|
|
PostTransportAudition|
|
|
|
|
PostTransportLocate|
|
2009-11-08 11:28:21 -05:00
|
|
|
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 */
|
2012-10-29 12:33:38 -04: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;
|
2008-06-02 17:41:35 -04:00
|
|
|
void locations_changed ();
|
|
|
|
void locations_added (Location*);
|
|
|
|
void handle_locations_changed (Locations::LocationList&);
|
|
|
|
|
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
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void first_stage_init (std::string path, std::string snapshot_name);
|
2011-12-26 19:57:20 -05:00
|
|
|
int second_stage_init ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_empty_sounds ();
|
|
|
|
|
|
|
|
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();
|
|
|
|
|
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 ();
|
|
|
|
|
|
|
|
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
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_play_loop (bool yn);
|
|
|
|
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);
|
|
|
|
void start_locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=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);
|
2012-06-22 10:45:44 -04:00
|
|
|
void set_transport_speed (double speed, 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 ();
|
|
|
|
|
|
|
|
TempoMap *_tempo_map;
|
2010-02-19 13:09:08 -05:00
|
|
|
void tempo_map_changed (const PBD::PropertyChange&);
|
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;
|
|
|
|
|
2012-03-07 08:24:20 -05:00
|
|
|
void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save);
|
2012-12-04 09:32:28 -05:00
|
|
|
void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect);
|
|
|
|
bool _adding_routes_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);
|
|
|
|
|
2011-02-26 20:59:04 -05:00
|
|
|
bool find_route_name (std::string const &, uint32_t& id, char* name, size_t name_len, bool);
|
2011-03-15 15:32:21 -04:00
|
|
|
void count_existing_track_channels (ChanCount& in, ChanCount& out);
|
2011-03-20 18:09:46 -04:00
|
|
|
void auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
|
2011-06-01 12:50:12 -04:00
|
|
|
bool with_lock, bool connect_inputs = true,
|
|
|
|
ChanCount input_start = ChanCount (), ChanCount output_start = ChanCount ());
|
|
|
|
void midi_output_change_handler (IOChange change, void* /*src*/, boost::weak_ptr<Route> midi_track);
|
2010-02-23 17:45:07 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* mixer stuff */
|
|
|
|
|
2009-07-01 09:36:50 -04:00
|
|
|
bool solo_update_disabled;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-07-01 09:36:50 -04:00
|
|
|
void route_listen_changed (void *src, boost::weak_ptr<Route>);
|
2008-06-02 17:41:35 -04:00
|
|
|
void route_mute_changed (void *src);
|
2010-04-26 23:10:53 -04:00
|
|
|
void route_solo_changed (bool self_solo_change, void *src, boost::weak_ptr<Route>);
|
2010-05-06 14:40:37 -04:00
|
|
|
void route_solo_isolated_changed (void *src, boost::weak_ptr<Route>);
|
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>);
|
|
|
|
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:
|
2008-06-02 17:41:35 -04:00
|
|
|
SourceMap sources;
|
|
|
|
|
|
|
|
public:
|
|
|
|
SourceMap get_sources() { return sources; }
|
2008-08-04 18:37:24 -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
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string get_best_session_directory_for_new_source ();
|
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
|
|
|
|
2013-07-30 17:48:57 -04:00
|
|
|
// void timebase_callback (TransportState, pframes_t, jack_position_t*, int);
|
|
|
|
int jack_sync_callback (TransportState, framepos_t);
|
2008-06-02 17:41:35 -04:00
|
|
|
void reset_jack_connection (jack_client_t* jack);
|
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
|
|
|
|
|
|
|
/* 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
|
|
|
|
|
|
|
/* number of hardware ports we're using,
|
|
|
|
based on max (requested,available)
|
|
|
|
*/
|
|
|
|
|
2010-07-27 20:43:15 -04:00
|
|
|
ChanCount n_physical_outputs;
|
|
|
|
ChanCount n_physical_inputs;
|
2008-12-12 09:43:24 -05:00
|
|
|
|
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;
|
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
|
|
|
|
2010-04-21 16:42:22 -04:00
|
|
|
void update_have_rec_enabled_track ();
|
|
|
|
gint _have_rec_enabled_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*
|
|
|
|
get_rt_event (boost::shared_ptr<RouteList> rl, T targ, SessionEvent::RTeventCallback after, bool group_override,
|
|
|
|
void (Session::*method) (boost::shared_ptr<RouteList>, T, bool)) {
|
|
|
|
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 ();
|
|
|
|
|
|
|
|
return ev;
|
|
|
|
}
|
2009-12-10 12:45:18 -05:00
|
|
|
|
2012-01-25 16:19:48 -05:00
|
|
|
void rt_cancel_solo_after_disconnect (boost::shared_ptr<RouteList>, bool upstream, bool /* ignored*/ );
|
2009-12-10 12:45:18 -05:00
|
|
|
void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
|
|
|
void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, bool /* ignored*/ );
|
|
|
|
void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
|
|
|
void rt_set_listen (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
2010-05-06 14:40:37 -04:00
|
|
|
void rt_set_solo_isolated (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
2010-07-24 12:40:56 -04:00
|
|
|
void rt_set_record_enabled (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
2011-10-20 14:50:29 -04:00
|
|
|
void rt_set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, bool 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
|
|
|
|
2010-12-03 17:26:29 -05:00
|
|
|
void add_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
|
|
|
|
|
|
|
void update_locations_after_tempo_map_change (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
|
|
|
|
|
|
|
uint32_t next_control_id () const;
|
|
|
|
bool ignore_route_processor_changes;
|
2012-01-27 08:22:55 -05:00
|
|
|
|
|
|
|
MidiClockTicker* midi_clock;
|
2012-10-25 15:46:23 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<IO> _ltc_input;
|
|
|
|
boost::shared_ptr<IO> _ltc_output;
|
|
|
|
|
|
|
|
void reconnect_ltc_input ();
|
|
|
|
void reconnect_ltc_output ();
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ARDOUR
|
|
|
|
|
|
|
|
#endif /* __ardour_session_h__ */
|