Doublage guitares et compatiblité mono

11 réponses
5 participants
744 vues
6 followers

Firesledge

Posteur·euse AFfranchi·e

Membre depuis 8 ans

Sujet de la discussion Posté le 16/03/2019 à 10:50:40

Bonjour,

Je me suis mis à doubler mes guitares (prises différentes d’une même partition, je précise) pour leur donner plus d’ampleur stéréo. De nombreuses personnes préconisent de les balancer 100 % à gauche et à droite pour un effet maximum. Ça marche très bien quand on écoute en stéréo, que ce soit sur enceintes ou sur casque. Par contre une fois le mix converti en mono, ça donne des effets de phasing ou de chorus qui changent à chaque note. Bref, la tonalité est altérée et c’est assez désagréable.

J’ai essayé plusieurs solutions :

– Ramener la prise 1 plus proche du centre, 25 % à gauche par exemple. Garder la prise 2 100 % à droite et la descendre de 4–5 dB. Ajouter un delay d’environ 15–25 ms (effet Haas) sur cette prise 2, balancé 100 % à gauche à un niveau d’environ 7–8 dB sous la prise originale. La compatibilité mono est très bonne mais le son est quand même moins spatial.

– Utiliser un égaliseur mid/side sur le groupe pour monter de 4–5 dB la partie mid et baisser de 6 dB la partie side, les deux sur une bande relativement large centrée sur 1,5 kHz. L’effet est intéressant mais altère un peu le timbre en stéréo.

– Éditer toute les notes de la prise 2 pour qu’elles soient en phase avec la prise 1, sans être nécessairement strictement synchronisées. Bref, le décalage entre les deux prises pour chaque note sera toujours un multiple de la période de la fondamentale. Ça marche relativement bien pour les notes simples, moins pour les accords. La compatiblité mono est excellente mais l’effet de spatialisation est plus aléatoire, et surtout c’est un boulot monstre.

Et vous, vous faites comment pour traiter ce problème sur vos doublage ?

Afficher le sujet de la discussion

LD55

491

Posteur·euse AFfamé·e

Membre depuis 9 ans

11 Posté le 27/03/2019 à 20:44:27

J'avais déjà essayé ça :

Les deux pistes de guitares sont pannées l'une 100% à gauche, l'autre 100% à droite.

Toutes deux sont aussi routées vers un bus mono bien compressé et creusé à l'EQ vers les 800hz (ou autre selon le goût et le son de basse). On monte le volume du bus jusqu'à satisfation.

Une sorte de compression parallèle mono des guitares, ça peut plaire... ou pas.

Firesledge

Posteur·euse AFfranchi·e

Membre depuis 8 ans

12 Posté le 26/03/2023 à 17:54:47

Je déterre mon propre sujet… Finalement j’ai conservé la première méthode que je proposais dans mon message initial, c’est ce qui me donne le meilleur compromis quelle que soit la méthode d’enregistrement. J’ai fait un JSFX pour Reaper de façon à avoir immédiatement le traitement des prises sans avoir à ressortir plein de plug-ins. Il suffit de mettre le JSFX suivant sur une piste répertoire, et mettre les deux pistes de guitare dans ledit répertoire, pannées 100 % à gauche et à droite.


/*****************************************************************************

    Double track stereo fix
    Author: Laurent de Soras, 2023

Production tool to make a double hard-panned track more "mono-compatible"
while keeping a decent spatialisation.

Typical use case: two takes of the same guitar part, simultaneously played.
Even when using different sound settings, mixing them together the naive way
will bring an unwanted phasing effect.

The left ("main") input channel is panned closer to the center, keeping the
right one ("aux") hard-panned but with a reduced gain and a Haas delay effect
on the opposite output channel. Therefore when converted to mono, the main
channel has more weight than the aux and interferences are reduced (frequency
cancellations or build-up), preserving the overall tone.

The delay output is filterd to remove superfluous infomation: low-cut at
150 Hz, high-cut at 10 kHz and slight dip at 3 kHz.

Instructions: create a folder track with two subtracks for the sources.
Pan them hard to left and right. Insert this effect on the folder track.

Channels     : stereo in - stereo out
Compatibility: Reaper 5.0+

Parameters:

* Spread
Selects what to do with the input channels
-200 %: hard pan, main -> L and aux -> R
-100 %: mono-compatible spatial mode
   0 %: pure mono, main and aux are mixed at -6 dB.
+100 %: mono-compatible spatial mode, inverted
+200 %: hard pan, main -> R and aux -> L

* Main pan
Indicates how the main channel is panned (in % towards L or R ) when Spread is
in mono-compatible mode.

* Aux level
Level of the aux channel when Spread is in mono-compatible mode.

* Haas level
Level of the Haas effect applied to the aux channel when Spread is in mono-
compatible mode. The value is relative to the aux level.

* Haas delay
Time of the delay applied to the aux on its opposite channel.

* Main input
Indicates if the main channel is taken from the left input channel (normal
operations) or from the right one (swapped input).

Note: parameters are intended to be static, no effort have been made to make
them click-free during an automation.

--- Legal ---

This program is free software. It comes without any warranty, to
the extent permitted by applicable law. You can redistribute it
and/or modify it under the terms of the Do What The Fuck You Want
To Public License, Version 2, as published by Sam Hocevar. See
[url]http://www.wtfpl.net/[/url] for more details.

*****************************************************************************/



desc:Double track stereo fix
tags:Stereo

slider1:spread_pc=-100<-200,200,5>Spread (%)
slider2:main_pan_pc=25<0,50,1>Main pan (%)
slider3:aux_db=-4<-12,0,0.2>Aux level (dB)
slider4:haas_db=-6<-20,0,0.5>Haas level (dB)
slider5:haas_ms=20<1,30,0.5>Haas delay (ms)
slider6:inv_in=0<0,1,1{L,R}>Main input

in_pin:main input
in_pin:aux input
out_pin:left output
out_pin:right output



@init

// -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
// Constants

// Utility values
sqrt_0_5   = 0.7071067811865475244; // sqrt (0.5)
db2exp     = 0.1151292546497022842; // ln (10) / 20

// Maximum delay time, ms. Must be >= max slider value
dly_max_ms = 30;

// Linear gain for each source in the pure mono mode. 0.5 = -6 dB
mono_lvl   = 0.5;



// -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
// Functions

function round (x) ( floor (x + 0.5); );

function lerp (a0, a1, x) ( a0 + (a1 - a0) * x; );

/*
Reference: Andrew Simper,
Linear Trapezoidal State Variable Filter (SVF) in state increment form:
state += val, 2014-06-07, updated 2014-07-03,
[url]http://www.cytomic.com/technical-papers[/url]
*/

function svf_set_g_coefs (k w) local (s1 s2 nrm)
(
    s1       = sin (    w);
    s2       = sin (2 * w);
    nrm      = 1 / (2 + k * s2);
    this.g0  =                     s2  * nrm;
    this.g1  = (-2 * s1 * s1 - k * s2) * nrm;
    this.g2  =   2 * s1 * s1           * nrm;
);

function svf_set_f0q (f0 fs q)
(
    this.svf_set_g_coefs (1 / q, $pi * f0 / fs);
);

function svf_setup_lpf_flat (f0 fs)
(
    // Butterworth: q = sqrt(1/2)
    this.svf_set_f0q (f0, fs, sqrt_0_5);
    this.v0m = 0;
    this.v1m = 0;
    this.v2m = 1;
);

function svf_setup_hpf_flat (f0 fs)
(
    // Butterworth: q = sqrt(1/2)
    this.svf_set_f0q (f0, fs, sqrt_0_5);
    this.v0m =  1;
    this.v1m = -1 / sqrt_0_5;
    this.v2m = -1;
);

function svf_setup_bell (f0 fs q lvl)
(
    this.svf_set_f0q (f0, fs, q);
    this.v0m = 1;
    this.v1m = (lvl - 1) / q;
    this.v2m = 0;
);

// v0 = input
function svf_process (v0) local (t0 t1 t2 v1 v2)
(
    t0         = v0 - this.ic2eq;
    t1         = this.g0 * t0 + this.g1 * this.ic1eq;
    t2         = this.g2 * t0 + this.g0 * this.ic1eq;
    v1         = t1 + this.ic1eq;
    v2         = t2 + this.ic2eq;
    this.ic1eq = 2 * t1 + this.ic1eq;
    this.ic2eq = 2 * t2 + this.ic2eq;

    v0 * this.v0m + v1 * this.v1m + v2 * this.v2m;
);



// -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -  -
// Init code

dly_pos_w = 0;
// +1 ms to make sure we won't overwrite the data to be read in the circular
// buffer during delay processing, even if the delay is 0.
dly_len   = round (srate * (dly_max_ms + 1) * 0.001);
freembuf (dly_len);

dly_eq_hpf.svf_setup_hpf_flat (  150, srate);
dly_eq_lpf.svf_setup_lpf_flat (10000, srate);
dly_eq_dip.svf_setup_bell (3000, srate, sqrt_0_5, sqrt_0_5);

// +100 ms for the filter tail
ext_tail_size = round (srate * (dly_max_ms + 100) * 0.001);



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

spread     = spread_pc * 0.01;
spread_abs = abs (spread);

aux_db2    = min (2 - spread_abs, 1) * aux_db;
aux_lvl    = exp (aux_db2 * db2exp);

haas_lvl   = exp (haas_db * db2exp);
haas_lvl  *= aux_lvl;
haas_lvl  *= (1 - abs (1 - spread_abs)); // Shape on [-2 ; +2]: /\/\

// The whole stereo field covers 200 %, converted here to a [0 ; 1] range
main_pan_ref = main_pan_pc * 0.005;

// Range [0 ; 1]
main_pan   =
      (spread < -1) ?     (0.5 - main_pan_ref) * (2 + spread)
    : (spread >  1) ? 1 - (0.5 - main_pan_ref) * (2 - spread)
    :                      0.5 + main_pan_ref  *      spread;

// Simple pan law with -3 dB crossover
main_lvl_l = cos ($pi * 0.5 * main_pan);
main_lvl_r = sin ($pi * 0.5 * main_pan);

// Hard pan Aux and Haas signals depending on the spread sign
spread_pos = (spread > 0) ? 1 : 0;
spread_neg = (spread < 0) ? 1 : 0;
aux_lvl_l  = aux_lvl  * spread_pos;
aux_lvl_r  = aux_lvl  * spread_neg;
haas_lvl_l = haas_lvl * spread_neg;
haas_lvl_r = haas_lvl * spread_pos;

// Crossfading to pure mono when spread is in the +/-100 % range
mono_lerp  = min (spread_abs, 1);
main_lvl_l = lerp (mono_lvl, main_lvl_l, mono_lerp);
main_lvl_r = lerp (mono_lvl, main_lvl_r, mono_lerp);

// Slightly closer to equal-power mix. Ideal formula: 1 - sqrt (1 - m*m)
mono_lerp2 = mono_lerp * mono_lerp;
aux_lvl_l  = lerp (mono_lvl, aux_lvl_l , mono_lerp2);
aux_lvl_r  = lerp (mono_lvl, aux_lvl_r , mono_lerp2);

// Delay time
haas_spl   = round (haas_ms * srate * 0.001);
dly_pos_r  = (dly_pos_w + dly_len - haas_spl) % dly_len;



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

(inv_in != 0) ? (
    val_main = spl1;
    val_aux  = spl0;
) : (
    val_main = spl0;
    val_aux  = spl1;
);

// Delay
dly_pos_w [0] = val_aux;
val_dly = dly_pos_r [0];
(dly_pos_w += 1) >= dly_len ? dly_pos_w = 0;
(dly_pos_r += 1) >= dly_len ? dly_pos_r = 0;

// Delay filtering
val_dly = dly_eq_hpf.svf_process (val_dly);
val_dly = dly_eq_lpf.svf_process (val_dly);
val_dly = dly_eq_dip.svf_process (val_dly);

// Final mix
spl0 = val_main * main_lvl_l + val_aux * aux_lvl_l + val_dly * haas_lvl_l;
spl1 = val_main * main_lvl_r + val_aux * aux_lvl_r + val_dly * haas_lvl_r;



/* EOF **********************************************************************/

[ Dernière édition du message le 26/03/2023 à 17:56:13 ]

< Liste des sujets
Charte

Liste des modérateurs