Document complet en format pdf

École Polytechnique
Université de Montréal
Réalisation d'un processeur audio multi-effets dans l'environnement
“Cubase VST” et sur le DSP56002 de Motorola
Rapport de projet de fin d’études soumis
comme condition partielle à l’obtention du
diplôme de baccalauréat en ingénierie.
Présenté par :
Jasmin Frenette
Matricule :
58475
Directeur de projet : Michel Lemire
Département de Génie Électrique
et de Génie Informatique
Décembre 1998
Réalisation d'un processeur audio multi-effets dans l'environnement
“Cubase VST” et sur le DSP56002 de Motorola
Les nouveaux PCs, de plus en plus performants, remettent en question
l'utilisation de DSPs dédiés pour réaliser des effets audio en temps réel. Dans le cadre
de ce projet, les équations mathématiques des effets les plus répandus en musique
(écho, chorus, flanger, réverbération et compression) ont été développées et implantées
sur un PC (dans l’environnement du logiciel audio «Cubase VST») et sur le DSP56002
de Motorola. Nous avons ainsi pu constater que la plate-forme PC se démarquait par
son interface utilisateur flexible, sa facilité de programmation et sa grande quantité de
mémoire. De plus, il est ressortit que malgré la performance considérable du DSP, sa
mémoire limitée, sa faible résolution interne et son architecture à point fixe rend sa
programmation beaucoup plus complexe. Finalement, la sonorité des effets implantés
s’est avérée excellente sur le PC tout comme sur le DSP.
Mots Clés : processeur – multi-effet – DSP – audio – musique.
ii
TABLE DES MATIÈRES
LISTE DES FIGURES ................................................................................................................................ V
LISTE DES TABLEAUX ............................................................................................................................ V
LISTES DES SYMBOLES ET DES ABRÉVIATIONS .......................................................................... VI
1
INTRODUCTION ................................................................................................................................ 1
2
PROBLÉMATIQUE ............................................................................................................................ 2
3
MÉTHODOLOGIE.............................................................................................................................. 4
3.1 CHOIX DES PLATE-FORMES ET DES LOGICIELS .................................................................... 4
3.2 DESCRIPTION DES PLATE-FORMES ET DES LOGICIELS....................................................... 5
3.3 RÉALISATION DES ALGORITHMES ........................................................................................... 7
4
RÉSULTATS ........................................................................................................................................ 8
4.1 RÉALISATION DE L’ÉCHO ........................................................................................................... 8
4.2 RÉALISATION DU FLANGER ..................................................................................................... 10
4.3 RÉALISATION DU CHORUS ....................................................................................................... 15
4.4 RÉALISATION DE LA RÉVERBÉRATION................................................................................. 22
4.5 RÉALISATION DU COMPRESSEUR........................................................................................... 25
4.6 MODIFICATIONS ET AMÉLIORATIONS POSSIBLES ............................................................. 31
5
DISCUSSION...................................................................................................................................... 33
5.1 QUALITÉ DES ALGORITHMES IMPLANTÉS ........................................................................... 33
5.2 COMPARAISON DES PROBLÈMES DE CONCEPTION SUR PC ET DSP............................... 33
5.3 CARACTÉRISTIQUES DES PLATES-FORMES ......................................................................... 35
CONCLUSION............................................................................................................................................ 38
RÉFÉRENCES............................................................................................................................................ 40
ANNEXE A.................................................................................................................................................. 42
ANNEXE B .................................................................................................................................................. 45
iii
REMERCIEMENTS
J’aimerais exprimer ma reconnaissance à tous ceux qui ont contribué à la
réalisation de ce travail. Plus particulièrement à Mlle Renée Touzin pour son aide dans
le domaine des générateurs de nombres pseudo-aléatoires et à M. Michel Lemire qui a
accepté d’être mon directeur de PFE et qui m’a assisté tout au long du projet.
iv
LISTE DES FIGURES
Fig. 1 – Interface Graphique des plugins dans le logiciel Cubase VST............................. 5
Fig. 2 – Modèle de l’effet d’écho ....................................................................................... 8
Fig. 3 – Comportement temporel du flanger.................................................................... 10
Fig. 4 – Modèle du Flanger ............................................................................................. 11
Fig. 5 – Diagramme de l’oscillateur numérique ............................................................... 12
Fig. 6 – Listing et simulation Matlab de l’oscillateur du DSP ........................................... 14
Fig. 7 – Comportement temporel du chorus .................................................................... 15
Fig. 8 – Modèle du chorus ............................................................................................... 16
Fig. 9 – Filtrage de la séquence pseudo-aléatoire sur le PC........................................... 18
Fig. 10 – Séquence pseudo-aléatoire sur le PC.............................................................. 19
Fig. 11 – Comportement temporel des quatre séquences pseudo-aléatoires sur le PC . 19
Fig. 12 – Séquences pseudo-aléatoires sur le DSP........................................................ 21
Fig. 13 – Modèle de la réverbération............................................................................... 22
Fig. 14 – Modèle détaillé des «all pass reverbs» ............................................................ 23
Fig. 15 – Modèle détaillé des «comb filters» ................................................................... 23
Fig. 16 – Modèle du compresseur ................................................................................... 25
Fig. 17 – Modèle détaillé du «offset filter»....................................................................... 26
Fig. 18 – Modèle détaillé du «release stage».................................................................. 27
Fig. 19 – Modèle détaillé du «loop filter»......................................................................... 28
Fig. 20 – Comportement du «loop filter» ......................................................................... 28
Fig. 21 – Paramètres du compresseur ............................................................................ 29
LISTE DES TABLEAUX
Tableau 1 - Paramètres du Flanger................................................................................. 10
Tableau 2 - Paramètres du Chorus ................................................................................. 15
Tableau 3 - Paramètres de la réverbération.................................................................... 24
Tableau 4 - Paramètres du compresseur ........................................................................ 29
v
LISTES DES SYMBOLES ET DES ABRÉVIATIONS
AES
Audio Engineering Society
CPU
Central Processing Unit
DSP
Digital Signal Processing (désigne aussi «Digital Signal Processor»)
FIFO
First In First Out
MAC
Multiply Accumulate (instruction standard d’un DSP)
MIPS
Million Instructions Per Second
ROM
Read Only Memory
SRAM
Static Random Acces Memory
LFO
Low Frequency Oscillator
RNG
Random Number Generator
vi
1 INTRODUCTION
Les nouveaux PCs, de plus en plus performants, remettent en question
l'utilisation de DSPs dédiés pour réaliser des effets audio en temps réel. C’est pourquoi
on voit apparaître sur le marché de plus en plus de logiciels destinés à faire le même
traitement audio que les appareils «hardware» traditionnels. Ainsi, ces derniers devront
miser sur leurs avantages sur les logiciels et réorienter leur marché s’ils veulent rivaliser
avec les performances et les coûts des nouveaux processeurs virtuels qui font leur
apparition dans le monde des PC.
Dans le cadre de ce projet, afin de mieux caractériser les plates-formes
logicielles et matérielles, nous nous proposons de réaliser plusieurs effets audio
traditionnels. Ces effets seront réalisés à la fois sur un PC et sur un DSP, ce qui nous
permettra de mettre en évidence les qualités de chacune de ces plates-formes.
Les
algorithmes
utilisés
seront
élaborés
à
partir
des
descriptions
comportementales des effets audio traditionnels. Les effets réalisés seront l’écho, le
flanger, le chorus, la réverbération et la compression.
Tout au long de ce projet, nous ferons état des difficultés ou particularités de
conception afin de dresser un portrait révélateur des plates-formes évaluées. Nous
pourrons donc les comparer et porter un jugement sur leur puissance, leur flexibilité, la
qualité de leur traitement audio et leur facilité d’utilisation et de programmation.
1
2 PROBLÉMATIQUE
La plupart des effets audio numériques actuels sont inspirés des effets
électroniques, acoustiques où mécaniques traditionnels.
Avant l’avènement de la
numérisation, les effets à base de délai (écho, chorus, flanger, etc.) étaient réalisés à
l’aide d’enregistreurs à ruban. Les réverbérations étaient réalisées à partir de ressorts
ou alors simulées en enregistrant le son provenant de haut-parleurs dans une salle
possédant de bonnes qualités acoustiques.
Finalement, d’autres effets comme les
compresseurs étaient réalisés de façon analogique à l’aide de transistors.
Ce n’est que vers la fin des années 50 que les ordinateurs sont devenus assez
puissants pour permettre le traitement de l’audio en un temps relativement acceptable
(mais encore très loin du temps réel). Depuis, les processeurs appelés DSP sont sortit
sur le marché.
Leur langage assembleur optimisé pour le traitement du signal leur
permet de réaliser des effets audio de plus en plus complexes en temps réel. Ainsi, de
nos jours, il est courant d’en retrouver un peu partout, d’autant plus que leur taille permet
leur utilisation dans une vaste gamme d’appareils. Puis les PC actuels sont devenus si
rapides que même s’ils n’ont pas étés conçus pour le traitement du signal, ils sont
maintenant en mesure de rivaliser avec les DSPs. Leur interface graphique conviviale et
leurs environnements de programmation élaborés les rendent très attrayants, tant pour
les programmeurs que pour les utilisateurs.
L’objectif de ce projet est donc de fournir une base de comparaison entre les
environnements de programmation du PC et du DSP pour fournir à l’ingénieur en
traitement de signal l’information nécessaire pour prendre une décision plus éclairée lors
d’un choix de plate-forme de programmation.
Pour ce faire, les caractéristiques
suivantes des deux plates-formes seront observées :
•
la facilité d’utilisation du multi-effet par l’utilisateur ;
•
la flexibilité de l’algorithme : le nombre de paramètres accessibles à l’usagé ;
•
le niveau de complexité de l’algorithme réalisable en temps réel (la puissance et
la rapidité du processeur) ;
2
•
la mémoire disponible ;
•
la qualité du son produit : le nombre de bits des échantillons lors du traitement
interne et la fréquence d’échantillonnage ;
•
le temps de développement d’un effet selon sa complexité ;
•
le temps d’apprentissage de l’environnement de programmation ;
•
la puissance de l’environnement de programmation.
Afin de bien évaluer toutes ces caractéristiques, tous les effets réalisés seront
implantés sur les deux plates-formes. De plus, des effets audio simples et complexes
seront réalisés, ce qui permettra de distinguer les avantages des plates-formes selon la
complexité de l’algorithme à implanter.
3
3 MÉTHODOLOGIE
3.1
3.1.1
CHOIX DES PLATE-FORMES ET DES LOGICIELS
Choix du logiciel sur le PC
Le traitement de l’audio sur Mac ou PC, il n’y a pas si longtemps réservé aux
studios d’enregistrement et aux salles de montage vidéo professionnelles, est
maintenant beaucoup plus abordable et donc accessible aux particuliers qui
s’intéressent à la musique. Bien que la plupart des programmes professionnels (Pro
Tools, Soundscape, PARIS, etc.) nécessitent un ajout matériel à l’ordinateur afin de le
rendre plus performant, les nouveaux logiciels destinés aux particuliers ou aux petits
studios (Sound Forge, Cakewalk, Emagic Logic Audio, etc.) exploitent la vitesse des
nouveaux CPUs pour réaliser le traitement audio en temps réel. La plupart de ces
logiciels supportent les «plugins». Un plugin est un petit logiciel qui vient complémenter
un programme d’enregistrement ou de traitement audio en lui offrant une fonctionnalité
supplémentaire. La plupart des plugins sont des effets audio (réverbération, égalisation
graphique, distorsion, etc.) que l’usager peut acheter après s’être procuré le programme
audio principal de son choix.
Pour la réalisation du projet sur PC, le logiciel Cubase VST de la compagnie
Steinberg a été retenu car la méthode de réalisation des plugins qu’il supporte est
accessible gratuitement et est très bien documentée [19]. De plus, les plugins VST sont
de plus en plus reconnus par les logiciels audio sur PC.
3.1.2
Choix du DSP
Par ailleurs, pour le traitement audio à l’aide d’un DSP, plusieurs compagnies
offrent des solutions abordables (Analog Devices, AT&T, Motorola, NEC, Texas
Instruments, Zoran, etc.). Les vitesses de leurs DSPs en juin 1995 se situaient entre 8.8
et 70 MIPS et leur prix, entre 6$ et 450$ (pour une commande de 1000 pièces) [10].
Certains modèles (avec arithmétique à point fixe) représentent les échantillons audio par
des entiers ou des fractions entre –1.0 et 1.0 alors que d’autres (à points flottants) les
4
représentent à l’aide d’une mantisse suivit d’un exposant. Notons que dans le premier
cas, il est aussi possible (bien que coûteux en temps de calcul) de simuler l’arithmétique
flottante lorsque nécessaire.
Dans le cadre de ce projet, le DSP56002 de Motorola a été choisi car il est assez
puissant pour effectuer les effets audio envisagés et relativement peu dispendieux. De
plus, un module d’évaluation et les outils de développement du DSP sont disponibles à
prix raisonnable.
3.2
3.2.1
DESCRIPTION DES PLATE-FORMES ET DES LOGICIELS
Caractéristiques du logiciel Cubase VST et du PC
Le logiciel Cubase offre une interface graphique standard pour les plugins qui a
l’apparence des processeurs audio «hardware» traditionnels (voir fig.1), ce qui permet
de sauver du temps lors de la programmation de l’interface usagé. Le langage utilisé
pour la programmation des plugins est le C++ (bien qu’il y ait aussi moyen d’utiliser le C)
car le logiciel Cubase a été réalisé en C++. Les échanges entre les plugins et Cubase
se font aisément à l’aide de fonctions définies de façon très précise dans le guide de
programmation des développeurs fournis par Steinberg [19]. Tous les échantillons audio
sont codés sur 16 bits, mais ils sont convertis en nombres à point flottant de 32 ou de 64
bits (floats ou doubles) pour tous les calculs internes. Notons aussi que la mémoire
utilisée par les plugins est une partie de celle réservée par Windows à l’application
Cubase.
Fig. 1 – Interface graphique des plugins dans le logiciel Cubase VST
Pour le projet, la programmation C++ se fera avec le compilateur Visual C++ 5.
Le logiciel Cubase VST (version 3.553) roule sur Windows 95 sur un Pentium II 266MHz
5
avec 64 Mb de RAM et disque dur Quantum «Vicking II». L’interface audio est «Layla»
de Event Electronics (convertisseurs A/N et N/A 20 bits à 44.1kHz).
3.2.2
Caractéristiques du module d’évaluation du DSP56002
Le module d’évaluation du DSP56002 n’offre aucune interface à l’utilisateur.
Pour chaque effet, le développeur doit programmer le code en assembleur DSP à l’aide
de logiciels de développement sur PC, compiler le code et envoyer le fichier compilé
dans le DSP du module d’évaluation par l’intermédiaire du port série de l’ordinateur. En
plus du DSP, le module d’évaluation comprend 32k de mémoire SRAM à mots de 24
bits, des convertisseurs N/A et A/N 16 bits à 48kHz et une interface RS-232. Ainsi, les
échantillons audio entrent et sortent du DSP en format 16 bits et sont traités de façon
interne en format 24 bits (ou exceptionnellement en format 48 bits).
Le DSP est cadencé à 40 MHz (20 MIPS) et utilise l’arithmétique à point fixe sur
mots de 24 bits. Comme la plupart des DSP, il possède des instructions très rapides
propres au traitement des signaux numériques comme MAC (et MACR) qui consistent
en une multiplication suivie d’une addition (et possiblement d’un arrondissement). Il
possède aussi une architecture qui lui permet de faire simultanément une opération ALU
et deux accès mémoire. Finalement, il est possible d’effectuer des boucles de façon
«hardware». Lors de l’utilisation des boucles appelées «hardware modulo loop», il n’y a
aucun délai entre l’exécution de la dernière instruction de la boucle et l’exécution de la
première instruction grâce à une vérification automatique de façon matérielle à chaque
itération de la boucle.
Bien que les logiciels de développement permettent la programmation en C et en
assembleur, c’est la programmation en assembleur qui a été retenue dans le cadre de
ce projet pour des raisons de performance.
6
3.3
RÉALISATION DES ALGORITHMES
Les algorithmes choisis (écho, flanger, chorus, réverbération et compression)
seront élaborés à partir de la documentation disponible dans les livres d’audio et dans
les manuels des appareils multi-effets et des logiciels professionnels [18].
Plus
particulièrement, l’algorithme de chorus est inspiré du livre de Alan V. Oppenheim [13] et
l’algorithme de compression est tiré d’un article de Mix Magazine [21] et de l’article de
Stikvoort publié dans le journal de l’Audio Engineering Society [20].
Finalement,
l’algorithme de réverbération est fondé sur les travaux de Schroeder [16] [17] et de
James Moorer [11] et sur les exemples d’applications de Motorola [15].
Des modèles mathématiques seront proposés à partir du comportement désiré
des effets audio ou à partir des modèles décris dans la documentation. Nous dériverons
ensuite les algorithmes décrivant ces modèles pour finalement les implanter dans
Cubase et sur le DSP. Dans la mesure du possible, afin de comparer ces deux platesformes, le même algorithme sera utilisé pour chaque effet sur les deux plates-formes.
Cependant, pour profiter des avantages de chacune des plates-formes, l’implantation
finale pourra être différente. Finalement, la fonctionnalité de l’effet et sa sonorité seront
évaluées et des modifications seront apportées au modèle mathématique lorsque
nécessaire.
De plus, dans les cas qui le nécessiteront, des simulations sur Matlab
pourront être réalisées afin de décrire plus en détail où de vérifier le fonctionnement d’un
algorithme.
7
4 RÉSULTATS
4.1
RÉALISATION DE L’ÉCHO
L’écho est un effet à la fois très simple et très efficace. Bien que les délais de
plus de 100 ms soient ceux qu’on distingue le plus facilement, on utilise aussi souvent
des délais inférieurs pour obtenir certains effets. Par exemple, un délai de l’ordre de 60
à 100 ms peut rendre un son beaucoup plus «plein», un délai de 30 à 60 ms peut être
utilisé pour simuler un deuxième instrument et finalement, un délai entre 0 et 30 ms peut
être utilisé pour rendre un son plus «gros».
L’effet désiré doit donc permettre un délai variable (de 0 à quelques secondes)
pour le canal de droite et celui de gauche et un contrôle sur la quantité du signal de
sortie réintroduite dans les lignes de délai. La figure 2 illustre le modèle de l’effet désiré.
IN1
+
Σ
LDelay
+
DEL1
OUT1
LDelayLevel
LFeedBack
+
Σ
RDelay
+
DEL2
OUT2
RDelayLevel
RFeedBack
Fig. 2 – Modèle de l’effet d’écho
Ainsi, pour le canal 1 (canal de gauche), on obtient les équations suivantes :
OUT1(n) = LVolume • DEL1(n)
où
DEL1(n) = IN1(n-LDelay) + LFeedBack • DEL1(n-LDelay)
8
4.1.1
Implantation sur Cubase
On peut facilement implanter cet algorithme sur Cubase en créant deux buffers
sous forme de FIFO pour sauvegarder les valeurs intermédiaires. La taille de l’espace
mémoire nécessaire dépend du temps maximal du délai désiré. Pour la plupart des
situations, un délai de 4 secondes est plus que suffisant et demande une quantité de
mémoire raisonnable (4 s • 4 Octets/éch. • 44100 éch./s ≈ 689 kOctets).
Nous remarquons cependant que l’utilisation de buffers nous force à faire une
vérification à chaque itération pour s’assurer que lorsque la fin d’un buffer est atteinte,
nous retournons au début de celui-ci. Par contre, on peut procéder au traitement d’un
ensemble d’échantillons («batch processing») sans faire de vérification si on s’assure au
départ que la limite du buffer ne sera pas atteinte lors du traitement. Pour ce faire, on
doit tout simplement utiliser un indice pour savoir combien d’éléments on peut traiter
avant d’atteindre la fin du buffer.
Avec cette façon de procéder, on sauve une
vérification à chaque itération lors du traitement du groupe d’échantillons.
4.1.2
Implantation sur le DSP
Pour implanter un buffer sur le DSP56002, on fait normalement appel aux
«hardware modulo loops» du DSP prévus à cette fin.
Dans ce mode, sept buffers
peuvent être utilisés simultanément. Cependant, plusieurs restrictions s’appliquent à
l’utilisation de ce mode et la mémoire maximum disponible simultanément sur le module
d’évaluation est de 8 kWords (un Word est un échantillon de 24 bits) sur le canal de
gauche et de 16 kWords sur celui de droite, ce qui permet des délais respectifs de :
8192 éch. / (48000 éch./s) ≈ 170 ms à gauche et 341 ms à droite.
La mémoire
disponible sur le module d’évaluation est donc très restreinte par rapport à la mémoire
disponible sur le PC. Remarquons que si le module d’évaluation avait comporté plus de
mémoire, les «hardware modulo loops» auraient pu offrir le double de ces délais soit 341
ms à gauche et 682 ms à droite. Malheureusement, on constate que même avec plus
de mémoire externe et une gestion de la mémoire manuelle, des délais de plusieurs
secondes par canal sont irréalisables.
9
4.2
RÉALISATION DU FLANGER
Le flanger est un effet utilisé à l’occasion pour rehausser certains sons,
particulièrement les sons des guitares. Pour ce faire, on combine le son original avec le
son retardé d’un délai variable. En pratique, on utilise un oscillateur à basse fréquence
pour faire varier le délai. On crée ainsi un filtre très riche qui balaye constament les
fréquences. De plus, pour un effet stéréo, on utilise deux canaux dont les oscillateurs
sont déphasés de 180 degrés.
Pour avoir plein contrôle sur les paramètres de l’effet, l’usager doit être en
mesure de contrôler la fréquence et la profondeur du balayage («ModFreq» et
«ModDepth»), le temps moyen de délai (ModDelayTime) et la quantité de feedback.
Amplitude
Signal
direct
ModDepth
L
R
temps
Fig. 3 – Comportement temporel du flanger
Paramètres
Valeurs limites
ModFreq
0.1 – 5 Hz
ModDelayTime
0.1 – 50 ms
ModDepth
0.1 – 5 ms
si ModDelayTime > 5ms
0.1 – ModDelayTime
si ModDelayTime ≤ 5ms
FeedBack
0
– 100 %
Tableau 1 - Paramètres du Flanger
10
Voici le modèle permettant d’obtenir cet effet de flange.
IN1
+
_
Σ
LDelay
OUT1
Osc
FeedBack
+
_
Σ
RDelay
OUT2
Osc
+180°
FeedBack
Fig. 4 – Modèle du Flanger
Ainsi, pour le canal 1 (canal de gauche), on obtient les équations suivantes :
OUT1(n) = IN1( n-LDelay(n) ) + LFeedBack • OUT1( n-LDelay(n) )
avec LDelay(n) = ModDelayTime + ModDepth • cos(Ω0 n)
où
Ω0 = 2π • ModFreq • n • Ts
dans lesquelles Ts est la période d’échantillonnage.
Bien que la valeur du cosinus puisse être obtenue à chaque itération par l’appel
d’une fonction standard du langage C (sur le PC) où par l’utilisation de tables (présentes
sous forme de ROM dans le DSP), nous utiliserons plutôt la transformé en z pour
réaliser un oscillateur numérique très simple :
Trans. en z de [cos(Ω0n) • u(n)]
d’où
=
1 – cos(Ω0) z-1 _
1 – 2 cos(Ω0) z-1 + z-2
y(n) = 2cos(Ω0) • y(n-1) – y(n-2) + x(n) – cos(Ω0) • x(n-1)
11
y(n)
x(n)
Σ
z-1
- cos(Ω0)
z-1
2cos(Ω0)
z-1
-1
Fig. 5 – Diagramme de l’oscillateur numérique
Sur le PC tout comme sur le DSP, seulement 2 espaces mémoire, un coefficient
(cos Ω0) et quelques opérations sont nécessaires pour implanter l’oscillateur. Notons
aussi que la fonction cos() ne peut être appelée sur un DSP, mais qu’on peut obtenir le
coefficient cos(Ω0) à l’aide des fonctions du compilateur. Nous verrons les autres détails
d’implantation particuliers au DSP un peu plus loin.
4.2.1
Implantation sur Cubase
L’implantation de cet algorithme est semblable à celui de l’écho.
La seule
différence est le fait que le temps de délai soit variable. On utilise donc un oscillateur à
basse fréquence (LFO) pour faire varier la position réelle de sortie des buffers autour de
la position moyenne de sortie.
Pour pouvoir continuer à faire du «batch processing» tel qu’utilisé dans
l’algorithme de l’écho, nous devons déterminer le nombre d’échantillons traitables sans
que les limites des buffers ne soient atteintes. Seulement, puisque la position de sortie
réelle des buffers varie à chaque itération, nous ne pouvons faire systématiquement
appel à du «batch processing». Dans certains cas critiques, par exemple lorsque la
position de sortie moyenne du buffer est très près de la fin du buffer, la position réelle de
sortie peut être soit elle aussi près de la fin ou encore près du début, tout dépendant de
la valeur du LFO à cet instant. Nous devons donc, dans les cas comme celui-ci, faire
une vérification des limites à chaque itération. Nous nous retrouvons donc avec deux
algorithmes semblables : le premier est en mesure de traiter un groupe d’échantillons, et
12
le second s’occupe des cas limite en traitant les échantillons un à un. Afin de recourir à
l’algorithme de «batch processing» le plus souvent possible, on prendra des buffers
relativement gros (de l’ordre de quelques secondes) : ainsi les cas limites se
présenteront beaucoup moins souvent.
Quant à l’implémentation de l’oscillateur numérique, notons que les registres
temporaires mémorisant les valeurs du LFO doivent être sauvegardés avec toute la
précision possible car pour des fréquences très basses, les calculs sont très sensibles à
la précision des valeurs intermédiaires. Par exemple, pour une fréquence de 2 Hz, on
remarque qu’après seulement 10 itérations, on obtient une erreur de l’ordre de 2
•
10-6
entre une implantation avec valeurs intermédiaires codées sur 32 bits (float) et une autre
avec valeurs intermédiaires codées sur 64 bits (double). Pour des fréquences inférieures
à 0.17 Hz, un algorithme avec valeurs intermédiaires de 32 bits est même complètement
inopérant. Par ailleurs, on se doit de réinitialiser les buffers de l’oscillateur à chaque
changement de fréquence pour éviter qu’il devienne instable.
4.2.2
Implantation sur le DSP
On peut implanter le Flanger sur le DSP de façon similaire à l’effet d’écho.
L’implantation des délais variables demeure très simple car les «hardware modulo
loops» s’occupent encore une fois de vérifier les limites à chaque itération.
Comme mentionné plus haut, la précision nécessaire au fonctionnement du LFO
n’est pas suffisante avec les mots standards du DSP de 24 bits. On doit donc utiliser
des algorithmes plus complexes qui simulent des opérations en double précision (48
bits). Bien sur, toutes les valeurs intermédiaires sont aussi sauvegardées en double
précision.
Un autre détail est essentiel au fonctionnement de l’oscillateur : toutes les valeurs
intermédiaires doivent être comprises dans l’interval [-1, 1[ . On doit donc recourir à
plusieurs mise à l’échelle selon la grandeur des résultats intermédiaires. Dans le cas de
l’oscillateur, une atténuation de 2-16 est suffisante pour des fréquences d’oscillation
13
supérieures à 0.117 Hz. La figure 5 illustre le modèle Matlab de l’algorithme utilisé pour
réaliser le LFO sur le DSP :
%----------------------------------------------------% Simulation d'un oscillateur optimisé pour DSP
%----------------------------------------------------freq = 3;
att = 2^-16;
Fs = 48000;
oscBuffer1 = 0;
oscBuffer2 = 1 * att;
%
%
%
%
"freq" doit être supérieur à 0.117 Hz pour que le
facteur d'atténuation (2-16) soit suffisant
Facteur d'att. pour que "bn" soit entre -1 et 1
Fréquence d’échantillonnage
% Valeur initiale réduite
cosw = cos(2*pi*freq / Fs);
% Constante
simTime = 48000;
bn = zeros(1,simTime);
output = zeros(1,simTime);
% Temps de simulation
for i=1:simTime
bn(i) = 2 * cosw * oscBuffer2 - oscBuffer1;
output(i) = (bn(i) - cosw * oscBuffer2) / att; % Sortie (entre -1 et 1)
oscBuffer1 = oscBuffer2;
oscBuffer2 = bn(i);
end
Fig. 6 – Listing et simulation Matlab de l’oscillateur du DSP
14
4.3
RÉALISATION DU CHORUS
Le chorus est un effet qui permet de transformer un soliste en un chœur de
plusieurs musiciens. On réussit à simuler ce chœur en reproduisant le son direct quatre
fois, avec un délai différent pour chaque canal.
Ainsi, on a l’impression que cinq
instruments (en incluant le son direct) jouent en même temps. Pour plus de réalisme, les
délais varient dans le temps aléatoirement. De plus, pour simuler différent vibratos, on
module l’amplitude de chaque signal à l’aide d’un LFO. Finalement, pour obtenir un effet
stéréo, on envoi deux des canaux à gauche et les deux autres à droite.
De la même façon que pour le flanger, l’usager a plein contrôle sur la profondeur
des différents délais («ModDepth»), le temps moyen de délai (ModDelayTime) et la
quantité de feedback. Il peut aussi modifier la fréquence et l’amplitude de la modulation
AM («ModFreq» et «AMDepth»).
Amplitude
Signal
direct
ModDepth
L
R
AMDepth
temps
Fig. 7 – Comportement temporel du chorus
Paramètres
Valeurs limites
ModFreq
0.1 – 5 Hz
ModDelayTime
0.1 – 50 ms
ModDepth
0.1 – 5 ms
si ModDelayTime > 5ms
0.1 – ModDelayTime
si ModDelayTime ≤ 5ms
AMDepth
0 – 30 %
FeedBack
0 – 100 %
Tableau 2 - Paramètres du Chorus
15
Voici le modèle permettant d’obtenir cet effet de chorus.
IN1
+
Σ
+
Delay1
Del1
Ch1
Σ
OUT1
Σ
OUT2
RNG1
Osc
FeedBack
+
Σ
+
Delay2
Del2
RNG2
Osc
+ 90°
FeedBack
+
Σ
+
Delay3
Del3
Σ
+
Ch3
RNG3
Osc
+180°
FeedBack
+
Ch2
Delay4
Del4
Ch4
RNG4
FeedBack
Osc
+270°
Fig. 8 – Modèle du chorus
Ainsi, pour le canal 1 (canal de gauche), on obtient les équations suivantes :
OUT1(n) = Ch1(n) + Ch2(n)
avec Ch1(n) = [0.7 + 0.3 AMDepth • Cos(Ω0n)] • Del1(n)
où Ω0 = 2π • ModFreq • n • Ts
dans lequel Del1(n) = IN1(n-LDelay) + LFeedBack • Del1(n-LDelay)
où LDelay(n) = ModDelayTime + ModDepth • RNG1(n)
dans lesquelles Ts est la période d’échantillonnage et RNG est un générateur de
nombres pseudo-aléatoires.
16
La
modulation
d’amplitude
peut
être
réalisée
à
l’aide
de
deux
oscillateurs déphasés de 90° : le cosinus (pour «Osc» et «Osc+180°») est obtenu de la
même façon que pour le flanger et le sinus (pour «Osc+90°» et «Osc+270°») est obtenu
à l’aide des équations suivantes :
Trans. en z de [sin(Ω0n) • u(n)]
d’où
=
1 – sin(Ω0) z-1 _
1 – 2 cos(Ω0) z-1 + z-2
y(n) = 2cos(Ω0) • y(n-1) – y(n-2) + x(n) – sin(Ω0) • x(n-1)
Maintenant, la réalisation du RNG est un peu plus délicate. On recherche une
séquence de nombre dont la variation est surtout située de 0 à 5 Hz. Pour ce faire, nous
devons réaliser un générateur de nombres entre –1 et 1 que nous devons ensuite
passer dans un filtre passe-bas. Voici en premier lieu l’algorithme du RNG :
RNG(n) = [ 209 • RNG(n-1) ] % 4093
dans lequel le symbole % signifie modulo. On obtient ainsi une séquence de nombres
entre 1 et 4092 tel que chaque nombre n’est produit qu’une seule fois. On peut ensuite
mettre la sortie à l’échelle pour obtenir des valeurs dans l’intervalle [-1, 1] et filtrer ces
valeurs dans un filtre passe-bas pour limiter les variations trop brusques.
4.3.1
Implantation sur Cubase
L’implantation de cet algorithme sur PC est semblable au flanger en ce qui
concerne les oscillateurs et les lignes de délai. Cependant, la réalisation du générateur
pseudo-aléatoire est un peu plus délicate. Des simulations sur Matlab ont montré que le
générateur, utilisé tel quel, ne contenait pas assez d’information en basses fréquences :
il n’en résultait qu’une sinusoïde à la sortie du filtre passe-bas.
Par contre, en
échantillonnant les valeurs du RNG à toutes les N itérations et en insérant des ‘0’ à
toutes les autres, on peut enrichir le contenu à basse fréquence du générateur. La
valeur N=100 a été retenue par essais successifs.
Pour obtenir une coupure assez abrupte à basse fréquence, nous avons choisi
un filtre IIR Chebichev (type 1) d’ordre 4 avec 0.5 dB de ripple et fréquence de coupure à
17
2Hz.
De plus, le faible gain à la sortie du filtre a été compensé en augmentant
sensiblement les coefficients du filtre (au numérateur).
La première tentative
d’implémentation était instable et les espaces mémoire temporaires à 32 bits en étaient
la cause. C’est en grande partie la fréquence de coupure très basse qui rend le filtre IIR
plus susceptible de devenir instable.
Nous avons donc utilisé des «double» comme
espaces mémoires et le filtre s’est stabilisé.
Fig. 9 – Filtrage de la séquence pseudo-aléatoire sur le PC
18
Fig. 10 – Séquence pseudo-aléatoire sur le PC
Finalement, pour générer quatre séquences pseudo-aléatoires subjectivement
différentes, nous avons utilisé des nombres de départ différents (1, 3, 60 et 61). Nous
avons donc quatre fois la même séquence, mais décalée dans le temps. La figure
suivante illustre les séquences résultantes.
Fig. 11 – Comportement temporel des quatre séquences pseudo-aléatoires sur le PC
19
4.3.2
Implantation sur le DSP
Un détail nous empêche cependant de porter cet algorithme sur le DSP. Si on
observe les coefficients du filtre Chébichev nécessaire au filtrage du bruit aléatoire, on
remarque que les plus petit d’entre eux sont de l’ordre de 10-7. Or, pour cet ordre de
grandeur, la précision du DSP (24 bits à point fixe) ne laisse qu’un chiffre significatif…
Même en élaborant un algorithme à double précision (assez coûteux en temps
d’exécution), chaque coefficient disposerait de 8 chiffres significatifs, ce qui risque de ne
pas être suffisant pour maintenir la stabilité du filtre, surtout lorsqu’on considère la
précision requise à son fonctionnement sur le PC.
Afin de pouvoir réaliser un générateur de bruit sur le DSP, nous avons donc
envisager un autre moyen beaucoup plus efficace. En faisant la sommation des valeurs
de trois oscillateurs ayant des fréquences n'ayant aucune relation entière entre elles, on
arrive à générer un signal «quasi-périodique» qui se comporte presque comme un signal
aléatoire. Nous avons donc pris des fréquences de 1 Hz, 21/2 Hz et 31/2 Hz que nous
avons additionnées et soustraites pour générer quatre séquences pseudo-aléatoires. À
l’audition du résultat, des fréquences un peu plus rapides ont finalement été retenues
(1.2 Hz, 1.2
•
21/2 Hz et 1.2
•
31/2 Hz).
La figure de la page suivante illustre le
comportement temporel des quatre séquences résultantes.
20
Fig. 12 – Séquences pseudo-aléatoires sur le DSP
a) Osc @ 1.2 Hz + Osc @ 1.2 • 21/2 Hz + Osc @ 1.2 • 31/2 Hz
1/2
1/2
b) Osc @ 1.2 Hz - Osc @ 1.2 • 2 Hz + Osc @ 1.2 • 3 Hz
1/2
1/2
c) - Osc @ 1.2 Hz - Osc @ 1.2 • 2 Hz + Osc @ 1.2 • 3 Hz
1/2
d) - Osc @ 1.2 Hz + Osc @ 1.2 • 2 Hz + Osc @ 1.2 • 31/2 Hz
21
4.4
RÉALISATION DE LA RÉVERBÉRATION
La réalisation d’une réverbération synthétique est l’un des effets les plus
complexes à créer car l’acoustique d’une salle de concert, par exemple, est très difficile
à modéliser. Par contre, avec l’aide de la réverbération artificielle, on peut se permettre
d’enregistrer dans une pièce où l’acoustique est très «sèche» et ensuite ajouter la bonne
dose de réverbération pour créer une sonorité plus riche et plus naturelle.
Dans le cadre de ce projet, nous réaliserons un algorithme de réverbération
artificielle typique d’une salle de concert. Le modèle utilisé est illustré dans la figure
suivante :
Alignment
Delay
CombIn
APOut2
IN1
All Pass
Reverb #2
Pre
Delay
Early
Reflections
Comb Filter #1
Comb Filter #2
Rev1
+
Rev2
+
Σ
OUT1
+
Comb Filter #3
Rev3
+
APIn2
All Pass
Reverb #1
Comb Filter #4
Rev4
+
Σ
OUT2
+
ERef
EarlyRefGain
Fig. 13 – Modèle de la réverbération
Décrivons brièvement le principe de fonctionnement de cet algorithme. On extrait
de l’entrée quelques réflexions primaires (après un très court délai) qu’on envoie dans
deux unités de réverbération en série. Ces unités basées sur un délai très court avec
feedback fournissent une très grande densité d’écho. Ces échos sont ensuite retardés
pour ne pas masquer les réflexions primaires. On envoie ensuite les échos dans quatre
filtres en peigne pour augmenter le temps de réverbération. Finalement, on combine
une partie des réflexions primaires avec les échos résultant pour fournir une sortie
stéréo.
22
Ainsi, pour le canal 1 (canal de gauche), on obtient les équations suivantes :
OUT1(n) = Rev1(n) + Rev2(n) + EarlyRefGain • ERef(n)
CombIn(n) = APOut2(n-AlignmentDelay)
7
ERef(n) =
et
∑
i=1
RefGain i • IN1(n-RefDelay i)
Par ailleurs, les figures 13 et 14 illustrent les modèles utilisés pour réaliser les
«all pass reverbs» et les «comb filters».
–g
+
APIn i
Σ
AP i Delay
+
APDel i
+
Σ
APOut i
1 – g2
+
g
Fig. 14 – Modèle détaillé des «all pass reverbs»
Pour le deuxième «all pass reverb», on obtient donc les équations suivantes :
APOut2(n) = - g • APIn2(n) + (1 - g2) • APDel2(n)
avec
CombIn
APDel2(n) = APIn2(n-AP2Delay) + g • APDel2(n-AP2Delay)
+
Σ
Comb i Delay
Rev i
+
+
g
Σ
1 Sample
Delay
+
LFP i Gain
Fig. 15 – Modèle détaillé des «comb filters»
Ainsi, pour le premier «comb filter», on obtient l’équation suivante :
Rev1(n) = CombIn(n-Comb1Delay)
23
+ g • [Rev1(n-Comb1Delay) + LFP1Gain • Rev1(n-Comb1Delay-1)]
Les paramètres accessibles à l’usager sont décris dans le tableau suivant :
Paramètres
Valeurs limites
Valeurs suggérées
DecayTime
1 ms – 3 sec.
0.6 sec.
PreDelay
0 – 250 ms
50 ms
EarlyRefGain
0 – 100 %
30 %
Comb1Delay
0.1 – 100 ms
46 ms
Comb2Delay
0.1 – 100 ms
56 ms
Comb3Delay
0.1 – 100 ms
66 ms
Comb4Delay
0.1 – 100 ms
72 ms
AP1Delay
0.1 – 20 ms
1.7 ms
AP2Delay
0.1 – 20 ms
5
Alignment Delay
0 – 100 ms
27 ms
ms
Tableau 3 - Paramètres de la réverbération
Notons que :
_–3 • MaxDel_
Fs • DecayTime
g = 10
où MaxDel = max(Comb1Delay, Comb2Delay, Comb3Delay, Comb4Delay)
4.4.1
Implantation
Malgré la complexité de son algorithme, l’implantation de la réverbération sur
Cubase VST n’a pas comporté de difficultés particulières. Quant à l’implantation sur le
DSP, un peu plus d’attention a été portée sur la répartition de l’espace mémoire utilisée
par les lignes de délai. De plus, le DSP ne disposant que de huit «hardware modulo
loops», il a donc fallu les utiliser judicieusement pour rendre l’algorithme à la fois le plus
simple et le plus performant possible.
Finalement, la détermination de valeur des
paramètres offrant une bonne sonorité a été très délicate. Les valeurs retenues sont
présentées dans le tableau 3.
24
4.5
RÉALISATION DU COMPRESSEUR
La compression dynamique est un des effets les plus utiles car il permet un
contrôle automatique du gain. Utilisé autant en radio pour procurer un son très gros et
riche, en télévision pour normaliser les volumes de chaque émission et en studio pour
stabiliser les instruments dont la dynamique nuit à la balance sonore, le compresseur est
un effet très versatile. L’usager doit donc avoir le contrôle sur plusieurs paramètres
critiques au fonctionnement adéquat du compresseur.
Puisque le fonctionnement du compresseur a déjà été décrit dans plusieurs
articles [3] [20] [21], concentrons-nous sur l’algorithme spécifique que nous voulons
implanter. Ainsi, l’usager doit avoir le contrôle sur le seuil (ou «treshold»), la fenêtre
d’évaluation, le temps d’attaque, le temps de relâchement, la quantité de compression et
le gain de sortie. La fenêtre d’évaluation est tout simplement le temps pendant lequel la
valeur moyenne du signal est évaluée. Ainsi, si l’usager choisit la valeur minimale de la
fenêtre d’évaluation, le compresseur réagira à la valeur crête du signal (moyenne d’un
seul échantillon). Le modèle de l’algorithme utilisé est illustré dans la figure 16. Notons
aussi qu’un algorithme stéréo peut être réalisé en appliquant le gain sur les deux canaux
simultanément après avoir passé chacun d’entre eux dans le «offset filter» et dans la
ligne de délai.
IN
Offset
filter
Signal
Delay
OUT
Gain
Level
Detector
Rel.
In
Release
Stage
Rel.
Out
Compression
Caracteristic
OutputGain
Loop
Filter
Fig. 16 – Modèle du compresseur
Le calcul du gain se fait de la façon suivante. Le signal est tout d’abord filtré pour
en éliminer la composante continue car ette dernière pourrait grandement fausser les
calculs subséquents. Le «level detector» est ensuite responsable de calculer la valeur
moyenne ou crête du signal (au choix de l’usager). On passe ensuite cette valeur dans
un circuit de retenu (ou «peak-hold circuit») de façon à ce que l’arrêt de la compression
25
se fasse en douceur. On compare ensuite la valeur résultante avec la valeur du seuil et
on calcul si nécessaire le niveau de compression à appliquer à partir du ratio de
compression demandé. Finalement, on passe la valeur résultante dans un filtre pour
que la compression s’applique en douceur et on module l’amplitude du signal à traiter.
À partir de la figure 16, on obtient l’équation générale suivante :
OUT1(n) = Signal(n-Delay) • Gain(n) • OutputGain
où
Delay = LFGroupDelay • Fs – AttackTime
avec
LFGroupDelay = 35 ms (Voir la description du «loop filter»)
Décrivons maintenant les modules un à la fois.
Commençons par le «offset
filter», un filtre de premier ordre avec fréquence de coupure à 15 Hz :
Signal
IN
z-1
0.99893
Σ
- 0.99893
z-1
0.9978628
Fig. 17 – Modèle détaillé du «offset filter»
On obtient donc l’équation aux différences suivante :
Signal(n) = 0.9978628 • Signal(n-Delay) + 0.99893 • IN1(n) – 0.99893 • IN(n-1)
Ensuite, décrivons le fonctionnement du «level detector» :
N
Rel.In(n) =
∑
Signal(n-i)
i=1
N
où N est déterminé par la grandeur de la fenêtre de détection :
N = DetectionWindow • Fs
26
Puis, voici le «release stage», un circuit de retenue du 3e ordre :
Rel.In
Stg1
1–c
Stg2
Σ
1–c
Stg3
Σ
z-1
z-1
z-1
Rel.Out
c
c
c
Fig. 18 – Modèle détaillé du «release stage»
On obtient les équations aux différences des trois étages :
Rel.Out(n) = Stg3(n-1)
Stg3(n) = max { Rel.In(n) , [c • Stg3(n-1) + (1-c) • Stg2(n)] }
Stg2(n) = max { Rel.In(n) , [c • Stg2(n-1) + (1-c) • stg1(n)] }
Stg1(n) = max { Rel.In(n) , (c • Rel.Out) }
où c = e
-3.25 / (ReleaseTime • Fs)
Vient ensuite le calcul du niveau de compression :
A(n) = (Rel.Out(n)/threshold)
R-1
Ratio
où R = 1/10
Finalement, le «loop filter» qui contribue à ralentir le temps d’attaque est décrit
dans la figure 19. La documentation sur les filtres Butterworth Thomson décrits dans
l’article de Stikvoort [20] n’étant pas disponible lors de la conception du filtre, nous avons
opté pour un filtre IIR Butterworth passe-bas du 4e ordre dont la fréquence de coupure
est fixée à 13 Hz, ce qui correspond à un groupe délai de τ = 35 ms. Malheureusement,
le dépassement de ce filtre est assez élevé (10.8%) alors qu’un filtre Butterworth
Thomson aurait permis un dépassement inférieur à 0.03%.
27
B
A
z-1
5.07207641•10
-7
z-1
1.01441528•10
-6
5.07207641•10
-7
Σ
1.9989081979
Gain
z-1
z-1
5.06817058•10
-7
z-1
z-1
1.01363412•10
-6
5.06817058•10
-7
- 0.98910226760
Σ
z-1
1.9973689077
z-1
- 0.99737093502
Fig. 19 – Modèle détaillé du «loop filter»
Fig. 20 – Comportement du «loop filter»
On obtient donc les équations aux différences suivantes :
Gain(n) = 5.068170576075424 • 10-7 B(n) + 1.013634115215085 • 10-6 B(n-1)
+ 5.068170576075424 • 10-7 B(n-2) + 1.997368907747316 Gain(n-1)
– 0.9973709350155460 Gain(n-2)
B(n) = 5.072076406979474 • 10-7 A(n) + 1.014415281395895 • 10-6 A(n-1)
+ 5.072076406979474 • 10-7 A(n-2) + 1.998908197928963 B(n-1)
– 0.9989102267595256 B(n-2)
28
Les paramètres du compresseur accessibles à l’usager sont énoncés dans le
tableau suivant :
Paramètres
Valeurs limites
Threshold
- inf dB – 0 dB
Ratio
1:1 – 16:1
Detection Window
0.022 – 5 ms
Attack Time
0 – 30 ms
Release Time
0.3 ms – 1 s
Output Gain
- inf dB – +3.5 dB
Tableau 4 - Paramètres du compresseur
Pour illustrer le comportement final du compresseur, une simulation sur Matlab a
été réalisée et les résultats sont illustrés dans la figure 20. Le seuil a été fixé à -3 dB
(0.707), le ratio à 2:1 et la moyenne est faite sur 3 échantillons. Notons aussi que le
groupe délai du «loop filter» a été réduit pour bien démontrer le fonctionnement du
compresseur ; les temps d’attaque et de relâchement sont donc très rapides (autour de
10 ms).
Fig. 21 – Paramètres du compresseur
La partie inférieure de la figure (a) illustre le signal d’entrée et les trois étages du circuit de retenue.
La courbe supérieure est le signal de contrôle du gain. Le seuil de 0.707 est aussi tracé. La figure
(b) illustre le signal d’entrée et le signal de sortie (qui subit un léger délai). On peut observer le
ratio de 2:1 au-dessus du seuil de -3 dB.
29
4.5.1
Implantation
L’implantation du compresseur sur le PC était plus délicate que celle des autres
effets : chacun des modules du compresseur se devait d’être réalisé avec grand soin.
Le premier module, le filtre de tension continue s’est réalisé sans problème. Par contre,
dans le second module, la moyenne des échantillons précédents était tout d’abord faite
en additionnant tous les échantillons, puis en les divisant par le nombre total
d’échantillons. Cette méthode était possible pour une dizaine d’échantillons,
mais
lorsque l’usager demandait une moyenne sur plusieurs centaines d’échantillons,
l’algorithme était beaucoup trop lent. Nous avons donc opté pour la méthode suivante,
qui est beaucoup plus efficace :
Buffer = |x(n)| + Buffer – |x(n – NbÉchantillons)|
y(n) = Buffer / NbÉchantillons
Ainsi, même si on ne peut l’illustrer clairement dans le schéma de la figure 16, la ligne de
délai du signal d’entrée sert aussi au calcul de la moyenne.
Les autres modules se sont réalisés aisément à l’exception du «loop filter».
Notre but initial était de contrôler la fréquence de coupure du filtre – et donc son groupe
délai – simultanément avec le délai du signal d’entrée lors d’une modification par
l’usager du temps d’attaque du compresseur. C’est pourquoi un filtre simple et connu
(Butterworth)
a été choisi de façon à ce que le compresseur soit en mesure de
recalculer les coefficients du «loop filter» en temps réel. Il ne resterait donc plus qu’à
trouver la relation entre le groupe délai τ et la fréquence de coupure du filtre pour rendre
cette option fonctionnelle.
Par ailleurs, le temps de nous a malheureusement pas permis de réaliser
l’implantation du compresseur sur le DSP.
Par contre, encore une fois, nous
remarquons que le filtre Butterworth aurait été difficilement réalisable sur le DSP à cause
de ses coefficients très faibles. Nous aurions cependant pu utiliser un filtre semblable
avec une fréquence de coupure plus élevée (de l’ordre de 100 Hz) donnant lieu à des
temps d’attaque plus rapides (groupe délai de 4.5 ms). Dans ce cas, les coefficients (de
30
l’ordre de 10-3) auraient probablement étés assez élevés. Pour obtenir de plus long
temps d’attaque, il aurait alors fallut compenser en réduisant le délai du signal.
4.6
4.6.1
MODIFICATIONS ET AMÉLIORATIONS POSSIBLES
Écho
Plusieurs modifications pourraient être apportées à l’algorithme de base de
l’écho. Entre autres, le temps de délai pourrait être affiché sous forme de tempo musical
avec choix du nombre d’écho par mesure. De plus, à la place d’envoyer un écho dans le
canal de droite et l’autre dans celui de gauche, on pourrait offrir à l’usager le choix du
pourcentage du signal se répartissant dans les deux canaux ou même faire varier leur
position autour du centre à l’aide d’un LFO.
4.6.2
Flanger
Bien que l’effet de flange soit de qualité comparable aux flangers professionnels,
quelques modifications pourraient y être apportées de façon à lui donner la sonorité du
«tape flange». Cet effet était autrefois causé en créant volontairement un petit délai lors
de l’enregistrement d’un instrument en exerçant une faible pression sur les bobines de
l’enregistreur utilisé.
4.6.3
Chorus
On remarque que même sans appliquer de modulation AM à la sortie des canaux
du chorus, une variation d’amplitude est causée par la superposition des ondes de
sorties (additions et annulations de certaines fréquences). La modulation AM n’est donc
pas un élément majeur dans l’algorithme et pourrait être omise pour permettre un
traitement plus rapide si les circonstances le nécessitent.
Par ailleurs, certains chorus contemporains ne font plus appel aux séquences
pseudo-aléatoires : ils ne font que faire varier le délai à l’aide de sinusoïdes pour faire
31
varier constament la justesse de l’instrument qui utilise le chorus. Par contre, le nombre
de canaux utilisés peut aller jusqu’à 32 pour obtenir une sonorité très, très riche !
4.6.4
Réverbération
La réalisation d’algorithme de réverbération de grande qualité serait possible en
modifiant l’algorithme de base de façon à tenir compte de nombreux autres facteurs qui
ont étés négligés.
Entre autre, l’atténuation des hautes et des basses fréquences
pourrait être modifiable de façon indépendante par l’usagé. De plus, la configuration des
lignes de délai qui procure la grande densité d’écho pourrait varier selon le type de
réverbération désiré. Finalement, afin de simplifier l’interface utilisateur, les paramètres
accessibles à l’usager pourraient être moins nombreux. Par exemple, un même contrôle
modifierait les paramètres de plusieurs lignes de délai simultanément.
4.6.5
Compresseur
Mis à part les modifications éventuelles au comportement du temps d’attaque qui
ont déjà étés discutés, plusieurs autres modifications auraient pu être apportées à
l’algorithme de base du compresseur. En effet, la plupart des compresseurs modernes
offrent beaucoup d’autres options à l’usager.
Tout d’abord, le détecteur de niveau
maximal, en plus de pouvoir détecter la valeur crête et la valeur moyenne peut souvent
détecter la valeur RMS du signal. De plus, une fonction «soft» ou «over-easy» permet
parfois de commencer la compression tranquillement avant même que le signal dépasse
le seuil critique. La compression est ainsi de plus en plus forte jusqu’à ce que le signal
dépasse le seuil (où on obtient alors la compression maximale demandée).
Les
compresseurs très sophistiqués peuvent aussi permettre à l’usager de définir des paliers
de compression. Par exemple, l’usager peut imposer une compression de 2 :1 entre –6
dB et –3 dB et une compression de 6 :1 entre –3 dB et 0 dB. De plus, on combine
souvent le compresseur à un «noise-gate» ou un «expander» qui atténuera le signal (et
préférablement, le bruit résiduel) s’il est inférieur à un seuil déterminé par l’usager.
32
5 DISCUSSION
5.1
QUALITÉ DES ALGORITHMES IMPLANTÉS
Avant de comparer les deux plates-formes, parlons un peu de la sonorité des
algorithmes utilisés. L’algorithme d’écho est à la fois très simple et très efficace et d’une
excellente sonorité sur les deux plates-formes. De même, l’algorithme du flanger est
d’une qualité comparable à celle des multi-effets professionnels. Par contre, puisqu’il n’y
a pas vraiment de standard établi pour l’algorithme d’un chorus, la sonorité de l’effet sur
le PC est très riche bien qu’elle soit différente des chorus professionnels actuels. Il en
est de même pour le chorus sur le DSP qui sonne de façon comparable au chorus du
PC, malgré les différences entre leurs algorithmes. Quant à la réverbération, le temps et
les notions solides en acoustique nécessaires à l’élaboration d’un algorithme à sonorité
naturelle rendaient très difficile l’amélioration de l’algorithme de base disponible
publiquement. La sonorité de l’algorithme résultant est donc plus ou moins métallique,
et la densité de la réverbération semble être inférieure à celle des véritables salles de
concerts. Finalement, l’algorithme de compression est très efficace et d’une sonorité
tout à fait acceptable et transparente.
5.2
COMPARAISON DES PROBLÈMES DE CONCEPTION SUR PC ET DSP
L’implantation des mêmes algorithmes (sauf celui du chorus) à la fois sur le PC et
sur le DSP nous permet maintenant de faire une comparaison des avantages et des
inconvénients qu’offrent les deux plates-formes lors de l’implantation des algorithmes.
5.2.1
Écho
Grâce à sa grande simplicité, l’algorithme d’écho s’est implanté plus facilement
sur le DSP que sur le PC. Par contre, on constate que seul le PC peut offrir la mémoire
suffisante aux délais pouvant aller jusqu’à quelques secondes.
33
5.2.2
Flanger
La particularité du flanger est l'utilisation de l'oscillateur à basse fréquence. Le
choix le plus économique au niveau CPU, le calcul de la valeur actuelle du cosinus à
partir des deux valeurs précédentes, à été implanté sur les deux plates-formes. Alors
que l'implantation s'est révélée très rapide sur le PC (en prenant bien soin de garder
toute la précision des valeurs intermédiaires), l'implantation sur le DSP a demandé un
peu plus de travail. En fait, puisque le DSP est à point fixe, il était important de garder
toutes les valeurs intermédiaires dans l'intervalle [-1.0 1.0[ . Ce travail supplémentaire
ne serait pas nécessaire sur d'autres DSPs à point flottant comme la famille DSP96k de
Motorola.
5.2.3
Chorus
Le chorus introduit un nouveau module : le générateur de bruit aléatoire. Alors
qu’un générateur traditionnel suivit d’un filtre passe-bas était réalisable sur le PC, ce
choix s’est révélé assez demandant au niveau CPU car 4 générateurs fonctionnaient
simultanément avec quatre filtres passe-bas.
On aurait pu n’utiliser qu’un seul
générateur pour alimenter les quatre filtres mais il n’aurait pas été balancé (un même
nombre aurait put revenir plusieurs fois dans la séquence alors qu’un autre ne se serait
jamais présenté). De plus, on aurait put prendre des filtres d’ordre 3 où 2, mais la
sonorité du chorus en aurait été affectée.
Quant à l’implémentation sur le DSP, la réalisation du filtre dont les coefficients
sont de l’ordre de 10-7 aurait été très difficile à cause de la précision limitée du DSP et de
la très basse fréquence de coupure du filtre IIR. C’est pourquoi une autre méthode de
génération du bruit aléatoire a été utilisée. Cette méthode, en plus d’être très simple
(sommation de trois LFOs) permet de générer les 4 séquences pseudo-aléatoires avec
un effort CPU très raisonnable. De plus, aucun filtrage n’est nécessaire et la sonorité
résultante est comparable à celle de l’algorithme utilisé sur le PC.
Il serait donc
intéressant d’implanter cette méthode sur le PC pour en mesurer le gain de
performance.
34
5.2.4
Réverbération
Bien que les deux plates-formes ont été en mesure d'implanter l’algorithme de
réverbération, la mémoire du DSP n’aurait encore une fois pas permis des
réverbérations complexes de plusieurs secondes. De plus, le nombre de lignes de délai
de l’algorithme de réverbération était limité par le nombre de «hardware modulo loops»
du DSP, rendant plus compliqué (et surtout beaucoup moins efficace) la conception
d’algorithmes utilisant plus de 8 modules de délai.
5.3
CARACTÉRISTIQUES DES PLATES-FORMES
Suite à la réalisation et à l’utilisation des différents effets audio implantés, il est
maintenant possible de dresser une liste des principales caractéristiques des deux
plates-formes au niveau de leur sonorité, de leur environnement de programmation et de
la qualité de leur interface utilisateur. Voici donc les points forts et points faibles des
deux plates-formes.
Avantages de la plate-forme PC :
•
Changement de la valeur de tous les paramètres de l’effet en temps réel :
Le nombre de paramètres accessible à l’usagé peut aller jusqu’à quelques
dizaines.
Il revient donc au programmeur de faire un compromis entre la
facilité d’utilisation et la flexibilité de l’effet.
•
Interface graphique simple et intuitive :
L’interface graphique peut être standard (avoir l’apparence d’un processeur
à effet conventionnel) ou dessinée par le programmeur. Dans ce dernier cas,
l’usager peut entrer les valeurs des paramètres par le clavier, à l’aide de
boutons poussoirs ou de boutons tournants, de «faders», etc. Les indicateurs
visuels des niveaux d’entrées et de sorties (ou «peak meters») sont aussi
habituellement très utiles.
Des graphiques peuvent même illustrer le
fonctionnement de l’effet en temps réel.
35
•
Plusieurs effets disponibles simultanément (implémentation modulaire) ;
•
Excellente qualité audio : conversion A/N et N/A 20 bits, mise en mémoire sur 16
bits, traitement interne sur 32 ou 64 bits en points flottants ;
•
Applications complexes relativement simples à programmer ;
•
Temps de développement relativement rapide ;
•
Grande quantité de mémoire disponible :
La quantité de mémoire disponible à un effet dépend directement de la
charge de travail du CPU. En fait, Cubase partage la RAM avec tous les
plugins utilisés. Lors d’une charge CPU modéré, plusieurs Megs de RAM sont
donc disponibles à chaque plugin.
Désavantages de la plate-forme PC :
•
Programmation de haut niveau en langage C++ (perte de puissance
possible);
Avantages du module d’évaluation du DSP56002 :
•
Applications simples faciles et rapides à programmer :
Puisque aucune interface graphique n’est réalisée, la programmation d’un
effet simple est très rapide. Aussi, la plupart des algorithmes de traitement du
signal sont très près du langage machine et les DSP sont optimisés pour ce
type de traitement, ce qui simplifie grandement la programmation en
assembleur.
•
Gain de performance pour une même vitesse de CPU :
Le DSP, étant optimisé pour le traitement de signal numérique, dispose
d’instructions spécialisées très rapides, de boucles «FOR» extrêmement
efficaces et même d’instructions parallèles qui le rendent extrêmement
performant.
36
Désavantages du module d’évaluation du DSP56002 :
•
Paramètres fixes (ils ne peuvent être changés en temps réel) :
Notons qu’il y aurait eu moyen de concevoir une interface utilisateur
externe reliée aux trois interruptions matérielles du DSP. Il aurait alors fallu
programmer du code assembleur responsable de mettre à jour les paramètres
des effets en temps réel.
•
Réalisation difficile des algorithmes nécessitant une très grande précision
(>24 bits) et des filtres à faibles coefficients ;
•
Quantité de mémoire disponible restreinte ;
•
Développement alourdi par l’arithmétique à point fixe et les mises à l’échelle
résultantes ;
•
Courbe d’apprentissage du DSP relativement longue ;
Points comparables :
•
Fréquences d’échantillonnage semblables (44.1kHz pour le PC et 48kHz pour
le DSP) ;
•
Qualité de l’audio sur le module d’évaluation du DSP un peu inférieur à celle
du PC (convertisseur A/N et N/A du module à16 bits et traitement interne sur
le DSP à 24 bits ou 48 bits à point fixe) ;
•
Puissance et rapidité d’exécution des algorithmes :
Tous les algorithmes ont étés réalisables en temps réel : la vitesse des
deux processeurs était donc suffisante à la réalisation des effets implantés.
•
Environnements de programmation comparables :
Les deux environnements de programmation offraient les outils standards
nécessaires au déverminage des effets. Par contre, bien que la compilation
se fasse plus rapidement sur le DSP, le déverminage du code était beaucoup
plus lent, du à l’interface série entre le logiciel et le module d’évaluation du
DSP.
37
CONCLUSION
Dans le cadre de ce projet, plusieurs effets audio traditionnels ont été réalisés à
la fois sur un PC et sur un DSP, ce qui nous a permis de mettre en évidence les qualités
de chacune de ces plates-formes.
Premièrement, l’interface graphique et la variation des paramètres en temps réel
sont deux très grands avantages de la plate-forme PC. Au niveau de la programmation,
la rapidité du développement des effets complexes et la quantité de mémoire disponible
aux plugins contribuent aussi à faire du PC une plate-forme de choix.
Le DSP se
démarque quant à lui par l’aisance de sa programmation d’algorithmes relativement
simples et par sa grande performance. Toutefois, il ne dispose à la base d’aucune
interface pour l’utilisateur, ce qui rend difficile le changement des paramètres des effets
audio en temps réel. Sa faible précision rend aussi difficile l’implantation de quelques
algorithmes et son arithmétique à point fixe allonge le temps de développement. De
plus, la quantité de mémoire présente sur le module d’évaluation restreint les possibilités
de certains algorithmes.
Par ailleurs, au niveau de leur sonorité et de leurs environnements de
programmation, les deux plates-formes sont comparables. Notons finalement que les
vitesses des processeurs n’ont pas été un facteur limitatif dans la réalisation des effets
qui ont été implantés. Il serait donc intéressant de réaliser des effets plus complexes
afin de comparer ce dernier aspect.
Même si ce rapport a fait une comparaison des deux plates-formes au niveau de
leur sonorité, de leur environnement de programmation et de la qualité de leur interface
utilisateur, certains autres points mériteraient aussi d’être étudiés lors du développement
d’un produit. En fait, pour être en mesure de faire le choix judicieux d’une plate-forme, il
faudrait évidemment aussi tenir compte des autres facteurs qui entrent en jeu mais qui
n’ont pas été étudiées lors de ce projet comme le coût de développement et de
fabrication du produit à développer.
Pour le PC, il faudrait par exemple aussi tenir
compte de l’influence de la vitesse du CPU, de la quantité de RAM disponible, du type
de plugin utilisé, etc. De la même façon pour les DSPs, il faudrait comparer les marques
38
et modèles fonctionnant à différentes vitesses, à point fixe où à point flottant, avec
différentes résolutions, etc.
Finalement, nous pourrions aussi envisager l’utilisation
d’autres plates-formes comme les systèmes Macs et UNIX, les microprocesseurs à
usage générique, les ASICs, etc.
39
RÉFÉRENCES
[1]
Chen, Chi-Tsong, One-Dimensional Digital Signal Processing, Marcel Dekker,
1979.
[2]
Chrysafis, Andreas, Motorola Digital Signal Processors: Digital Sine-Wave
Synthesis Using the DSP56001/2, Motorola Inc., 1998.
[3]
MERLIN Compressor 1A Description, EVI Audio
(http://www.eviaudio.com/merlin/ONLHelp/Isp-10000000066.html)
[4]
DSP56000 Macro Assembler Reference Manual, Motorola Inc., 1986.
[5]
DSP56002 Digital Signal Processor User’s Manual, Motorola Inc., 1993.
[6]
DSP56000 Digital Signal Processor Family Manual, Motorola Inc., 1995.
[7]
El-Sharkawy, Mohamed, Digital Signal Processing Applications with Motorola’s
DSP56002 Processor ; with appendices provided by the applications engineering
staff of Motorola’s DSP Operation, Prentice Hall, 1996.
[8]
Ifeachor, E.C., and B.W. Jervis, Digital Signal Processing: a Practical Approach,
Addison-Wesley, 1993.
[9]
Kadis, Jay, MUSIC 320 course lectures, Center for Computer Research in Music
and Acoustics, Stanford University, 1996. (http://www-ccrma.stanford.edu)
[10] Lapsley, Phil, Bier Jeff, Amit Shoham and Edward A. Lee, DSP Processor
Fundamentals: architectures and features, IEEE Press, 1997.
[11] Moorer, James, About this Reverberation Business, Computer Music Journal, 3
(2):13-28, 1979.
[12] Oppenheim, A.V., and R.W. Schafer, Digital Signal Processing, Prentice-Hall, 1975.
[13] Oppenheim, A.V., ed., Applications of Digital Signal Processing, Prentice-Hall,
1978.
[14] Pohlmann, K.C., Principles of Digital Audio, 3rd ed., McGraw-Hill, 1995.
[15] Reverberation assembly program in the Motorola DSP bulletin board, Motorola DSP
Operation. (http://www.mot.com/pub/SPS/DSP/software/dr_bub/56000.zip –
rvb.asm & rvb2.asm)
[16] Schroeder, M.R. and B.F. Logan, ‘Colorless’ Artificial Reverberation, J. Audio Eng.
Soc., vol. 9, no. 3, July, 1961.
[17] Schroeder, M.R., Natural Sounding Artificial Reverberation, J. Audio Eng. Soc., vol.
10, no. 3, July, 1962.
40
[18] SPX90 Digital Multi-Effect User Manual, Yamaha.
[19] Steinberg VST PlugIn SDK, Steinberg Soft und Hardware GmbH, 1996.
(http://www.steinberg.net/developers)
[20] Stikvoort, E.F., Digital Dynamic Range Compressor for Audio, J. Audio Eng. Soc.,
vol. 34, no. 1/2, janvier, 1986.
[21] Wolpert, Joey, The Fine Art of Compression, Keyboard Magazine, October, 1991.
41
ANNEXE A
EXEMPLE DE CODE SOURCE
42
EXEMPLE DE CODE SOURCE
À titre de comparaison entre les styles de programmation PC et DSP, voici des
extraits du code de l’algorithme du flanger.
Sur le PC, on effectue tout d’abord le calcul de la valeur de l’oscillateur à basses
fréquences.
Deuxièmement, on calcule la variation du pointeur de sortie du buffer.
Troisièmement, on lit les valeurs du buffer d’entrée et on lit les valeurs pointées par la
somme et la différence du pointeur de sortie et de la variation calculée précédemment ;
ces dernières valeurs sont les valeurs de sortie. Quatrièmement, on calcul les valeurs
qui seront réinjectées dans les lignes de délai. Finalement, on envoie ces dernières
valeurs dans les lignes de délais et on assigne les valeurs de sortie aux buffers de
sortie.
inline void AFlanger::subProcessReplacing(float *in, float *out1, float *out2,
float *dest1, float *dest2, float *del1, float *del2, long sampleframes)
{
long outPosShift;
float feed = fFeedBack;
float oscValue, xn1, xn2, yn1, yn2;
double bn;
while(--sampleframes >= 0)
{
// Osc. current value
bn = 2 * cosw * oscBuffer[1] - oscBuffer[0];
oscValue = (float) (bn - cosw * oscBuffer[1]);
oscBuffer[0] = oscBuffer[1];
oscBuffer[1] = bn;
// Current additionnal delay
outPosShift = (long) (depthRatio * oscValue);
// Process
xn1 = xn2 = *in++;
yn1 = *(del1++ + outPosShift);
yn2 = *(del2++ - outPosShift);
xn1 -= yn1 * feed;
xn2 -= yn2 * feed;
// Fill delay and output buffers
*dest1++ = xn1;
*dest2++ = xn2;
*out1++ = yn1;
*out2++ = yn2;
}
}
43
Le même principe s’applique à l’algorithme du DSP. Remarquons toutefois les
calculs supplémentaires qu’exige l’algorithme à double précision utilisé lors du calcul de
la valeur de l’oscillateur.
process
;Store input values
move
a,x:xn1
move
b,x:xn2
;Osc. current value
ori
#$40,mr
move
l:oscbuf1,x
move
l:cosw,y
mpy
x0,y0,a
mac
x1,y0,a
mac
x0,y1,a
mac
y1,x1,a
move
a,l:temp
andi
#$BF,mr
nop
nop
nop
move
L:oscbuf0,b
subl
b,a
move
a,L:bn
move
L:temp,b
sub
b,a
rep
#16
asl
a
move
a,y0
; Enter double precision mul. mode
; Compute "cosw * oscBuffer[1]"
; "cosw * oscBuffer[1]" -> L:temp
; Exit mul. mode
; "2*cosw*oscBuffer[1]-oscBuffer[0]"
; "oscValue/65536" in A
; Get current osc. value
;Osc. buffer's update
move
l:oscbuf1,x
move
x,l:oscbuf0
move
l:bn,x
move
x,l:oscbuf1
;Current additionnal delay
move
x:depthRatio,x0
mpy
x0,y0,b
move
b,n1
neg
b
move
b,n2
;Process
move
x:(r1+n1),x1
move
y:(r2+n2),y1
move
x:feedBack,y0
mpyr
-x1,y0,a
x:xn1,x0
mpyr
-y1,y0,b
x:xn2,y0
add
x0,a
(r1)+
add
y0,b
(r2)+
move
a,x:(r0)
move
b,y:(r0)+
move
x1,a
move
y1,b
; Current additionnal delay in A
; X1: yn1
; A: 'yn1 * -feed'
; A: xn1 = 'xn1 + (yn1 * feed)'
; Save the left samples
; Save the right samples
rts
44
ANNEXE B
ARTICLES DE L’AES
45