É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 CHOIX DES PLATE-FORMES ET DES LOGICIELS

3.1.1 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 DESCRIPTION DES PLATE-FORMES ET DES LOGICIELS

3.2.1 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 plates-

formes, 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é.

RDelay

k

Σ

LDelay

Σ l

IN1

Fig. 2 – Modèle de l’effet d’écho

Ainsi, pour le canal 1 (canal de gauche), on obtient les éq

OUT1(n) = LVolume • DEL1(n)

où DEL1(n) = IN1(n-LDelay) + LFeedBack • DEL1(n-LDe

RDelayLevel

RFeedBac

uations suivantes

lay)

OUT2

LDelayLeve

LFeedBack

OUT1

DEL1

DEL2

+

+

+

+

:

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.

h

Fig. 3 – Comportement tempo

Paramètres

ModFreq

ModDelayTime

ModDepth

FeedBack

Tableau 1 - Paramètres du Fla

ModDept

L

rel d

Val

0.1

0.1

0.1

0.1

0

nge

R

Signal direct

Amplitude

u flanger

eurs limites

– 5 Hz

– 50 ms

– 5 ms

– ModDelayTime

si ModDelayTime > 5m

si ModDelayTime ≤ 5m

– 100 %

r

temps

s

s

10

Voici le modèle permettant d’obtenir cet effet de flange.

RDelay

ΣOsc +180°

LDelay

ΣIN1

Fig. 4 – Modèle du Flanger

Ainsi, pour le canal 1 (canal de ga

OUT1(n) = IN1( n-LDelay(n)

avec LDelay(n) = ModDelayTime +

où Ω0 = 2π • ModFreq • n • Ts

dans lesquelles Ts est la période d’échan

Bien que la valeur du cosinus pu

d’une fonction standard du langage C (su

sous forme de ROM dans le DSP), n

réaliser un oscillateur numérique très sim

Trans. en z de [cos(Ω0n) • u(n)] =

d’où y(n) = 2cos(Ω0) • y(

FeedBack

uche), on obtient les équations

) + LFeedBack • OUT1( n-LDelay(

ModDepth • cos(Ω0 n)

tillonnage.

isse être obtenue à chaque ité

r le PC) où par l’utilisation de

ous utiliserons plutôt la trans

ple :

1 – cos(Ω0) z-1 _ 1 – 2 cos(Ω0) z-1 + z-2

n-1) – y(n-2) + x(n) – cos(Ω0) •

OUT2

FeedBack

OUT1

_

+

+

_

Osc

suivantes :

n) )

ration par l’appel

tables (présentes

formé en z pour

x(n-1)

11

z-1 Σ

x(n)

y(n)

-1

z-1

Fig. 5 – Diagram

Sur le PC to

(cos Ω0) et quelque

aussi que la fonctio

coefficient cos(Ω0) à

d’implantation partic

4.2.1 Implantation

L’implantatio

différence est le fait

basse fréquence (LF

la position moyenne

Pour pouvo

l’algorithme de l’éch

que les limites des

réelle des buffers v

appel à du «batch

position de sortie m

sortie peut être soit

la valeur du LFO à

une vérification des

algorithmes sembla

- cos(Ω0)

me de l’oscillateur n

ut comme sur le D

s opérations son

n cos() ne peut êt

l’aide des fonctio

uliers au DSP un

sur Cubase

n de cet algorith

que le temps de

O) pour faire var

de sortie.

ir continuer à f

o, nous devons d

buffers ne soient

arie à chaque it

processing». Da

oyenne du buffer

elle aussi près de

cet instant. Nou

limites à chaque

bles : le premier e

2cos(Ω0)

- 1

z

umérique

SP, seulement 2 espaces mémoire, un coefficient

t nécessaires pour implanter l’oscillateur. Notons

re appelée sur un DSP, mais qu’on peut obtenir le

ns du compilateur. Nous verrons les autres détails

peu plus loin.

me est semblable à celui de l’écho. La seule

délai soit variable. On utilise donc un oscillateur à

ier la position réelle de sortie des buffers autour de

aire du «batch processing» tel qu’utilisé dans

éterminer le nombre d’échantillons traitables sans

atteintes. Seulement, puisque la position de sortie

ération, nous ne pouvons faire systématiquement

ns certains cas critiques, par exemple lorsque la

est très près de la fin du buffer, la position réelle de

la fin ou encore près du début, tout dépendant de

s devons donc, dans les cas comme celui-ci, faire

itération. Nous nous retrouvons donc avec deux

st 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; % "freq" doit être supérieur à 0.117 Hz pour que le % facteur d'atténuation (2-16) soit suffisant att = 2^-16; % Facteur d'att. pour que "bn" soit entre -1 et 1 Fs = 48000; % Fréquence d’échantillonnage oscBuffer1 = 0; oscBuffer2 = 1 * att; % Valeur initiale réduite cosw = cos(2*pi*freq / Fs); % Constante simTime = 48000; % Temps de simulation bn = zeros(1,simTime); output = zeros(1,simTime); 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»).

h

Fig. 7 – Comportemen

Paramètres

ModFreq

ModDelayTime

ModDepth

AMDepth

FeedBack

Tableau 2 - Paramètre

ModDept

t

s

L

temporel d

Val

0.1

0.1

0.1

0.1

0 –

0 –

du Chorus

R

h

Signal direct

Amplitude

u chorus

eurs limites

– 5 Hz

– 50 ms

– 5 ms

– ModDelayTime

si ModDelayTime >

si ModDelayTime ≤ 5

30 %

100 %

temps

AMDept

5ms

ms

15

Voici le modèle permettant d’obtenir cet effet de chorus.

Delay2 Σ

FeedBack

+

Delay1 Σ

FeedBack

+

Ch1 Σ

Osc + 90°

RNG2

Delay4

FeedBack

Σ RNG4+

Delay3 +

+

FeedBack

Σ RNG3 +

Ch3

Ch4

Σ

IN1 Del1

Osc

Del2 Ch2

Del3

Osc +180°

Del4

Osc +270°

Fig. 8 – Modèle du chorus

Ainsi, pour le canal 1 (canal de gauche), on obtient les équations suiva

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

nombres pseudo-aléatoires.

OUT1

+

+

RNG1

OUT2

ntes :

érateur de

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)] = 1 – sin(Ω0) z-1 _ 1 – 2 cos(Ω0) z-1 + z-2

d’où 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 b) Osc @ 1.2 Hz - Osc @ 1.2 • 21/2 Hz + Osc @ 1.2 • 31/2 Hz c) - Osc @ 1.2 Hz - Osc @ 1.2 • 21/2 Hz + Osc @ 1.2 • 31/2 Hz d) - Osc @ 1.2 Hz + Osc @ 1.2 • 21/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 :

IN1

Early Reflections

Comb Filter #1

All Pass Reverb #2

AlignmentDelay

Comb Filter #2

Comb Filter #3

Comb Filter #4

Σ

Σ

All Pass Reverb #1

ERef

Pre Delay

CombIn

n

Fig. 13 – Modèle de la réverbération

Décrivons brièvement le principe de fonctionnement de cet algorithme. On

de l’entrée quelques réflexions primaires (après un très court délai) qu’on envoi

deux unités de réverbération en série. Ces unités basées sur un délai très cou

feedback fournissent une très grande densité d’écho. Ces échos sont ensuite re

pour ne pas masquer les réflexions primaires. On envoie ensuite les échos dans

filtres en peigne pour augmenter le temps de réverbération. Finalement, on co

une partie des réflexions primaires avec les échos résultant pour fournir une

stéréo.

OUT1

OUT2

EarlyRefGai

+

+

+

+

+

+

Rev1

Rev2

Rev3

Rev4

APOut2

APIn2

extrait

e dans

rt avec

tardés

quatre

mbine

sortie

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

et ERef(n) = ∑ RefGain i • IN1(n-RefDelay i) i = 1

Par ailleurs, les figures 13 et 14 illustrent les modèles utilisés pour réaliser les

«all pass reverbs» et les «comb filters».

+ + AΣ

g

APIn i

Fig. 14 – Modèle détaillé des «al

Pour le deuxième «all pass

APOut2(n) = - g • AP

avec APDel2(n) = APIn2(n

ComΣ

CombIn

Fig. 15 – Modèle détaillé des «co

Ainsi, pour le premier «com

Rev1(n) = CombIn(n-Comb1D

–

Σ +P i Delay APDel i

2

APOut i

+

l pass reverbs»

reverb», on obtien

In2(n) + (1 - g2) • A

-AP2Delay) + g • AP

Σ

b i Delay

g

mb filters»

b filter», on obtien

elay)

1 – g

g

t donc les équations suivantes :

PDel2(n)

Del2(n-AP2Delay)

1 Sample Delay

Rev i

+

+

+

+

t l’éq

LFP i Gain

uation suivante :

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 ms

Alignment Delay 0 – 100 ms 27 ms

Tableau 3 - Paramètres de la réverbération

_–3 • MaxDel_

Notons que : g = 10 Fs • DecayTime

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.

Delay Offset filter

Level Detector

OutputGain

Loop Filter

CompressionCaracteristic

ReleaseStage

IN Signal

Fig. 16 – Modèle du compresseur

Le calcul du gain se fait de la façon suivante. Le signal est tout d’abord filtré

en éliminer la composante continue car ette dernière pourrait grandement fausse

calculs subséquents. Le «level detector» est ensuite responsable de calculer la v

moyenne ou crête du signal (au choix de l’usager). On passe ensuite cette valeur

un circuit de retenu (ou «peak-hold circuit») de façon à ce que l’arrêt de la compre

OUT

Gain

Rel.

In

Rel.

Out

pour

r les

aleur

dans

ssion

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 :

z-1 0.99893 Σ z-1

IN Signal

- 0.99893 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 :

z-1

Rel.In

Σ

1 – c Σ

Stg2

z-1

1 – c

z-1

Rel.Out c c

Stg3

Fig. 18 –

On obtient les

Rel.Out

Stg3(n)

Stg2(n)

Stg1(n)

où c =

Vient ensuite l

A(n) =

où R =

Finalem

dans la figure

l’article de Stik

opté pour un f

est fixée à 13

le dépasseme

Thomson aura

c

Modèle détaillé du «release sta

équations aux différences

(n) = Stg3(n-1)

= max Rel.In(n) , [c • Stg

= max Rel.In(n) , [c • Stg

= max Rel.In(n) , (c • Rel

e -3.25 / (ReleaseTime • Fs)

e calcul du niveau de comp

(Rel.Out(n)/threshold) R-1

1/10Ratio

ent, le «loop filter» qui c

19. La documentation su

voort [20] n’étant pas disp

iltre IIR Butterworth passe

Hz, ce qui correspond à un

nt de ce filtre est assez

it permis un dépassement

ge»

des trois étages :

3(n-1) + (1-c) • Stg2(n)]

2(n-1) + (1-c) • stg1(n)]

.Out)

ression :

ontribue à ralentir le temp

r les filtres Butterworth T

onible lors de la conception

-bas du 4e ordre dont la fr

groupe délai de τ = 35 ms

élevé (10.8%) alors qu

inférieur à 0.03%.

Stg1

s d’attaque est décrit

homson décrits dans

du filtre, nous avons

équence de coupure

. Malheureusement,

’un filtre Butterworth

27

z-1 5.07207641•10-7 Σ z-1

B

z-1 5.06817058•10-7

Σ

Gain

z-1

z-1

- 0.99737093502 5.06817058•10-7

1.9973689077 1.01363412•10-6

z-1

- 0.98910226760

z-1

5.07207641•10-7

1.9989081979 1.01441528•10-6 z-1

A

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 MODIFICATIONS ET AMÉLIORATIONS POSSIBLES

4.6.1 É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 ; Enter double precision mul. mode move l:oscbuf1,x ; Compute "cosw * oscBuffer[1]" move l:cosw,y mpy x0,y0,a mac x1,y0,a mac x0,y1,a mac y1,x1,a move a,l:temp ; "cosw * oscBuffer[1]" -> L:temp andi #$BF,mr ; Exit mul. mode nop nop nop move L:oscbuf0,b subl b,a ; "2*cosw*oscBuffer[1]-oscBuffer[0]" move a,L:bn move L:temp,b sub b,a ; "oscValue/65536" in A rep #16 asl a ; Get current osc. value move a,y0 ;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 ; Current additionnal delay in A move b,n1 neg b move b,n2 ;Process move x:(r1+n1),x1 ; X1: yn1 move y:(r2+n2),y1 move x:feedBack,y0 mpyr -x1,y0,a x:xn1,x0 ; A: 'yn1 * -feed' mpyr -y1,y0,b x:xn2,y0 add x0,a (r1)+ ; A: xn1 = 'xn1 + (yn1 * feed)' add y0,b (r2)+ move a,x:(r0) ; Save the left samples move b,y:(r0)+ ; Save the right samples move x1,a move y1,b rts

44

ANNEXE B

ARTICLES DE L’AES

45