2 Copyright (C) 2006 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 #ifndef __ardour_track_h__
20 #define __ardour_track_h__
22 #include <boost/shared_ptr.hpp>
24 #include "ardour/route.h"
25 #include "ardour/public_diskstream.h"
36 class Track : public Route, public PublicDiskstream
39 Track (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
44 bool set_name (const std::string& str);
46 TrackMode mode () const { return _mode; }
47 virtual int set_mode (TrackMode /*m*/) { return false; }
48 virtual bool can_use_mode (TrackMode /*m*/, bool& /*bounce_required*/) { return false; }
49 PBD::Signal0<void> TrackModeChanged;
51 virtual int no_roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame,
52 bool state_changing, bool can_record, bool rec_monitors_input);
54 int silent_roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame,
55 bool can_record, bool rec_monitors_input, bool& need_butler);
57 virtual int roll (nframes_t nframes, framepos_t start_frame, framepos_t end_frame,
58 int declick, bool can_record, bool rec_monitors_input, bool& need_butler) = 0;
60 bool needs_butler() const { return _needs_butler; }
61 void toggle_monitor_input ();
65 virtual void use_new_diskstream () = 0;
66 virtual void set_diskstream (boost::shared_ptr<Diskstream>);
68 nframes_t update_total_latency();
69 void set_latency_delay (nframes_t);
77 FreezeState freeze_state() const;
79 virtual void freeze_me (InterThreadInfo&) = 0;
80 virtual void unfreeze () = 0;
82 virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
83 virtual boost::shared_ptr<Region> bounce_range (nframes_t start, nframes_t end, InterThreadInfo&, bool enable_processing = true) = 0;
86 XMLNode& get_template();
87 virtual int set_state (const XMLNode&, int version) = 0;
88 static void zero_diskstream_id_in_xml (XMLNode&);
90 boost::shared_ptr<PBD::Controllable> rec_enable_control() { return _rec_enable_control; }
92 bool record_enabled() const;
93 void set_record_enabled (bool yn, void *src);
95 /* XXX: unfortunate that this is exposed */
96 PBD::ID const & diskstream_id () const;
98 void set_block_size (nframes_t);
100 /* PublicDiskstream interface */
101 boost::shared_ptr<Playlist> playlist ();
102 void monitor_input (bool);
103 bool destructive () const;
104 std::list<boost::shared_ptr<Source> > & last_capture_sources ();
105 void set_capture_offset ();
106 std::list<boost::shared_ptr<Source> > steal_write_sources();
107 void reset_write_sources (bool, bool force = false);
108 float playback_buffer_load () const;
109 float capture_buffer_load () const;
111 int do_flush (RunContext, bool force = false);
112 uint32_t read_data_count() const;
113 uint32_t write_data_count() const;
114 void set_pending_overwrite (bool);
115 int seek (nframes_t, bool complete_refill = false);
116 bool hidden () const;
117 int can_internal_playback_seek (nframes_t);
118 int internal_playback_seek (nframes_t);
119 void non_realtime_input_change ();
120 void non_realtime_locate (nframes_t);
121 void non_realtime_set_speed ();
122 int overwrite_existing_buffers ();
123 nframes_t get_captured_frames (uint32_t n = 0);
124 int set_loop (Location *);
125 void transport_looped (nframes_t);
126 bool realtime_set_speed (double, bool);
127 void transport_stopped_wallclock (struct tm &, time_t, bool);
128 bool pending_overwrite () const;
129 double speed () const;
130 void prepare_to_stop (framepos_t);
131 void set_slaved (bool);
132 ChanCount n_channels ();
133 nframes_t get_capture_start_frame (uint32_t n = 0);
134 AlignStyle alignment_style () const;
135 nframes_t current_capture_start () const;
136 nframes_t current_capture_end () const;
137 void playlist_modified ();
138 int use_playlist (boost::shared_ptr<Playlist>);
139 void set_align_style (AlignStyle);
140 int use_copy_playlist ();
141 int use_new_playlist ();
142 void adjust_playback_buffering ();
143 void adjust_capture_buffering ();
145 PBD::Signal0<void> DiskstreamChanged;
146 PBD::Signal0<void> FreezeChange;
147 PBD::Signal0<void> PlaylistChanged;
148 PBD::Signal0<void> RecordEnableChanged;
149 PBD::Signal0<void> SpeedChanged;
150 PBD::Signal0<void> AlignmentStyleChanged;
153 virtual XMLNode& state (bool full) = 0;
155 boost::shared_ptr<Diskstream> _diskstream;
156 MeterPoint _saved_meter_point;
160 ChanCount input_streams () const;
163 struct FreezeRecordProcessorInfo {
164 FreezeRecordProcessorInfo(XMLNode& st, boost::shared_ptr<Processor> proc)
165 : state (st), processor (proc) {}
168 boost::shared_ptr<Processor> processor;
172 struct FreezeRecord {
174 : have_mementos(false)
179 boost::shared_ptr<Playlist> playlist;
180 std::vector<FreezeRecordProcessorInfo*> processor_info;
185 struct RecEnableControllable : public PBD::Controllable {
186 RecEnableControllable (Track&);
188 void set_value (float);
189 float get_value (void) const;
194 virtual void set_state_part_two () = 0;
196 FreezeRecord _freeze_record;
197 XMLNode* pending_state;
200 boost::shared_ptr<RecEnableControllable> _rec_enable_control;
203 void diskstream_playlist_changed ();
204 void diskstream_record_enable_changed ();
205 void diskstream_speed_changed ();
206 void diskstream_alignment_style_changed ();
209 }; /* namespace ARDOUR*/
211 #endif /* __ardour_track_h__ */