along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id: diskstream.h 579 2006-06-12 19:56:37Z essej $
*/
#ifndef __ardour_diskstream_h__
#define __ardour_diskstream_h__
-#include <sigc++/signal.h>
-
-#include <cmath>
#include <string>
#include <queue>
#include <map>
#include <vector>
-
+#include <cmath>
#include <time.h>
+#include <sigc++/signal.h>
+
+#include <evoral/types.hpp>
+
#include <pbd/fastlog.h>
#include <pbd/ringbufferNPT.h>
#include <pbd/stateful.h>
#include <ardour/ardour.h>
#include <ardour/configuration.h>
-#include <ardour/session.h>
-#include <ardour/route_group.h>
-#include <ardour/route.h>
-#include <ardour/port.h>
+#include <ardour/location.h>
+#include <ardour/session_object.h>
+#include <ardour/types.h>
#include <ardour/utils.h>
+#include <ardour/chan_count.h>
struct tm;
namespace ARDOUR {
class AudioEngine;
+class IO;
+class Playlist;
+class Processor;
+class Region;
class Send;
class Session;
-class Playlist;
-class IO;
- class Diskstream : public PBD::StatefulDestructible
+class Diskstream : public SessionObject
{
public:
enum Flag {
Diskstream (Session &, const string& name, Flag f = Recordable);
Diskstream (Session &, const XMLNode&);
virtual ~Diskstream();
-
- string name () const { return _name; }
- virtual int set_name (string str);
+
+ bool set_name (const string& str);
ARDOUR::IO* io() const { return _io; }
void set_io (ARDOUR::IO& io);
virtual float playback_buffer_load() const = 0;
virtual float capture_buffer_load() const = 0;
- void set_flag (Flag f) { _flags |= f; }
- void unset_flag (Flag f) { _flags &= ~f; }
+ void set_flag (Flag f) { _flags = Flag (_flags | f); }
+ void unset_flag (Flag f) { _flags = Flag (_flags & ~f); }
AlignStyle alignment_style() const { return _alignment_style; }
void set_align_style (AlignStyle);
void set_persistent_align_style (AlignStyle a) { _persistent_alignment_style = a; }
nframes_t roll_delay() const { return _roll_delay; }
- void set_roll_delay (nframes_t);
+ void set_roll_delay (nframes_t);
bool record_enabled() const { return g_atomic_int_get (&_record_enabled); }
virtual void set_record_enabled (bool yn) = 0;
void set_speed (double);
void non_realtime_set_speed ();
+ virtual void non_realtime_locate (nframes_t location) {};
+ virtual void playlist_modified ();
boost::shared_ptr<Playlist> playlist () { return _playlist; }
nframes_t get_capture_start_frame (uint32_t n=0);
nframes_t get_captured_frames (uint32_t n=0);
- uint32_t n_channels() { return _n_channels; }
+ ChanCount n_channels() { return _n_channels; }
static nframes_t disk_io_frames() { return disk_io_chunk_frames; }
static void set_disk_io_chunk_frames (uint32_t n) { disk_io_chunk_frames = n; }
virtual XMLNode& get_state(void) = 0;
virtual int set_state(const XMLNode& node) = 0;
- // FIXME: makes sense for all diskstream types?
virtual void monitor_input (bool) {}
- nframes_t capture_offset() const { return _capture_offset; }
- virtual void set_capture_offset ();
+ nframes_t capture_offset() const { return _capture_offset; }
+ virtual void set_capture_offset ();
bool slaved() const { return _slaved; }
void set_slaved(bool yn) { _slaved = yn; }
void remove_region_from_last_capture (boost::weak_ptr<Region> wregion);
+ void move_processor_automation (boost::weak_ptr<Processor>,
+ list< Evoral::RangeMove<nframes_t> > const &);
+
sigc::signal<void> RecordEnableChanged;
sigc::signal<void> SpeedChanged;
sigc::signal<void> ReverseChanged;
sigc::signal<void> AlignmentStyleChanged;
sigc::signal<void,Location *> LoopSet;
- static sigc::signal<void> DiskOverrun;
- static sigc::signal<void> DiskUnderrun;
+ static sigc::signal<void> DiskOverrun;
+ static sigc::signal<void> DiskUnderrun;
protected:
friend class Session;
};
/* The two central butler operations */
- virtual int do_flush (Session::RunContext context, bool force = false) = 0;
+ 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_modified ();
virtual void playlist_deleted (boost::weak_ptr<Playlist>);
+ virtual void playlist_ranges_moved (list< Evoral::RangeMove<nframes_t> > const &);
- virtual void finish_capture (bool rec_monitors_input) = 0;
virtual void transport_stopped (struct tm&, time_t, bool abort) = 0;
+ virtual void transport_looped (nframes_t transport_frame) = 0;
struct CaptureInfo {
uint32_t start;
virtual void get_input_sources () = 0;
virtual void check_record_status (nframes_t transport_frame, nframes_t nframes, bool can_record) = 0;
virtual void set_align_style_from_io() {}
- virtual void setup_destructive_playlist () = 0;
- virtual void use_destructive_playlist () = 0;
+ virtual void setup_destructive_playlist () {}
+ virtual void use_destructive_playlist () {}
static nframes_t disk_io_chunk_frames;
- vector<CaptureInfo*> capture_info;
+ std::vector<CaptureInfo*> capture_info;
Glib::Mutex capture_info_lock;
uint32_t i_am_the_modifier;
- string _name;
- ARDOUR::Session& _session;
ARDOUR::IO* _io;
- uint32_t _n_channels;
+ ChanCount _n_channels;
boost::shared_ptr<Playlist> _playlist;
nframes_t wrap_buffer_size;
nframes_t speed_buffer_size;
- uint64_t last_phase;
- uint64_t phi;
+ uint64_t last_phase;
+
+ /// diskstream speed in 40.24 fixed point math
+ uint64_t phi;
+
+ /// target diskstream speed in 40.24 fixed point math
+ uint64_t target_phi;
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;
sigc::connection ports_created_c;
sigc::connection plmod_connection;
sigc::connection plgone_connection;
+ sigc::connection plregion_connection;
- unsigned char _flags;
+ Flag _flags;
};
}; /* namespace ARDOUR */