shakers.cpp

Mobile STK for Symbian OS V0.1

    }
    else if (inst == 18) { // Mug + Franc
      nFreqs_ = 6;
      gains_[4] = temp*0.7;
      gains_[5] = temp*0.4;
      gains_[6] = temp*0.3;
      setFreqAndReson(4,FRANC_FREQ0,FRANC_RES);
      setFreqAndReson(5,FRANC_FREQ1,FRANC_RES);
      setFreqAndReson(6,FRANC_FREQ2,FRANC_RES);
    }
    else if (inst == 19) { // Mug + Peso
      nFreqs_ = 6;
      gains_[4] = temp;
      gains_[5] = temp*1.2;
      gains_[6] = temp*0.7;
      setFreqAndReson(4,PESO_FREQ0,PESO_RES);
      setFreqAndReson(5,PESO_FREQ1,PESO_RES);
      setFreqAndReson(6,PESO_FREQ2,PESO_RES);
    }
  }
  else if (inst == 20) { // Big Rocks
    nFreqs_ = 1;
    rv = inst;
    nObjects_ = BIGROCKS_NUM_PARTS;
    defObjs_[inst] = BIGROCKS_NUM_PARTS;
    setDecays(BIGROCKS_SOUND_DECAY,BIGROCKS_SYSTEM_DECAY);
    defDecays_[inst] = BIGROCKS_SYSTEM_DECAY;
    decayScale_[inst] = 0.95;
    baseGain_ = BIGROCKS_GAIN;
    temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
    gains_[0]=temp;
    freqalloc_[0] = 1;
    freq_rand_[0] = 0.11;
    setFreqAndReson(0,BIGROCKS_FREQ,BIGROCKS_RES);
    setFinalZs(1.0,0.0,-1.0);
  }
  else if (inst == 21) { // Little Rocks
    nFreqs_ = 1;
    rv = inst;
    nObjects_ = LITLROCKS_NUM_PARTS;
    defObjs_[inst] = LITLROCKS_NUM_PARTS;
    setDecays(LITLROCKS_SOUND_DECAY,LITLROCKS_SYSTEM_DECAY);
    defDecays_[inst] = LITLROCKS_SYSTEM_DECAY;
    decayScale_[inst] = 0.95;
    baseGain_ = LITLROCKS_GAIN;
    temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
    gains_[0]=temp;
    freqalloc_[0] = 1;
    freq_rand_[0] = 0.18;
    setFreqAndReson(0,LITLROCKS_FREQ,LITLROCKS_RES);
    setFinalZs(1.0,0.0,-1.0);
  }
  else if (inst == 22) { // Tuned Bamboo
    rv = inst;
    nObjects_ = TBAMB_NUM_TUBES;
    defObjs_[inst] = TBAMB_NUM_TUBES;
    setDecays(TBAMB_SOUND_DECAY, TBAMB_SYSTEM_DECAY);
    defDecays_[inst] = TBAMB_SYSTEM_DECAY;
    decayScale_[inst] = 0.7;
    nFreqs_ = 7;
    baseGain_ = TBAMB_GAIN;
    temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
    gains_[0]=temp;
    gains_[1]=temp;
    gains_[2]=temp;
    gains_[3]=temp;
    gains_[4]=temp;
    gains_[5]=temp;
    gains_[6]=temp;
    freqalloc_[0] = 0;
    freqalloc_[1] = 0;
    freqalloc_[2] = 0;
    freqalloc_[3] = 0;
    freqalloc_[4] = 0;
    freqalloc_[5] = 0;
    freqalloc_[6] = 0;
    freq_rand_[0] = 0.0;
    freq_rand_[1] = 0.0;
    freq_rand_[2] = 0.0;
    freq_rand_[3] = 0.0;
    freq_rand_[4] = 0.0;
    freq_rand_[5] = 0.0;
    freq_rand_[6] = 0.0;
    setFreqAndReson(0,TBAMB_CENTER_FREQ0,TBAMB_RESON);
    setFreqAndReson(1,TBAMB_CENTER_FREQ1,TBAMB_RESON);
    setFreqAndReson(2,TBAMB_CENTER_FREQ2,TBAMB_RESON);
    setFreqAndReson(3,TBAMB_CENTER_FREQ3,TBAMB_RESON);
    setFreqAndReson(4,TBAMB_CENTER_FREQ4,TBAMB_RESON);
    setFreqAndReson(5,TBAMB_CENTER_FREQ5,TBAMB_RESON);
    setFreqAndReson(6,TBAMB_CENTER_FREQ6,TBAMB_RESON);
    setFinalZs(1.0,0.0,-1.0);
  }
  else { // Maraca (inst == 0) or default
    rv = 0;
    nObjects_ = MARA_NUM_BEANS;
    defObjs_[0] = MARA_NUM_BEANS;
    setDecays(MARA_SOUND_DECAY,MARA_SYSTEM_DECAY);
    defDecays_[0] = MARA_SYSTEM_DECAY;
    decayScale_[inst] = 0.9;
    nFreqs_ = 1;
    baseGain_ = MARA_GAIN;
    temp = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
    gains_[0]=temp;
    freqalloc_[0] = 0;
    setFreqAndReson(0,MARA_CENTER_FREQ,MARA_RESON);
    setFinalZs(1.0,-1.0,0.0);
  }
  return rv;
}

void Shakers :: noteOn(StkFloat frequency, StkFloat amplitude)
{
  // Yep ... pretty kludgey, but it works!
  int noteNum = (int) ((12*log(frequency/220.0)/log(2.0)) + 57.01) % 32;
  if (instType_ !=  noteNum) instType_ = this->setupNum(noteNum);
  shakeEnergy_ += amplitude * MAX_SHAKE * 0.1;
  if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;
  if (instType_==10 || instType_==3) ratchetPos_ += 1;

#if defined(_STK_DEBUG_)
  errorString_ << "Shakers::NoteOn: frequency = " << frequency << ", amplitude = " << amplitude << '.';
  handleError( StkError::DEBUG_WARNING );
#endif
}

void Shakers :: noteOff(StkFloat amplitude)
{
  shakeEnergy_ = 0.0;
  if (instType_==10 || instType_==3) ratchetPos_ = 0;
}

const StkFloat MIN_ENERGY = 0.3;

StkFloat Shakers :: computeSample()
{
  StkFloat data;
  StkFloat temp_rand;
  int i;

  if (instType_ == 4) {
  	if (shakeEnergy_ > MIN_ENERGY)	{
      lastOutput_ = wuter_tick();
      lastOutput_ *= 0.0001;
    }
    else {
      lastOutput_ = 0.0;
    }
  }
  else if (instType_ == 22) {
    lastOutput_ = tbamb_tick();
  }
  else if (instType_ == 10 || instType_ == 3) {
    if (ratchetPos_ > 0) {
      ratchet_ -= (ratchetDelta_ + (0.002*totalEnergy_));
      if (ratchet_ < 0.0) {
        ratchet_ = 1.0;
        ratchetPos_ -= 1;
	    }
      totalEnergy_ = ratchet_;
      lastOutput_ = ratchet_tick();
      lastOutput_ *= 0.0001;
    }
    else lastOutput_ = 0.0;
  }
  else  { // generic_tick()
    if (shakeEnergy_ > MIN_ENERGY) {
      shakeEnergy_ *= systemDecay_;               // Exponential system decay
      if (float_random(1024.0) < nObjects_) {
        sndLevel_ += shakeEnergy_;   
        for (i=0;i<nFreqs_;i++) {
          if (freqalloc_[i])	{
            temp_rand = t_center_freqs_[i] * (1.0 + (freq_rand_[i] * noise_tick()));
            coeffs_[i][0] = -resons_[i] * 2.0 * cos(temp_rand * TWO_PI / Stk::sampleRate());
          }
        }
    	}
      inputs_[0] = sndLevel_ * noise_tick();      // Actual Sound is Random
      for (i=1; i<nFreqs_; i++)	{
        inputs_[i] = inputs_[0];
      }
      sndLevel_ *= soundDecay_;                   // Exponential Sound decay 
      finalZ_[2] = finalZ_[1];
      finalZ_[1] = finalZ_[0];
      finalZ_[0] = 0;
      for (i=0;i<nFreqs_;i++)	{
        inputs_[i] -= outputs_[i][0]*coeffs_[i][0];  // Do
        inputs_[i] -= outputs_[i][1]*coeffs_[i][1];  // resonant
        outputs_[i][1] = outputs_[i][0];            // filter
        outputs_[i][0] = inputs_[i];                // calculations
        finalZ_[0] += gains_[i] * outputs_[i][1];
      }
      data = finalZCoeffs_[0] * finalZ_[0];     // Extra zero(s) for shape
      data += finalZCoeffs_[1] * finalZ_[1];    // Extra zero(s) for shape
      data += finalZCoeffs_[2] * finalZ_[2];    // Extra zero(s) for shape
      if (data > 10000.0)	data = 10000.0;
      if (data < -10000.0) data = -10000.0;
      lastOutput_ = data * 0.0001;
    }
    else lastOutput_ = 0.0;
  }

  return lastOutput_;
}

void Shakers :: controlChange(int number, StkFloat value)
{
  StkFloat norm = value * ONE_OVER_128;
  if ( norm < 0 ) {
    norm = 0.0;
#if !defined(SYMBIAN)
    errorString_ << "Shakers::controlChange: control value less than zero ... setting to zero!";
    handleError( StkError::WARNING );
#endif
  }
  else if ( norm > 1.0 ) {
    norm = 1.0;
#if !defined(SYMBIAN)
    errorString_ << "Shakers::controlChange: control value greater than 128.0 ... setting to 128.0!";
    handleError( StkError::WARNING );
#endif
  }

  StkFloat temp;
  int i;

  if (number == __SK_Breath_) { // 2 ... energy
    shakeEnergy_ += norm * MAX_SHAKE * 0.1;
    if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;
    if (instType_==10 || instType_==3) {
	    ratchetPos_ = (int) fabs(value - lastRatchetPos_);
	    ratchetDelta_ = 0.0002 * ratchetPos_;
	    lastRatchetPos_ = (int) value;
    }
  }
  else if (number == __SK_ModFrequency_) { // 4 ... decay
    if (instType_ != 3 && instType_ != 10) {
      systemDecay_ = defDecays_[instType_] + ((value - 64.0) *
                                           decayScale_[instType_] *
                                           (1.0 - defDecays_[instType_]) / 64.0 );
      gains_[0] = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
      for (i=1;i<nFreqs_;i++) gains_[i] = gains_[0];
      if (instType_ == 6) { // tambourine
        gains_[0] *= TAMB_SHELL_GAIN;
        gains_[1] *= 0.8;
      }
      else if (instType_ == 7) { // sleighbell
        gains_[3] *= 0.5;
        gains_[4] *= 0.3;
      }
      else if (instType_ == 12) { // cokecan
        for (i=1;i<nFreqs_;i++) gains_[i] *= 1.8;
      }
      for (i=0;i<nFreqs_;i++) gains_[i] *= ((128-value)/100.0 + 0.36);
    }
  }
  else if (number == __SK_FootControl_) { // 11 ... number of objects
    if (instType_ == 5) // bamboo
      nObjects_ = (StkFloat) (value * defObjs_[instType_] / 64.0) + 0.3;
    else
      nObjects_ = (StkFloat) (value * defObjs_[instType_] / 64.0) + 1.1;
    gains_[0] = log(nObjects_) * baseGain_ / (StkFloat) nObjects_;
    for (i=1;i<nFreqs_;i++) gains_[i] = gains_[0];
    if (instType_ == 6) { // tambourine
      gains_[0] *= TAMB_SHELL_GAIN;
      gains_[1] *= 0.8;
    }
    else if (instType_ == 7) { // sleighbell
      gains_[3] *= 0.5;
      gains_[4] *= 0.3;
    }
    else if (instType_ == 12) { // cokecan
      for (i=1;i<nFreqs_;i++) gains_[i] *= 1.8;
    }
    if (instType_ != 3 && instType_ != 10) {
      // reverse calculate decay setting
      double temp = (double) (64.0 * (systemDecay_-defDecays_[instType_])/(decayScale_[instType_]*(1-defDecays_[instType_])) + 64.0);
      // scale gains_ by decay setting
      for (i=0;i<nFreqs_;i++) gains_[i] *= ((128-temp)/100.0 + 0.36);
    }
  }
  else if (number == __SK_ModWheel_) { // 1 ... resonance frequency
    for (i=0; i<nFreqs_; i++)	{
      if (instType_ == 6 || instType_ == 2 || instType_ == 7) // limit range a bit for tambourine
        temp = center_freqs_[i] * pow (1.008,value-64);
      else
        temp = center_freqs_[i] * pow (1.015,value-64);
      t_center_freqs_[i] = temp;

      coeffs_[i][0] = -resons_[i] * 2.0 * cos(temp * TWO_PI / Stk::sampleRate());
      coeffs_[i][1] = resons_[i]*resons_[i];
    }
  }
  else if (number == __SK_AfterTouch_Cont_) { // 128
    shakeEnergy_ += norm * MAX_SHAKE * 0.1;
    if (shakeEnergy_ > MAX_SHAKE) shakeEnergy_ = MAX_SHAKE;
    if (instType_==10 || instType_==3)	{
	    ratchetPos_ = (int) fabs(value - lastRatchetPos_);
	    ratchetDelta_ = 0.0002 * ratchetPos_;
	    lastRatchetPos_ = (int) value;
    }
  }
  else  if (number == __SK_ShakerInst_) { // 1071
    instType_ = (int) (value + 0.5);	//  Just to be safe
    this->setupNum(instType_);
  }                                       
  else {
#if !defined(SYMBIAN)
    errorString_ << "Shakers::controlChange: undefined control number (" << number << ")!";
    handleError( StkError::WARNING );
#endif
  }

#if defined(_STK_DEBUG_)
#if !defined(SYMBIAN)
    errorString_ << "Shakers::controlChange: number = " << number << ", value = " << value << '.';
	handleError( StkError::DEBUG_WARNING );
#endif
#endif
}

// KLUDGE-O-MATIC-O-RAMA

StkFloat Shakers :: wuter_tick() {
  StkFloat data;
  int j;
  shakeEnergy_ *= systemDecay_;               // Exponential system decay
  if (my_random(32767) < nObjects_) {     
    sndLevel_ = shakeEnergy_;   
    j = my_random(3);
	  if (j == 0)   {
      center_freqs_[0] = WUTR_CENTER_FREQ1 * (0.75 + (0.25 * noise_tick()));
	    gains_[0] = fabs(noise_tick());
	  }
	  else if (j == 1)      {
      center_freqs_[1] = WUTR_CENTER_FREQ1 * (1.0 + (0.25 * noise_tick()));
	    gains_[1] = fabs(noise_tick());
	  }
	  else  {
      center_freqs_[2] = WUTR_CENTER_FREQ1 * (1.25 + (0.25 * noise_tick()));
	    gains_[2] = fabs(noise_tick());
	  }
	}
	
  gains_[0] *= resons_[0];
  if (gains_[0] >  0.001) {
    center_freqs_[0]  *= WUTR_FREQ_SWEEP;
    coeffs_[0][0] = -resons_[0] * 2.0 * 
      cos(center_freqs_[0] * TWO_PI / Stk::sampleRate());
  }
  gains_[1] *= resons_[1];
  if (gains_[1] > 0.001) {
    center_freqs_[1] *= WUTR_FREQ_SWEEP;
    coeffs_[1][0] = -resons_[1] * 2.0 * 
      cos(center_freqs_[1] * TWO_PI / Stk::sampleRate());
  }
  gains_[2] *= resons_[2];
  if (gains_[2] > 0.001) {
    center_freqs_[2] *= WUTR_FREQ_SWEEP;
    coeffs_[2][0] = -resons_[2] * 2.0 * 
      cos(center_freqs_[2] * TWO_PI / Stk::sampleRate());
  }
	
  sndLevel_ *= soundDecay_;        // Each (all) event(s) 
                                   // decay(s) exponentially 
  inputs_[0] = sndLevel_;
  inputs_[0] *= noise_tick();     // Actual Sound is Random
  inputs_[1] = inputs_[0] * gains_[1];
  inputs_[2] = inputs_[0] * gains_[2];
  inputs_[0] *= gains_[0];
  inputs_[0] -= outputs_[0][0]*coeffs_[0][0];
  inputs_[0] -= outputs_[0][1]*coeffs_[0][1];
  outputs_[0][1] = outputs_[0][0];
  outputs_[0][0] = inputs_[0];
  data = gains_[0]*outputs_[0][0];
  inputs_[1] -= outputs_[1][0]*coeffs_[1][0];
  inputs_[1] -= outputs_[1][1]*coeffs_[1][1];
  outputs_[1][1] = outputs_[1][0];
  outputs_[1][0] = inputs_[1];
  data += gains_[1]*outputs_[1][0];
  inputs_[2] -= outputs_[2][0]*coeffs_[2][0];
  inputs_[2] -= outputs_[2][1]*coeffs_[2][1];
  outputs_[2][1] = outputs_[2][0];
  outputs_[2][0] = inputs_[2];
  data += gains_[2]*outputs_[2][0];
 
  finalZ_[2] = finalZ_[1];
  finalZ_[1] = finalZ_[0];
  finalZ_[0] = data * 4;

  data = finalZ_[2] - finalZ_[0];
  return data;
}

StkFloat Shakers :: ratchet_tick() {
  StkFloat data;
  if (my_random(1024) < nObjects_) {
    sndLevel_ += 512 * ratchet_ * totalEnergy_;
  }
  inputs_[0] = sndLevel_;
  inputs_[0] *= noise_tick() * ratchet_;
  sndLevel_ *= soundDecay_;
		 
  inputs_[1] = inputs_[0];
  inputs_[0] -= outputs_[0][0]*coeffs_[0][0];
  inputs_[0] -= outputs_[0][1]*coeffs_[0][1];
  outputs_[0][1] = outputs_[0][0];
  outputs_[0][0] = inputs_[0];
  inputs_[1] -= outputs_[1][0]*coeffs_[1][0];
  inputs_[1] -= outputs_[1][1]*coeffs_[1][1];
  outputs_[1][1] = outputs_[1][0];
  outputs_[1][0] = inputs_[1];
     
  finalZ_[2] = finalZ_[1];
  finalZ_[1] = finalZ_[0];
  finalZ_[0] = gains_[0]*outputs_[0][1] + gains_[1]*outputs_[1][1];
  data = finalZ_[0] - finalZ_[2];
  return data;
}

StkFloat Shakers :: tbamb_tick() {
  StkFloat data, temp;
#if !defined(SYMBIAN)
  static int which = 0;
#endif
  int i;

  if (shakeEnergy_ > MIN_ENERGY)	{
      shakeEnergy_ *= systemDecay_;    // Exponential system decay
      if (float_random(1024.0) < nObjects_) {
	    sndLevel_ += shakeEnergy_;
	    which = my_random(7);
	  }  
      temp = sndLevel_ * noise_tick();      // Actual Sound is Random
	  for (i=0;i<nFreqs_;i++)	inputs_[i] = 0;
	  inputs_[which] = temp;
      sndLevel_ *= soundDecay_;                   // Exponential Sound decay 
      finalZ_[2] = finalZ_[1];
      finalZ_[1] = finalZ_[0];
      finalZ_[0] = 0;
      for (i=0;i<nFreqs_;i++)	{
        inputs_[i] -= outputs_[i][0]*coeffs_[i][0];  // Do
        inputs_[i] -= outputs_[i][1]*coeffs_[i][1];  // resonant
        outputs_[i][1] = outputs_[i][0];            // filter
        outputs_[i][0] = inputs_[i];                // calculations
        finalZ_[0] += gains_[i] * outputs_[i][1];
      }
      data = finalZCoeffs_[0] * finalZ_[0];     // Extra zero(s) for shape
      data += finalZCoeffs_[1] * finalZ_[1];    // Extra zero(s) for shape
      data += finalZCoeffs_[2] * finalZ_[2];    // Extra zero(s) for shape
      if (data > 10000.0)	data = 10000.0;
      if (data < -10000.0) data = -10000.0;
      data = data * 0.0001;
  }
  else data = 0.0;
  return data;
}