void cSystem_onMessage(HvBase *_c, void *o, int letIn, const HvMessage *const m,
    void (*sendMessage)(HvBase *, int, const HvMessage *const)) {

  HvMessage *n = HV_MESSAGE_ON_STACK(1);
  if (msg_compareSymbol(m, 0, "samplerate")) {
    msg_initWithFloat(n, msg_getTimestamp(m), (float) ctx_getSampleRate(_c));
  } else if (msg_compareSymbol(m, 0, "numInputChannels")) {
    msg_initWithFloat(n, msg_getTimestamp(m), (float) ctx_getNumInputChannels(_c));
  } else if (msg_compareSymbol(m, 0, "numOutputChannels")) {
    msg_initWithFloat(n, msg_getTimestamp(m), (float) ctx_getNumOutputChannels(_c));
  } else if (msg_compareSymbol(m, 0, "currentTime")) {
    msg_initWithFloat(n, msg_getTimestamp(m), (float) msg_getTimestamp(m));
  } else if (msg_compareSymbol(m, 0, "table")) {
    // NOTE(mhroth): no need to check message format for symbols as table lookup will fail otherwise
    HvTable *table = ctx_getTableForHash(_c, msg_getHash(m,1));
    if (table != NULL) {
      if (msg_compareSymbol(m, 2, "length")) {
        msg_initWithFloat(n, msg_getTimestamp(m), (float) hTable_getLength(table));
      } else if (msg_compareSymbol(m, 2, "size")) {
        msg_initWithFloat(n, msg_getTimestamp(m), (float) hTable_getSize(table));
      } else if (msg_compareSymbol(m, 2, "head")) {
        msg_initWithFloat(n, msg_getTimestamp(m), (float) hTable_getHead(table));
      } else return;
    } else return;
  } else return;
  sendMessage(_c, 0, n);
}
Ejemplo n.º 2
0
void cSlice_onMessage(HvBase *_c, ControlSlice *o, int letIn, const HvMessage *const m,
    void (*sendMessage)(HvBase *, int, const HvMessage *const)) {
  switch (letIn) {
    case 0: {
      // if the start point is greater than the number of elements in the source message, do nothing
      if (o->i < msg_getNumElements(m)) {
        int x = msg_getNumElements(m) - o->i; // number of elements in the new message
        if (o->n > 0) x = hv_min_i(x, o->n);
        HvMessage *n = HV_MESSAGE_ON_STACK(x);
        msg_init(n, x, msg_getTimestamp(m));
        hv_memcpy(&n->elem, &m->elem+o->i, x*sizeof(Element));
        sendMessage(_c, 0, n);
      } else {
        // if nothing can be sliced, send a bang out of the right outlet
        HvMessage *n = HV_MESSAGE_ON_STACK(1);
        msg_initWithBang(n, msg_getTimestamp(m));
        sendMessage(_c, 1, n);
      }
      break;
    }
    case 1: {
      if (msg_isFloat(m,0)) {
        o->i = (int) msg_getFloat(m,0);
        if (msg_isFloat(m,1)) {
          o->n = (int) msg_getFloat(m,1);
        }
      }
      break;
    }
    case 2: {
      if (msg_isFloat(m,0)) {
        o->n = (int) msg_getFloat(m,0);
      }
      break;
    }
    default: break;
  }
}
void cVar_onMessage(HvBase *_c, ControlVar *o, int letIn, const HvMessage *const m,
    void (*sendMessage)(HvBase *, int, const HvMessage *const)) {
  switch (letIn) {
    case 0: {
      switch (msg_getType(m,0)) {
        case HV_MSG_BANG: {
          HvMessage *n = HV_MESSAGE_ON_STACK(1);
          if (o->e.type == HV_MSG_FLOAT) msg_initWithFloat(n, msg_getTimestamp(m), o->e.data.f);
          else if (o->e.type == HV_MSG_HASH) msg_initWithHash(n, msg_getTimestamp(m), o->e.data.h);
          else return;
          sendMessage(_c, 0, n);
          break;
        }
        case HV_MSG_FLOAT: {
          o->e.type = HV_MSG_FLOAT;
          o->e.data.f = msg_getFloat(m,0);
          sendMessage(_c, 0, m);
          break;
        }
        case HV_MSG_SYMBOL:
        case HV_MSG_HASH: {
          o->e.type = HV_MSG_HASH;
          o->e.data.h = msg_getHash(m,0);
          sendMessage(_c, 0, m);
          break;
        }
        default: return;
      }
      break;
    }
    case 1: {
      switch (msg_getType(m,0)) {
        case HV_MSG_FLOAT: {
          o->e.type = HV_MSG_FLOAT;
          o->e.data.f = msg_getFloat(m,0);
          break;
        }
        case HV_MSG_SYMBOL:
        case HV_MSG_HASH: {
          o->e.type = HV_MSG_HASH;
          o->e.data.h = msg_getHash(m,0);
          break;
        }
        default: break;
      }
    }
    default: return;
  }
}
Ejemplo n.º 4
0
static void sEnv_sendMessage(HvBase *_c, SignalEnvelope *o, float rms,
    void (*sendMessage)(HvBase *, int, const HvMessage *)) {
  // finish RMS calculation. sqrt is removed as it can be combined with the log operation.
  // result is normalised such that 1 RMS == 100 dB
  rms = 10.0f * log10f(rms) + 100.0f;

  // prepare the outgoing message. Schedule it at the beginning of the next block.
  HvMessage *const m = HV_MESSAGE_ON_STACK(1);

  msg_initWithFloat(m, ctx_getBlockStartTimestamp(_c) + HV_N_SIMD, (rms < 0.0f) ? 0.0f : rms);
  ctx_scheduleMessage(Base(_c), m, sendMessage, 0);

  hv_memcpy(o->buffer, o->buffer+o->period, sizeof(float)*(o->numSamplesInBuffer - o->period));
  o->numSamplesInBuffer -= o->period;
}
Ejemplo n.º 5
0
void hv_vscheduleMessageForReceiver(HvBase *c, const char *receiverName, const double delayMs, const char *format, ...) {
  va_list ap;
  va_start(ap, format);

  const int numElem = (int) hv_strlen(format);
  HvMessage *m = HV_MESSAGE_ON_STACK(numElem);
  msg_init(m, numElem, c->blockStartTimestamp + (hv_uint32_t) (hv_max_d(0.0, delayMs)*ctx_getSampleRate(c)/1000.0));
  for (int i = 0; i < numElem; i++) {
    switch (format[i]) {
      case 'b': msg_setBang(m,i); break;
      case 'f': msg_setFloat(m, i, (float) va_arg(ap, double)); break;
      case 's': msg_setSymbol(m, i, (char *) va_arg(ap, char *)); break;
      default: break;
    }
  }
  ctx_scheduleMessageForReceiver(c, receiverName, m);

  va_end(ap);
}
Ejemplo n.º 6
0
void __hv_sample_f(HvBase *_c, SignalSample *o, hv_bInf_t bIn,
    void (*sendMessage)(HvBase *, int, const HvMessage *)) {
  if (o->i != __HV_SAMPLE_NULL) {

#if HV_SIMD_AVX || HV_SIMD_SSE
    float out = bIn[o->i & HV_N_SIMD_MASK];
#elif HV_SIMD_NEON
    float out = bIn[o->i & HV_N_SIMD_MASK];
#else // HV_SIMD_NONE
    float out = bIn;
#endif

    HvMessage *n = HV_MESSAGE_ON_STACK(1);
    hv_uint32_t ts = (o->i + HV_N_SIMD) & ~HV_N_SIMD_MASK; // start of next block
    msg_initWithFloat(n, ts, out);
    ctx_scheduleMessage(_c, n, sendMessage, 0);
    o->i = __HV_SAMPLE_NULL; // reset the index
  }
}
Ejemplo n.º 7
0
void ctx_scheduleMessageForReceiverV(HvBase *const _c, const char *name,
    const hv_uint32_t timestamp, const char *format, ...) {
  va_list ap;
  va_start(ap, format);

  const int numElem = (int) hv_strlen(format);
  HvMessage *m = HV_MESSAGE_ON_STACK(numElem);
  msg_init(m, numElem, timestamp);
  for (int i = 0; i < numElem; i++) {
    switch (format[i]) {
      case 'b': msg_setBang(m,i); break;
      case 'f': msg_setFloat(m, i, (float) va_arg(ap, double)); break;
      case 's': msg_setSymbol(m, i, (char *) va_arg(ap, char *)); break;
      default: break;
    }
  }
  _c->f_scheduleMessageForReceiver(_c, name, m);

  va_end(ap);
}
Ejemplo n.º 8
0
void cTabread_onMessage(HvBase *_c, ControlTabread *o, int letIn, const HvMessage *const m,
    void (*sendMessage)(HvBase *, int, const HvMessage *const)) {
  switch (letIn) {
    case 0: {
      if (msg_isFloat(m,0) && msg_getFloat(m,0) >= 0.0f && o->table != NULL) {
        const hv_uint32_t x = (hv_uint32_t) msg_getFloat(m,0);
        if (x < hTable_getSize(o->table)) {
          HvMessage *n = HV_MESSAGE_ON_STACK(1);
          msg_initWithFloat(n, msg_getTimestamp(m), hTable_getBuffer(o->table)[x]);
          sendMessage(_c, 0, n);
        }
      }
      break;
    }
    case 1: {
      if (msg_isHashLike(m,0)) {
        o->table = ctx_getTableForHash(_c, msg_getHash(m,0));
      }
      break;
    }
    default: return;
  }
}