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