libs/ardour/export_channel.cc

   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 #include "ardour/audio_buffer.h"
  22 #include "ardour/audio_port.h"
  23 #include "ardour/audio_track.h"
  24 #include "ardour/audioengine.h"
  25 #include "ardour/export_channel.h"
  26 #include "ardour/export_failed.h"
  27 #include "ardour/session.h"
  28
  29 #include "pbd/error.h"
  30
  31 using namespace ARDOUR;
  32
  33 bool
  34 PortExportChannel::operator< (ExportChannel const & other) const
  35 {
  36         PortExportChannel const * pec;
  37         if (!(pec = dynamic_cast<PortExportChannel const *> (&other))) {
  38                 return this < &other;
  39         }
  40         return ports < pec->ports;
  41 }
  42
  43 void
  44 PortExportChannel::read (Sample * data, framecnt_t frames) const
  45 {
  46         memset (data, 0, frames * sizeof (float));
  47
  48         for (PortSet::const_iterator it = ports.begin(); it != ports.end(); ++it) {
  49                 if (*it != 0) {
  50                         Sample* port_buffer = (*it)->get_audio_buffer(frames).data();
  51
  52                         for (uint32_t i = 0; i < frames; ++i) {
  53                                 data[i] += (float) port_buffer[i];
  54                         }
  55                 }
  56         }
  57 }
  58
  59 void
  60 PortExportChannel::get_state (XMLNode * node) const
  61 {
  62         XMLNode * port_node;
  63         for (PortSet::const_iterator it = ports.begin(); it != ports.end(); ++it) {
  64                 if ((port_node = node->add_child ("Port"))) {
  65                         port_node->add_property ("name", (*it)->name());
  66                 }
  67         }
  68 }
  69
  70 void
  71 PortExportChannel::set_state (XMLNode * node, Session & session)
  72 {
  73         XMLProperty * prop;
  74         XMLNodeList xml_ports = node->children ("Port");
  75         for (XMLNodeList::iterator it = xml_ports.begin(); it != xml_ports.end(); ++it) {
  76                 if ((prop = (*it)->property ("name"))) {
  77                         std::string const & name = prop->value();
  78                         AudioPort * port = dynamic_cast<AudioPort *> (session.engine().get_port_by_name (name));
  79                         if (port) {
  80                                 ports.insert (port);
  81                         } else {
  82                                 PBD::warning << string_compose (_("Could not get port for export channel \"%1\", dropping the channel"), name) << endmsg;
  83                         }
  84                 }
  85         }
  86 }
  87
  88 RegionExportChannelFactory::RegionExportChannelFactory (Session * session, AudioRegion const & region, AudioTrack & track, Type type) :
  89   region (region),
  90   track (track),
  91   type (type),
  92   frames_per_cycle (session->engine().frames_per_cycle ()),
  93   buffers_up_to_date (false),
  94   region_start (region.position()),
  95   position (region_start),
  96
  97   mixdown_buffer (0),
  98   gain_buffer (0)
  99 {
 100         switch (type) {
 101           case Raw:
 102                 n_channels = region.n_channels();
 103                 break;
 104           case Fades:
 105                 n_channels = region.n_channels();
 106
 107                 mixdown_buffer = new Sample [frames_per_cycle];
 108                 gain_buffer = new Sample [frames_per_cycle];
 109                 memset (gain_buffer, 1.0, sizeof (Sample) * frames_per_cycle);
 110
 111                 break;
 112           case Processed:
 113                 n_channels = track.n_outputs().n_audio();
 114                 break;
 115           default:
 116                 throw ExportFailed ("Unhandled type in ExportChannelFactory constructor");
 117         }
 118
 119         session->ProcessExport.connect_same_thread (export_connection, boost::bind (&RegionExportChannelFactory::new_cycle_started, this, _1));
 120
 121         buffers.ensure_buffers (DataType::AUDIO, n_channels, frames_per_cycle);
 122         buffers.set_count (ChanCount (DataType::AUDIO, n_channels));
 123 }
 124
 125 RegionExportChannelFactory::~RegionExportChannelFactory ()
 126 {
 127         delete[] mixdown_buffer;
 128         delete[] gain_buffer;
 129 }
 130
 131 ExportChannelPtr
 132 RegionExportChannelFactory::create (uint32_t channel)
 133 {
 134         assert (channel < n_channels);
 135         return ExportChannelPtr (new RegionExportChannel (*this, channel));
 136 }
 137
 138 void
 139 RegionExportChannelFactory::read (uint32_t channel, Sample * data, framecnt_t frames_to_read)
 140 {
 141         assert (channel < n_channels);
 142         assert (frames_to_read <= frames_per_cycle);
 143
 144         if (!buffers_up_to_date) {
 145                 update_buffers(frames_to_read);
 146                 buffers_up_to_date = true;
 147         }
 148
 149         memcpy (data, buffers.get_audio (channel).data(), frames_to_read * sizeof (Sample));
 150 }
 151
 152 void
 153 RegionExportChannelFactory::update_buffers (framecnt_t frames)
 154 {
 155         assert (frames <= frames_per_cycle);
 156
 157         switch (type) {
 158           case Raw:
 159                 for (size_t channel = 0; channel < n_channels; ++channel) {
 160                         region.read (buffers.get_audio (channel).data(), position - region_start, frames, channel);
 161                 }
 162                 break;
 163           case Fades:
 164                 assert (mixdown_buffer && gain_buffer);
 165                 for (size_t channel = 0; channel < n_channels; ++channel) {
 166                         memset (mixdown_buffer, 0, sizeof (Sample) * frames);
 167                         region.read_at (buffers.get_audio (channel).data(), mixdown_buffer, gain_buffer, position, frames, channel);
 168                 }
 169                 break;
 170           case Processed:
 171                 track.export_stuff (buffers, position, frames);
 172                 break;
 173           default:
 174                 throw ExportFailed ("Unhandled type in ExportChannelFactory::update_buffers");
 175         }
 176
 177         position += frames;
 178 }