libs/ardour/ardour/disk_io.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_io_h__
  21 #define __ardour_disk_io_h__
  22
  23 #include <vector>
  24 #include <string>
  25 #include <exception>
  26
  27 #include "pbd/ringbufferNPT.h"
  28 #include "pbd/rcu.h"
  29
  30 #include "ardour/interpolation.h"
  31 #include "ardour/processor.h"
  32
  33 namespace ARDOUR {
  34
  35 class AudioFileSource;
  36 class AudioPlaylist;
  37 class Location;
  38 class MidiPlaylist;
  39 class Playlist;
  40 class Route;
  41 class Route;
  42 class Session;
  43
  44 template<typename T> class MidiRingBuffer;
  45
  46 class LIBARDOUR_API DiskIOProcessor : public Processor
  47 {
  48   public:
  49         enum Flag {
  50                 Recordable  = 0x1,
  51                 Hidden      = 0x2,
  52                 Destructive = 0x4,
  53                 NonLayered   = 0x8
  54         };
  55
  56         static const std::string state_node_name;
  57
  58         DiskIOProcessor (Session&, const std::string& name, Flag f);
  59
  60         void set_route (boost::shared_ptr<Route>);
  61
  62         static void set_buffering_parameters (BufferingPreset bp);
  63
  64         int set_block_size (pframes_t);
  65         bool configure_io (ChanCount in, ChanCount out);
  66         bool can_support_io_configuration (const ChanCount& in, ChanCount& out);
  67
  68         /** @return A number between 0 and 1, where 0 indicates that the playback buffer
  69          *  is dry (ie the disk subsystem could not keep up) and 1 indicates that the
  70          *  buffer is full.
  71          */
  72         virtual float playback_buffer_load() const = 0;
  73         virtual float capture_buffer_load() const = 0;
  74
  75         void set_flag (Flag f)   { _flags = Flag (_flags | f); }
  76         void unset_flag (Flag f) { _flags = Flag (_flags & ~f); }
  77
  78         bool           hidden()      const { return _flags & Hidden; }
  79         bool           recordable()  const { return _flags & Recordable; }
  80         bool           non_layered()  const { return _flags & NonLayered; }
  81         bool           reversed()    const { return _actual_speed < 0.0f; }
  82         double         speed()       const { return _visible_speed; }
  83
  84         virtual void non_realtime_locate (framepos_t);
  85
  86         void non_realtime_set_speed ();
  87         bool realtime_set_speed (double sp, bool global);
  88
  89         virtual void punch_in()  {}
  90         virtual void punch_out() {}
  91
  92         virtual float buffer_load() const = 0;
  93
  94         bool slaved() const      { return _slaved; }
  95         void set_slaved(bool yn) { _slaved = yn; }
  96
  97         int set_loop (Location *loc);
  98
  99         PBD::Signal1<void,Location *> LoopSet;
 100         PBD::Signal0<void>            SpeedChanged;
 101         PBD::Signal0<void>            ReverseChanged;
 102
 103         int set_state (const XMLNode&, int version);
 104
 105         int add_channel (uint32_t how_many);
 106         int remove_channel (uint32_t how_many);
 107
 108         bool need_butler() const { return _need_butler; }
 109
 110         boost::shared_ptr<Playlist>      get_playlist (DataType dt) const { return _playlists[dt]; }
 111         boost::shared_ptr<MidiPlaylist>  midi_playlist() const;
 112         boost::shared_ptr<AudioPlaylist> audio_playlist() const;
 113
 114         virtual void playlist_modified () {}
 115         virtual int use_playlist (DataType, boost::shared_ptr<Playlist>);
 116         virtual int use_new_playlist (DataType);
 117         virtual int use_copy_playlist (DataType);
 118
 119         PBD::Signal1<void,DataType>   PlaylistChanged;
 120
 121   protected:
 122         friend class Auditioner;
 123         virtual int  seek (framepos_t which_sample, bool complete_refill = false) = 0;
 124
 125   protected:
 126         Flag         _flags;
 127         uint32_t      i_am_the_modifier;
 128         double       _visible_speed;
 129         double       _actual_speed;
 130         double       _speed;
 131         double       _target_speed;
 132         /* items needed for speed change logic */
 133         bool         _buffer_reallocation_required;
 134         bool         _seek_required;
 135         bool         _slaved;
 136         Location*     loop_location;
 137         bool          in_set_state;
 138         framecnt_t    wrap_buffer_size;
 139         framecnt_t    speed_buffer_size;
 140         bool         _need_butler;
 141         boost::shared_ptr<Route> _route;
 142
 143         void init ();
 144
 145         Glib::Threads::Mutex state_lock;
 146
 147         static bool get_buffering_presets (BufferingPreset bp,
 148                                            framecnt_t& read_chunk_size,
 149                                            framecnt_t& read_buffer_size,
 150                                            framecnt_t& write_chunk_size,
 151                                            framecnt_t& write_buffer_size);
 152
 153         enum TransitionType {
 154                 CaptureStart = 0,
 155                 CaptureEnd
 156         };
 157
 158         struct CaptureTransition {
 159                 TransitionType   type;
 160                 framepos_t       capture_val; ///< The start or end file frame position
 161         };
 162
 163         /** Information about one audio channel, playback or capture
 164          * (depending on the derived class)
 165          */
 166         struct ChannelInfo : public boost::noncopyable {
 167
 168                 ChannelInfo (framecnt_t buffer_size);
 169                 ~ChannelInfo ();
 170
 171                 /** A ringbuffer for data to be played back, written to in the
 172                     butler thread, read from in the process thread.
 173                 */
 174                 PBD::RingBufferNPT<Sample>* buf;
 175
 176                 Sample* scrub_buffer;
 177                 Sample* scrub_forward_buffer;
 178                 Sample* scrub_reverse_buffer;
 179
 180                 PBD::RingBufferNPT<Sample>::rw_vector rw_vector;
 181
 182                 /* used only by capture */
 183                 boost::shared_ptr<AudioFileSource> write_source;
 184                 PBD::RingBufferNPT<CaptureTransition> * capture_transition_buf;
 185                 // the following are used in the butler thread only
 186                 framecnt_t                     curr_capture_cnt;
 187
 188                 void resize (framecnt_t);
 189         };
 190
 191         typedef std::vector<ChannelInfo*> ChannelList;
 192         SerializedRCUManager<ChannelList> channels;
 193
 194         int add_channel_to (boost::shared_ptr<ChannelList>, uint32_t how_many);
 195         int remove_channel_from (boost::shared_ptr<ChannelList>, uint32_t how_many);
 196
 197         CubicInterpolation interpolation;
 198
 199         boost::shared_ptr<Playlist> _playlists[DataType::num_types];
 200         PBD::ScopedConnectionList playlist_connections;
 201
 202         virtual void playlist_changed (const PBD::PropertyChange&) {}
 203         virtual void playlist_deleted (boost::weak_ptr<Playlist>);
 204         virtual void playlist_ranges_moved (std::list< Evoral::RangeMove<framepos_t> > const &, bool) {}
 205         int find_and_use_playlist (DataType, std::string const &);
 206
 207         /* The MIDI stuff */
 208
 209         MidiRingBuffer<framepos_t>*  _midi_buf;
 210         gint                         _frames_written_to_ringbuffer;
 211         gint                         _frames_read_from_ringbuffer;
 212         CubicMidiInterpolation        midi_interpolation;
 213 };
 214
 215 } // namespace ARDOUR
 216
 217 #endif /* __ardour_disk_io_h__ */