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 ();
- Playlist* playlist () { return _playlist; }
+ boost::shared_ptr<Playlist> playlist () { return _playlist; }
- virtual int use_playlist (Playlist *);
+ virtual int use_playlist (boost::shared_ptr<Playlist>);
virtual int use_new_playlist () = 0;
virtual int use_copy_playlist () = 0;
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 (Playlist*);
+ 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 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;
ChanCount _n_channels;
- Playlist* _playlist;
+
+ boost::shared_ptr<Playlist> _playlist;
mutable gint _record_enabled;
double _visible_speed;
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 plstate_connection;
sigc::connection plgone_connection;
+ sigc::connection plregion_connection;
- unsigned char _flags;
+ Flag _flags;
};
}; /* namespace ARDOUR */
projects / ardour.git / blobdiff