server/supernova/sc/sc_synth.cpp

   1 //  synth based on supercollider-style synthdef
   2 //  Copyright (C) 2009, 2010 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 #include <cstdio>
  20
  21 #include <boost/bind.hpp>
  22
  23 #include "sc_synth.hpp"
  24 #include "sc_ugen_factory.hpp"
  25 #include "../server/server.hpp"
  26
  27 namespace nova
  28 {
  29
  30 sc_synth::sc_synth(int node_id, sc_synth_prototype_ptr const & prototype):
  31     abstract_synth(node_id, prototype), trace(0), unit_buffers(0)
  32 {
  33     World const & world = sc_factory->world;
  34     mNode.mWorld = &sc_factory->world;
  35     rgen.init((uint32_t)(uint64_t)this);
  36
  37     /* initialize sc wrapper class */
  38     mRGen = &rgen;
  39     mSubsampleOffset = world.mSubsampleOffset;
  40     mSampleOffset = world.mSampleOffset;
  41     mLocalAudioBusUnit = 0;
  42     mLocalControlBusUnit = 0;
  43
  44     localBufNum = 0;
  45     localMaxBufNum = 0;
  46
  47     mNode.mID = node_id;
  48
  49     sc_synthdef const & synthdef = *prototype;
  50
  51     const size_t parameter_count = synthdef.parameter_count();
  52     const size_t constants_count = synthdef.constants.size();
  53
  54     /* we allocate one memory chunk */
  55     const size_t alloc_size = prototype->memory_requirement();
  56
  57     const size_t sample_alloc_size = world.mBufLength * synthdef.buffer_count
  58         + vec<float>::size * sizeof(float) /* for alignment */;
  59
  60     char * chunk = (char*)rt_pool.malloc(alloc_size + sample_alloc_size*sizeof(sample));
  61     if (chunk == NULL)
  62         throw std::bad_alloc();
  63
  64     /* prepare controls */
  65     mNumControls = parameter_count;
  66     mControls = (float*)chunk;     chunk += sizeof(float) * parameter_count;
  67     mControlRates = (int*)chunk;   chunk += sizeof(int) * parameter_count;
  68     mMapControls = (float**)chunk; chunk += sizeof(float*) * parameter_count;
  69
  70     /* initialize controls */
  71     for (size_t i = 0; i != parameter_count; ++i) {
  72         mControls[i] = synthdef.parameters[i]; /* initial parameters */
  73         mMapControls[i] = &mControls[i]; /* map to control values */
  74         mControlRates[i] = 0;                  /* init to 0*/
  75     }
  76
  77     /* allocate constant wires */
  78     mWire = (Wire*)chunk;          chunk += sizeof(Wire) * constants_count;
  79     for (size_t i = 0; i != synthdef.constants.size(); ++i) {
  80         Wire * wire = mWire + i;
  81         wire->mFromUnit = 0;
  82         wire->mCalcRate = 0;
  83         wire->mBuffer = 0;
  84         wire->mScalarValue = get_constant(i);
  85     }
  86
  87     unit_count = prototype->unit_count();
  88     calc_unit_count = prototype->calc_unit_count();
  89     units = (Unit**)chunk; chunk += unit_count * sizeof(Unit*);
  90     calc_units = (Unit**)chunk; chunk += calc_unit_count * sizeof(Unit*);
  91     unit_buffers = (sample*)chunk; chunk += sample_alloc_size*sizeof(sample);
  92
  93     const int alignment_mask = vec<float>::size * sizeof(float) - 1;
  94     unit_buffers = (sample*) ((size_t(unit_buffers) + alignment_mask) & ~alignment_mask);     /* next aligned pointer */
  95
  96     /* allocate unit generators */
  97     sc_factory->allocate_ugens(synthdef.graph.size());
  98     for (size_t i = 0; i != synthdef.graph.size(); ++i) {
  99         sc_synthdef::unit_spec_t const & spec = synthdef.graph[i];
 100         units[i] = spec.prototype->construct(spec, this, &sc_factory->world, chunk);
 101     }
 102
 103     for (size_t i = 0; i != synthdef.calc_unit_indices.size(); ++i) {
 104         int32_t index = synthdef.calc_unit_indices[i];
 105         calc_units[i] = units[index];
 106     }
 107
 108     assert((char*)mControls + alloc_size <= chunk); // ensure the memory boundaries
 109 }
 110
 111 namespace
 112 {
 113
 114 void free_ugen(struct Unit * unit)
 115 {
 116     sc_ugen_def * def = reinterpret_cast<sc_ugen_def*>(unit->mUnitDef);
 117     def->destruct(unit);
 118 }
 119
 120 } /* namespace */
 121
 122 sc_synth::~sc_synth(void)
 123 {
 124     std::for_each(units, units + unit_count, free_ugen);
 125     sc_factory->free_ugens(unit_count);
 126     rt_pool.free(mControls);
 127 }
 128
 129 void sc_synth::prepare(void)
 130 {
 131     for (size_t i = 0; i != unit_count; ++i) {
 132         struct Unit * unit = units[i];
 133         sc_ugen_def * def = reinterpret_cast<sc_ugen_def*>(unit->mUnitDef);
 134         def->initialize(unit);
 135     }
 136 }
 137
 138 void sc_synth::set(slot_index_t slot_index, sample val)
 139 {
 140     if (slot_index >= mNumControls) {
 141         log("argument number out of range\n");
 142         return;
 143     }
 144
 145     mControlRates[slot_index] = 0;
 146     mMapControls[slot_index] = &mControls[slot_index];
 147     mControls[slot_index] = val;
 148 }
 149
 150 void sc_synth::set_control_array(slot_index_t slot_index, size_t count, sample * val)
 151 {
 152     if (slot_index+count >= mNumControls)
 153         return;
 154     for (size_t i = 0; i != count; ++i)
 155         set(slot_index+i, val[i]);
 156 }
 157
 158
 159 void sc_synth::map_control_bus_control (unsigned int slot_index, int control_bus_index)
 160 {
 161     if (slot_index >= mNumControls)
 162         return;
 163
 164     World *world = mNode.mWorld;
 165     if (control_bus_index < 0) {
 166         mControlRates[slot_index] = 0;
 167         mMapControls[slot_index] = mControls + slot_index;
 168     }
 169     else if (uint32(control_bus_index) < world->mNumControlBusChannels) {
 170         mControlRates[slot_index] = 1;
 171         mMapControls[slot_index] = world->mControlBus + control_bus_index;
 172     }
 173 }
 174
 175 void sc_synth::map_control_buses_control (unsigned int slot_index, int control_bus_index, int count)
 176 {
 177     if (slot_index >= mNumControls)
 178         return;
 179
 180     int slots_to_set = std::min(count, int(mNumControls - slot_index));
 181
 182     for (int i = 0; i != slots_to_set; ++i)
 183         map_control_bus_control(slot_index+i, control_bus_index+i);
 184 }
 185
 186 void sc_synth::map_control_bus_audio (unsigned int slot_index, int audio_bus_index)
 187 {
 188     if (slot_index >= mNumControls)
 189         return;
 190
 191     World *world = mNode.mWorld;
 192
 193     if (audio_bus_index < 0) {
 194         mControlRates[slot_index] = 0;
 195         mMapControls[slot_index] = mControls + slot_index;
 196     } else if (uint(audio_bus_index) < world->mNumAudioBusChannels) {
 197         mControlRates[slot_index] = 2;
 198         mMapControls[slot_index] = world->mAudioBus + (audio_bus_index * world->mBufLength);
 199     }
 200 }
 201
 202 void sc_synth::map_control_buses_audio (unsigned int slot_index, int audio_bus_index, int count)
 203 {
 204     if (slot_index >= mNumControls)
 205         return;
 206
 207     int slots_to_set = std::min(count, int(mNumControls - slot_index));
 208
 209     for (int i = 0; i != slots_to_set; ++i)
 210         map_control_bus_audio(slot_index+i, audio_bus_index+i);
 211 }
 212
 213 void sc_synth::apply_unit_cmd(const char * unit_cmd, unsigned int unit_index, struct sc_msg_iter *args)
 214 {
 215     Unit * unit = units[unit_index];
 216     sc_ugen_def * def = reinterpret_cast<sc_ugen_def*>(unit->mUnitDef);
 217
 218     def->run_unit_command(unit_cmd, unit, args);
 219 }
 220
 221 void sc_synth::run(void)
 222 {
 223     perform();
 224 }
 225
 226 extern spin_lock log_guard;
 227
 228 #if defined(__GNUC__) && !defined(__APPLE__)
 229 #define thread_local __thread
 230 #endif
 231
 232 #ifdef thread_local
 233 static thread_local boost::array<char, 32768> trace_scratchpad;
 234 #else
 235 static boost::array<char, 32768> trace_scratchpad;
 236 #endif
 237
 238 struct scratchpad_printer
 239 {
 240     scratchpad_printer(char * str):
 241         string(str), position(0)
 242     {
 243         clear();
 244     }
 245
 246     void printf(const char *fmt, ...)
 247     {
 248         va_list vargs;
 249         va_start(vargs, fmt);
 250         printf(fmt, vargs);
 251     }
 252
 253     const char * data(void) const
 254     {
 255         return string;
 256     }
 257
 258     bool shouldFlush(void) const
 259     {
 260         return position + 1024 > 32768;
 261     }
 262
 263     void clear(void)
 264     {
 265         position = 0;
 266         string[0] = '\0'; // zero-terminated
 267     }
 268
 269 private:
 270     void printf(const char *fmt, va_list vargs)
 271     {
 272         position += vsprintf(string + position, fmt, vargs);
 273     }
 274
 275     char * string;
 276     int position;
 277 };
 278
 279 void sc_synth::run_traced(void)
 280 {
 281     trace = 0;
 282
 283 #ifndef thread_local
 284     spin_lock::scoped_lock lock (log_guard);
 285 #endif
 286
 287     scratchpad_printer printer(trace_scratchpad.data());
 288
 289     printer.printf("\nTRACE %d  %s    #units: %d\n", id(), this->prototype_name(), calc_unit_count);
 290
 291     for (size_t i = 0; i != calc_unit_count; ++i) {
 292         Unit * unit = calc_units[i];
 293
 294         sc_ugen_def * def = reinterpret_cast<sc_ugen_def*>(unit->mUnitDef);
 295         printer.printf("  unit %zd %s\n    in ", i, def->name());
 296         for (uint16_t j=0; j!=unit->mNumInputs; ++j) {
 297             printer.printf(" %g", unit->mInBuf[j][0]);
 298             if (printer.shouldFlush()) {
 299 #ifdef thread_local
 300                 spin_lock::scoped_lock lock (log_guard);
 301 #endif
 302                 log(printer.data());
 303                 printer.clear();
 304             }
 305         }
 306
 307         printer.printf("\n");
 308
 309         (unit->mCalcFunc)(unit, unit->mBufLength);
 310
 311         printer.printf("    out");
 312         for (int j=0; j<unit->mNumOutputs; ++j) {
 313             printer.printf(" %g", unit->mOutBuf[j][0]);
 314             if (printer.shouldFlush()) {
 315 #ifdef thread_local
 316                 spin_lock::scoped_lock lock (log_guard);
 317 #endif
 318                 log(printer.data());
 319                 printer.clear();
 320             }
 321         }
 322         printer.printf("\n");
 323     }
 324     printer.printf("\n");
 325
 326 #ifdef thread_local
 327     spin_lock::scoped_lock lock (log_guard);
 328 #endif
 329     log(printer.data());
 330 }
 331
 332 } /* namespace nova */