rework design of midi clock ticker to avoid expensive generalization that has turned...
[ardour.git] / libs / ardour / send.cc
1 /*
2     Copyright (C) 2000 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 #include <iostream>
21 #include <algorithm>
22
23 #include "pbd/xml++.h"
24 #include "pbd/boost_debug.h"
25
26 #include "ardour/amp.h"
27 #include "ardour/send.h"
28 #include "ardour/session.h"
29 #include "ardour/port.h"
30 #include "ardour/audio_port.h"
31 #include "ardour/buffer_set.h"
32 #include "ardour/meter.h"
33 #include "ardour/panner.h"
34 #include "ardour/io.h"
35
36 #include "i18n.h"
37
38 using namespace ARDOUR;
39 using namespace PBD;
40 using namespace std;
41
42 string
43 Send::name_and_id_new_send (Session& s, Role r, uint32_t& bitslot)
44 {
45         if (r == Role (0)) {
46                 /* this happens during initial construction of sends from XML, 
47                    before they get ::set_state() called. lets not worry about
48                    it.
49                 */
50                 bitslot = 0;
51                 return string ();
52         }
53
54         switch (r) {
55         case Delivery::Aux:
56                 return string_compose (_("aux %1"), (bitslot = s.next_aux_send_id ()) + 1);
57         case Delivery::Listen:
58                 return _("listen"); // no ports, no need for numbering
59         case Delivery::Send:
60                 return string_compose (_("send %1"), (bitslot = s.next_send_id ()) + 1);
61         default:
62                 fatal << string_compose (_("programming error: send created using role %1"), enum_2_string (r)) << endmsg;
63                 /*NOTREACHED*/
64                 return string();
65         }
66         
67 }
68
69 Send::Send (Session& s, boost::shared_ptr<Pannable> p, boost::shared_ptr<MuteMaster> mm, Role r)
70         : Delivery (s, p, mm, name_and_id_new_send (s, r, _bitslot), r)
71         , _metering (false)
72 {
73         if (_role == Listen) {
74                 /* we don't need to do this but it keeps things looking clean
75                    in a debugger. _bitslot is not used by listen sends.
76                 */
77                 _bitslot = 0;
78         }
79
80         boost_debug_shared_ptr_mark_interesting (this, "send");
81
82         _amp.reset (new Amp (_session));
83         _meter.reset (new PeakMeter (_session));
84
85         add_control (_amp->gain_control ());
86 }
87
88 Send::~Send ()
89 {
90         _session.unmark_send_id (_bitslot);
91 }
92
93 void
94 Send::activate ()
95 {
96         _amp->activate ();
97         _meter->activate ();
98
99         Processor::activate ();
100 }
101
102 void
103 Send::deactivate ()
104 {
105         _amp->deactivate ();
106         _meter->deactivate ();
107         _meter->reset ();
108
109         Processor::deactivate ();
110 }
111
112 void
113 Send::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
114 {
115         if (_output->n_ports() == ChanCount::ZERO) {
116                 _meter->reset ();
117                 _active = _pending_active;
118                 return;
119         }
120
121         if (!_active && !_pending_active) {
122                 _meter->reset ();
123                 _output->silence (nframes);
124                 _active = _pending_active;
125                 return;
126         }
127
128         // we have to copy the input, because deliver_output() may alter the buffers
129         // in-place, which a send must never do.
130
131         BufferSet& sendbufs = _session.get_mix_buffers (bufs.count());
132         sendbufs.read_from (bufs, nframes);
133         assert(sendbufs.count() == bufs.count());
134
135         /* gain control */
136
137         // Can't automate gain for sends or returns yet because we need different buffers
138         // so that we don't overwrite the main automation data for the route amp
139         // _amp->setup_gain_automation (start_frame, end_frame, nframes);
140         _amp->run (sendbufs, start_frame, end_frame, nframes, true);
141
142         /* deliver to outputs */
143
144         Delivery::run (sendbufs, start_frame, end_frame, nframes, true);
145
146         /* consider metering */
147
148         if (_metering) {
149                 if (_amp->gain_control()->get_value() == 0) {
150                         _meter->reset();
151                 } else {
152                         _meter->run (*_output_buffers, start_frame, end_frame, nframes, true);
153                 }
154         }
155
156         /* _active was set to _pending_active by Delivery::run() */
157 }
158
159 XMLNode&
160 Send::get_state(void)
161 {
162         return state (true);
163 }
164
165 XMLNode&
166 Send::state (bool full)
167 {
168         XMLNode& node = Delivery::state(full);
169         char buf[32];
170
171         node.add_property ("type", "send");
172         snprintf (buf, sizeof (buf), "%" PRIu32, _bitslot);
173
174         if (_role != Listen) {
175                 node.add_property ("bitslot", buf);
176         }
177
178         node.add_child_nocopy (_amp->state (full));
179
180         return node;
181 }
182
183 int
184 Send::set_state (const XMLNode& node, int version)
185 {
186         if (version < 3000) {
187                 return set_state_2X (node, version);
188         }
189
190         const XMLProperty* prop;
191
192         Delivery::set_state (node, version);
193
194         /* don't try to reset bitslot if there is a node for it already: this can cause
195            issues with the session's accounting of send ID's
196         */
197
198         if ((prop = node.property ("bitslot")) == 0) {
199                 if (_role == Delivery::Aux) {
200                         _bitslot = _session.next_aux_send_id ();
201                 } else if (_role == Delivery::Send) {
202                         _bitslot = _session.next_send_id ();
203                 } else {
204                         // bitslot doesn't matter but make it zero anyway
205                         _bitslot = 0;
206                 }
207         } else {
208                 if (_role == Delivery::Aux) {
209                         _session.unmark_aux_send_id (_bitslot);
210                         sscanf (prop->value().c_str(), "%" PRIu32, &_bitslot);
211                         _session.mark_aux_send_id (_bitslot);
212                 } else if (_role == Delivery::Send) {
213                         _session.unmark_send_id (_bitslot);
214                         sscanf (prop->value().c_str(), "%" PRIu32, &_bitslot);
215                         _session.mark_send_id (_bitslot);
216                 } else {
217                         // bitslot doesn't matter but make it zero anyway
218                         _bitslot = 0;
219                 }
220         }
221
222         XMLNodeList nlist = node.children();
223         for (XMLNodeIterator i = nlist.begin(); i != nlist.end(); ++i) {
224                 if ((*i)->name() == X_("Processor")) {
225                         _amp->set_state (**i, version);
226                 }
227         }
228
229         return 0;
230 }
231
232 int
233 Send::set_state_2X (const XMLNode& node, int /* version */)
234 {
235         /* use the IO's name for the name of the send */
236         XMLNodeList const & children = node.children ();
237
238         XMLNodeList::const_iterator i = children.begin();
239         while (i != children.end() && (*i)->name() != X_("Redirect")) {
240                 ++i;
241         }
242
243         if (i == children.end()) {
244                 return -1;
245         }
246
247         XMLNodeList const & grand_children = (*i)->children ();
248         XMLNodeList::const_iterator j = grand_children.begin ();
249         while (j != grand_children.end() && (*j)->name() != X_("IO")) {
250                 ++j;
251         }
252
253         if (j == grand_children.end()) {
254                 return -1;
255         }
256
257         XMLProperty const * prop = (*j)->property (X_("name"));
258         if (!prop) {
259                 return -1;
260         }
261
262         set_name (prop->value ());
263
264         return 0;
265 }
266
267 bool
268 Send::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
269 {
270         /* sends have no impact at all on the channel configuration of the
271            streams passing through the route. so, out == in.
272         */
273
274         out = in;
275         return true;
276 }
277
278 /** Caller must hold process lock */
279 bool
280 Send::configure_io (ChanCount in, ChanCount out)
281 {
282         if (!_amp->configure_io (in, out) || !_meter->configure_io (in, out)) {
283                 return false;
284         }
285
286         if (!Processor::configure_io (in, out)) {
287                 return false;
288         }
289
290         reset_panner ();
291
292         return true;
293 }
294
295 /** Set up the XML description of a send so that its name is unique.
296  *  @param state XML send state.
297  *  @param session Session.
298  */
299 void
300 Send::make_unique (XMLNode &state, Session &session)
301 {
302         uint32_t const bitslot = session.next_send_id() + 1;
303
304         char buf[32];
305         snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
306         state.property("bitslot")->set_value (buf);
307
308         string const name = string_compose (_("send %1"), bitslot);
309
310         state.property("name")->set_value (name);
311
312         XMLNode* io = state.child ("IO");
313
314         if (io) {
315                 io->property("name")->set_value (name);
316         }
317 }
318
319 bool
320 Send::set_name (const string& new_name)
321 {
322         string unique_name;
323
324         if (_role == Delivery::Send) {
325                 char buf[32];
326
327                 /* rip any existing numeric part of the name, and append the bitslot
328                  */
329
330                 string::size_type last_letter = new_name.find_last_not_of ("0123456789");
331
332                 if (last_letter != string::npos) {
333                         unique_name = new_name.substr (0, last_letter + 1);
334                 } else {
335                         unique_name = new_name;
336                 }
337
338                 snprintf (buf, sizeof (buf), "%u", (_bitslot + 1));
339                 unique_name += buf;
340
341         } else {
342                 unique_name = new_name;
343         }
344
345         return Delivery::set_name (unique_name);
346 }
347
348 bool
349 Send::display_to_user () const
350 {
351         /* we ignore Deliver::_display_to_user */
352
353         if (_role == Listen) {
354                 /* don't make the monitor/control/listen send visible */
355                 return false;
356         }
357
358         return true;
359 }