BrainModular

Bonjour.
Toujours dans la fabrication de mes loopers, j'ai intègré un nouveau mode de synchro entre deux sampler.
Le principe est plus simple que les précédents et plus efficace.
je fais une boucle de par exemple 10 sec sur mon premier looper.
lorsque je lance l'enregistrement sur mon second looper, celui démarre un compte de 10/4 soit 2,5 sec et recommence chaque fois
qu'il a terminé. quand je sort de mon enregistrement, le looper attend de rencontrer une fin de compte pour stopper le rec.
Cela me permet de sortir avec un boucle égale à un quart, la moitié, 3/4 ou la même durée ou encore 2 ou 3 fois la longueur de ma première boucle.
Ma première question est : d'après vous est il possible que la quantization du découpage se fasse en fonction de la longueur de ma
deuxième boucle (je pensais à la place d'avoir un nombre fixe comme 4 utiliser une variable = l1/l2 ("l" étant la longueur de mes rec).
ma deuxième question concerne ce curieux décalage que je constate. En effet si ma première loop fait dix seconde et que je sort de ma deuxième boucle à 9 sec, le rec devrait attendre 10 pour sortir et ma 2eme loop devrait faire pile 10 sec.
En fait elle est toujours un peu plus longue et je résoud le problème en soustrayant 5 ms à mon compte.
D'où vient ce décalage ?
est ce dût à un problème de latence de carte audio ?
Aurais je le même décalage avec n'importe quelle config ?
Encore une fois désolé pour le dérangement et merci d'avance.
JF

Personnellement,
je travaille autrement :
plutôt que d'enregistrer une première boucle qui va servir de base de temps,
je travaille avec le tempo d'Usine, et je choisis la longueur d'un cycle (1,2,3... mesures) ->
ensuite, chaque fois que j'enregistre une boucle sur sample, j'ai créé un patch qui lance l'enregistrement en début de cycle et le stoppe en fin de cycle.
Et ainsi tout est bien calé, de la même longueur, etc.

c'est effectivement une autre façon de faire mais elle implique trop de rigueur. Mon cahier des charge était de n'avoir aucune contrainte tant au moment où l'on entre dans la boucle qu'au moment où on sort. ta méthode implique que l'on joue au tempo. Comment faire quand on part sur une improvisation libre et sans click ?

Et si ta boucle de départ définissait le tempo et la longueur du cycle ?
Ainsi, tu enregistrerais tes autres boucles sur des cycles définis par ta première boucle ?

C'est une idée,
parce que en travaillant directement sur les temps, là je suis incapable de t'aider.

A vrai dire c'était mon idée de départ mais comment usine peut définir le tempo si je ne lui indique pas le nombre de mesure ?

Et si tu lui donnais le nombre de mesures par un signal (par exemple une pédale sur laquelle tu bats la mesure,
pendant que tu joues à la guitare ?).

Sinon, sans rien indiquer à Usine, je vois pas de solution simple...

"Ma première question est : d'après vous est il possible que la quantization du découpage se fasse en fonction de la longueur de ma
deuxième boucle (je pensais à la place d'avoir un nombre fixe comme 4 utiliser une variable = l1/l2 ("l" étant la longueur de mes rec)."

Je comprends pas vraiment ce que tu veux...Ta deuxième boucle servirait de référence? Ou alors tu veux des subdivisions supérieures à 4?

Ma solution fonctionne Si ce n'est ce curieux décalage de 5ms.
c'est ma première boucle qui me sert de référence.
Ce que je disais à propos de la subdivision c'est que pour le moment j'ai choisi arbitrairement de la faire par 4.
Par exemple si ma première boucle fait pile 10 secondes , au moment où j'enregistre sur le 2ème sampler, Usine ce met à compter 10/4 c-a-d 2,5 seconde en boucle.
lorsque j'appuie sur mon switch pour arrêter le rec, usine va attendre la fin d'un cycle de 2,5 sec pour stopper l'enregistrement (il s'agit d une sorte de quantization mais seulement en fin de rec).
maintenant si ma boucle fait 1 minute mon système ne suffit plus car je ne pourrais sortir de mon rec qu'à 15, 30 ,45 ou 60 secondes.
alors que j'aimerais pouvoir sortir à par exemple 6 secondes (60/6) ou 12 ou encore 24.
A ce moment là me direz vous pourquoi diviser pas 4 et no par 16 ou 32 voir 64 ? Parce que ces subdivision seraient trop fortes pour une boucle courte.
En gros il me faut un diviseur qui soit adapté à la longueur de ma boucle. c'est pourquoi je pensais diviser l1/l2 pour déterminer celui-ci:
ex l1=100 l2 =10 mon diviseur est 10
l1=100 l2=30 mon diviseur devient 3.33333
comme je suis en train d'enregistrer; la longueur change en permanence (et vers une valeur plus grande) ce qui fait qu'à mesure que les deux longueurs se rapprochent mon diviseur devient de plus en plus petit.
Mais que ce passe t'il quand j'arrive en valeur négative ?