libs/ardour/internal_return.cc

   1 /*
   2     Copyright (C) 2009 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 #include <glibmm/thread.h>
  20
  21 #include "pbd/failed_constructor.h"
  22
  23 #include "ardour/internal_return.h"
  24 #include "ardour/mute_master.h"
  25 #include "ardour/session.h"
  26 #include "ardour/internal_send.h"
  27
  28 using namespace std;
  29 using namespace ARDOUR;
  30
  31 PBD::Signal1<void, pframes_t> InternalReturn::CycleStart;
  32
  33 InternalReturn::InternalReturn (Session& s)
  34         : Return (s, true)
  35 {
  36         CycleStart.connect_same_thread (*this, boost::bind (&InternalReturn::cycle_start, this, _1));
  37         _display_to_user = false;
  38 }
  39
  40 void
  41 InternalReturn::run (BufferSet& bufs, framepos_t /*start_frame*/, framepos_t /*end_frame*/, pframes_t nframes, bool)
  42 {
  43         if (!_active && !_pending_active) {
  44                 return;
  45         }
  46
  47         /* _sends is only modified with the process lock held, so this is ok, I think */
  48
  49         for (list<InternalSend*>::iterator i = _sends.begin(); i != _sends.end(); ++i) {
  50                 if ((*i)->active ()) {
  51                         bufs.merge_from ((*i)->get_buffers(), nframes);
  52                 }
  53         }
  54
  55         _active = _pending_active;
  56 }
  57
  58 bool
  59 InternalReturn::configure_io (ChanCount in, ChanCount out)
  60 {
  61         IOProcessor::configure_io (in, out);
  62         allocate_buffers (_session.engine().frames_per_cycle());
  63         return true;
  64 }
  65
  66 int
  67 InternalReturn::set_block_size (pframes_t nframes)
  68 {
  69         allocate_buffers (nframes);
  70         return 0;
  71 }
  72
  73 void
  74 InternalReturn::allocate_buffers (pframes_t nframes)
  75 {
  76         buffers.ensure_buffers (_configured_input, nframes);
  77         buffers.set_count (_configured_input);
  78 }
  79
  80 void
  81 InternalReturn::add_send (InternalSend* send)
  82 {
  83         Glib::Mutex::Lock lm (_session.engine().process_lock());
  84         _sends.push_back (send);
  85 }
  86
  87 void
  88 InternalReturn::remove_send (InternalSend* send)
  89 {
  90         Glib::Mutex::Lock lm (_session.engine().process_lock());
  91         _sends.remove (send);
  92 }
  93
  94 void
  95 InternalReturn::cycle_start (pframes_t nframes)
  96 {
  97         /* called from process cycle - no lock necessary */
  98         if (!_sends.empty ()) {
  99                 /* don't bother with this if nobody is going to feed us anything */
 100                 buffers.silence (nframes, 0);
 101         }
 102 }
 103
 104 XMLNode&
 105 InternalReturn::state (bool full)
 106 {
 107         XMLNode& node (Return::state (full));
 108         /* override type */
 109         node.add_property("type", "intreturn");
 110         return node;
 111 }
 112
 113 XMLNode&
 114 InternalReturn::get_state()
 115 {
 116         return state (true);
 117 }
 118
 119 int
 120 InternalReturn::set_state (const XMLNode& node, int version)
 121 {
 122         return Return::set_state (node, version);
 123 }
 124
 125 bool
 126 InternalReturn::can_support_io_configuration (const ChanCount& in, ChanCount& out) const
 127 {
 128         out = in;
 129         return true;
 130 }
 131
 132