implement velum support in voxbox

Velum is not implemented in tubular <<voxbox/tubular>>, but it is in implemented in tract <<voxbox/tract>>. Getting tract code tangled and re-examine what needs to be added.

The original tract waveguide had a fixed size of 28, which should be a size in CM (which will most likely be expressed as proptional percentage of the tract width in practice).

The harddcoded size is 28, which I believe is 2x oversampled, so that's 14 samples.

Looks like it is around 10-12cm:

To derive, I opened the equation I was using to convert tract len (cm) to samples in bc:

(len * 0.01)/(speed_of_sound / sr)

or

(16 * 0.01)/(343.0 / 44100.0)

I forgot this week was the game jam. My velum work will have to wait a few days.

"Velum" refers to the membrane separating the oral cavity (mouth) from the nasal cavity (nose). The nose is another waveguide. The velum is just a value that controls the opening of this waveguide.

I think I understand enough to start coding some things up.

Things start to get trickier here beacuse I'm trying to separate tract and nose code, but this needs stuff from tract.

Above it is the computation for the left junction. I'd imagine a symmetry between them, but it is not symmetrical. The original voc source code looks like this as well. I think I may have to go back to Pink trombone and check on it. At some point. In the meantime, I've dropped a TODO.

It's the damn LCG again in the glottis.

going off track a little bit

But it sounds cool. Might want to import my reverb for added effect.

But the good news is that it did build.

I gotta get ready for a presentation.

Line by line debugging, comparing to reference C file. Yick.

looking at it again. I have tried to clean up the code to make it more readable.

Must be dividing by zero somewhere.

ns_r and ns_l both have it (which makes sense). Not sure which one gets it first. Going to check above.

Listing these as I go.

1367: tr_jr[nose_start].

1367: tr_l[nose_start] is NaN before tr_jr[nose_start].

NaN-hunting fries my brain.

So far, I believe tr_l[nose_start] to be the earliest introduction of a NaN as sample position 1367.

tr_l[nose_start] has a NaN at 1366 at the end of the computation loop, after the nasal component is made. It happens right after update_waveguide.

tr_l is copying over tr_jl with a multiply by 0.999. Where is the last place junction left is begin updated?

Junction Left at the nose start is the earliest instance of a NaN I have found in my code. At 1366, it is introduced before the nose tick, but after compute scattering junctions.

There is something wrong with the omega (w) coefficient being computed inside of compute_scattering_junctions. Peeling that back some more now.

w_r[i - 1] is fine, and doesn't NaN before w.

w_l[i] is also fine, and doesn't NaN out before w. r[i] is the only variable left in there. Let's see if it NaNs.

r[i] is also fine. huh?

I'm guessing it must be an overflow NaN. Some big numbers somewhere. Going to use dbg! to inspect the variables w_r[i - 1], w_l[i], and r[i].

Check it out:

[src/tract.rs:183:17] w_r[i - 1] = 2.5360622e38
[src/tract.rs:183:17] w_l[i] = 1.0904602e38
[src/tract.rs:183:17] r[i] = 0.0

So, I gotta figure out why these numbers are getting so large. In my experience, it's usually due to numbers being so small.

I could change the precision to f64 instead of f32, but this moves the goal posts, and might not actually fix the underlying problem.

Found an intersting thing here. I wanted to break down the components giving me NaN. So I wrote some debugging code that looked like this:

    let add1 = w_r[i - 1] + w_l[i];
    let add2 = r[i] * add1;
    if add2.is_nan() {
        dbg!(r[i], add1);
        panic!("NAN");
    }

The results of this are here:

[src/tract.rs:190:17] r[i] = 0.0
[src/tract.rs:190:17] add1 = inf
thread 'main' panicked at src/tract.rs:191:17:
NAN

If it's false, it's inf.

It's going to be in the nose tick function somewhere I think.

Specifically, i is at position 11.

Specifically at tr_jr[nose_start].

It seems like the reflection coefficients might be causing things to blow up.

In the rust version, I'm getting 2.0. In the original, it's -0.1.

Similar deal actually. The original is still a small negative value.

I have my velum set to be 0 in the rust version. So there is definitely something wrong with these left/right reflection coefficient calculations.

It is larger in the reference (~7.3) vs my implementation (1.062).

I had my nose starting position calculated using a relative percentage of the tract length. Maybe this is an unstable way to do this?

There were typos in my reflection calculations. Additions that were supposed to be subtractions. Looking up the wrong index.

I lost the ideal tube shape sound. Going to need to fiddle around with the interactive example.

I think this was getting in the way of wasm compilation.

lots and lots of trial and error

At this point, I'm just having fun. I think the velum is correct haha

Now, time for cleanup.

My shapes for the throat singing example are ruined once again because there was some code I accidentally commented out.