Commits

Pierre Pagnoux committed cecb88f

Added old reports.

Comments (0)

Files changed (15)

doc/sout3/Makefile

 ## <surply_p@gmail.com>
 ## 
 ## Started on  Thu Dec 27 19:54:17 2012 Pierre Surply
-## Last update Sun May 26 18:15:34 2013 Vincent Molinié
+## Last update Sun May 26 19:28:36 2013 Pierre Pagnoux
 ##
 
 # Add your file(s) here
 
-FILES		= intro.md \
-		  gui.md   \
-		  reverb.md\
-		  stereo.md
+FILES		= intro.md		\
+		  tasks.md		\
+		  pulse.md		\
+		  files.md		\
+		  amp.md		\
+		  equalizer.md		\
+		  echo.md		\
+		  reverb.md		\
+		  stereo.md		\
+		  handler.md		\
+		  cli.md		\
+		  gui.md		\
+		  website.md		\
+		  template_engine.md	\
+		  concl.md
+
 
 PROJECT		= StarDSP
 PROMO		= 2016
+# Amplification
+
+Le but principal de ce projet est d’amplifier une onde sonore et à cela s’ajoute divers effets. Le son est une onde produite par la vibration mécanique d’un support *fluide* ou *mécanique* et propagée grâce à l’élasticité du milieu environnant sous forme d’ondes *longitudinales*. Dans notre cas, le son est produit par un instrument de musique et est capté par un micro — classique ou bien piézo-électrique. On obtient alors un signal analogique continu qui est transmis via un câble jusqu’à la carte son de notre ordinateur.
+
+## Signaux analogiques et discrets
+
+Sur un modèle électronique, un amplificateur et les autres effets sont reliés les uns à la suite des autres. Les modifications du signal opèrent grâce des matériaux électroniques — condensateurs, transistors, résistances, etc ... Le signal analogue d’entré $x(t)$ est traduit en un nouveau signal analogue de sortie $y(t)$.
+
+Sur un modèle informatique, l’ordinateur manipule des valeurs dites *discrètes*. Le signal analogique est capté par un récepteur — un micro — et est traduit par le périphérique d’*acquisition* — carte son — en signal discret. Le signal est enregistré dans un tableau appelé *buffer* sur lequel est effectué le traitement. Le signal d’entré $x[t]$ est alors transformé en un nouveau signal discret de sortie $y[t]$.
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[scale=0.20]{../img/analog_discrete.png}
+\caption{Terminologie des signaux et systèmes analogiques et discrets.}
+\end{figure}
+
+Lorsque le signal entre dans la carte son, il est échantillonné selon la *fréquence d’échantillonnage*. Plus la fréquence d’échantillonnage est élevée plus le signal est précis *i-e* que nous sommes capable de visualiser les fréquences élevée du signal analogique. De même la *résolution de quantification* — en *bits* permet d’améliorer la précision de la mesure du signal. Par example, un disque compact est échantillonné à $44,1$ KHz et quantifié à 16 bits.
+
+## Distorsion
+
+Un amplificateur idéal conserve la forme du signal d’entrée et augmente l’amplitude. L’amplification que nous souhaitons n’est pas celle d’un amplificateur idéal. Nous souhaitons reproduire les effets de *sustain* et *crunch* des amplis pour guitare électrique. 
+
+Grâce à la distorsion, les notes acquièrent un son diffus. Plus on augmente la distorsion et plus le son naturel de l’instrument est brouillé au profit du *crunch* et du *sustain* qui augmentent. Cet effet, obtenu par saturation d’un amplificateur classique, procède par *écrêtage* : comprime l’attaque de la note jouée tout en augmentant ses armoniques, ce qui lui donne plus de tenue et de fluidité ainsi qu’un *timbre* substantiellement modifié.
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[scale=0.50]{../img/ecretage.png}
+\caption{L’effet d’écrêtage.}
+\end{figure}
+
+D’une manière simple, le phénomène recherché est produit par une perte d’information volontaire. Il suffit donc de définir un seuil pour notre signal. Notre signal est transformé de manière à ne pas dépasser ce seuil.
+# CLI \& GUI
+
+## Command Line Interface
+
+*CLI* ou bien *Command Line Interface* permet à l’utilisateur de se passer d’une interface graphique.
+
+\begin{verbatim}
+$ ./stardsp —help
+Usage : ./stardsp [OPTIONS]
+Input : PulseAudio or AIFF
+	-gui						GUI Mode
+	-file <path>				AIFF file input
+	-dev <device>				TTY
+	-send-surface <data>		test Control-surface
+	-use-surface				Use Control-surface
+\end{verbatim}
+
+Les options qui sont présentes permettent à l’utilisateur de choisir le mode d’éxecution de StarDSP :
+
+- `PulseAudio`
+- Fichier `AIFF`
+- GUI
+
+De même, nous avons également ajouté des options pour la manipulation de la *surface de contrôle*.
+
+Cette interface textuelle se réalise facilement avec le module `Arg` d’`OCaml`.

doc/sout3/concl.md

+\chapter*{Conclusion}

doc/sout3/echo.md

+# Nouveaux effets
+
+Par mesure simplicité, nos effets respectent le *format* suivant :
+
+* `init` : permet d’initialiser l’effet — donne la structure par défaut.
+* `update` : permet de mettre à jour le comportement de l’effet.
+* `compute` : permet d’appliquer l’effet : `float -> float`.
+
+## Echo
+
+### Explication
+
+Cet effet est très répendu en musique. Il est semblable à l’écho que nous pouvons reproduire dans les régions montagneuse. Le son produit se propage jusqu’à ce que celui-ci rencontre un obstacle — la montagne — et est renvoyé dans la direction opposée avec une légère atténuation due à l’élasticité du milieu. On peut donc entendre plusieurs fois le même son à interval régulier jusqu’à ce qu’il devienne inaudible à cause de l’atténuation.
+	
+### Implémentation
+
+Il faut conserver le son pendant un certain temps et le restituer en sortie. Cela se traduit par la création d’un *buffer circulaire*.
+
+#### Notion de temps
+
+Le temps est représenté par nos *buffer*. La valeur d’échantillonage — par défaut $44,100$ KHz — signifie que la carte son vas recueillir $44,100$ mille échantillons en *une seconde*. Le buffer principal de notre application de taille $44,100$K est donc modifié une fois par seconde. En une seconde, le processeur est suffisamment rapide pour pouvoir appliquer tout les effets demandés. Pour conserver une valeur pendant 4 secondes il suffit de stocker celle-ci dans un buffer de taille $4 * f$, $f$ étant la fréquence d’échantillonnage.
+
+#### Echo
+
+Nous stockons le *sample* d’entrée en additionnant l’ancienne valeur multipliée par le *coefficient d’atténuation*. D’une manière générale, l’opération d’un délais est décrite comme :
+
+\begin{figure}[htpb]
+\centering
+delayed($n$) = $s(n - d)$
+\end{figure}
+
+où $s$ représente le tableau d’entrée, $n$ le *sample* courant et $d$ le décalage — en quantité de *sample*.
+
+L’implémentation d’un filtre d’écho en `C` :
+
+\begin{verbatim}
+	for (n = 0; n < N; n++)
+	{
+		out[n] = (in[n] + delayed) * 0.5; /* filter equation */
+		delayed = in[n]; / * keep previous input */
+	}
+\end{verbatim}

doc/sout3/equalizer.md

+# Égaliseur *3-Band*
+
+La première fonctionnalité que nous avons ajouté est celle d’un *égaliseur* simple à trois bandes. Ceci permet de modifier le signal de manière à favoriser une partie du *spectre sonore*[^1]. Concrêtement, l’utilisateur peux choisir de favoriser les basses fréquences, les mediums ou bien les hautes fréquences à sa guise.
+
+## Traitement du signal
+
+### Les séries de \textsc{Fourier}
+Pour réaliser cet effet, il faut pouvoir décomposer notre signal. Une onde sonore est en réalité composée d’une somme de signaux.
+
+\label{series}
+\begin{figure}[htbp]
+\centering
+\includegraphics[width=15cm]{../img/fourier.pdf}
+\caption{Séries de Joseph \textsc{Fourier}}
+\end{figure}
+
+Dans l’example de la figure \ref{series}, le signal *bleu* se décompose en une série de trois fonctions sinusoïdales.
+
+\begin{displaymath}
+f(x)=\cos \; x\; -\; \frac{1}{3}\cos \; 3x\; +\; \frac{1}{5}\cos \; 5x
+\end{displaymath}
+
+Ainsi, toute fonction continue sinusoïdale peut se décomposer en *série de Fourier*.
+
+
+\begin{figure}
+\begin{displaymath}
+\sum_{n=0}^{+\infty}{\left( \mathcal{A} _{n}\sin \left( n\omega _{0}t \right)\; +\;\mathcal{B}_{n}\cos \left( n\omega _{0}t \right) \right)}
+\end{displaymath}
+\caption{Série de \textsc{Fourier}}
+\end{figure}
+
+Dans l’équation, on voit qu’il s’agit d’une combinaison linéaire de fonctions trigonométriques qui ont toutes des pulsations proportionnelles à la pulsation $\omega_{0}$ : cette pulsation fondamentale $\omega_{0}$ est la pulsation de la note jouée par une corde de guitare.
+
+On obtient ainsi divers signaux avec des fréquences différentes. Si nous souhaitons augmenter les basses dans notre son, il faut augmenter l’amplitude des signaux basse fréquence et inversement pour les aïgus.
+
+### La transformée de \textsc{Fourier} discrète
+
+Diviser pour régner est la stratégie utilisée ici. Le signal d’entrée est très complexe. Pour pouvoir le traiter, on se propose de le décomposer en somme sinusoïdes. C’est ainsi beaucoup plus simple pour faire les modifications souhaitées.
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[scale=0.4]{../img/dft.png}
+\caption{Décomposition d’un signal et synthèse.}
+\end{figure}
+
+Un signal peut être continu ou discret, et périodique ou apériodique. Cela donne quatre catégories de transformée de \textsc{Fourier} :
+
+- Apériodique, continue :
+	Transformée de \textsc{Fourier}
+- Périodique, continue :
+	Série de \textsc{Fourier}
+- Apériodique, discrète :
+	Transformée de \textsc{Fourier} à temps discret
+- Périodique, discrète :
+	Transformée de Fourier discrète
+	
+Pour des raisons de simplicité nous n’avons pour le moment pas réalisé d’implémentation de la tranformée de \textsc{Fourier}.
+
+### Convolution
+
+Une autre méthode très utilisée dans le traitement des signaux est la *convolution* également très connue dans le traitement d’image via les matrices de convolution.
+
+La convolution est une méthode mathématique pour combiner deux signaux pour en former un troisième. C’est l’une des techniques incontournable dans le traitement des signaux. La convolution prend en compte trois signaux : le signal d’*entrée*, le signal de *sortie* et la *réponse impulsionnelle*.
+
+La *réponse impulsionnelle* est obtenue lorsque l’entrée est une impulsion, c’est-à-dire une variation soudaine et brève du signal. Dans un système à temps continu, le modèle mathématique d’une impulsion est une distribution de \textsc{Dirac}. Pour un système à temps discret, une impulsion est définie par la suite $\delta(n)$ valant $1$ si $n = 0$ et $0$ sinon. Cette fonction est aussi appelée l’*impulsion unitaire*. On peut donc visualiser notre signal comme un groupement d’impulsions.
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[scale=0.4]{../img/delta_impulse.png}
+\caption{\label{delta}Définition de la fonction \emph{delta} et de la \emph{réponse impulsionnelle}.}
+\end{figure}
+
+Dans la figure \ref{delta}, $\delta[n]$ est la fonction *delta*. La *réponse impulsionnelle* d’un système linéaire, dénotée par $h[n]$, est la sortie du système lorsque l’entrée est la fonction *delta*.
+
+\begin{figure}[htbp]
+\centering
+\includegraphics[scale=0.3]{../img/input_impulse.png}
+\caption{\label{input}Le signal d’entrée est convolutionné par la \emph{réponse impulsionnelle} du système.}
+\end{figure}
+
+Le système \ref{input} est représenté par l’équation suivante :
+\begin{displaymath}
+x[n] \ast h[n] = y[n]
+\end{displaymath}
+
+La *convolution* est représentée par le signe $\ast$. Le signal d’entré est convolutionné par la *réponse impulsionnelle* et produit le signal de sortie.
+
+#### Example
+\begin{figure}[!hb]
+\centering
+\includegraphics[scale=0.4]{../img/lowpass_filter.png}
+\caption{Filtre passe-bas.}
+\end{figure}
+
+ 
+## Implémentation
+
+Au niveau de l’implémentation, on utilise le principe de convolution évoqué dans la partie d’avant. On défini une structure, pour stocker les nouvelles valeurs — ainsi que les anciennes — et faire les calculs. Il s’agit d’une implémentation très efficace.
+
+On calcule donc avant toute chose, les valeurs des fréquence de *coupure* des filtres *passe-bas* et *passe-haut*, stockée dans `lf` et `hf`. Les valeurs de gain à appliquer sont stockée dans `lg`, `mg`, et `hg` correspondant respectivement aux gains des filtres *passe-bas*, *passe-haut* et *passe-bande*. Les champs *type* `f1p0`, etc ... représentent la *réponse impulsionnelle*. Il faut voir la réponse impulsionnelle comme un effet d’inertie — les calculs précédents ont une influence sur les prochains.
+
+~~~{.ocaml}
+type state =
+{
+  mutable lf	: float;
+  mutable f1p0	: float;
+  mutable f1p1	: float;
+  mutable f1p2	: float;
+  mutable f1p3	: float;
+
+  mutable hf	: float;
+  mutable f2p0	: float;
+  mutable f2p1	: float;
+  mutable f2p2	: float;
+  mutable f2p3	: float;
+
+  mutable sdm1	: float;
+  mutable sdm2	: float;
+  mutable sdm3	: float;
+
+  mutable lg	: float;
+  mutable mg	: float;
+  mutable hg	: float;
+}
+~~~
+
+On initialise notre structure avec les valeurs des fréquences des filtres passe-bas et passe-haut — on calcule les fréquences de coupure des filtres.
+
+~~~{.ocaml}
+let init lowfreq highfreq mixfreq =
+  let pi = 4. *. atan 1. in
+  let es =
+    {
+      lf	= 2. *. sin(pi *. (lowfreq /. mixfreq));
+      f1p0	= 0.;
+      f1p1	= 0.;
+      f1p2	= 0.;
+      f1p3	= 0.;
+
+      hf	= 2. *. sin(pi *. (highfreq /. mixfreq));
+      f2p0	= 0.;
+      f2p1	= 0.;
+      f2p2	= 0.;
+      f2p3	= 0.;
+
+      sdm1	= 0.;
+      sdm2	= 0.;
+      sdm3	= 0.;
+
+      lg	= 0.1;
+      mg	= 0.5;
+      hg	= 1.;
+    }
+  in
+  es
+~~~
+
+On réalise via cette fonction l’égalisation, selon le principe de convolution. La petite valeur `vsa` permet de corriger les erreurs d’arrondi. La valeur du nouveau *sample* sera la somme de ce que chaque filtre aura calculé. Le filtre *passe-bande* est obtenu par différence des deux filtres *passe-bas* et *passe-haut*.
+
+~~~{.ocaml}
+let compute es sample =
+  let vsa = 1. /. 4294967295. in
+  es.f1p0 <- es.f1p0 +. (es.lf *. (sample -. es.f1p0)) +. vsa;
+  es.f1p1 <- es.f1p1 +. (es.lf *. (es.f1p0 -. es.f1p1));
+  es.f1p2 <- es.f1p2 +. (es.lf *. (es.f1p1 -. es.f1p2));
+  es.f1p3 <- es.f1p3 +. (es.lf *. (es.f1p2 -. es.f1p3));
+  let l = es.f1p3 in
+  es.f2p0 <- es.f2p0 +. (es.hf *. (sample -. es.f2p0)) +. vsa;
+  es.f2p1 <- es.f2p1 +. (es.hf *. (es.f2p0 -. es.f2p1));
+  es.f2p2 <- es.f2p2 +. (es.hf *. (es.f2p1 -. es.f2p2));
+  es.f2p3 <- es.f2p3 +. (es.hf *. (es.f2p2 -. es.f2p3));
+  let h = es.sdm3 -. es.f2p3 in
+  let m = sample -. (h +. l) in
+  let l = l *. es.lg in
+  let m = m *. es.mg in
+  let h = h *. es.hg in
+  es.sdm3 <- es.sdm2;
+  es.sdm2 <- es.sdm1;
+  es.sdm1 <- sample;
+  l +. m +. h
+~~~
+
+[^1]: L’ensemble des fréquences harmoniques ou inharmoniques.

doc/sout3/files 2.md

+# Fichiers audio
+
+## Problème
+Lors de la précédente soutenance, nous avions présenté la possibilité de lire des fichiers `AIFF` afin de pouvoir effectuer des tests sur notre logiciel. Le problème de saturation que nous avions rencontré, qui a été source de conflits et de perte de temps est maintenant résolu.
+
+## Changement de bibliothèque
+Le problème était une amplification involontaire sur nos fichiers `AIFF`. Le son était complétement saturé à cause d’une perte d’information et des valeurs mal converties par la précédente bibliothèque. Pour palier ce problème, nous avons radicalement changé de bibliothèque pour lire les fichiers. Nous utilisons maintenant `libsndfile`. Cette nouvelle bibliothèque permet en outre de lire beaucoup plus de format de fichier. *StarDSP* peut maintenant être utilisé avec ces quelques formats de fichier :
+
+#### Liste des formats de fichier pris en charge par *StarDSP*
+* Microsoft `WAV`
+* Apple `AIFF/AIFC`
+* Format `RAW`
+* Paris Audio File `PAF`
+* Apple `CAF`
+* Free Lossless Audio Codec `FLAC`
+* Soundforge `W64`
+
+Cela offre beaucoup plus de souplesse ! Cette nouvelle bibliothèque a été également l’occasion d’alléger notre code. Celle-ci s’occupe des différentes conversions à effectuer.

doc/sout3/files.md

+## Fichiers AIFF
+
+Au cours de la phase de développement de ce projet, nous avons besoin de régulierement tester notre travail. C'est pourquoi, nous avons ajouté la prise en charge de la lecture de fichiers `AIFF`. Pour cela, nous reprenons une bibliothèque écrite en `C`. La `LibAIFF` nous a permis de nous simplifier la tâche, en ce qui concerne la lecture de ce format de fichier, étant donné que cela n'est pas le but principal de notre projet.
+
+Nous avons réalisé un *binding* de cette bibliothèque. Cela consiste à traduire les fonctions de cette bibliothèque en `OCaml`. Nous obtenons au final des fonctions simples :
+
+~~~ {.ocaml}
+val open_file	: string -> t
+val close_file	: t -> unit
+val read		: t -> (float, Bigarray.float32_elt, Bigarray.c_layout)
+	Bigarray.Array1.t -> int -> int
+~~~
+
+On peux facilement remarquer que la lecture des fichiers AIFF consiste a remplir un *buffer* de nombres flottants -- representant les valeurs discrètes du signal sonore numérisé. On appelle communément ces valeurs *sample*.

doc/sout3/handler.md

+# Encapsulation
+
+## Module *core* Audio
+
+### Problématique
+
+Lors de la précédente version de *StarDSP*, l’accès direct aux ressources audio n’était pas protégé. De plus, il en résultait un code très verbeux et n’était pas facilement modulable. Par ailleurs, l’arrivée des *threads* nous a obligé à restructurer notre programme.
+
+### Création d’un module dédié
+
+La gestion des interactions avec `PulseAudio` est désormais *encapsulée* via la création d’un module. Cela instaure une autonomie dans le fonctionnement de notre logiciel et prévient l’apparition d’erreur inopinée.
+
+Ce module permet donc tout simplement d’initialiser le moteur son, de libérer les ressources, et gère de lui même les mécanismes de gestion des effets. Nous en avons profité également pour ajouter des *modes de fonctionnement* :
+
+* Mode lecture de fichier
+* Mode temps réel
+* Mode inactif
+
+L’utilisateur peux désormais basculer à tout moment dans chacun de ces modes sans avoir à réinitialiser toute l’application. Le développement de l’application est beaucoup plus simple grâce à l’*encapsulation* c’est-à-dire que le principe est semblable à la programmation orientée objet : l’implémentation n’est pas directement accessible. Il suffit de lire l’interface `mli` pour comprendre le fonctionnement des divers modules sans avoir a lire leurs implémentations.
+
+## Gestion des effets
+### Intérêt
+
+Au fur et à mesure que le projet se développe, nous avons de plus en plus d’effets à traiter. C’est pourquoi afin de prendre en charge l’interface utilisateur, nous avons ajouté un gestionnaire d’effets. L’utilisateur a désormais le choix d’ajouter, de supprimer, ou bien de déplacer l’ordre d’application des effets. Le son produit en sortie, peut-être différent en fonction de l’ordre d’application. 
+
+Cela nous permet d’avoir un niveau d’abstraction élevé par rapport à la version précédente. La gestion des effets permet simplement de contrôler chacun d’eux sans avoir à se soucier des détails au niveau de l’implémentation qui peuvent encore évoluer. En outre, cela simplifie notre travail en équipe : on peut ajouter facilement un effet sans avoir à comprendre en détail le fonctionnement du coeur du programme.
+
+### Conception & implémentation
+
+#### Principe
+
+L’idée est de pouvoir stocker facilement les différents effets dans un ordre bien particulier. Étant donné que le nombre d’effets applicables est variable, nous avons besoin d’une structure de donnée évolutive : les listes. Après mures réflexions, nous nous sommes aperçu que ce n’était pas les effets en eux même qu’il fallait ordonner mais les fonctions permettant de les appliquers. Nous partons donc du principe qu’il suffit de lire la liste d’effets dans l’ordre et d’appliquer un à un chaque effets.
+
+#### Implémentation
+
+Le principe évoqué ci-dessus est facilement applicable dans un langage fonctionnel comme le `OCaml`. Le *Caml* a une fonctionnalité particulièrement intéressante : les applications partielles. En effet, nous avons décidé afin de simplifier et de satisfaire le typage fort du *Caml* de normaliser le typage des fonctions de nos effets en fonctions du type `unit -> unit`.
+
+Nous fournissons pour effectuer cela un module exclusivement réservé à la gestion des effets. Les listes en *Caml* sont récursives, nous avons donc implémenté des fonctions afin de pouvoir effectuer des ajouts/suppressions et déplacement *en place*.
+
+~~~ {.ocaml}
+
+val add : 'a -> int -> 'a list -> 'a list
+(** Add an element at the index position in ocaml list.
+    Index begin at position 1.
+*)
+
+val del : int -> 'a list -> 'a list
+(** Delete an element at the index position in ocaml list.
+    Index begin at position 1.
+*)
+
+val move : int -> int -> 'a list -> 'a list
+(** Move an element at src position to dst position in ocaml list.
+*)
+
+~~~
+
+#### Applications partielles
+
+Le seul paramètre variable lors de l’application d’un effet est bien entendu la source sonore. Il est donc inutile de passer en paramètre la structure de donnée de l’effet. Nous utilisons les *applications partielles* pour réaliser cela. En effet dans le cas d’une fonction d’effet de base de type : `t -> float -> float` où `t` est la structure de donnée, l’application partielle de cette fonction avec le premier paramètre nous retourne une nouvelle fonction du type : `float -> float`.
+
+D’une façon similaire, nous convertissons cette fonction en une fonction de type `unit -> unit` en automatisant la récupération et la modification des valeurs d’entrée et sortie indépendamment du *buffer* principal.

doc/sout3/intro.md

 \chapter*{Introduction}
 
-Notre projet *StarDSP* est un processeur de signal numérique — *DSP* -- que l'on utilisera comme amplificateur de guitare électrique ou plus généralement de piste audio.\newline
+Nous tenons tout d’abord à remercier M. Christophe \textsc{Boullay} pour nous avoir confié un projet *libre* lors de ce second semestre de SPÉ. Ce projet à été l’occasion de mettre en oeuvre toutes nos compétences acquises à l’ÉPITA pendant ces deux années de prépa. Nous avons mis tout notre savoir faire en programmation, mathématiques, architecture et en électronique pour concevoir *StarDSP*.\newline
+
+Notre projet *StarDSP* est un processeur de signal numérique — *DSP* — que l'on utilisera comme amplificateur de guitare électrique ou plus généralement de piste audio.\newline
 
 Ce rapport de projet présente le chemin accompli pour la réalisation du projet. Il reprend les étapes effectués lors des deux soutenances précédentes et présente la version finale de ce projet.\newline
 
 *StarDSP* est un projet algorithmiquement complexe et très complet. Il permet d'appliquer différents effets parmi les six proposés sur une piste audio préalablement enregistré ou en temps réel. Il propose trois modes de commande: par la console, par l'interface graphique ou bien par la surface de contrôle.\newline
 
-Nous espérons vous intéresser tout au long de ce rapport et qui sait peut-être même vous étonner.\newline
+Nous espérons vous intéresser tout au long de ce rapport et qui sait peut-être même vous étonner.

doc/sout3/pulse.md

+# PulseAudio
+
+## Adaptation de la bibliothèque client *PulseAudio* pour le langage *OCaml*
+
+PulseAudio est le serveur de son que nous utilisons dans ce projet. Il permet de grandement simplifier l'utilisation du matériel audio de la machine.
+
+Cependant, la bibliothèque permettant de communiquer avec ce serveur est seulement disponible en *C*. C'est pour cela qu'il a été nécessaire de l'adapter au *Caml*.
+
+L'interface réalisée spécialement pour ce projet prend la forme du bibliothèque *Caml* indépendante de *StarDSP*. Elle doit donc être installée au préable sur la machine de l'utilisateur avant de pouvoir utiliser notre projet.
+
+La bibliothèque en elle-même fournit des fonctions pour jouer et lire du son en faisant une complète abstraction du matériel de l'utilisateur. Les données sont échangées sous forme de *buffer* dont la taille peut être paramétrée au préalable. Les traitements effectués par *StarDSP* s'appliquerons donc sur ces derniers.
+
+## Exemple d'utilisation de la bibliothèque *PA*
+
+Le programme ci-dessous joue simplement sur la sortie audio principale le son transmit par le microphone.
+
+~~~ {.ocaml}
+
+let main () =
+  let ss =
+    {
+      Pa.rate = 44100;
+      Pa.channels = 2;
+    }
+  in
+  let size = 512 in
+  let buffer = Bigarray.Array1.create
+    Bigarray.float32
+    Bigarray.c_layout
+    size
+  in
+  let simple_rec =
+    Pa.create
+      ~name:"Echo"
+      ~direction:Pa.Record
+      ~stream_name:"read"
+      ~ss:ss ()
+  in
+  let simple_play =
+    Pa.create
+      ~name:"Echo"
+      ~direction:Pa.Playback
+      ~stream_name:"play"
+      ~ss:ss ()
+  in
+  while true do
+    Pa.read simple_rec buffer size;
+    Pa.write simple_play buffer size
+  done;
+  Pa.free simple_rec;
+  Pa.free simple_play;
+  exit 0
+
+let _ = main ()
+~~~

doc/sout3/tasks.md

+#### Répartition des tâches
+* Pierre \textsc{Surply}
+	* PulseAudio *binding*
+	* Surface de contrôle
+	* Mara
+	* CGI \& moteur de template
+* Pierre \textsc{Pagnoux}
+	* Fichiers AIFF
+	* Amplification
+	* Égaliseur *3-Band*
+* Alexandra \textsc{Pizzini}
+	* GUI
+	* Contenu du site web
+* Vincent \textsc{Molinié}

doc/sout3/template_engine.md

+## CGI et moteur de template
+
+Pour la réalisation du site web, j'ai un réalisé un `CGI` en `OCaml` pour assurer la partie dynamique du site. Son principal intêret réside dans le moteur de template qu'il intègre.
+
+Ce dernier est destiné à traiter des templates `HTML` (situés dans le dossier `/website/templates/`) et de les liés avec du contenu dynamique afin de produire une page web.
+
+### Syntaxe
+
+J'ai défini la syntaxe des templates ainsi :
+
+* `[begin` *sect* `]` *html code* `[end]` : délimite une section de code html
+* `{` *sect* `}` : Inclut au template le contenu de la section *sect* délimitée précédemment
+* `{%` *fun* `%}` : Inclut le resultat de la fonction `OCaml` *fun*. Elle doit être déclarée dans le fichier `/website/cgi-bin/cgi_functions.ml`
+* `{@` *temp* `@}` : Indique au moteur de template que le template courant est inclus dans le template *temp*
+
+Une fois que le traitement est terminé, le contenu de la section `base` est envoyé au client grâce au serveur web (Nous utilisons `Apache` dans le cadre du projet).
+
+
+### `URL` dispatcher
+
+L'`URL` entrée par le client sera divisée par le `CGI` de cette manière :
+
+  http://domain?arg0/arg1/arg2/...
+
+`arg0` represente le nom de la page demandée par l'utilisateur.
+Il est possible de liéer `arg0` à un template dans le fichier `/website/cgi-bin/url.ml`.
+Les autres arguments peuvent être récupérés avec la fonctions `Env.get_url_arg n`.
+
+### Exemples
+
+#### base.html
+
+~~~html
+[begin base]
+<!DOCTYPE html>
+<html>
+  <head>
+   <title>OCaml-OCR -{ title }</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+  </head>
+  <body>
+    <nav>
+      <ul>
+	<li><a href="?index/">Home</a></li>
+	<li><a href="?about/">About</a></li>
+      </ul>
+    </nav>
+    { body }
+  </body>
+</html>
+[end]
+~~~
+
+#### templates/index.html
+
+~~~html
+{@ base.html @}
+
+[begin title] Index [end]
+
+[begin body]
+<h1>Hello World ! </h1>
+<p>{% get_time %}</p>
+[end]
+~~~
+
+#### templates/about.html
+
+~~~html
+{@ base.html @}
+
+[begin title] About [end]
+
+[begin body]
+<h1>About</h1>
+[end]
+~~~
+
+#### cgi-bin/url.ml
+
+~~~ocaml
+let get_page_from_url () =
+  match Env.get_url_arg 0 with
+    | "about" -> "about.html"
+    | _ -> "index.html"
+~~~
+
+#### cgi-bin/cgi_functions.ml
+
+~~~ocaml
+let get_function = function
+  | "get_time" -> Date.get_date ()
+  | f -> "Cannot find function : " ^ f
+~~~

doc/sout3/website 2.md

+# Site internet
+
+## Évolutions
+Nous arrivons à mi-parcours. Le site présenté précedemment était viable pour présenter un utilitaire. Mais nous avons préféré le refaire complètement afin d’y ajouter un aspect plus *multimédia* et plus *didactique*. Notre site internet se voit donc offrir un tout nouveau look !
+
+\begin{figure}[h]
+\centering
+\includegraphics[scale=0.4]{../img/website.png}
+\caption{\emph{Design} du nouveau site internet}
+\end{figure}
+
+Le site internet a été restructuré de la façon suivante pour plus lisibilité.
+
+* Une page d’accueil allant à l’essentiel.
+* Une section de *présentation détaillée*.
+* Une section *documentation*.
+* Une section *téléchargement*.
+* Une section *à propos*.
+
+La nouvelle page d’accueil permet de montrer en quelques coups d’oeil les différentes fonctionnalités qu’offre *StarDSP*. La section *téléchargement* permet de distribuer rapidement notre logiciel et nos rapports de soutenance. La section *documentation* permet quant à elle d’explique en détails le fonctionnement de *StarDSP* et préciser les solutions aux eventuels problèmes. La présentation *détaillée* présente globalement le logiciel mais avec beaucoup plus d’explication et de détails par rapport à la page d’accueil qui se limite à la présentation des points forts. La section *à propos* permet quant à elle de présenter le travail effectué par chaque membres de l’équipe, ainsi que des liens vers des projets personnels. On notera également que le site est désormais rédigé exclusivement en anglais pour pouvoir attirer un public plus large.
+
+## Hébergement
+
+Le projet commence à prendre de l’ampleur. C’est pourquoi nous hébergeons le site sur un serveur. Notre site étant réalisé grâce au moteur de *template* de Pierre \textsc{Surply}, il est nécessaire de le compiler pour pouvoir l’afficher. Le serveur distant n’ayant pas forcément la même configuration que nos ordinateurs personnels, nous devons effectuer la compilation sur le serveur distant.
+
+Pour la dernière soutenance le site internet sera éventuellement disponible sur internet, cela dépendra de la capacité de notre hébergeur à exécuter un site internet en *CGI*.

doc/sout3/website.md

+# Site web
+
+Pour ce projet le site Web est le principal support d'information de notre projet. Il devra permettre à l'utilisateur de disposer de toute l'aide et informations nécessaire à la bonne utilisation de *StarDSP*. Il aura ainsi accès à la description du projet ainsi qu'a une brève présentation de l'équipe.
+
+## Conception du site web
+
+Le projet StarDSP, se classant dans la catégorie des utilitaires, nous avons opté pour un style très épuré. Le site web est un élément important. Il s’agit du premier contact avec l’utilisateur. Nous avons donc décidé d’aborder une interface très claire et simple d’utilisation. Il est a noter que le design *CSS* a été fait de nos propres mains !
+
+La grande nouveauté pour ce projet est l’utilisation d’un moteur de template, réalisé par Pierre — *l’autre !* Ce moteur de template a considérablement accéléré la création du site internet. Et évite l’apprentissage d’un langage comme *PHP*.