libs/ardour/ardour/export_channel.h

   1 /*
   2     Copyright (C) 2008 Paul Davis
   3     Author: Sakari Bergen
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #ifndef __ardour_export_channel_h__
  22 #define __ardour_export_channel_h__
  23
  24 #include <set>
  25
  26 #include <boost/scoped_array.hpp>
  27 #include <boost/shared_ptr.hpp>
  28
  29 #include "pbd/signals.h"
  30
  31 #include "ardour/buffer_set.h"
  32 #include "ardour/export_pointers.h"
  33
  34 namespace ARDOUR {
  35
  36 class Session;
  37 class AudioTrack;
  38 class AudioPort;
  39 class AudioRegion;
  40 class CapturingProcessor;
  41
  42 /// Export channel base class interface for different source types
  43 class ExportChannel : public boost::less_than_comparable<ExportChannel>
  44 {
  45   public:
  46
  47         virtual ~ExportChannel () {}
  48
  49         virtual void set_max_buffer_size(framecnt_t) { }
  50
  51         virtual void read (Sample const *& data, framecnt_t frames) const = 0;
  52         virtual bool empty () const = 0;
  53
  54         /// Adds state to node passed
  55         virtual void get_state (XMLNode * node) const = 0;
  56
  57         /// Sets state from node passed
  58         virtual void set_state (XMLNode * node, Session & session) = 0;
  59
  60         // Operator< must be defined for usage in e.g. std::map or std::set to disallow duplicates when necessary
  61         virtual bool operator< (ExportChannel const & other) const = 0;
  62 };
  63
  64 /// Basic export channel that reads from AudioPorts
  65 class PortExportChannel : public ExportChannel
  66 {
  67   public:
  68         typedef std::set<boost::weak_ptr<AudioPort> > PortSet;
  69
  70         PortExportChannel ();
  71         void set_max_buffer_size(framecnt_t frames);
  72
  73         void read (Sample const *& data, framecnt_t frames) const;
  74         bool empty () const { return ports.empty(); }
  75
  76         void get_state (XMLNode * node) const;
  77         void set_state (XMLNode * node, Session & session);
  78
  79         bool operator< (ExportChannel const & other) const;
  80
  81         void add_port (boost::weak_ptr<AudioPort> port) { ports.insert (port); }
  82         PortSet const & get_ports () { return ports; }
  83
  84   private:
  85         PortSet ports;
  86         boost::scoped_array<Sample> buffer;
  87         framecnt_t buffer_size;
  88 };
  89
  90
  91 /// Handles RegionExportChannels and does actual reading from region
  92 class RegionExportChannelFactory
  93 {
  94   public:
  95         enum Type {
  96                 Raw,
  97                 Fades,
  98                 Processed
  99         };
 100
 101         RegionExportChannelFactory (Session * session, AudioRegion const & region, AudioTrack & track, Type type);
 102         ~RegionExportChannelFactory ();
 103
 104         ExportChannelPtr create (uint32_t channel);
 105         void read (uint32_t channel, Sample const *& data, framecnt_t frames_to_read);
 106
 107   private:
 108
 109         int new_cycle_started (framecnt_t) { buffers_up_to_date = false; return 0; }
 110         void update_buffers (framecnt_t frames);
 111
 112         AudioRegion const & region;
 113         AudioTrack & track;
 114         Type type;
 115
 116         framecnt_t frames_per_cycle;
 117         size_t n_channels;
 118         BufferSet buffers;
 119         bool buffers_up_to_date;
 120         framecnt_t region_start;
 121         framecnt_t position;
 122
 123         boost::scoped_array<Sample> mixdown_buffer;
 124         boost::scoped_array<Sample> gain_buffer;
 125
 126         PBD::ScopedConnection export_connection;
 127 };
 128
 129 /// Export channel that reads from region channel
 130 class RegionExportChannel : public ExportChannel
 131 {
 132         friend class RegionExportChannelFactory;
 133
 134   public:
 135         void read (Sample const *& data, framecnt_t frames_to_read) const { factory.read (channel, data, frames_to_read); }
 136         void get_state (XMLNode * /*node*/) const {};
 137         void set_state (XMLNode * /*node*/, Session & /*session*/) {};
 138         bool empty () const { return false; }
 139         // Region export should never have duplicate channels, so there need not be any semantics here
 140         bool operator< (ExportChannel const & other) const { return this < &other; }
 141
 142   private:
 143
 144         RegionExportChannel (RegionExportChannelFactory & factory, uint32_t channel)
 145                 : factory (factory)
 146                 , channel (channel)
 147         {}
 148
 149         RegionExportChannelFactory & factory;
 150         uint32_t channel;
 151 };
 152
 153 /// Export channel for exporting from different positions in a route
 154 class RouteExportChannel : public ExportChannel
 155 {
 156         class ProcessorRemover; // fwd declaration
 157
 158   public:
 159         RouteExportChannel(boost::shared_ptr<CapturingProcessor> processor, size_t channel,
 160                            boost::shared_ptr<ProcessorRemover> remover);
 161         ~RouteExportChannel();
 162
 163         static void create_from_route(std::list<ExportChannelPtr> & result, Route & route);
 164
 165   public: // ExportChannel interface
 166         void set_max_buffer_size(framecnt_t frames);
 167
 168         void read (Sample const *& data, framecnt_t frames) const;
 169         bool empty () const { return false; }
 170
 171         void get_state (XMLNode * node) const;
 172         void set_state (XMLNode * node, Session & session);
 173
 174         bool operator< (ExportChannel const & other) const;
 175
 176   private:
 177
 178         // Removes the processor from the track when deleted
 179         class ProcessorRemover {
 180           public:
 181                 ProcessorRemover (Route & route, boost::shared_ptr<CapturingProcessor> processor)
 182                         : route (route), processor (processor) {}
 183                 ~ProcessorRemover();
 184           private:
 185                 Route & route;
 186                 boost::shared_ptr<CapturingProcessor> processor;
 187         };
 188
 189         boost::shared_ptr<CapturingProcessor> processor;
 190         size_t channel;
 191         // Each channel keeps a ref to the remover. Last one alive
 192         // will cause the processor to be removed on deletion.
 193         boost::shared_ptr<ProcessorRemover> remover;
 194 };
 195
 196 } // namespace ARDOUR
 197
 198 #endif