server/supernova/sc/sc_plugin_interface.hpp

   1 //  interface for supercollider plugins
   2 //  Copyright (C) 2009 Tim Blechmann
   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; see the file COPYING.  If not, write to
  16 //  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17 //  Boston, MA 02111-1307, USA.
  18
  19 #ifndef SC_PLUGIN_INTERFACE_HPP
  20 #define SC_PLUGIN_INTERFACE_HPP
  21
  22 #include <vector>
  23
  24 #include "../server/audio_bus_manager.hpp"
  25 #include "../server/node_types.hpp"
  26 #include "../server/synth.hpp"
  27 #include "../server/memory_pool.hpp"
  28
  29 #include "SC_InterfaceTable.h"
  30 #include "SC_World.h"
  31
  32 #include <boost/scoped_array.hpp>
  33 #include <boost/thread/mutex.hpp>
  34
  35 #include "../../common/SC_SndFileHelpers.hpp"
  36
  37 namespace nova
  38 {
  39
  40 class sc_done_action_handler
  41 {
  42 public:
  43     void add_pause_node(server_node * node)
  44     {
  45         spin_lock::scoped_lock lock(cmd_lock);
  46         pause_nodes.push_back(node);
  47     }
  48
  49     void add_resume_node(server_node * node)
  50     {
  51         spin_lock::scoped_lock lock(cmd_lock);
  52         resume_nodes.push_back(node);
  53     }
  54
  55     void add_done_node(server_node * node)
  56     {
  57         spin_lock::scoped_lock lock(cmd_lock);
  58         done_nodes.push_back(node);
  59     }
  60
  61     void add_freeDeep_node(abstract_group * node)
  62     {
  63         spin_lock::scoped_lock lock(cmd_lock);
  64         freeDeep_nodes.push_back(node);
  65     }
  66
  67     void add_freeAll_node(abstract_group * node)
  68     {
  69         spin_lock::scoped_lock lock(cmd_lock);
  70         freeAll_nodes.push_back(node);
  71     }
  72
  73     void update_nodegraph(void);
  74
  75 protected:
  76     typedef rt_pool_allocator<server_node*> server_node_alloc;
  77     typedef rt_pool_allocator<abstract_group*> abstract_group_alloc;
  78     std::vector<server_node*, server_node_alloc> done_nodes, pause_nodes, resume_nodes;
  79     std::vector<abstract_group*, abstract_group_alloc> freeAll_nodes, freeDeep_nodes;
  80
  81 private:
  82     spin_lock cmd_lock; /* multiple synths can be scheduled for removal, so we need to guard this
  83                            later we can try different approaches like a lockfree stack or bitmask */
  84 };
  85
  86 class sc_plugin_interface:
  87     public sc_done_action_handler
  88 {
  89 public:
  90     void initialize(class server_arguments const & args, float * control_busses);
  91     void reset_sampling_rate(int sr);
  92
  93     sc_plugin_interface(void):
  94         synths_to_initialize(false)
  95     {}
  96
  97     ~sc_plugin_interface(void);
  98
  99     InterfaceTable sc_interface;
 100     World world;
 101
 102     audio_bus_manager audio_busses;
 103
 104     int buf_counter(void) const
 105     {
 106         return world.mBufCounter;
 107     }
 108
 109     /* @{ */
 110     /* audio buffer handling */
 111     SndBuf* allocate_buffer(uint32_t index, uint32_t frames, uint32_t channels);
 112     int allocate_buffer(SndBuf * buf, uint32_t frames, uint32_t channels, double samplerate);
 113     int buffer_read_alloc(uint32_t index, const char * filename, uint32_t start, uint32_t frames);
 114     int buffer_alloc_read_channels(uint32_t index, const char * filename, uint32_t start, uint32_t frames, uint32_t channel_count,
 115                                    const uint32_t * channel_data);
 116     int buffer_read(uint32_t index, const char * filename, uint32_t start_file, uint32_t frames, uint32_t start_buffer,
 117                     bool leave_open);
 118     int buffer_read_channel(uint32_t index, const char * filename, uint32_t start_file, uint32_t frames, uint32_t start_buffer,
 119                     bool leave_open, uint32_t channel_count, const uint32_t * channel_data);
 120
 121     sample * get_nrt_mirror_buffer(uint32_t index)
 122     {
 123         return world.mSndBufsNonRealTimeMirror[index].data;
 124     }
 125
 126     sample * get_buffer(uint32_t index)
 127     {
 128         return world.mSndBufs[index].data;
 129     }
 130
 131     SndBuf * get_buffer_struct(uint32_t index)
 132     {
 133         return world.mSndBufs + index;
 134     }
 135
 136     int buffer_write(uint32_t index, const char * filename, const char * header_format, const char * sample_format,
 137                      uint32_t start, uint32_t frames, bool leave_open);
 138
 139     void buffer_zero(uint32_t index);
 140     void buffer_close(uint32_t index);
 141
 142     sample * buffer_generate(uint32_t index, const char * cmd_name, struct sc_msg_iter & msg);
 143
 144     void increment_write_updates(uint32_t index)
 145     {
 146         world.mSndBufUpdates[index].writes++;
 147     }
 148
 149     void free_buffer(uint32_t index);
 150
 151     typedef boost::mutex::scoped_lock buffer_lock_t;
 152
 153     boost::mutex & buffer_guard(size_t index)
 154     {
 155         return async_buffer_guards[index];
 156     }
 157
 158 private:
 159     boost::scoped_array<boost::mutex> async_buffer_guards;
 160     /* @} */
 161
 162 public:
 163     /* copies nrt mirror to rt buffers */
 164     void buffer_sync(uint32_t index);
 165
 166     /* @{ */
 167     /* control bus handling */
 168
 169 private:
 170     void controlbus_set_unchecked(uint32_t bus, float value)
 171     {
 172         world.mControlBus[bus] = value;
 173         world.mControlBusTouched[bus] = world.mBufCounter;
 174     }
 175
 176 public:
 177     void controlbus_set(uint32_t bus, float value)
 178     {
 179         if (bus < world.mNumControlBusChannels)
 180             controlbus_set_unchecked(bus, value);
 181     }
 182
 183     void controlbus_fill(uint32_t bus, size_t count, float value)
 184     {
 185         if (bus + count >= world.mNumControlBusChannels)
 186             count = world.mNumAudioBusChannels - bus;
 187
 188         for (size_t i = 0; i != count; ++i)
 189             controlbus_set_unchecked(bus + i, value);
 190     }
 191
 192     sample controlbus_get(uint32_t bus)
 193     {
 194         if (bus < world.mNumControlBusChannels)
 195             return world.mControlBus[bus];
 196         else
 197             return 0.f;
 198     }
 199
 200     void controlbus_getn(uint32_t bus, size_t count, size_t * r_count, float * r_values)
 201     {
 202         size_t remain = count;
 203         if (bus + count >= world.mNumControlBusChannels)
 204             remain = world.mNumAudioBusChannels - bus;
 205         *r_count = remain;
 206
 207         for (size_t i = 0; i != remain; ++i)
 208             r_values[i] = world.mControlBus[i];
 209     }
 210     /* @}*/
 211
 212     /* @{ */
 213     /** synth initialization. called in the beginning of each dsp tick */
 214     void initialize_synths(void)
 215     {
 216         if (likely(!synths_to_initialize))
 217             return; // fast-path
 218
 219         initialize_synths_perform();
 220     }
 221
 222     void schedule_for_preparation(abstract_synth * synth)
 223     {
 224         synths_to_initialize = true;
 225         uninitialized_synths.push_back(synth);
 226         synth->add_ref();
 227     }
 228
 229 private:
 230     bool synths_to_initialize;
 231
 232     void initialize_synths_perform(void);
 233     std::vector<abstract_synth*, rt_pool_allocator<abstract_synth*> > uninitialized_synths;
 234     /* @} */
 235 };
 236
 237 } /* namespace nova */
 238
 239 #endif /* SC_PLUGIN_INTERFACE_HPP */