Simple windowed stretching algorithm broken?

[Phazma]

I assume that Reaper's "simple windowed" algorithm is intended to be what is often referred to as "cyclic stretching" algorithm. But compared to similar algorithms in other software it sounds.. rather odd.

Here a video where I compare a breakbeat sample stretched with TAL's, Akaizer's and Logic's cyclic stretching modes (in this order) to Reaper's simple windowed stretching (last one) and you will hear what I mean:

https://vimeo.com/707819983

As you can hear in Reaper the stretched sample sounds totally crushed. I bet some bug has sneaked into the implementation of this algorithm which makes it sound so low quality? I hope this can be fixed so that the "simple windowed" algorithm can become a useful "cyclic" stretching algorithm.

[Phazma]

Bump.

[Justin]

If it sounds different to other algorithms that's expected -- if you can point to a project using this mode that sounds different to a previous REAPER version, then that would be helpful. It may have always been "broken."

[Phazma]

I think in REAPER it always sounded like this and my guess was that it always has been "broken".

As the "granularization" (for lack of a better word) itself sounds pretty much identical to all these algorithms from other software, but the sound quality is somehow much worse (lacking high frequencies and sounding noisy as if heavy sample rate reduction and bitcrushing are going on), I thought something had gone wrong with the implementation. I believed that it was meant to sound like the other algorithms in my video but some line of code regarding resampling has an error and nobody reported it before because everybody thought it was intentional.

But if what you are hearing from the last audio in my demo video is how the algorithm is meant to sound then probably this should rather be a feature request for an actual, proper "cyclic time stretching" mode like the other audios in my video.

[mozart999uk]

Originally Posted by Phazma

I think in REAPER it always sounded like this and my guess was that it always has been "broken".

As the "granularization" (for lack of a better word) itself sounds pretty much identical to all these algorithms from other software, but the sound quality is somehow much worse (lacking high frequencies and sounding noisy as if heavy sample rate reduction and bitcrushing are going on), I thought something had gone wrong with the implementation. I believed that it was meant to sound like the other algorithms in my video but some line of code regarding resampling has an error and nobody reported it before because everybody thought it was intentional.

But if what you are hearing from the last audio in my demo video is how the algorithm is meant to sound then probably this should rather be a feature request for an actual, proper "cyclic time stretching" mode like the other audios in my video.

Did you get any further with a FR for this?

I found this video on YT: https://www.youtube.com/watch?v=RUmOOFg0UNE

[Phazma]

Originally Posted by mozart999uk

Did you get any further with a FR for this?

I found this video on YT: https://www.youtube.com/watch?v=RUmOOFg0UNE

I don't remember if I have created a FR already and currently I am too busy to search or deal with it (maybe I find time this weekend).

But I definitely still very much wish for a proper cyclic time stretch algorithm.

[lewloiwc]

By first pitch shifting with Simple windowed and then resampling with Linear Interpolation, I was able to reproduce 100% of the current REAPER algorithm.
In other words, to solve this problem, I believe that the order of pitch shifting and resampling should simply be swapped.

Translated with www.DeepL.com/Translator (free version)

[mozart999uk]

I'm guessing from Justin's comment above that it's not considered a bug, which is fair enough. Maybe we should create a FR for this instead?

[Phazma]

Give me a little more time guys, I will create a proper FR in the next days (before 2023).

[Justin]

Originally Posted by lewloiwc

By first pitch shifting with Simple windowed and then resampling with Linear Interpolation, I was able to reproduce 100% of the current REAPER algorithm.
In other words, to solve this problem, I believe that the order of pitch shifting and resampling should simply be swapped.

Translated with www.DeepL.com/Translator (free version)

Correct, here is the code:

https://github.com/justinfrankel/WDL...e_pitchshift.h

Hmm, perhaps we should use the current mode when speeding up content (pitch shifting down, then resampling to speed up), and the reverse when slowing down (resampling to slow down, then pitch adjusting up)

[Phazma]

Originally Posted by Justin

Correct, here is the code:

https://github.com/justinfrankel/WDL...e_pitchshift.h

Hmm, perhaps we should use the current mode when speeding up content (pitch shifting down, then resampling to speed up), and the reverse when slowing down (resampling to slow down, then pitch adjusting up)

Can the code be tried out somehow?

If you decide to update the algorithm as described and include it in an upcoming dev build I would be very happy to test it and give feedback/opinions

[Justin]

A new mode is coming in the next +dev series...

[lewloiwc]

I checked Texture Mode, which is Simple windowed in Ableton Live, and it seems that resampling is not actually used for time stretching.

I found it difficult to explain in words, so I would like to explain by posting the jsfx I created and a video of it.

The simplest possible code to express this is as follows.

spl0 = 0[b += pitch];
c === 3000 ? (
    c = 0;
    b = a
) : (
    c += 1;
);
a += rate;
spl1 *= post;

The "a" always advances along the time axis at the rate speed, and the "b = a" periodically executed determines the starting position of memory reading and advances the time of the "b" to perform time stretching.

Full Version Code

desc:math_exp_26 Texture Mode 0.0.4

slider1:size_slider=50<1,1000,0.1>Size (ms)
slider2:flux_slider=0<0,100,0.1>Flux (%)
slider3:rate_slider=1<0.01,10,0.01>Rate
slider4:pitch_slider=0<-24,24,1>Pitch (st)



@init //----------------------------------------------------------------

function fc(n)
(
    floor(n+0.5)
);

function lerp(a,b,t)
(
    (1 - t)*a + t*b;
);

function mem_lerp2(mem,x)
(
    lerp(
        mem[floor(x)*2],
        mem[floor(x)*2 + 2],
        x - floor(x)
    );
);

function fade(x)
(
    cos($pi*(x - 0.5));
);



mem = 0;

file_handle = file_open(#file);
file_nch = 'rqsr';
file_riff(file_handle,file_nch,srate);
file_len = file_avail(file_handle)/file_nch; 
file_mem(file_handle,mem,file_len*file_nch);
file_close(file_handle);



pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);

cnt_mem_global = -size*4;

cnt_mem_a = 0;
pitch_a = 0;
cnt_fade_a = 0;

cnt_mem_b = 0;
pitch_b = 0;
cnt_fade_b = 0.5;

size_lock = 0;
fade_lock = 0;

cnt_switch = 0;
switch = 0;
switch_ = 0;



@slider //----------------------------------------------------------------

pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);

flux = flux_slider*0.01;



@sample //----------------------------------------------------------------

switch === 0 ? (
    cnt_mem_a = cnt_mem_global;
    pitch_a = pitch;
    cnt_fade_a = 0;
);

switch === 1 ? (
    cnt_mem_b = cnt_mem_global;
    pitch_b = pitch;
    cnt_fade_b = 0;
);

switch === 0 || switch === 1 ? (
    size_lock = size2;
    fade_lock = 0.5/size_lock;
);

spl0 =
    mem_lerp2(mem    ,cnt_mem_a)*fade(cnt_fade_a) +
    mem_lerp2(mem    ,cnt_mem_b)*fade(cnt_fade_b);
spl1 =
    mem_lerp2(mem + 1,cnt_mem_a)*fade(cnt_fade_a) +
    mem_lerp2(mem + 1,cnt_mem_b)*fade(cnt_fade_b);

cnt_switch < size_lock - 1 ? (
    cnt_switch += 1;
    switch = -1;
) : (
    cnt_switch = 0;
    switch = switch_ = !switch_;
);

cnt_mem_a += pitch_a;
cnt_mem_b += pitch_b;

cnt_fade_a += fade_lock;
cnt_fade_b += fade_lock;

cnt_mem_global += rate_slider;



size2 = size*lerp(1,rand(2),flux);



@serialize //----------------------------------------------------------------

file_string(0,#file);



@gfx //----------------------------------------------------------------

gfx_getdropfile(0,#file);

gfx_set(0.4);
gfx_rect(3,3,gfx_w - 6,gfx_h - 6,0);
gfx_x = 0;
gfx_y = 0;
gfx_drawstr("Drag and drop audio files here",5,gfx_w,gfx_h);

Texture Mode is only 50% fade, so I did not know if other % fade settings are possible.

[Justin]

yeah simple windowed is pitch-shifting + optional resampling. If you want timestretch + optional resampling, try SoundTouch, that's what it does. Though I guess it tries to make everything fit, which might not be what you're looking for. Maybe it's time to do a new timestretch + optional resample mode, using the higher quality resample modes we have, too. Can actually base it somewhat on Rrreeeaaa (replacing the polyphase synthesis component with window overlapping), mmm.

[mozart999uk]

Does anyone here have the facility to compare any new modes to the original cyclic / akai timestretch? Unfortunately not got access to a s series sampler any more 🙁

[nofish]

Originally Posted by mozart999uk

Does anyone here have the facility to compare any new modes to the original cyclic / akai timestretch? Unfortunately not got access to a s series sampler any more ��

https://the-akaizer-project.blogspot.com/
(if you don't know it yet)

[Vagelis]

Originally Posted by Justin

Maybe it's time to do a new timestretch + optional resample mode, using the higher quality resample modes we have, too. Can actually base it somewhat on Rrreeeaaa (replacing the polyphase synthesis component with window overlapping), mmm.

That would be amazing! Also it would be really useful if we could change the window size with a slider to any window size we want instead of the premade values from the dropdown menu. In ableton it's possible to automate it with an envelope which is super useful for precise time stretching by changing the size in realtime.

[Phazma]

Originally Posted by lewloiwc

Full Version Code

desc:math_exp_26 Texture Mode 0.0.4

slider1:size_slider=50<1,1000,0.1>Size (ms)
slider2:flux_slider=0<0,100,0.1>Flux (%)
slider3:rate_slider=1<0.01,10,0.01>Rate
slider4:pitch_slider=0<-24,24,1>Pitch (st)



@init //----------------------------------------------------------------

function fc(n)
(
    floor(n+0.5)
);

function lerp(a,b,t)
(
    (1 - t)*a + t*b;
);

function mem_lerp2(mem,x)
(
    lerp(
        mem[floor(x)*2],
        mem[floor(x)*2 + 2],
        x - floor(x)
    );
);

function fade(x)
(
    cos($pi*(x - 0.5));
);



mem = 0;

file_handle = file_open(#file);
file_nch = 'rqsr';
file_riff(file_handle,file_nch,srate);
file_len = file_avail(file_handle)/file_nch; 
file_mem(file_handle,mem,file_len*file_nch);
file_close(file_handle);



pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);

cnt_mem_global = -size*4;

cnt_mem_a = 0;
pitch_a = 0;
cnt_fade_a = 0;

cnt_mem_b = 0;
pitch_b = 0;
cnt_fade_b = 0.5;

size_lock = 0;
fade_lock = 0;

cnt_switch = 0;
switch = 0;
switch_ = 0;



@slider //----------------------------------------------------------------

pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);

flux = flux_slider*0.01;



@sample //----------------------------------------------------------------

switch === 0 ? (
    cnt_mem_a = cnt_mem_global;
    pitch_a = pitch;
    cnt_fade_a = 0;
);

switch === 1 ? (
    cnt_mem_b = cnt_mem_global;
    pitch_b = pitch;
    cnt_fade_b = 0;
);

switch === 0 || switch === 1 ? (
    size_lock = size2;
    fade_lock = 0.5/size_lock;
);

spl0 =
    mem_lerp2(mem    ,cnt_mem_a)*fade(cnt_fade_a) +
    mem_lerp2(mem    ,cnt_mem_b)*fade(cnt_fade_b);
spl1 =
    mem_lerp2(mem + 1,cnt_mem_a)*fade(cnt_fade_a) +
    mem_lerp2(mem + 1,cnt_mem_b)*fade(cnt_fade_b);

cnt_switch < size_lock - 1 ? (
    cnt_switch += 1;
    switch = -1;
) : (
    cnt_switch = 0;
    switch = switch_ = !switch_;
);

cnt_mem_a += pitch_a;
cnt_mem_b += pitch_b;

cnt_fade_a += fade_lock;
cnt_fade_b += fade_lock;

cnt_mem_global += rate_slider;



size2 = size*lerp(1,rand(2),flux);



@serialize //----------------------------------------------------------------

file_string(0,#file);



@gfx //----------------------------------------------------------------

gfx_getdropfile(0,#file);

gfx_set(0.4);
gfx_rect(3,3,gfx_w - 6,gfx_h - 6,0);
gfx_x = 0;
gfx_y = 0;
gfx_drawstr("Drag and drop audio files here",5,gfx_w,gfx_h);

This jsfx is EXACTLY the stretching that I hope we will get in Reaper! I best like it with the size parameter at 25ms. If Reaper gets this stretching algorithm it would be amazing if it also allows us to set the window size to any number, perhaps via a number input box (rather than just some presets as simple windowed currently has).

Originally Posted by Justin

Maybe it's time to do a new timestretch + optional resample mode, using the higher quality resample modes we have, too. Can actually base it somewhat on Rrreeeaaa (replacing the polyphase synthesis component with window overlapping), mmm.

Wow this sounds interesting! So would it be 2 new modes, a new/updated pitchshift(+resampling) mode and a new timestretch(+resampling) mode, the latter based on Rrreeeaaa?

Would the window overlapping Rrreeeaaa sound somewhat like this?

https://streamable.com/jur5dk

That would be very cool because as much as Rrreeeaaa is a nice tool for sounddesign, sometimes it would be useful to have its smooth stretching sound applied in a way that is more true to the original audio without completely smearing transients. I can see that be useful not just for creative but also corrective time stretching.

[lewloiwc]

I'm almost done with jsfx, so I'm posting it anyway.
I'm sleepy, so I'll do the explanation and minor code fixes next time I wake up, but one thing I want to mention is that I checked and Akaizer and Ableton Live's Texture Mode is 99% the same.

desc:math_exp_26 Texture Mode 0.1.1

slider1:size_slider=50<1,1000,0.1>Size (ms)
slider2:flux_slider=0<0,100,0.1>Flux (%)
slider3:rate_slider=1<0.01,10,0.01>Rate
slider4:pitch_slider=0<-24,24,1>Pitch (st)



@init //----------------------------------------------------------------

function frac(n)
(
    n - floor(n)
);

function fc(n)
(
    floor(n+0.5)
);

function lerp(a,b,t)
(
    (1 - t)*a + t*b;
);

function mem_lim(offset)
(
    floor(offset) < 0 ? 0 : floor(offset)[];
);

function mem_lerp_1ch(offset)
(
    lerp(
        mem_lim(offset),
        mem_lim(offset + 1),
        frac(offset)
    );
);

function mem_lagrange3_1ch(offset)
local(
    a,b,c,d,x
)
(
    a = mem_lim(offset - 1);
    b = mem_lim(offset);
    c = mem_lim(offset + 1);
    d = mem_lim(offset + 2);
    
    x = 1 + frac(offset);
    a - x*((a - b) + (1 - x)*0.5*((a - 2*b + c) + (2 - x)*0.3333333333333333*(a - 3*b + 3*c - d)));
);

function mem_lerp_2ch(mem,x)
(
    lerp(
        mem_lim(mem + floor(x)*2),
        mem_lim(mem + floor(x)*2 + 2),
        frac(x)
    );
);

function mem_lagrange3_2ch(mem,x)
local(
    a,b,c,d,x
)
(
    a = mem_lim(mem + floor(x)*2 - 2);
    b = mem_lim(mem + floor(x)*2);
    c = mem_lim(mem + floor(x)*2 + 2);
    d = mem_lim(mem + floor(x)*2 + 4);
    
    x = 1 + frac(x);
    a - x*((a - b) + (1 - x)*0.5*((a - 2*b + c) + (2 - x)*0.3333333333333333*(a - 3*b + 3*c - d)));
);

function fade(x)
(
    cos($pi*(x - 0.5));
);



mem = 0;

file_handle = file_open(#file);
file_nch = 'rqsr';
file_riff(file_handle,file_nch,srate);
file_len = file_avail(file_handle)/file_nch; 
file_mem(file_handle,mem,file_len*file_nch);
file_close(file_handle);



pitch = 2^(pitch_slider/12);



cnt_mem_global = 0;

size_lock = 0;
fade_lock = 0;

pitch_lock_a = 0;
cnt_mem_a = 0;
cnt_fade_a = 0;

pitch_lock_b = pitch;
cnt_mem_b = 0;
cnt_fade_b = 0.5;

cnt_switch = 0;
switch = 0;
switch_ = 0;



@slider //----------------------------------------------------------------

pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);



@sample //----------------------------------------------------------------

switch === 0 || switch === 1 ? (
    size_lock = size*lerp(1,rand(2),flux_slider*0.01);
    fade_lock = 0.5/size_lock;
);

switch === 0 ? (
    pitch_lock_a = pitch;
    cnt_mem_a = cnt_mem_global - size_lock*pitch_lock_a + size_lock*rate_slider;
    cnt_fade_a = 0;
);

switch === 1 ? (
    pitch_lock_b = pitch;
    cnt_mem_b = cnt_mem_global - size_lock*pitch_lock_b + size_lock*rate_slider;
    cnt_fade_b = 0;
);

file_nch === 1 ? (
    spl1 = spl0 =
        mem_lagrange3_1ch(mem +   cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_1ch(mem +   cnt_mem_b)*fade(cnt_fade_b);
) :
file_nch === 2 ? (
    spl0 =
        mem_lagrange3_2ch(mem    ,cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_2ch(mem    ,cnt_mem_b)*fade(cnt_fade_b);
    spl1 =
        mem_lagrange3_2ch(mem + 1,cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_2ch(mem + 1,cnt_mem_b)*fade(cnt_fade_b);
);

cnt_switch < size_lock - 1 ? (
    cnt_switch += 1;
    switch = -1;
) : (
    cnt_switch = 0;
    switch = switch_ = !switch_;
);

cnt_mem_a += pitch_lock_a;
cnt_mem_b += pitch_lock_b;

cnt_fade_a += fade_lock;
cnt_fade_b += fade_lock;

cnt_mem_global += rate_slider;



@serialize //----------------------------------------------------------------

file_string(0,#file);



@gfx //----------------------------------------------------------------

gfx_getdropfile(0,#file);

gfx_set(0.4);
gfx_rect(3,3,gfx_w - 6,gfx_h - 6,0);
gfx_x = 0;
gfx_y = 0;
gfx_drawstr("Drag and drop audio files here",5,gfx_w,gfx_h);

Translated with www.DeepL.com/Translator (free version)

[Vagelis]

Originally Posted by lewloiwc

I'm almost done with jsfx, so I'm posting it anyway.
I'm sleepy, so I'll do the explanation and minor code fixes next time I wake up, but one thing I want to mention is that I checked and Akaizer and Ableton Live's Texture Mode is 99% the same.

Sounds pretty good!

Another important function is the window types. Depending on the audio source and what we want to achieve, different windows types can change how the transients sound which is very useful for better sound quality.
A problem in Simple windowed is that there is only one window type with different fade values.

@Justin
Would it be possible to include different window types for this new mode just like in Rrreeeaaa?

[Justin]

Thanks lewloiwc, that is incredibly instructive!

Check the latest +dev build

(here's what our stretcher does: http://1014.org/_/overlap.h.txt )

[Phazma]

Thanks Justin for adressing this and thanks to lewloiwc for putting in the work and providing the script which made this possible!

[Vagelis]

Originally Posted by Justin

Thanks lewloiwc, that is incredibly instructive!

Check the latest +dev build

(here's what our stretcher does: http://1014.org/_/overlap.h.txt )

Thank you very much it's amazing, you guys rock!

[mozart999uk]

This is great. Thanks all 👍

[djtt]

I would love to play with this myself, however I'm a blind guy that use a screen reader and keybord commands to use Reaper, so wonder, is it possible to rewrite this plugin with a standard open file window instead of drag and drop?

Originally Posted by lewloiwc

I'm almost done with jsfx, so I'm posting it anyway.
I'm sleepy, so I'll do the explanation and minor code fixes next time I wake up, but one thing I want to mention is that I checked and Akaizer and Ableton Live's Texture Mode is 99% the same.

desc:math_exp_26 Texture Mode 0.1.1

slider1:size_slider=50<1,1000,0.1>Size (ms)
slider2:flux_slider=0<0,100,0.1>Flux (%)
slider3:rate_slider=1<0.01,10,0.01>Rate
slider4:pitch_slider=0<-24,24,1>Pitch (st)



@init //----------------------------------------------------------------

function frac(n)
(
    n - floor(n)
);

function fc(n)
(
    floor(n+0.5)
);

function lerp(a,b,t)
(
    (1 - t)*a + t*b;
);

function mem_lim(offset)
(
    floor(offset) < 0 ? 0 : floor(offset)[];
);

function mem_lerp_1ch(offset)
(
    lerp(
        mem_lim(offset),
        mem_lim(offset + 1),
        frac(offset)
    );
);

function mem_lagrange3_1ch(offset)
local(
    a,b,c,d,x
)
(
    a = mem_lim(offset - 1);
    b = mem_lim(offset);
    c = mem_lim(offset + 1);
    d = mem_lim(offset + 2);
    
    x = 1 + frac(offset);
    a - x*((a - b) + (1 - x)*0.5*((a - 2*b + c) + (2 - x)*0.3333333333333333*(a - 3*b + 3*c - d)));
);

function mem_lerp_2ch(mem,x)
(
    lerp(
        mem_lim(mem + floor(x)*2),
        mem_lim(mem + floor(x)*2 + 2),
        frac(x)
    );
);

function mem_lagrange3_2ch(mem,x)
local(
    a,b,c,d,x
)
(
    a = mem_lim(mem + floor(x)*2 - 2);
    b = mem_lim(mem + floor(x)*2);
    c = mem_lim(mem + floor(x)*2 + 2);
    d = mem_lim(mem + floor(x)*2 + 4);
    
    x = 1 + frac(x);
    a - x*((a - b) + (1 - x)*0.5*((a - 2*b + c) + (2 - x)*0.3333333333333333*(a - 3*b + 3*c - d)));
);

function fade(x)
(
    cos($pi*(x - 0.5));
);



mem = 0;

file_handle = file_open(#file);
file_nch = 'rqsr';
file_riff(file_handle,file_nch,srate);
file_len = file_avail(file_handle)/file_nch; 
file_mem(file_handle,mem,file_len*file_nch);
file_close(file_handle);



pitch = 2^(pitch_slider/12);



cnt_mem_global = 0;

size_lock = 0;
fade_lock = 0;

pitch_lock_a = 0;
cnt_mem_a = 0;
cnt_fade_a = 0;

pitch_lock_b = pitch;
cnt_mem_b = 0;
cnt_fade_b = 0.5;

cnt_switch = 0;
switch = 0;
switch_ = 0;



@slider //----------------------------------------------------------------

pitch = 2^(pitch_slider/12);
size = fc(size_slider*(srate/1000)/pitch);



@sample //----------------------------------------------------------------

switch === 0 || switch === 1 ? (
    size_lock = size*lerp(1,rand(2),flux_slider*0.01);
    fade_lock = 0.5/size_lock;
);

switch === 0 ? (
    pitch_lock_a = pitch;
    cnt_mem_a = cnt_mem_global - size_lock*pitch_lock_a + size_lock*rate_slider;
    cnt_fade_a = 0;
);

switch === 1 ? (
    pitch_lock_b = pitch;
    cnt_mem_b = cnt_mem_global - size_lock*pitch_lock_b + size_lock*rate_slider;
    cnt_fade_b = 0;
);

file_nch === 1 ? (
    spl1 = spl0 =
        mem_lagrange3_1ch(mem +   cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_1ch(mem +   cnt_mem_b)*fade(cnt_fade_b);
) :
file_nch === 2 ? (
    spl0 =
        mem_lagrange3_2ch(mem    ,cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_2ch(mem    ,cnt_mem_b)*fade(cnt_fade_b);
    spl1 =
        mem_lagrange3_2ch(mem + 1,cnt_mem_a)*fade(cnt_fade_a) +
        mem_lagrange3_2ch(mem + 1,cnt_mem_b)*fade(cnt_fade_b);
);

cnt_switch < size_lock - 1 ? (
    cnt_switch += 1;
    switch = -1;
) : (
    cnt_switch = 0;
    switch = switch_ = !switch_;
);

cnt_mem_a += pitch_lock_a;
cnt_mem_b += pitch_lock_b;

cnt_fade_a += fade_lock;
cnt_fade_b += fade_lock;

cnt_mem_global += rate_slider;



@serialize //----------------------------------------------------------------

file_string(0,#file);



@gfx //----------------------------------------------------------------

gfx_getdropfile(0,#file);

gfx_set(0.4);
gfx_rect(3,3,gfx_w - 6,gfx_h - 6,0);
gfx_x = 0;
gfx_y = 0;
gfx_drawstr("Drag and drop audio files here",5,gfx_w,gfx_h);

Translated with www.DeepL.com/Translator (free version)

[Suzuki]

lewloiwc's Texture Mode JSFX is now in my ReaPack.
https://forum.cockos.com/showthread.php?t=285649