rescale

microtonal scaler core, enabling to select custom ratios for the 12 tones of the keyboard used to control the "tune" module, so each oscillator can follow the same tuning. When selectors are set to 0, the most common ratios are used for the scale. Offsetting the selectors will select another ratio, the higher/lower the value, the further away from the commonly chosen ratios. Closest to ideal equal temperament (but not exactly the same, using higher primes and not "commonly used") is the following list of offsets: C:0 cis:-1 D:-1 dis:-1 E:1 F:0 fis:-1 G:0 gis:-1 A:1 ais:-1 B:1
Author: Remco van der Most
License: BSD
Github: sss/harmony/rescale.axo

Inlets

frac32 pitch

int32 key

Outlets

frac32 scaled

Parameters

int32 C

int32 cis

int32 D

int32 dis

int32 E

int32 F

int32 fis

int32 G

int32 gis

int32 A

int32 ais

int32 B

Displays

bool32 C

bool32 cis

bool32 D

bool32 dis

bool32 E

bool32 F

bool32 fis

bool32 G

bool32 gis

bool32 A

bool32 ais

bool32 B

Declaration
;
int8_t octave;
int8_t semitone;
float32_t freq;
int32_t scaled;
int32_t frac_log(int32_t a) {
  Float_t f;
  f.f = a;
  int32_t r1 = ((f.parts.exponent & 0x7F) - 18) << 24;
  int32_t r3 = logt[f.parts.mantissa >> 15] << 10;
  return r1 + r3;
}
int16_t lfo;

Float_t f;
float32_t intfreq;
float32_t LOG1;
float32_t LOG2;
float32_t LOG3;
int32_t r1;
int32_t r2;
float32_t base;
float32_t scale[24];

float32_t nt[98] = {1,
                    (float)(128) / 125,
                    (float)(40) / 39,
                    (float)(33) / 32,
                    (float)(25) / 24,
                    (float)(21) / 20,
                    (float)(256) / 243,
                    (float)(35) / 33,
                    (float)(17) / 16,
                    (float)(16) / 15,
                    (float)(15) / 14,
                    (float)(14) / 13,
                    (float)(12) / 11,
                    (float)(1125) / 1024,
                    (float)(11) / 10,
                    (float)(10) / 9,
                    (float)(28) / 25,
                    (float)(9) / 8,
                    (float)(256) / 225,
                    (float)(8) / 7,
                    (float)(144) / 125,
                    (float)(15) / 13,
                    (float)(7) / 6,
                    (float)(75) / 64,
                    (float)(33) / 28,
                    (float)(13) / 11,
                    (float)(32) / 27,
                    (float)(19) / 16,
                    (float)(25) / 21,
                    (float)(6) / 5,
                    (float)(40) / 33,
                    (float)(11) / 9,
                    (float)(16) / 13,
                    (float)(5) / 4,
                    (float)(81) / 64,
                    (float)(14) / 11,
                    (float)(32) / 25,
                    (float)(9) / 7,
                    (float)(13) / 10,
                    (float)(125) / 96,
                    (float)(21) / 16,
                    (float)(33) / 25,
                    (float)(4) / 3,
                    (float)(27) / 20,
                    (float)(15) / 11,
                    (float)(512) / 375,
                    (float)(11) / 8,
                    (float)(25) / 18,
                    (float)(7) / 5,
                    (float)(45) / 32,
                    (float)(64) / 45,
                    (float)(729) / 512,
                    (float)(10) / 7,
                    (float)(36) / 25,
                    (float)(13) / 9,
                    (float)(16) / 11,
                    (float)(35) / 24,
                    (float)(375) / 256,
                    (float)(3) / 2,
                    (float)(32) / 21,
                    (float)(192) / 125,
                    (float)(20) / 13,
                    (float)(14) / 9,
                    (float)(25) / 16,
                    (float)(11) / 7,
                    (float)(128) / 81,
                    (float)(8) / 5,
                    (float)(21) / 13,
                    (float)(13) / 8,
                    (float)(18) / 11,
                    (float)(33) / 20,
                    (float)(5) / 3,
                    (float)(27) / 16,
                    (float)(128) / 75,
                    (float)(12) / 7,
                    (float)(125) / 72,
                    (float)(7) / 4,
                    (float)(225) / 128,
                    (float)(16) / 9,
                    (float)(24) / 14,
                    (float)(9) / 5,
                    (float)(20) / 11,
                    (float)(2048) / 1125,
                    (float)(11) / 6,
                    (float)(24) / 13,
                    (float)(13) / 7,
                    (float)(28) / 15,
                    (float)(15) / 8,
                    (float)(243) / 128,
                    (float)(40) / 21,
                    (float)(21) / 11,
                    (float)(48) / 25,
                    (float)(25) / 13,
                    (float)(35) / 18,
                    (float)(125) / 64};
Init
base = ((float32_t)330) / 1000;

f.f = 2 << 21;
r1 = ((f.parts.exponent & 0x7F) - 18) << 24;
r2 = logt[f.parts.mantissa >> 15] << 10;
LOG3 = r1 + r2;

f.f = base * (4 << 21);
r1 = ((f.parts.exponent & 0x7F) - 18) << 24;
r2 = logt[f.parts.mantissa >> 15] << 10;
LOG2 = r1 + r2;
Control Rate
lfo = (lfo + 1) & 1023;
int32_t gate;
gate = lfo > 512 ? 1 : 0;

int32_t pitch = (inlet_pitch >> 21) + 48;
octave = pitch / 12;
semitone = pitch - octave * 12;
octave = octave - 4;
int32_t key;
key = inlet_key >= 0 ? inlet_key * 7 : -inlet_key * 5 - 3;
key = key - (key / 12) * 12;
key = key < 0 ? key + 12 : key;

scale[12] = nt[0 + param_C];
scale[13] = nt[9 + param_cis];
scale[14] = nt[18 + param_D];
scale[15] = nt[30 + param_dis];
scale[16] = nt[34 + param_E];
scale[17] = nt[43 + param_F];
scale[18] = nt[52 + param_fis];
scale[19] = nt[60 + param_G];
scale[20] = nt[68 + param_gis];
scale[21] = nt[73 + param_A];
scale[22] = nt[82 + param_ais];
scale[23] = nt[89 + param_B];
int32_t C;
int32_t D;
int32_t E;
int32_t F;
int32_t G;
int32_t A;
int32_t B;

if (inlet_key >= 0) {
  C = 0 + key;
  D = 2 + key;
  E = 4 + key;
  F = 5 + key;
  G = 7 + key;
  A = 9 + key;
  B = 11 + key;
}

if (inlet_key < 0) {
  C = 0 + key;
  D = 2 + key;
  E = 3 + key;
  F = 5 + key;
  G = 7 + key;
  A = 8 + key;
  B = 10 + key;
}

C = C - (C / 12) * 12;
D = D - (D / 12) * 12;
E = E - (E / 12) * 12;
F = F - (F / 12) * 12;
G = G - (G / 12) * 12;
A = A - (A / 12) * 12;
B = B - (B / 12) * 12;

disp_C = (C == 0) || (D == 0) || (E == 0) || (F == 0) || (G == 0) || (A == 0) ||
         (B == 0);
disp_cis = (C == 1) || (D == 1) || (E == 1) || (F == 1) || (G == 1) ||
           (A == 1) || (B == 1);
disp_D = (C == 2) || (D == 2) || (E == 2) || (F == 2) || (G == 2) || (A == 2) ||
         (B == 2);
disp_dis = (C == 3) || (D == 3) || (E == 3) || (F == 3) || (G == 3) ||
           (A == 3) || (B == 3);
disp_E = (C == 4) || (D == 4) || (E == 4) || (F == 4) || (G == 4) || (A == 4) ||
         (B == 4);
disp_F = (C == 5) || (D == 5) || (E == 5) || (F == 5) || (G == 5) || (A == 5) ||
         (B == 5);
disp_fis = (C == 6) || (D == 6) || (E == 6) || (F == 6) || (G == 6) ||
           (A == 6) || (B == 6);
disp_G = (C == 7) || (D == 7) || (E == 7) || (F == 7) || (G == 7) || (A == 7) ||
         (B == 7);
disp_gis = (C == 8) || (D == 8) || (E == 8) || (F == 8) || (G == 8) ||
           (A == 8) || (B == 8);
disp_A = (C == 9) || (D == 9) || (E == 9) || (F == 9) || (G == 9) || (A == 9) ||
         (B == 9);
disp_ais = (C == 10) || (D == 10) || (E == 10) || (F == 10) || (G == 10) ||
           (A == 10) || (B == 10);
disp_B = (C == 11) || (D == 11) || (E == 11) || (F == 11) || (G == 11) ||
         (A == 11) || (B == 11);

switch (key > 0 ? key : 0) {
case 0:
  disp_A = disp_C = gate;
  break;
case 1:
  disp_cis = gate;
  break;
case 2:
  disp_D = gate;
  break;
case 3:
  disp_dis = gate;
  break;
case 4:
  disp_E = gate;
  break;
case 5:
  disp_F = gate;
  break;
case 6:
  disp_fis = gate;
  break;
case 7:
  disp_G = gate;
  break;
case 8:
  disp_gis = gate;
  break;
case 9:
  disp_A = gate;
  break;
case 10:
  disp_ais = gate;
  break;
case 11:
  disp_B = gate;
  break;
}
C += 12;
D += 12;
E += 12;
F += 12;
G += 12;
A += 12;
B += 12;
scale[0] = scale[C];
scale[1] = scale[C];
scale[2] = scale[D];
scale[3] = scale[D];
scale[4] = scale[E];
scale[5] = scale[F];
scale[6] = scale[F];
scale[7] = scale[G];
scale[8] = scale[G];
scale[9] = scale[A];
scale[10] = scale[A];
scale[11] = scale[B];

if (octave >= 0) {
  intfreq = (base * scale[semitone + 12]) * (1 << octave);
}
if (octave < 0) {
  intfreq = (base * scale[semitone + 12]) / (1 << -octave);
}

f.f = intfreq * (4 << 21);
r1 = ((f.parts.exponent & 0x7F) - 18) << 24;
r2 = logt[f.parts.mantissa >> 15] << 10;
LOG1 = r1 + r2;

outlet_scaled = ((LOG1 - LOG2) / LOG3) * (36 << 21);

Privacy

© 2024 Zrna Research