b467ffb316fd64611dec8da6c51f2c42d8396b40
[ardour.git] / libs / ardour / ardour / track.h
1 /*
2     Copyright (C) 2006 Paul Davis
3
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.
8
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.
13
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.
17 */
18
19 #ifndef __ardour_track_h__
20 #define __ardour_track_h__
21
22 #include <boost/shared_ptr.hpp>
23
24 #include "ardour/route.h"
25 #include "ardour/public_diskstream.h"
26
27 namespace ARDOUR {
28
29 class Session;
30 class Playlist;
31 class RouteGroup;
32 class Source;
33 class Region;
34 class Diskstream;
35
36 class Track : public Route, public PublicDiskstream
37 {
38   public:
39         Track (Session&, std::string name, Route::Flag f = Route::Flag (0), TrackMode m = Normal, DataType default_type = DataType::AUDIO);
40         virtual ~Track ();
41
42         int init ();
43
44         bool set_name (const std::string& str);
45
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;
50
51         virtual void set_monitoring (MonitorChoice);
52         MonitorChoice monitoring() const { return _monitoring; }
53         PBD::Signal0<void> MonitoringChanged;
54
55         virtual int no_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
56                              bool state_changing, bool can_record);
57
58         int silent_roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
59                          bool can_record, bool& need_butler);
60
61         virtual int roll (pframes_t nframes, framepos_t start_frame, framepos_t end_frame,
62                           int declick, bool can_record, bool& need_butler) = 0;
63
64         bool needs_butler() const { return _needs_butler; }
65         void toggle_monitor_input ();
66
67         virtual DataType data_type () const = 0;
68
69         bool can_record();
70
71         virtual void use_new_diskstream () = 0;
72         virtual void set_diskstream (boost::shared_ptr<Diskstream>);
73
74         void set_latency_compensation (framecnt_t);
75
76         enum FreezeState {
77                 NoFreeze,
78                 Frozen,
79                 UnFrozen
80         };
81
82         FreezeState freeze_state() const;
83
84         virtual void freeze_me (InterThreadInfo&) = 0;
85         virtual void unfreeze () = 0;
86
87         virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
88         virtual boost::shared_ptr<Region> bounce_range (framepos_t start, framepos_t end, InterThreadInfo&, bool enable_processing = true) = 0;
89
90         XMLNode&    get_state();
91         XMLNode&    get_template();
92         int set_state (const XMLNode&, int version);
93         static void zero_diskstream_id_in_xml (XMLNode&);
94
95         boost::shared_ptr<PBD::Controllable> rec_enable_control() { return _rec_enable_control; }
96
97         bool record_enabled() const;
98         void set_record_enabled (bool yn, void *src);
99
100         /* XXX: unfortunate that this is exposed */
101         PBD::ID const & diskstream_id () const;
102
103         void set_block_size (pframes_t);
104
105         /** @return true if the track can be bounced, or false if it cannot because
106          *  it has more outputs than diskstream channels.
107          */
108         virtual bool bounceable () const = 0;
109
110         /* PublicDiskstream interface */
111         boost::shared_ptr<Playlist> playlist ();
112         void monitor_input (bool);
113         bool destructive () const;
114         std::list<boost::shared_ptr<Source> > & last_capture_sources ();
115         void set_capture_offset ();
116         std::list<boost::shared_ptr<Source> > steal_write_sources();
117         void reset_write_sources (bool, bool force = false);
118         float playback_buffer_load () const;
119         float capture_buffer_load () const;
120         int do_refill ();
121         int do_flush (RunContext, bool force = false);
122         uint32_t read_data_count() const;
123         uint32_t write_data_count() const;
124         void set_pending_overwrite (bool);
125         int seek (framepos_t, bool complete_refill = false);
126         bool hidden () const;
127         int can_internal_playback_seek (framepos_t);
128         int internal_playback_seek (framepos_t);
129         void non_realtime_input_change ();
130         void non_realtime_locate (framepos_t);
131         void non_realtime_set_speed ();
132         int overwrite_existing_buffers ();
133         framecnt_t get_captured_frames (uint32_t n = 0) const;
134         int set_loop (Location *);
135         void transport_looped (framepos_t);
136         bool realtime_set_speed (double, bool);
137         void transport_stopped_wallclock (struct tm &, time_t, bool);
138         bool pending_overwrite () const;
139         double speed () const;
140         void prepare_to_stop (framepos_t);
141         void set_slaved (bool);
142         ChanCount n_channels ();
143         framepos_t get_capture_start_frame (uint32_t n = 0) const;
144         AlignStyle alignment_style () const;
145         AlignChoice alignment_choice () const;
146         framepos_t current_capture_start () const;
147         framepos_t current_capture_end () const;
148         void playlist_modified ();
149         int use_playlist (boost::shared_ptr<Playlist>);
150         void set_align_style (AlignStyle, bool force=false);
151         void set_align_choice (AlignChoice, bool force=false);
152         int use_copy_playlist ();
153         int use_new_playlist ();
154         void adjust_playback_buffering ();
155         void adjust_capture_buffering ();
156
157         PBD::Signal0<void> DiskstreamChanged;
158         PBD::Signal0<void> FreezeChange;
159         PBD::Signal0<void> PlaylistChanged;
160         PBD::Signal0<void> RecordEnableChanged;
161         PBD::Signal0<void> SpeedChanged;
162         PBD::Signal0<void> AlignmentStyleChanged;
163
164   protected:
165         XMLNode& state (bool full);
166         int _set_state (const XMLNode&, int version, bool);
167
168         boost::shared_ptr<Diskstream> _diskstream;
169         MeterPoint    _saved_meter_point;
170         TrackMode     _mode;
171         bool          _needs_butler;
172         MonitorChoice _monitoring;
173
174         //private: (FIXME)
175         struct FreezeRecordProcessorInfo {
176                 FreezeRecordProcessorInfo(XMLNode& st, boost::shared_ptr<Processor> proc)
177                         : state (st), processor (proc) {}
178
179                 XMLNode                      state;
180                 boost::shared_ptr<Processor> processor;
181                 PBD::ID                      id;
182         };
183
184         struct FreezeRecord {
185                 FreezeRecord()
186                         : have_mementos(false)
187                 {}
188
189                 ~FreezeRecord();
190
191                 boost::shared_ptr<Playlist>        playlist;
192                 std::vector<FreezeRecordProcessorInfo*> processor_info;
193                 bool                               have_mementos;
194                 FreezeState                        state;
195         };
196
197         struct RecEnableControllable : public PBD::Controllable {
198                 RecEnableControllable (Track&);
199
200                 void set_value (double);
201                 double get_value (void) const;
202
203                 Track& track;
204         };
205
206         virtual void set_state_part_two () = 0;
207
208         FreezeRecord          _freeze_record;
209         XMLNode*              pending_state;
210         bool                  _destructive;
211
212         void maybe_declick (BufferSet&, framecnt_t, int);
213
214         virtual bool send_silence () const;
215
216         boost::shared_ptr<RecEnableControllable> _rec_enable_control;
217         
218         framecnt_t check_initial_delay (framecnt_t nframes, framecnt_t&);
219
220 private:
221         void diskstream_playlist_changed ();
222         void diskstream_record_enable_changed ();
223         void diskstream_speed_changed ();
224         void diskstream_alignment_style_changed ();
225 };
226
227 }; /* namespace ARDOUR*/
228
229 #endif /* __ardour_track_h__ */