Subversion Repositories DIN Is Noise

/*
* binaural_drone.cc
* DIN Is Noise is copyright (c) 2006-2024 Jagannathan Sampath
* DIN Is Noise is released under GNU Public License 2.0
* For more information, please visit https://dinisnoise.org/
*/

#include "binaural_drone.h"
#include "audio.h"
#include "console.h"

extern void hz2step (float& hz, float& step);
extern void step2hz (float& step, float& hz);

extern char BUFFER[];

binaural_drone::binaural_drone (multi_curve* wav, float _lhz, float _rhz, float _vol, int _just, float _sep, float lx, float rx) {

  soll (wav);
  solr (wav);
  playl.set_wave (&soll);
  playr.set_wave (&solr);

  l_step = r_step = 0.0f;
  set_hz (_lhz, _rhz);
  if (lx == INVALID) // normal lx is in [0,1]
    sync ();
  else {
    playl.x = lx;
    playr.x = rx;
  }

  vol = 0.0f;
  set_vol (_vol);

  just = _just;
  sep = _sep;

  sel = 0;

}

void binaural_drone::make_name () {
  sprintf (BUFFER, BD_NAME, l_hz, sep, r_hz, vol * 100);
  name = BUFFER;
}

void binaural_drone::make_name (float stepl, float stepr) {
  float hzl, hzr; step2hz (stepl, hzl); step2hz (stepr, hzr);
  sprintf (BUFFER, BD_NAME, hzl, (hzr - hzl), hzr, vol * 100);
  name = BUFFER;
}

void binaural_drone::make_name (float v) {
  sprintf (BUFFER, BD_NAME, l_hz, sep, r_hz, v * 100);
  name = BUFFER;
}

void binaural_drone::set_hz (int i, float v) {

  float* step_prev [] = {&l_step_prev, &r_step_prev};
  float* hz [] = {&l_hz, &r_hz};
  float* step [] = {&l_step, &r_step};
  int flags [] = {fade_flags::L, fade_flags::R};
  float* step_cur [] = {&fading.l_step_cur, &fading.r_step_cur};
 
  float& step_prev_i = *step_prev[i];
  float& hz_i = *hz[i];
  float& step_i = *step[i];

  int j = !i;
  *step_cur[j] = *step[j];

  step_prev_i = step_i;
  hz_i = v;
  hz2step (hz_i, step_i);
  sep = r_hz - l_hz;

  int fi = flags[i];
  if (fading.hz) {
    if (fading.hz != fi) fading.hz = fade_flags::BOTH;
  } else fading.hz = fi;

}

void binaural_drone::set_hz (float _lhz, float _rhz) {
  l_step_prev = l_step;
  r_step_prev = r_step;
  l_hz = _lhz;
  r_hz = _rhz;
  sep = r_hz - l_hz;
  hz2step (l_hz, l_step);
  hz2step (r_hz, r_step);
  fill_hz ();
  make_name ();
}

void binaural_drone::fill_hz () {
  playl.fill_pitch (l_step);
  playr.fill_pitch (r_step);
}

void binaural_drone::set_vol (float v) {
  vol_prev = vol;
  vol = v;
  fading.vol = 1;
}

void binaural_drone::set_sep (float s) {
  switch (just) {
    case LEFT:
      set_hz (RIGHT, l_hz + s);
      break;
    case RIGHT:
      set_hz (LEFT, r_hz - s);
      break;
    case CENTER:
      float mid = (l_hz + r_hz) / 2.0, s2 = s / 2.0;
      set_hz (LEFT, mid - s2);
      set_hz (RIGHT, mid + s2);
      break;
  }
}

void binaural_drone::set_just (int j) {
  just = j;
}

void binaural_drone::render (float* L, float* R, float* vfdr, float* pfdr, int uv, int uh, int abort) {

  play* pl [] = {&playl, &playr};
  float* outf [] = {L, R};
  float* outi [] = {aout.bufL, aout.bufR};

  if (fading.vol) {
    calc_fader (aout.fdr1, vfdr, aout.samples_per_channel, vol_prev, vol, &fading.vol_cur);
    if (uv) {
      make_name (fading.vol_cur);
      if (abort) {
        vol = fading.vol_cur;
        fading.vol = fade_flags::NONE;
      }
    }
  }

  if (fading.hz) {
    if (fading.hz == fade_flags::L || fading.hz == fade_flags::BOTH)
      calc_fader (playl.pdx, pfdr, aout.samples_per_channel, l_step_prev, l_step, &fading.l_step_cur);
    if (fading.hz == fade_flags::R || fading.hz == fade_flags::BOTH)
      calc_fader (playr.pdx, pfdr, aout.samples_per_channel, r_step_prev, r_step, &fading.r_step_cur);
    if (uh) {
      make_name (fading.l_step_cur, fading.r_step_cur);
      if (abort) {
        l_step = fading.l_step_cur;
        r_step = fading.r_step_cur;
        step2hz (fading.l_step_cur, l_hz);
        step2hz (fading.r_step_cur, r_hz);
        sep = r_hz - l_hz;
        fill_hz ();
        fading.hz = fade_flags::NONE;
      }
    }
  }


  for (int i = 0; i < 2; ++i) {
    float* outfi = outf [i];
    float* outii = outi [i];
    memset (outii, 0, aout.samples_channel_size);
    play* pli = pl [i];
    if (fading.vol)
      pli->gen_wav_mix (outii, aout.fdr1, aout.samples_per_channel);
    else
      pli->gen_wav_mix (outii, vol, aout.samples_per_channel);
    for (int j = 0, k = aout.samples_per_channel; j < k; ++j) outfi[j] += outii[j];
  }

}

void binaural_drone::calc_fader (float* out, float* alpha, int n, float v1, float v2, float* cur) {
  float dv = v2 - v1;
  for (int i = 0; i < n; ++i) {
    float ai = alpha[i];
    out[i] = v1 + ai * dv;
  }
  *cur = out[n-1];
}

void binaural_drone::sync () {
  // so first += solves to y=0 [depends on waveform shape]
  playl.x = -playl.pdx[0];
  playr.x = -playr.pdx[0];
}