X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Ftrack.h;h=566153d02f82eb8ad9529ef1868c2238d809b0c6;hb=022818b4a796f52c0a91eea42e65aec0bc7bed43;hp=ec444e78dc34d5f9c0cb1f0cf21528e06df991e9;hpb=1ae094813858a2b8cf5b08569edcb9b15d910729;p=ardour.git

diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index ec444e78dc..566153d02f 100644
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -29,6 +29,7 @@ class Session;
 class Diskstream;
 class Playlist;
 class RouteGroup;
+class Region;
 
 class Track : public Route
 {
@@ -37,31 +38,33 @@ class Track : public Route
 
 	virtual ~Track ();
 	
-	int set_name (string str, void *src);
+	bool set_name (const std::string& str);
 
-	virtual int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-		jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input) = 0;
+	TrackMode mode () const { return _mode; }
+	virtual int set_mode (TrackMode m) { return false; }
+	virtual bool can_use_mode (TrackMode m, bool& bounce_required) { return false; }
+	sigc::signal<void> TrackModeChanged;
+
+	virtual int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, int declick, bool can_record, bool rec_monitors_input) = 0;
 	
-	virtual int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-		jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input) = 0;
+	virtual int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input) = 0;
 	
-	virtual int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-		jack_nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
+	virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+		nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
 
 	void toggle_monitor_input ();
 
-	virtual bool can_record();
+	bool can_record();
 
 	boost::shared_ptr<Diskstream> diskstream() const { return _diskstream; }
 
 	virtual int use_diskstream (string name) = 0;
 	virtual int use_diskstream (const PBD::ID& id) = 0;
 
-	TrackMode mode() const { return _mode; }
-	void      set_mode (TrackMode m);
-
-	jack_nframes_t update_total_latency();
-	void           set_latency_delay (jack_nframes_t);
+	nframes_t update_total_latency();
+	void           set_latency_delay (nframes_t);
 
 	enum FreezeState {
 		NoFreeze,
@@ -74,21 +77,20 @@ class Track : public Route
 	virtual void freeze (InterThreadInfo&) = 0;
 	virtual void unfreeze () = 0;
 
-	virtual void bounce (InterThreadInfo&) = 0;
-	virtual void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&) = 0;
+	virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
+	virtual boost::shared_ptr<Region> bounce_range (nframes_t start, nframes_t end, InterThreadInfo&) = 0;
 
 	XMLNode&    get_state();
 	XMLNode&    get_template();
 	virtual int set_state(const XMLNode& node) = 0;
 
-	PBD::Controllable& rec_enable_control() { return _rec_enable_control; }
+	boost::shared_ptr<PBD::Controllable> rec_enable_control() { return _rec_enable_control; }
 
 	bool record_enabled() const;
 	void set_record_enable (bool yn, void *src);
 	
 	void set_meter_point (MeterPoint, void* src);
 	
-	sigc::signal<void> ModeChanged;
 	sigc::signal<void> DiskstreamChanged;
 	sigc::signal<void> FreezeChange;
 
@@ -97,38 +99,35 @@ class Track : public Route
 
 	virtual XMLNode& state (bool full) = 0;
 
-	virtual void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, 
-		jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter) = 0;
-
-	virtual uint32_t n_process_buffers () = 0;
-	
 	boost::shared_ptr<Diskstream> _diskstream;
 	MeterPoint  _saved_meter_point;
 	TrackMode   _mode;
 
 	//private: (FIXME)
-	struct FreezeRecordInsertInfo {
-	    FreezeRecordInsertInfo(XMLNode& st, boost::shared_ptr<Insert> ins) 
-		    : state (st), insert (ins) {}
-
-	    XMLNode                   state;
-	    boost::shared_ptr<Insert> insert;
-	    PBD::ID                   id;
-	    UndoAction                memento;
+	struct FreezeRecordProcessorInfo {
+	    FreezeRecordProcessorInfo(XMLNode& st, boost::shared_ptr<Processor> proc) 
+		    : state (st), processor (proc) {}
+
+	    XMLNode                      state;
+	    boost::shared_ptr<Processor> processor;
+	    PBD::ID                      id;
+	    UndoAction                   memento;
 	};
 
 	struct FreezeRecord {
 	    FreezeRecord()
-		: playlist(0)
-		, have_mementos(false)
+		: have_mementos(false)
 	    {}
 
 	    ~FreezeRecord();
 
-	    Playlist*                       playlist;
-	    vector<FreezeRecordInsertInfo*> insert_info;
-	    bool                            have_mementos;
-	    FreezeState                     state;
+	    boost::shared_ptr<Playlist>        playlist;
+	    vector<FreezeRecordProcessorInfo*> processor_info;
+	    bool                               have_mementos;
+	    FreezeState                        state;
+	    gain_t                          gain;
+	    AutoState                       gain_automation_state;
+	    AutoState                       pan_automation_state;
 	};
 
 	struct RecEnableControllable : public PBD::Controllable {
@@ -140,19 +139,15 @@ class Track : public Route
 	    Track& track;
 	};
 
-	//virtual void diskstream_record_enable_changed (void *src) = 0;
-	//virtual void diskstream_input_channel_changed (void *src) = 0;
-
-	//virtual void input_change_handler (void *src) = 0;
-
 	virtual void set_state_part_two () = 0;
 
 	FreezeRecord          _freeze_record;
 	XMLNode*              pending_state;
 	sigc::connection      recenable_connection;
 	sigc::connection      ic_connection;
-	RecEnableControllable _rec_enable_control;
 	bool                  _destructive;
+	
+	boost::shared_ptr<RecEnableControllable> _rec_enable_control;
 };
 
 }; /* namespace ARDOUR*/