2 Copyright (C) 2000-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.
20 #ifndef __ardour_diskstream_h__
21 #define __ardour_diskstream_h__
30 #include <boost/utility.hpp>
32 #include "evoral/types.hpp"
34 #include "ardour/ardour.h"
35 #include "ardour/chan_count.h"
36 #include "ardour/session_object.h"
37 #include "ardour/types.h"
38 #include "ardour/utils.h"
39 #include "ardour/public_diskstream.h"
53 class Diskstream
: public SessionObject
, public PublicDiskstream
63 Diskstream (Session
&, const std::string
& name
, Flag f
= Recordable
);
64 Diskstream (Session
&, const XMLNode
&);
65 virtual ~Diskstream();
67 bool set_name (const std::string
& str
);
69 boost::shared_ptr
<ARDOUR::IO
> io() const { return _io
; }
70 void set_track (ARDOUR::Track
*);
72 virtual float playback_buffer_load() const = 0;
73 virtual float capture_buffer_load() const = 0;
75 void set_flag (Flag f
) { _flags
= Flag (_flags
| f
); }
76 void unset_flag (Flag f
) { _flags
= Flag (_flags
& ~f
); }
78 AlignStyle
alignment_style() const { return _alignment_style
; }
79 void set_align_style (AlignStyle
);
80 void set_persistent_align_style (AlignStyle a
) { _persistent_alignment_style
= a
; }
82 nframes_t
roll_delay() const { return _roll_delay
; }
83 void set_roll_delay (nframes_t
);
85 bool record_enabled() const { return g_atomic_int_get (&_record_enabled
); }
86 virtual void set_record_enabled (bool yn
) = 0;
87 virtual void get_input_sources () = 0;
89 bool destructive() const { return _flags
& Destructive
; }
90 virtual int set_destructive (bool /*yn*/) { return -1; }
91 virtual int set_non_layered (bool /*yn*/) { return -1; }
92 virtual bool can_become_destructive (bool& /*requires_bounce*/) const { return false; }
94 bool hidden() const { return _flags
& Hidden
; }
95 bool recordable() const { return _flags
& Recordable
; }
96 bool non_layered() const { return _flags
& NonLayered
; }
97 bool reversed() const { return _actual_speed
< 0.0f
; }
98 double speed() const { return _visible_speed
; }
100 virtual void punch_in() {}
101 virtual void punch_out() {}
103 void non_realtime_set_speed ();
104 virtual void non_realtime_locate (nframes_t
/*location*/) {};
105 virtual void playlist_modified ();
107 boost::shared_ptr
<Playlist
> playlist () { return _playlist
; }
109 virtual int use_playlist (boost::shared_ptr
<Playlist
>);
110 virtual int use_new_playlist () = 0;
111 virtual int use_copy_playlist () = 0;
113 nframes_t
current_capture_start() const { return capture_start_frame
; }
114 nframes_t
current_capture_end() const { return capture_start_frame
+ capture_captured
; }
115 nframes_t
get_capture_start_frame (uint32_t n
=0);
116 nframes_t
get_captured_frames (uint32_t n
=0);
118 ChanCount
n_channels() { return _n_channels
; }
120 static nframes_t
disk_io_frames() { return disk_io_chunk_frames
; }
121 static void set_disk_io_chunk_frames (uint32_t n
) { disk_io_chunk_frames
= n
; }
124 virtual XMLNode
& get_state(void) = 0;
125 virtual int set_state(const XMLNode
&, int version
) = 0;
127 virtual void monitor_input (bool) {}
129 nframes_t
capture_offset() const { return _capture_offset
; }
130 virtual void set_capture_offset ();
132 bool slaved() const { return _slaved
; }
133 void set_slaved(bool yn
) { _slaved
= yn
; }
135 int set_loop (Location
*loc
);
137 std::list
<boost::shared_ptr
<Source
> >& last_capture_sources () { return _last_capture_sources
; }
139 void handle_input_change (IOChange
, void *src
);
141 void move_processor_automation (boost::weak_ptr
<Processor
>,
142 std::list
<Evoral::RangeMove
<framepos_t
> > const &);
144 /** For non-butler contexts (allocates temporary working buffers) */
145 virtual int do_refill_with_alloc() = 0;
146 virtual void set_block_size (nframes_t
) = 0;
148 bool pending_overwrite () const {
149 return _pending_overwrite
;
152 PBD::Signal0
<void> RecordEnableChanged
;
153 PBD::Signal0
<void> SpeedChanged
;
154 PBD::Signal0
<void> ReverseChanged
;
155 PBD::Signal0
<void> PlaylistChanged
;
156 PBD::Signal0
<void> AlignmentStyleChanged
;
157 PBD::Signal1
<void,Location
*> LoopSet
;
159 static PBD::Signal0
<void> DiskOverrun
;
160 static PBD::Signal0
<void> DiskUnderrun
;
163 friend class Session
;
166 /* the Session is the only point of access for these because they require
167 * that the Session is "inactive" while they are called.
170 virtual void set_pending_overwrite (bool) = 0;
171 virtual int overwrite_existing_buffers () = 0;
172 virtual int internal_playback_seek (nframes_t distance
) = 0;
173 virtual int can_internal_playback_seek (nframes_t distance
) = 0;
174 virtual int rename_write_sources () = 0;
175 virtual void reset_write_sources (bool, bool force
= false) = 0;
176 virtual void non_realtime_input_change () = 0;
178 uint32_t read_data_count() const { return _read_data_count
; }
179 uint32_t write_data_count() const { return _write_data_count
; }
182 friend class Auditioner
;
183 virtual int seek (nframes_t which_sample
, bool complete_refill
= false) = 0;
188 virtual int process (nframes_t transport_frame
, nframes_t nframes
, bool can_record
, bool rec_monitors_input
, bool& need_butler
) = 0;
189 virtual bool commit (nframes_t nframes
) = 0;
193 enum TransitionType
{
198 struct CaptureTransition
{
200 nframes_t capture_val
; ///< The start or end file frame position
203 /* The two central butler operations */
204 virtual int do_flush (RunContext context
, bool force
= false) = 0;
205 virtual int do_refill () = 0;
207 /* XXX fix this redundancy ... */
209 virtual void playlist_changed (const PBD::PropertyChange
&);
210 virtual void playlist_deleted (boost::weak_ptr
<Playlist
>);
211 virtual void playlist_ranges_moved (std::list
< Evoral::RangeMove
<framepos_t
> > const &, bool);
213 virtual void transport_stopped_wallclock (struct tm
&, time_t, bool abort
) = 0;
214 virtual void transport_looped (nframes_t transport_frame
) = 0;
221 virtual int use_new_write_source (uint32_t n
=0) = 0;
223 virtual int find_and_use_playlist (const std::string
&) = 0;
225 virtual void allocate_temporary_buffers () = 0;
227 virtual bool realtime_set_speed (double, bool global_change
);
229 std::list
<boost::shared_ptr
<Source
> > _last_capture_sources
;
231 virtual int use_pending_capture_data (XMLNode
& node
) = 0;
233 virtual void check_record_status (nframes_t transport_frame
, nframes_t nframes
, bool can_record
);
234 virtual void prepare_record_status (nframes_t
/*capture_start_frame*/) {}
235 virtual void set_align_style_from_io() {}
236 virtual void setup_destructive_playlist () {}
237 virtual void use_destructive_playlist () {}
238 virtual void prepare_to_stop (framepos_t pos
);
240 void calculate_record_range(OverlapType ot
, sframes_t transport_frame
, nframes_t nframes
,
241 nframes_t
& rec_nframes
, nframes_t
& rec_offset
);
243 static nframes_t disk_io_chunk_frames
;
244 std::vector
<CaptureInfo
*> capture_info
;
245 Glib::Mutex capture_info_lock
;
247 uint32_t i_am_the_modifier
;
249 boost::shared_ptr
<ARDOUR::IO
> _io
;
251 ChanCount _n_channels
;
253 boost::shared_ptr
<Playlist
> _playlist
;
255 mutable gint _record_enabled
;
256 double _visible_speed
;
257 double _actual_speed
;
258 /* items needed for speed change logic */
259 bool _buffer_reallocation_required
;
263 nframes_t capture_start_frame
;
264 nframes_t capture_captured
;
266 nframes_t adjust_capture_position
;
267 nframes_t _capture_offset
;
268 nframes_t _roll_delay
;
269 nframes_t first_recordable_frame
;
270 nframes_t last_recordable_frame
;
271 int last_possibly_recording
;
272 AlignStyle _alignment_style
;
275 Location
* loop_location
;
276 nframes_t overwrite_frame
;
277 off_t overwrite_offset
;
278 bool _pending_overwrite
;
279 bool overwrite_queued
;
280 IOChange input_change_pending
;
281 nframes_t wrap_buffer_size
;
282 nframes_t speed_buffer_size
;
285 double _target_speed
;
287 nframes_t file_frame
;
288 nframes_t playback_sample
;
289 nframes_t playback_distance
;
291 uint32_t _read_data_count
;
292 uint32_t _write_data_count
;
295 AlignStyle _persistent_alignment_style
;
296 bool first_input_change
;
298 Glib::Mutex state_lock
;
300 nframes_t scrub_start
;
301 nframes_t scrub_buffer_size
;
302 nframes_t scrub_offset
;
304 PBD::ScopedConnectionList playlist_connections
;
306 PBD::ScopedConnection ic_connection
;
310 void route_going_away ();
313 }; /* namespace ARDOUR */
315 #endif /* __ardour_diskstream_h__ */