#include <cmath>
#include <time.h>
-#include <sigc++/signal.h>
-
#include <boost/utility.hpp>
#include "evoral/types.hpp"
-#include "pbd/fastlog.h"
-#include "pbd/ringbufferNPT.h"
-#include "pbd/stateful.h"
-#include "pbd/statefuldestructible.h"
-
#include "ardour/ardour.h"
+#include "ardour/chan_count.h"
#include "ardour/location.h"
#include "ardour/session_object.h"
#include "ardour/types.h"
#include "ardour/utils.h"
-#include "ardour/chan_count.h"
+#include "ardour/public_diskstream.h"
struct tm;
namespace ARDOUR {
-class AudioEngine;
class IO;
class Playlist;
class Processor;
class Region;
-class Route;
-class Send;
class Session;
+class Track;
-class Diskstream : public SessionObject, public boost::noncopyable
+class Diskstream : public SessionObject, public PublicDiskstream
{
public:
enum Flag {
bool set_name (const std::string& str);
boost::shared_ptr<ARDOUR::IO> io() const { return _io; }
- void set_route (ARDOUR::Route&);
+ void set_track (ARDOUR::Track *);
virtual float playback_buffer_load() const = 0;
virtual float capture_buffer_load() const = 0;
bool record_enabled() const { return g_atomic_int_get (&_record_enabled); }
virtual void set_record_enabled (bool yn) = 0;
+ virtual void get_input_sources () = 0;
bool destructive() const { return _flags & Destructive; }
virtual int set_destructive (bool /*yn*/) { return -1; }
virtual void punch_in() {}
virtual void punch_out() {}
- void set_speed (double);
void non_realtime_set_speed ();
virtual void non_realtime_locate (nframes_t /*location*/) {};
virtual void playlist_modified ();
void remove_region_from_last_capture (boost::weak_ptr<Region> wregion);
void move_processor_automation (boost::weak_ptr<Processor>,
- std::list< Evoral::RangeMove<nframes_t> > const &);
+ std::list<Evoral::RangeMove<framepos_t> > const &);
+
+ /** For non-butler contexts (allocates temporary working buffers) */
+ virtual int do_refill_with_alloc() = 0;
+ virtual void set_block_size (nframes_t) = 0;
- sigc::signal<void> RecordEnableChanged;
- sigc::signal<void> SpeedChanged;
- sigc::signal<void> ReverseChanged;
- sigc::signal<void> PlaylistChanged;
- sigc::signal<void> AlignmentStyleChanged;
- sigc::signal<void,Location *> LoopSet;
+ bool pending_overwrite () const {
+ return _pending_overwrite;
+ }
- static sigc::signal<void> DiskOverrun;
- static sigc::signal<void> DiskUnderrun;
+ PBD::Signal0<void> RecordEnableChanged;
+ PBD::Signal0<void> SpeedChanged;
+ PBD::Signal0<void> ReverseChanged;
+ PBD::Signal0<void> PlaylistChanged;
+ PBD::Signal0<void> AlignmentStyleChanged;
+ PBD::Signal1<void,Location *> LoopSet;
+
+ static PBD::Signal0<void> DiskOverrun;
+ static PBD::Signal0<void> DiskUnderrun;
protected:
friend class Session;
+ friend class Butler;
/* the Session is the only point of access for these because they require
* that the Session is "inactive" while they are called.
virtual void set_pending_overwrite (bool) = 0;
virtual int overwrite_existing_buffers () = 0;
- virtual void set_block_size (nframes_t) = 0;
virtual int internal_playback_seek (nframes_t distance) = 0;
virtual int can_internal_playback_seek (nframes_t distance) = 0;
virtual int rename_write_sources () = 0;
protected:
friend class Track;
- virtual void prepare ();
- virtual int process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input) = 0;
+ virtual int process (nframes_t transport_frame, nframes_t nframes, bool can_record, bool rec_monitors_input, bool& need_butler) = 0;
virtual bool commit (nframes_t nframes) = 0;
- virtual void recover (); /* called if commit will not be called, but process was */
//private:
virtual int do_flush (RunContext context, bool force = false) = 0;
virtual int do_refill () = 0;
- /** For non-butler contexts (allocates temporary working buffers) */
- virtual int do_refill_with_alloc() = 0;
-
/* XXX fix this redundancy ... */
- virtual void playlist_changed (Change);
+ virtual void playlist_changed (const PBD::PropertyChange&);
virtual void playlist_deleted (boost::weak_ptr<Playlist>);
- virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<nframes_t> > const &);
+ virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<framepos_t> > const &);
- virtual void transport_stopped (struct tm&, time_t, bool abort) = 0;
+ virtual void transport_stopped_wallclock (struct tm&, time_t, bool abort) = 0;
virtual void transport_looped (nframes_t transport_frame) = 0;
struct CaptureInfo {
uint32_t frames;
};
- virtual void init (Flag);
-
virtual int use_new_write_source (uint32_t n=0) = 0;
virtual int find_and_use_playlist (const std::string&) = 0;
virtual int use_pending_capture_data (XMLNode& node) = 0;
- virtual void get_input_sources () = 0;
virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record);
virtual void prepare_record_status (nframes_t /*capture_start_frame*/) {}
virtual void set_align_style_from_io() {}
virtual void setup_destructive_playlist () {}
virtual void use_destructive_playlist () {}
+ virtual void prepare_to_stop (framepos_t pos);
void calculate_record_range(OverlapType ot, sframes_t transport_frame, nframes_t nframes,
nframes_t& rec_nframes, nframes_t& rec_offset);
uint32_t i_am_the_modifier;
boost::shared_ptr<ARDOUR::IO> _io;
- Route* _route;
+ Track* _track;
ChanCount _n_channels;
boost::shared_ptr<Playlist> _playlist;
AlignStyle _alignment_style;
bool _scrubbing;
bool _slaved;
- bool _processed;
Location* loop_location;
nframes_t overwrite_frame;
off_t overwrite_offset;
- bool pending_overwrite;
+ bool _pending_overwrite;
bool overwrite_queued;
IOChange input_change_pending;
nframes_t wrap_buffer_size;
nframes_t file_frame;
nframes_t playback_sample;
nframes_t playback_distance;
- bool commit_should_unlock;
uint32_t _read_data_count;
uint32_t _write_data_count;
nframes_t scrub_buffer_size;
nframes_t scrub_offset;
- sigc::connection ports_created_c;
- sigc::connection plmod_connection;
- sigc::connection plgone_connection;
- sigc::connection plregion_connection;
+ PBD::ScopedConnectionList playlist_connections;
+
+ PBD::ScopedConnection ic_connection;
Flag _flags;
projects / ardour.git / blobdiff