a simple question about building a step sequencer with JSFX

[BryanChi]

I'm having difficulty with letting the JSFX know the current position within the sequencer's length.
I've figured out how to know the current playhead position in a measure with this simple equation:

MeasureNum= floor(beat_position/ts_denom);
BeatPos= beat_position - ts_denom* (MeasureNum);

but what happens when you want to make the sequencer longer than a measure?
Thank you!

[IXix]

You'd use something along the lines of...

current_pos = beat_position % sequence_length;

... then go from there.

[TonE]

Wo ai Taiwan, greetings to Taiwan.

[souk21]

Originally Posted by IXix

current_pos = beat_position % sequence_length;

This, but keep in mind % returns an integer. If you want a fractional position you need to use fmod

function fmod (n, k) (
  n - k * floor(n/k);
);
current_pos = fmod(beat_position, sequence_length);

If you want the sequencer to go along but not be tied to the arrangement specific position you can use something along the lines of

@block
beat_per_spl = tempo / (srate * 60);
beat_per_block = beat_per_spl * samplesblock;
//This replaces beat_position
bp += beat_per_block;
//Fractional position
current_pos = fmod(bp, sequence_length);
//Integer position
current_beat = floor(current_pos);

This will play even if transport is stopped, so if it's not desirable you've got to check play_state.

Then you can

@block
beat_per_spl = tempo / (srate * 60);
beat_per_block = beat_per_spl * samplesblock;
bp += beat_per_block;
current_pos = fmod(bp, sequence_length);
next_block_pos = fmod(bp + beat_per_block, sequence_length);

//Next block is going to start during next beat
floor(current_pos) != floor(next_block_pos) ? (
    //How far is next beat
    beat_offset = ceil(cur_position) - cur_position;
    spl_offset = beat_offset / beat_per_block * samplesblock;
    midisend(spl_offset, [...]);
);

The advantage being that you can do stuff like

beat_per_block = beat_per_spl * samplesblock;
beat_per_block *= speed;

And if you need it to be sync with transport you can do

@init
is_init = 0;

@block
//beat_position is not available in @init so you need to set it here
!is_init ? (
    is_init = 1;
    bp = beat_position;
);

[BryanChi]

@souk21 oh wow that is so comprehensive, thank you very much, you're a saint!

@IXix Thank you, I will try a bit and see how it goes!

@TonE hahaha Taiwan loves you too

[souk21]

You're welcome

Just noticed this part should be:

    //How far is next beat
    beat_offset = next_block_pos - floor(next_block_pos);
    spl_offset = (1 - beat_offset / beat_per_block) * samplesblock;
    midisend(spl_offset, [...]);

I edited my previous post to correct this

[souk21]

Or even clearer

//How far is next beat
beat_offset = ceil(cur_position) - cur_position;
spl_offset = beat_offset / beat_per_block * samplesblock;

[BryanChi]

Thank you souk21!
I used just the first bit of your code and have already achieved most of what I need. I'll look deeper into it when I need more advanced functionalities.

Can you please explain to me what this means?

Originally Posted by souk21

The advantage being that you can do stuff like

beat_per_block = beat_per_spl * samplesblock;
beat_per_block *= speed;

[souk21]

The advantage is that if you use the "simple" version

current_pos = fmod(beat_position, sequence_length);

If you want to change the speed, you can use the following code:

current_pos = fmod(beat_position * speed, sequence_length);

That works but current_pos will jump all over the place if you change speed while playing.

//e.g beat_position is 2 and speed is 1
current_pos = fmod(2 * 1, sequence_length);

//you change speed to 2
current_pos = fmod(2 * 2, sequence_length);

//current_pos has jumped from 2 to 4

Whereas with

beat_per_block = beat_per_spl * samplesblock;
beat_per_block *= speed;
next_block_pos = fmod(bp + beat_per_block, sequence_length);

You won't have this problem

//e.g bp is 2 and speed is 1
next_block_pos = fmod(2 + beat_per_block * 1, sequence_length);

//you change speed to 2
next_block_pos = fmod(2 + beat_per_block * 2, sequence_length);

//next_block_pos has only gone up beat_per_block*2 which is what we want

[souk21]

And this part

//How far is next beat
beat_offset = ceil(cur_position) - cur_position;
spl_offset = beat_offset / beat_per_block * samplesblock;

Is useful if you want to trigger your sound/midi on the beat with sample accuracy.
A block will never start at the beginning of a beat, so you need to know when in the buffer the beat is.

If you want to trigger audio you can do it like this:

@buffer
[...]
//Next block is going to start during next beat
floor(current_pos) != floor(next_block_pos) ? (
    //How far is next beat
    beat_offset = ceil(cur_position) - cur_position;
    spl_offset = floor(beat_offset / beat_per_block * samplesblock);
);
@sample
spl_offset == 0 ? (
  //Beat starts at this sample, e.g start playing buffer
);
spl_offset -= 1;

and if you want to trigger midi

//Next block is going to start during next beat
floor(current_pos) != floor(next_block_pos) ? (
    //How far is next beat
    beat_offset = ceil(cur_position) - cur_position;
    spl_offset = beat_offset / beat_per_block * samplesblock;
    midisend(spl_offset, [...]);
);