# PhaseWarp

### Overview

PhaseWarp can be thought of as a special kind of filter for normalized phasor signals. When used with a phasor and a table-lookup oscillator this produces what is known as phase distortion synthesis, famously used on Casio synthesizers like the VZ-1.

### Algorithm

The algorithm for PhaseWarp works by adjusting the midpoint position where the phasor reaches 0.5. The adjustment amount is usually a normalized bipolar signal in the range -1 to 1. When the position value is positive, it warps the midpoint towards the upper bounds, causing a greater slope in the upper half, while decreasing the slope in the lower half. A negative position does opposite, creating a higher slope in the lower half, and a lower slope in the upper half.

(The whole thing makes a lot more sense when you graph it. Someday, I'll do that here. For now, you'll just have to take my word for it.)

### Tangled Files

`phasewarp.c`

and `phasewarp.h`

.

*<<phasewarp.c>>=*```
#include "phasewarp.h"
<<funcs>>
```

*<<phasewarp.h>>=*```
#ifndef SK_PHASEWARP_H
#define SK_PHASEWARP_H
#ifndef SKFLT
#define SKFLT float
#endif
<<funcdefs>>
#endif
```

### Compute

This algorithm is so simple, it can be done in a stateless
function called `sk_phasewarp_tick`

. Its arguments are
the input phasor signal and the warp factor.

*<<funcdefs>>=*`SKFLT sk_phasewarp_tick(SKFLT in, SKFLT warp);`

*<<funcs>>=*```
SKFLT sk_phasewarp_tick(SKFLT in, SKFLT warp)
{
SKFLT out;
SKFLT wmp;
out = 0;
<<calculate_warped_midpoint>>
<<determine_side_and_warp>>
return out;
}
```

Calculate warped midpoint. Call it `wmp`

.

*<<calculate_warped_midpoint>>=*`wmp = (warp + 1.0) * 0.5;`

Determine side and compute. If the phasor position is less than the warped midpoint, than compute with lefthand slope. Otherwise, compute righthand slope.

*<<determine_side_and_warp>>=*```
if (in < wmp) {
<<compute_with_lefthand_slope>>
} else {
<<compute_with_righthand_slope>>
}
```

Compute With Lefthand Slope. This slope is equal to
`0.5/wmp`

. This value scales the phasor input `slope * in`

.

*<<compute_with_lefthand_slope>>=*`if (wmp != 0) out = ((SKFLT)0.5 / wmp) * in;`

Compute Righthand Slope. The righthand slope is computed as
`0.5/(1 - wmp)`

. The output is computed as
`slope * (in - wmp) + 0.5`

.

*<<compute_with_righthand_slope>>=*```
if (wmp != 1.0) {
out = ((SKFLT)0.5 / (SKFLT)(1.0 - wmp)) * (in - wmp) + 0.5;
}
```