#include "ardour/ardour.h"
#include "ardour/chan_count.h"
+#include "ardour/delivery.h"
+#include "ardour/interthread_info.h"
#include "ardour/rc_configuration.h"
#include "ardour/session_configuration.h"
#include "ardour/session_event.h"
namespace ARDOUR {
+class Amp;
class AudioEngine;
class AudioFileSource;
class AudioRegion;
class IO;
class IOProcessor;
class ImportStatus;
+class MidiClockTicker;
class MidiControlUI;
class MidiRegion;
class MidiSource;
class NamedSelection;
class Playlist;
class PluginInsert;
+class PluginInfo;
class Port;
class PortInsert;
class ProcessThread;
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
- static PBD::Signal0<void> AutoBindingOn;
- static PBD::Signal0<void> AutoBindingOff;
-
static PBD::Signal1<void,std::string> Dialog;
int ensure_subdirs ();
- std::string automation_dir () const;
- std::string analysis_dir() const;
- std::string plugins_dir() const;
+ 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
std::string peak_path (std::string) const;
void goto_start ();
void use_rf_shuttle_speed ();
void allow_auto_play (bool yn);
- void request_transport_speed (double speed);
- void request_transport_speed_nonzero (double);
+ void request_transport_speed (double speed, bool as_default = false);
+ void request_transport_speed_nonzero (double, bool as_default = false);
void request_overwrite_buffer (Track *);
void adjust_playback_buffering();
void adjust_capture_buffering();
);
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
- TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
+ const ChanCount& input, const ChanCount& output,
+ 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 = ""
);
void remove_route (boost::shared_ptr<Route>);
TempoMap& tempo_map() { return *_tempo_map; }
- /// signals the current transport position in frames, bbt and timecode time (in that order)
- PBD::Signal3<void, const framepos_t &, const Timecode::BBT_Time&, const Timecode::Time&> tick;
-
/* region info */
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
/* source management */
- void import_audiofiles (ImportStatus&);
+ void import_files (ImportStatus&);
bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
std::string build_tmp_convert_name (std::string file);
boost::shared_ptr<ExportHandler> get_export_handler ();
boost::shared_ptr<ExportStatus> get_export_status ();
- int start_audio_export (framepos_t position, bool realtime);
+ int start_audio_export (framepos_t position);
PBD::Signal1<int, framecnt_t> ProcessExport;
static PBD::Signal2<void,std::string, std::string> Exported;
/* flattening stuff */
boost::shared_ptr<Region> write_one_track (AudioTrack&, framepos_t start, framepos_t end,
- bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
- bool enable_processing = true);
+ bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
+ boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export);
int freeze_all (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
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);
+ void cancel_solo_after_disconnect (boost::shared_ptr<Route>, bool upstream, SessionEvent::RTeventCallback after = rt_cleanup);
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);
void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
PBD::Signal0<void> SoloChanged;
PBD::Signal0<void> IsolatedChanged;
- /* control/master out */
+ /* monitor/master out */
+
+ void add_monitor_section ();
+ void remove_monitor_section ();
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<Route> master_out() const { return _master_out; }
void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
void globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest);
void add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders);
+ 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>);
static void set_disable_all_loaded_plugins (bool yn) {
_disable_all_loaded_plugins = yn;
}
uint32_t next_send_id();
+ uint32_t next_aux_send_id();
uint32_t next_return_id();
uint32_t next_insert_id();
void mark_send_id (uint32_t);
+ void mark_aux_send_id (uint32_t);
void mark_return_id (uint32_t);
void mark_insert_id (uint32_t);
void unmark_send_id (uint32_t);
+ void unmark_aux_send_id (uint32_t);
void unmark_return_id (uint32_t);
void unmark_insert_id (uint32_t);
/* s/w "RAID" management */
- framecnt_t available_capture_duration();
+ boost::optional<framecnt_t> available_capture_duration();
/* I/O bundles */
return _current_trans_quarks;
}
+ bool operation_in_progress (GQuark) const;
+
void add_commands (std::vector<Command*> const & cmds);
std::map<PBD::ID,PBD::StatefulDestructible*> registry;
/* clicking */
boost::shared_ptr<IO> click_io() { return _click_io; }
+ boost::shared_ptr<Amp> click_gain() { return _click_gain; }
/* disk, buffer loads */
/* buffers for gain and pan */
gain_t* gain_automation_buffer () const;
+ gain_t* send_gain_automation_buffer () const;
pan_t** pan_automation_buffer () const;
void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
boost::shared_ptr<PBD::Controllable> solo_cut_control() const;
- SessionMetadata & metadata () { return *_metadata; }
-
SessionConfiguration config;
bool exporting () const {
void destroy ();
enum SubState {
- PendingDeclickIn = 0x1,
- PendingDeclickOut = 0x2,
- StopPendingCapture = 0x4,
- PendingLocate = 0x20,
+ 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,
};
/* stuff used in process() should be close together to
// varispeed playback
double _transport_speed;
+ double _default_transport_speed;
double _last_transport_speed;
double _target_transport_speed;
CubicInterpolation interpolation;
void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
- Glib::Mutex process_thread_lock;
- std::list<ProcessThread*> process_threads;
-
/* slave tracking */
static const int delta_accumulator_size = 25;
int pre_export ();
int stop_audio_export ();
void finalize_audio_export ();
+ bool _pre_export_mmc_enabled;
PBD::ScopedConnection export_freewheel_connection;
int process_routes (pframes_t, bool& need_butler);
int silent_process_routes (pframes_t, bool& need_butler);
+ /** @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.
+ */
int get_transport_declick_required () {
if (transport_sub_state & PendingDeclickIn) {
transport_sub_state &= ~PendingDeclickIn;
return 1;
} else if (transport_sub_state & PendingDeclickOut) {
+ /* XXX: not entirely sure why we don't clear this */
+ return -1;
+ } 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;
} else {
return 0;
}
PBD::ScopedConnectionList loop_connections;
void auto_loop_changed (Location *);
+ void auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
void first_stage_init (std::string path, std::string snapshot_name);
int second_stage_init ();
/* MIDI Machine Control */
- void spp_start (MIDI::Parser&, framepos_t timestamp);
- void spp_continue (MIDI::Parser&, framepos_t timestamp);
- void spp_stop (MIDI::Parser&, framepos_t timestamp);
+ void spp_start ();
+ void spp_continue ();
+ void spp_stop ();
void mmc_deferred_play (MIDI::MachineControl &);
void mmc_stop (MIDI::MachineControl &);
void start_locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false);
void force_locate (framepos_t frame, bool with_roll = false);
void set_track_speed (Track *, double speed);
- void set_transport_speed (double speed, bool abort = false, bool clear_state = false);
+ void set_transport_speed (double speed, bool abort = false, bool clear_state = false, bool as_default = false);
void stop_transport (bool abort = false, bool clear_state = false);
void start_transport ();
void realtime_stop (bool abort, bool clear_state);
SerializedRCUManager<RouteList> routes;
- void add_routes (RouteList&, bool auto_connect, bool save);
+ void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save);
uint32_t destructive_index;
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
/* INSERT AND SEND MANAGEMENT */
boost::dynamic_bitset<uint32_t> send_bitset;
+ boost::dynamic_bitset<uint32_t> aux_send_bitset;
boost::dynamic_bitset<uint32_t> return_bitset;
boost::dynamic_bitset<uint32_t> insert_bitset;
/* S/W RAID */
struct space_and_path {
- uint32_t blocks; /* 4kB blocks */
+ uint32_t blocks; ///< 4kB blocks
+ bool blocks_unknown; ///< true if blocks is unknown
std::string path;
- space_and_path() {
- blocks = 0;
- }
+ space_and_path ()
+ : blocks (0)
+ , blocks_unknown (true)
+ {}
};
struct space_and_path_ascending_cmp {
bool operator() (space_and_path a, space_and_path b) {
+ if (a.blocks_unknown != b.blocks_unknown) {
+ return !a.blocks_unknown;
+ }
return a.blocks > b.blocks;
}
};
std::vector<space_and_path> session_dirs;
std::vector<space_and_path>::iterator last_rr_session_dir;
uint32_t _total_free_4k_blocks;
+ /** 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;
Glib::Mutex space_lock;
bool no_questions_about_missing_files;
/* click track */
typedef std::list<Click*> Clicks;
- Clicks clicks;
- bool _clicking;
- boost::shared_ptr<IO> _click_io;
- Sample* click_data;
- Sample* click_emphasis_data;
- framecnt_t click_length;
- framecnt_t click_emphasis_length;
- mutable Glib::RWLock click_lock;
+ 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;
+ mutable Glib::RWLock click_lock;
static const Sample default_click[];
static const framecnt_t default_click_length;
boost::shared_ptr<Route> _master_out;
boost::shared_ptr<Route> _monitor_out;
+ void auto_connect_master_bus ();
+
/* Windows VST support */
long _windows_vst_callback (
static bool _disable_all_loaded_plugins;
- SessionMetadata * _metadata;
-
mutable bool have_looped; ///< Used in ::audible_frame(*)
void update_have_rec_enabled_track ();
return ev;
}
+ void rt_cancel_solo_after_disconnect (boost::shared_ptr<RouteList>, bool upstream, bool /* ignored*/ );
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);
and solo/mute computations.
*/
GraphEdges _current_route_graph;
+
+ uint32_t next_control_id () const;
+ bool ignore_route_processor_changes;
+
+ MidiClockTicker* midi_clock;
};
} // namespace ARDOUR
projects / ardour.git / blobdiff