Best way to set up instant retrigger functionality?

alexs1

This sort of ties into the Mobius as Sampler thread, but one thing I'd like to add to my performance flow is something like an Instant Retrigger. They're most common on samplers and some loopers (think DL4), where pressing a pad/switch will instantly retrigger a sample/loop from the beginning.

My idea for Mobius was to set up a CC pad that could retrigger a loop like a sampler would, where every time I press it, the loop restarts instantly from the beginning. To have it stay in sync with quantization without needing Realign, and to be as granular as possible, I would try to have it snap to a beat pulse (or subcycle?) so it's more like 'near instant.' And on top of that, I might add an unquantized Mute event on release, so it plays for as long as I have the trigger held down, and when I let go, it instantly mutes it, more like a sampler.

Syntactically-incorrect MSL chicken scratch:
#name Sampler Retrigger (Press)
in focused
switchQuantize = Subcycle
Restart
switchQuantize = loop

and a second script bound to the same trigger with "Release" checked in the binding panel:
#name Sampler Retrigger (Release)
in focused
quantize = off
Mute (*better yet, MuteRealign(?))
quantize = loop

I haven't tested this yet, but would there be maybe a simpler approach?

jeff

A few options here. Restart is one, it's an older function that used to be called Retrigger, and has some EDP baggage on it. It is technically a "loop switch" function but instead of moving to a different loop, it restarts the current one. But since it is part of the Switch family, it will obey SwitchQuantize and maybe some of the others but most of the Switch parameters don't make any sense since your staying in the same loop.

There is a newer one called Start I added to avoid the Switch complications and behave like most people expect without any surprises. It just starts the loop over from the beginning, and brings it out of Pause/Stop if you're in it. Start obeys regular quantize mode, and you can set what quantization for it is in that new Configuration->Options page. Or if you're in a script you can use wait to make the script suspend until the wait point, then do the Start.

Finally, there is Move which is similar to Start but let's you pick where you want to go. It is mostly used in scripts because the "where to go" is expressed in samples. Move(0) is an even simpler form of Start because I don't think it cancels Mute or Pause or anything else, it just moves the playback position to where you give it. As an example if you wanted to instantly move to the center of the loop you could do:

 Move(loopFrames / 2)

In some of the script variables you will see the word "Frames". You can think of this as "the sample position within the loop" though technically what a frame is is a collection of individual samples that happen at the same time. Currently Mobius always deals with audio data in stereo, so a frame contains two samples. But since you can't do anything to the individual samples within a frame, you can think of a frame and a sample as being the same thing when thinking about locations and lengths.

jeff

I was going to explain the Release checkbox in bindings, but I see you've already discovered that. I'm interested to see how that goes, like all new things, it's supposed to work, but it isn't something I use much. This is an example of using OnRelease that would be a alternative to a Release binding. Because of the #focused bug it will use "in focused"

#sustain
in focused Start
function OnRelease { in focused Mute }

This is ignoring quantization. Temporary changes to quantization in scripts is a perpetual thorn in the side, I have a few solutions in the works. But this is the recommended way for now:

#sustain
in focused {
   // save the current quantization setting
   variable saveQuant quantize
   // turn it off
   quantize = :off
   // do what needs to be done
   Start
   // and put it back
   quatize = saveQuant
}

function OnRelease {
  in focused {
     // same shit, different bottles
     variable saveQuant = quantize quantize = :off Mute quantize = saveQuant
  }
}

alexs1

jeff

Cool. I think what I want to do is have the OnRelease function be MuteRealign so that it comes back in sync once the loop completes.

So the script might look something more like this:
#sustain
in focused
Start

function OnRelease {
in focused (unquantized) Mute
Realign
}

or something.
Which is definitely simpler when Start is unquantized by default. MuteRealign should be kept quantized to Loop in Configuration Options. Or in this example, instaneously Mute and then follow up with a Realign. The only issue is that I'm having trouble getting MuteRealign or Realign to work. I see the mode come up in the UI but they don't really snap back into place with TSM or Host sync. MuteRealign doesn't enter Mute mode either. I remember you said there was some changeover since 2.5 with those functions though.

jeff

MuteRealign is broken, I'm fixing that.

I would have expected Realign to work, but it may have something to do with the same order dependency bug that was preventing synchronized Record from working. Try it again after build 44 and I'll run through some tests here.

alexs1

jeff

Forsure. I think I'm aiming for an instant "Now" MuteRealign job OnRelease (rather than loop quantize). To be clear, does Realign need to be set to Sync Unit in order to follow the beginning of the TSM loop?

jeff

The various RealignUnit options control when the Realign happens. The choice is personal preference. The EDP always did the equivalent of Loop, waiting for the "external start point" then retriggering the loop from the beginning. The other options let you choose locations that might be closer than waiting for the start point. When Realign Unit is Sync Unit, it means to use the same sync unit that is used for recording, either Sync Unit or Track Sync Unit. The choices Beat, Bar or Loop are used if you want something different than the recording unit.

Now means don't wait at all, just immediately realign the loop. When using Now, MuteRealign doesn't really do anything because it won't ever be in that dead zone between when you press the button and the source reaches the point you selected.

I think Loop was the most popular, in part because it was easier to implement, but also from the audience's perspective, it shuts off the misaligned loop and lets the audience hear just the drum machine or whatever you're syncing with to kind of mentally reorient where things are, then it gets to a musically satisfying position, they both start together again.

It isn't something I use much, and when I do it would be to correct a situation that wasn't supposed to happen to begin with, so I want it Now.

alexs1

jeff When using Now, MuteRealign doesn't really do anything because it won't ever be in that dead zone between when you press the button and the source reaches the point you selected.

Do you think it would be best practice to keept the OnRelease {MuteRealign} set to Now, or have it be the most granular Unit (such as Beat)? Say the TSM is a 4 second loop and on a different Track Sync track, I spam Start a few times. When I let go of the release, would "Now" correct alignment without a Mute (creating an audible audio 'skip')? In that case it actually might make more sense to have it set to Sync Unit (default = Loop).

jeff

Realign with Now will make a sudden playback adjustment to the track that is out of alignment, whether that sounds like a "skip" or not depends on the definition. It will be a sudden change, from the listeners perspective things were out of alignment maybe in an interesting way, and then suddenly everything snapped back into place. MuteRealign with Loop just gives a little breathing room between now and a place where it might make more sense to have things brought back together. It's all personal preference. I'd try both and see what you like best for the situation.

alexs1

My new script in b45 to do this is:

#name InstantMute
#focused
#sustain

Start

function OnRelease {
Mute(quantize=:off)
Realign
}

Still having trouble getting this to work. When I release the trigger, it instantly mutes the loop for a split second before Realign unmutes it. I made sure to uncheck Mute Cancel for Realign in Configuration Options. I also tried MuteRealign instead of Realign, but that doesn't seem to work either (couldn't get MuteRealign as the UI button to work, fwiw.)

jeff

There is quite possibly something broken with the MuteCancel options. The way Realign is done now is different than before and it probably isn't paying attention to that.

I'm not sure I understand the purpose of the Realign though. If what you want is a track to behave like a sampler where press means "play from the beginning" and release means "shut it off", then you could just use this:

function OnRelease {
  Stop
}

If you wanted release to Mute it, but press always Starts it, then it doesn't really matter where it is aligned while being muted. Start is always going to start it over from the beginning. So on release, it can just to back to the beginning and stop, you don't need either Mute or Realign. Am I missing something?

alexs1

jeff So on release, it can just to back to the beginning and stop, you don't need either Mute or Realign. Am I missing something?

When I use Start, it instantly retriggers playback on the loop, which is what I want. This also automatically knocks it out of alignment, so I added a Realign in the script which slingshots it back into place. However, the instant Realign creates an audible jump in playback, so when it snaps into place after OnRelease, I also want it to automatically Mute. The loop then remains muted until I manually unmute it, as it will still be in sync/aligned with all the other tracks.

Example: I have a vocal loop which starts with "oooo" on the first beat and later goes "la la la". I press the trigger three times to have it go "oo, oo, oo", (which knocks it out of sync) but on the last "oo", I release the trigger, it Realigns the loop back to normal sync source, and Mutes it all at once, so when I unmute it, I can have the whole "ooo la la la" be on time just as it was recorded.

The reason I use Mute instead of Stop is so that it is still running in sync in the background after it's realigned, ideally. But it seems like there's a conflict between Realign and Mute right now that prevents the script from working. I've also tried a "wait last" statement between Mute and Realign with no luck.

jeff

Interesting use case. It's kind of a hybrid track that can play a loop normally with Muting, but can also temporarily behave like a sampler or clip track.

I'm pretty sure there is a way to accomplish that, but it may require more steps in the script to work around the mute cancel bug.

alexs1

jeff I'm pretty sure there is a way to accomplish that, but it may require more steps in the script to work around the mute cancel bug.

Cool. Not in any rush