libs/ardour/ardour/disk_writer.h

   1 /*
   2     Copyright (C) 2009-2016 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
  20 #ifndef __ardour_disk_writer_h__
  21 #define __ardour_disk_writer_h__
  22
  23 #include <list>
  24 #include <vector>
  25
  26 #include "pbd/i18n.h"
  27
  28 #include "ardour/disk_io.h"
  29 #include "ardour/midi_buffer.h"
  30
  31 namespace ARDOUR
  32 {
  33
  34 class AudioFileSource;
  35 class SMFSource;
  36 class MidiSource;
  37
  38 class LIBARDOUR_API DiskWriter : public DiskIOProcessor
  39 {
  40   public:
  41         DiskWriter (Session&, std::string const & name, DiskIOProcessor::Flag f = DiskIOProcessor::Flag (0));
  42         ~DiskWriter ();
  43
  44         bool set_name (std::string const & str);
  45         std::string display_name() const { return std::string (_("writer")); }
  46
  47         virtual bool set_write_source_name (const std::string& str);
  48
  49         bool           recordable()  const { return _flags & Recordable; }
  50
  51         static framecnt_t chunk_frames() { return _chunk_frames; }
  52         static framecnt_t default_chunk_frames ();
  53         static void set_chunk_frames (framecnt_t n) { _chunk_frames = n; }
  54
  55         void run (BufferSet& /*bufs*/, framepos_t /*start_frame*/, framepos_t /*end_frame*/, double speed, pframes_t /*nframes*/, bool /*result_required*/);
  56         void non_realtime_locate (framepos_t);
  57         void realtime_handle_transport_stopped ();
  58
  59         virtual XMLNode& state (bool full);
  60         int set_state (const XMLNode&, int version);
  61
  62         std::string write_source_name () const {
  63                 if (_write_source_name.empty()) {
  64                         return name();
  65                 } else {
  66                         return _write_source_name;
  67                 }
  68         }
  69
  70         boost::shared_ptr<AudioFileSource> audio_write_source (uint32_t n=0) {
  71                 boost::shared_ptr<ChannelList> c = channels.reader();
  72                 if (n < c->size()) {
  73                         return (*c)[n]->write_source;
  74                 }
  75
  76                 return boost::shared_ptr<AudioFileSource>();
  77         }
  78
  79         boost::shared_ptr<SMFSource> midi_write_source () { return _midi_write_source; }
  80
  81         virtual std::string steal_write_source_name ();
  82         int use_new_write_source (DataType, uint32_t n = 0);
  83         void reset_write_sources (bool, bool force = false);
  84
  85         AlignStyle  alignment_style() const { return _alignment_style; }
  86         AlignChoice alignment_choice() const { return _alignment_choice; }
  87         void       set_align_style (AlignStyle, bool force=false);
  88         void       set_align_choice (AlignChoice a, bool force=false);
  89
  90         PBD::Signal0<void> AlignmentStyleChanged;
  91
  92         void set_input_latency (framecnt_t);
  93         framecnt_t input_latency () const { return _input_latency; }
  94
  95         bool configure_io (ChanCount in, ChanCount out);
  96
  97         std::list<boost::shared_ptr<Source> >& last_capture_sources () { return _last_capture_sources; }
  98
  99         bool         record_enabled() const { return g_atomic_int_get (const_cast<gint*>(&_record_enabled)); }
 100         bool         record_safe () const { return g_atomic_int_get (const_cast<gint*>(&_record_safe)); }
 101         virtual void set_record_enabled (bool yn);
 102         virtual void set_record_safe (bool yn);
 103
 104         bool destructive() const { return _flags & Destructive; }
 105         int set_destructive (bool yn);
 106         int set_non_layered (bool yn);
 107         bool can_become_destructive (bool& requires_bounce) const;
 108
 109         /** @return Start position of currently-running capture (in session frames) */
 110         framepos_t current_capture_start() const { return capture_start_frame; }
 111         framepos_t current_capture_end()   const { return capture_start_frame + capture_captured; }
 112         framepos_t get_capture_start_frame (uint32_t n = 0) const;
 113         framecnt_t get_captured_frames (uint32_t n = 0) const;
 114
 115         float buffer_load() const;
 116
 117         virtual void request_input_monitoring (bool) {}
 118         virtual void ensure_input_monitoring (bool) {}
 119
 120         framecnt_t   capture_offset() const { return _capture_offset; }
 121         virtual void set_capture_offset ();
 122
 123         int seek (framepos_t frame, bool complete_refill);
 124
 125         static PBD::Signal0<void> Overrun;
 126
 127         void set_note_mode (NoteMode m);
 128
 129         /** Emitted when some MIDI data has been received for recording.
 130          *  Parameter is the source that it is destined for.
 131          *  A caller can get a copy of the data with get_gui_feed_buffer ()
 132          */
 133         PBD::Signal1<void, boost::weak_ptr<MidiSource> > DataRecorded;
 134
 135         PBD::Signal0<void> RecordEnableChanged;
 136         PBD::Signal0<void> RecordSafeChanged;
 137
 138         void check_record_status (framepos_t transport_frame, bool can_record);
 139
 140         void transport_looped (framepos_t transport_frame);
 141         void transport_stopped_wallclock (struct tm&, time_t, bool abort);
 142
 143         void adjust_buffering ();
 144
 145   protected:
 146         friend class Track;
 147         int do_flush (RunContext context, bool force = false);
 148
 149         void get_input_sources ();
 150         void prepare_record_status (framepos_t /*capture_start_frame*/);
 151         void set_align_style_from_io();
 152         void setup_destructive_playlist ();
 153         void use_destructive_playlist ();
 154         void prepare_to_stop (framepos_t transport_pos, framepos_t audible_frame);
 155
 156         void engage_record_enable ();
 157         void disengage_record_enable ();
 158         void engage_record_safe ();
 159         void disengage_record_safe ();
 160
 161         bool prep_record_enable ();
 162         bool prep_record_disable ();
 163
 164         void calculate_record_range (
 165                 Evoral::OverlapType ot, framepos_t transport_frame, framecnt_t nframes,
 166                 framecnt_t& rec_nframes, framecnt_t& rec_offset
 167                 );
 168
 169         struct CaptureInfo {
 170                 framepos_t start;
 171                 framecnt_t frames;
 172         };
 173
 174         std::vector<CaptureInfo*> capture_info;
 175         mutable Glib::Threads::Mutex capture_info_lock;
 176
 177   private:
 178         framecnt_t   _input_latency;
 179         gint         _record_enabled;
 180         gint         _record_safe;
 181         framepos_t    capture_start_frame;
 182         framecnt_t    capture_captured;
 183         bool          was_recording;
 184         framecnt_t    adjust_capture_position;
 185         framecnt_t   _capture_offset;
 186         framepos_t    first_recordable_frame;
 187         framepos_t    last_recordable_frame;
 188         int           last_possibly_recording;
 189         AlignStyle   _alignment_style;
 190         AlignChoice  _alignment_choice;
 191         std::string   _write_source_name;
 192         boost::shared_ptr<SMFSource> _midi_write_source;
 193
 194         std::list<boost::shared_ptr<Source> > _last_capture_sources;
 195         std::vector<boost::shared_ptr<AudioFileSource> > capturing_sources;
 196
 197         static framecnt_t _chunk_frames;
 198
 199         NoteMode                     _note_mode;
 200         volatile gint                _frames_pending_write;
 201         volatile gint                _num_captured_loops;
 202         framepos_t                   _accumulated_capture_offset;
 203
 204         /** A buffer that we use to put newly-arrived MIDI data in for
 205             the GUI to read (so that it can update itself).
 206         */
 207         MidiBuffer                   _gui_feed_buffer;
 208         mutable Glib::Threads::Mutex _gui_feed_buffer_mutex;
 209
 210         void finish_capture (boost::shared_ptr<ChannelList> c);
 211 };
 212
 213 } // namespace
 214
 215 #endif /* __ardour_disk_writer_h__ */