assert() to help find some possible causes of #2991. Fix some confusion with GTK...
[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
25 #include "ardour/amp.h"
26 #include "ardour/send.h"
27 #include "ardour/session.h"
28 #include "ardour/port.h"
29 #include "ardour/audio_port.h"
30 #include "ardour/buffer_set.h"
31 #include "ardour/meter.h"
32 #include "ardour/panner.h"
33 #include "ardour/io.h"
34
35 #include "i18n.h"
36
37 using namespace ARDOUR;
38 using namespace PBD;
39 using namespace std;
40
41 Send::Send (Session& s, boost::shared_ptr<MuteMaster> mm, Role r)
42         : Delivery (s, mm, string_compose (_("send %1"), (_bitslot = s.next_send_id()) + 1), r)
43         , _metering (false)
44 {
45         _amp.reset (new Amp (_session, _mute_master));
46         _meter.reset (new PeakMeter (_session));
47
48         ProcessorCreated (this); /* EMIT SIGNAL */
49 }
50
51 Send::Send (Session& s, boost::shared_ptr<MuteMaster> mm, const XMLNode& node, int version, Role r)
52         : Delivery (s, mm, "send", r)
53         , _metering (false)
54 {
55         _amp.reset (new Amp (_session, _mute_master));
56         _meter.reset (new PeakMeter (_session));
57
58         if (set_state (node, version)) {
59                 throw failed_constructor();
60         }
61
62         ProcessorCreated (this); /* EMIT SIGNAL */
63 }
64
65 Send::~Send ()
66 {
67 }
68
69 void
70 Send::activate ()
71 {
72         _amp->activate ();
73         _meter->activate ();
74
75         Processor::activate ();
76 }
77
78 void
79 Send::deactivate ()
80 {
81         _amp->deactivate ();
82         _meter->deactivate ();
83         _meter->reset ();
84         
85         Processor::deactivate ();
86 }
87
88 void
89 Send::run (BufferSet& bufs, sframes_t start_frame, sframes_t end_frame, nframes_t nframes, bool)
90 {
91         if (_output->n_ports() == ChanCount::ZERO) {
92                 _meter->reset ();
93                 _active = _pending_active;
94                 return;
95         }
96
97         if (!_active && !_pending_active) {
98                 _meter->reset ();
99                 _output->silence (nframes);
100                 _active = _pending_active;
101                 return;
102         }
103
104         // we have to copy the input, because deliver_output() may alter the buffers
105         // in-place, which a send must never do.
106
107         BufferSet& sendbufs = _session.get_mix_buffers (bufs.count());
108         sendbufs.read_from (bufs, nframes);
109         assert(sendbufs.count() == bufs.count());
110
111         /* gain control */
112
113         // Can't automate gain for sends or returns yet because we need different buffers
114         // so that we don't overwrite the main automation data for the route amp
115         // _amp->setup_gain_automation (start_frame, end_frame, nframes);
116         _amp->run (sendbufs, start_frame, end_frame, nframes, true);
117
118         /* deliver to outputs */
119
120         Delivery::run (sendbufs, start_frame, end_frame, nframes, true);
121
122         /* consider metering */
123
124         if (_metering) {
125                 if (_amp->gain_control()->get_value() == 0) {
126                         _meter->reset();
127                 } else {
128                         _meter->run (*_output_buffers, start_frame, end_frame, nframes, true);
129                 }
130         }
131
132         /* _active was set to _pending_active by Delivery::run() */
133 }
134
135 XMLNode&
136 Send::get_state(void)
137 {
138         return state (true);
139 }
140
141 XMLNode&
142 Send::state(bool full)
143 {
144         XMLNode& node = Delivery::state(full);
145         char buf[32];
146
147         node.add_property ("type", "send");
148         snprintf (buf, sizeof (buf), "%" PRIu32, _bitslot);
149         node.add_property ("bitslot", buf);
150
151         return node;
152 }
153
154 int
155 Send::set_state (const XMLNode& node, int version)
156 {
157         XMLNodeList nlist = node.children();
158         XMLNodeIterator niter;
159         const XMLProperty* prop;
160
161         if ((prop = node.property ("bitslot")) == 0) {
162                 _bitslot = _session.next_send_id();
163         } else {
164                 sscanf (prop->value().c_str(), "%" PRIu32, &_bitslot);
165                 cerr << this << " scanned " << prop->value() << " to get " << _bitslot << endl;
166                 _session.mark_send_id (_bitslot);
167         }
168
169         const XMLNode* insert_node = &node;
170
171         /* XXX need to load automation state & data for amp */
172
173         Delivery::set_state (*insert_node, version);
174
175         return 0;
176 }
177
178 bool
179 Send::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
180 {
181         /* sends have no impact at all on the channel configuration of the
182            streams passing through the route. so, out == in.
183         */
184
185         out = in;
186         return true;
187 }
188
189 bool
190 Send::configure_io (ChanCount in, ChanCount out)
191 {
192         if (!_amp->configure_io (in, out) || !_meter->configure_io (in, out)) {
193                 return false;
194         }
195
196         if (!Processor::configure_io (in, out)) {
197                 return false;
198         }
199
200         reset_panner ();
201
202         return true;
203 }
204
205 /** Set up the XML description of a send so that its name is unique.
206  *  @param state XML send state.
207  *  @param session Session.
208  */
209 void
210 Send::make_unique (XMLNode &state, Session &session)
211 {
212         uint32_t const bitslot = session.next_send_id() + 1;
213
214         char buf[32];
215         snprintf (buf, sizeof (buf), "%" PRIu32, bitslot);
216         state.property("bitslot")->set_value (buf);
217
218         string const name = string_compose (_("send %1"), bitslot);
219
220         state.property("name")->set_value (name);
221
222         XMLNode* io = state.child ("IO");
223
224         if (io) {
225                 io->property("name")->set_value (name);
226         }
227 }
228
229 bool
230 Send::set_name (const string& new_name)
231 {
232         string unique_name;
233
234         if (_role == Delivery::Send) {
235                 char buf[32];
236
237                 /* rip any existing numeric part of the name, and append the bitslot
238                  */
239
240                 string::size_type last_letter = new_name.find_last_not_of ("0123456789");
241
242                 if (last_letter != string::npos) {
243                         unique_name = new_name.substr (0, last_letter + 1);
244                 } else {
245                         unique_name = new_name;
246                 }
247
248                 snprintf (buf, sizeof (buf), "%u", (_bitslot + 1));
249                 unique_name += buf;
250
251         } else {
252                 unique_name = new_name;
253         }
254
255         return Delivery::set_name (unique_name);
256 }
257
258 bool
259 Send::display_to_user () const
260 {
261         /* we ignore Deliver::_display_to_user */
262
263         if (_role == Listen) {
264                 return false;
265         }
266
267         return true;
268 }