Le son sur l ordinateur

Transcription

1 PGON.CA Le son sur l ordinateur Avec C++ et SDL Simon Levesque

2 1 Contenu Le son pour un ordinateur... 2 La fonction pour concevoir un échantillon avec une fréquence sonore désirée... 3 Créer un fichier WAV... 5 Comment mixer un son?... 7 Faire du son sur Simple DirectMedia Layer... 8 Le code source... 8 L explication du code... 10

3 2 Le son pour un ordinateur Dans le monde physique, le son est une onde qui se promène dans l air. S il n y a pas d air, tel dans l espace, il n y a pas de son. L air ambiant se contracte et se dilate et c est ce qui crée les différences de pressions que nos oreilles perçoivent. Tout le monde sait que la pression peut faire bouger des objets physiques comme compresser les parois d une bouteille de liqueur de 2 litres en plastique. De la même façon, la membrane dans l oreille ou la membrane dans un micro vibre au rythme du mouvement. Dans le cas d un micro, un courant électrique d une amplitude variable est créé par le phénomène d induction, grâce à une bobine de fils et un aimant, lorsque la membrane se déplace. Ce signal électrique est dit analogue parce qu il n a pas été transformé en série de nombres binaires (1 ou 0). Lors de la conversion analogue à digitale, il y a deux facteurs qui font perdre de la qualité au son. Les deux facteurs peuvent être améliorés, mais cela nécessite plus d espace mémoire et il est impossible de ne pas perdre de la qualité. Par contre, il est envisageable de prendre une valeur assez grande pour qu un humain soit totalement satisfait du résultat entendu. Les deux facteurs sont: la représentation numérique d une valeur et le nombre de valeurs prises par seconde. 1. La représentation numérique d une valeur est toujours faite à l aide de 0 et de 1. Le seul problème est de choisir le nombre de chiffres binaires (bits) qui représenterons une valeur qui peut être précise à l infini. Par exemple, si le voltage produit par un micro était de -1Volt à 1V, la mesure à un certain moment pourrait être de V. Avec un bit, il est possible d avoir 2 valeurs qui ne pourraient être que -1 et 0. Avec deux bits, la précision est doublée et ainsi 4 valeurs peuvent être prises tel -1, -0.5, 0, 0.5. Avec 3 bits, c est encore doublé pour aller à 8 valeurs, etc. Pour un ordinateur, les standards sont de 8 ou 16 bits représentants respectivement des plages de 256 ou valeurs différentes. 2. Le nombre de valeurs prises par seconde est appelé la fréquence d échantillonnage. Une fréquence sonore audible par un humain va d environ 20Hz à 20kHz ce qui signifie de 20 cycles pressurisations/dépressurisations à cycles pressurisations/dépressurisations. Un cycle irait par exemple de -0.2V à 0.2V et reviendrait à -0.2V pour compléter un cycle. Pour bien capter un son, il faut que l ordinateur prenne plusieurs mesures durant un cycle. Par exemple, pour un son de 100Hz, si nous prenons une fréquence d échantillonnage de 400Hz, nous obtiendrons 4 valeurs différentes par cycle. Par contre, si la fréquence d échantillonnage n était que de 100Hz, nous obtiendrons toujours la même valeur ce qui ne produirait aucun son. Il faut donc que ce nombre soit grand et les normes en informatique sont de 11025Hz, 22050Hz et 44100Hz. La section suivante montre des graphiques pour clarifier les choses. Pour connaître l espace de mémoire qu il faut pour avoir une certaine précision, il faut tenir compte de ces deux facteurs ci-haut mentionnés. Si nous prenons le meilleur cas avec des valeurs de 16 bits stéréo et une fréquence d échantillonnage de 44100Hz : À chaque seconde, valeurs sont prises. Chaque valeur est composée de 16 bits. C est donc 16*44100 bits par seconde. Cela donne bits par seconde.

4 3 Normalement l espace mémoire n est pas en bits, mais en octets. Un octet est composé de huit bits. Donc /8 = octets/seconde. Pour terminer, c est en stéréo. Il faut donc prendre deux fois plus de valeurs puisqu il y a deux canaux (gauche et droit). Ainsi, octets/seconde ou ko/seconde. Pour une musique à la radio de 3 minutes et 30 secondes, il y a 3*60+30 secondes. Il faut donc faire 176.4*210 = ko = 37 Mo. Ceux qui ont l habitude de prendre la musique d un CD et de la mettre en format WAV avant de l encoder en MP3 ne seront pas surpris par cette taille. Pour ceux qui n ont pas eu la chance d avoir des cours de physique ondulatoire (dieu aie leur âme), j ai trouvé un site qui fait un bon résumé de plusieurs sujets reliés au son. Le voici: La fonction pour concevoir un échantillon avec une fréquence sonore désirée Sâchant maintenant comment un ordinateur perçoit le son, il y a deux paramètres qui sont important pour générer un son: 1. La fréquence sonore à produire qui est le son lui-même. Par exemple la note LA qui a une fréquence de 440Hz. 2. La fréquence d échantillonnage qui est le nombre de valeurs prises par seconde. Prenons une fréquence sonore parfaite de 3Hz. Dans un sinus, un cycle est terminé lorsqu il y a eu 2*PI. PI étant égal à et que nous voulons qu il y ait 3 cycles par seconde: Le graphique est le suivant: ( ) ( ( ) ) ( ) ( ( ) )

5 4 Maintenant, avec une fréquence d échantillonnage de 18Hz, il y a 18 points par seconde qui sont mesurés. Ce sont les cercles rouges sur ce graphique: Techniquement, cela veut dire que si l ordinateur voulait reconstituer le son avec seulement ces valeurs, c est ce signal qu il enverrait aux haut-parleurs: Pour générer un son sur l ordinateur en tenant compte du nombre d échantillons déjà fourni plutôt que le temps courant que nous ne connaissons pas: Nous prenons la fonction du signal sinusoïdal que nous voulons construire. Pour le moment, la fonction parfaite est selon le temps et est : ( ) Pour fournir des points en sachant le nombre d échantillons déjà donnés, le compteur Progression est utilisé. Il commence à zéro et est incrémenté de un à chaque fois qu un point est donné. Au lieu de savoir la progression selon le temps, nous voulons savoir la progression par rapport au nombre d échantillons que le système prend. Ainsi, c est le rapport entre la progression et la fréquence d échantillonnage qui sert de temps. La fonction est alors ( )

6 5 Par exemple, si la fréquence d échantillonnage est de 18Hz, cela veut dire qu il y a 18 valeurs qui sont prises après une seconde. Puis, après une seconde, il y a eu fréquencesonore cycles. Alors en changeant progression = fréquenceéchantillonnage, cela revient à: ( ) où progression = fréquenceéchantillonnage ( ) ( ) ( ). C est justement la valeur après une seconde. Créer un fichier WAV Je sais qu il y a déjà beaucoup de librairies qui permettent de lire et d écrire des fichiers WAV. D ailleurs, SDL permet de les lire, mais pas de les écrire. Par contre, c est tellement plus plaisant de faire tout soit même et d ainsi mieux comprendre ce qui existe. Voici un petit programme C++ qui permet d émettre la note LA. #include <cmath> #include <fstream> #include <iostream> using namespace std; struct Wave_File_Header { unsigned int ChunkID; // Le type de fichier «RIFF» unsigned int ChunkDataSize; // La grandeur du fichier sans le header unsigned int RiffType; // Le type de RIFF «WAVE» ; struct Format_Chunk { unsigned int ChunkID; // «fmt» unsigned int ChunkDataSize; // La grandeur de la partie donnee (16) short unsigned int CompressionCode; short unsigned int NumberOfChannels; unsigned int SampleRate; unsigned int AverageBytesPerSeconds; short unsigned int BlockAlign; short unsigned int SignificantBitsPerSample; ; struct Data_Chunk { unsigned int ChunkID; // «data» unsigned int ChunkDataSize; // La grandeur de la partie donnee (16) ; int main(int argc, char *argv[]) { // Remplir le header du fichier Wave_File_Header monhead; monhead.chunkid = ; // «RIFF» monhead.rifftype = ; // «WAVE»

7 6 // Remplir le format du fichier Format_Chunk monformat; monformat.chunkid = 0x20746D66; // «fmt» monformat.chunkdatasize = 16; monformat.compressioncode = 1; // PCM/uncompressed monformat.numberofchannels = 1; // Mono monformat.samplerate = 22050; // 22kHz monformat.significantbitspersample = 16; monformat.blockalign = monformat.significantbitspersample / 8 * monformat.numberofchannels; monformat.averagebytesperseconds = monformat.samplerate * monformat.blockalign; // Remplir le header du data chunk Data_Chunk mondata; mondata.chunkid = ; // «data» mondata.chunkdatasize = monformat.chunkdatasize/8*monformat.samplerate; // Le nombre d echantillons dans une seconde multiplie par le nombre d octets // Entrer la grosseur total du fichier sans le header dans le header monhead.chunkdatasize = sizeof(format_chunk) + sizeof(data_chunk) + mondata.chunkdatasize; // Ouvrir le fichier de son ofstream fout(«tmp.wav», ios::binary); // Ecrire les headers fout.write((char *) &monhead, sizeof(monhead)); fout.write((char *) &monformat, sizeof(monformat)); fout.write((char *) &mondata, sizeof(mondata)); // Generer une seconde double valeurdouble; short int valeur16; for(double i=0; i<monformat.samplerate; i++) { // Calculer valeurdouble = * sin(i/monformat.samplerate*2*3.1416*440); valeur16 = (short int) valeurdouble; // Ecrire fout.write((char *) &valeur16, sizeof(valeur16)); // Fermer le fichier fout.close(); Un fichier WAV est un type dans le format de fichier RIFF 1 (Resource Interchange File Format). Le contenu d un tel fichier est fait de plusieurs paquets de données appelés chunks. Il faut d abord définir dans le fichier que c est un RIFF avec du WAVE dedans. Ceci est fait avec la structure Wave_File_Header. Ensuite, il faut définir le format du fichier dans le Format_Chunk. 1

8 7 Puis dire combien de données il y a dans le fichier pour ainsi pouvoir connaitre la progression sans même avoir reçu la fin (streaming). C est écrit dans Data_Chunk. Pour finir, les données sont mises. Dans cet exemple, nous savons déjà qu il y a pour une seconde de données. Il est donc possible de calculer les grosseurs d avance, mais dans un vrai projet, il faut parfois aller au fur et à mesure. Pour ne pas se casser la tête, voici ce qui peut être fait: 1. Écrire dans le fichier les headers avec des données manquantes. 2. Écrire les données tout en incrémentant les compteurs dans les headers. 3. Revenir au début dans le fichier. (Avec ofstream, simplement appeler variable.seekp(0)) 4. Puis réécrire les headers et fermer le fichier. Pour plus d informations sur le format WAV, ce site est excellent: The Sonic Spot 2 Comment mixer un son? Superposer deux sons dans la réalité est très simple. Il suffit d additionner les sons jusqu à s en casser les tympans. Par contre en informatique, il y a une limite au volume maximal. Par exemple, pour un échantillon de 16 bits signé, le volume maximum est de = Si l addition des sons donne un nombre au-dessus de cette valeur, le compteur retombera à Si nous additionnons , normalement, nous voulons avoir 32770, mais ce nombre est de 3 au-dessus de la valeur maximale. Ainsi, nous obtiendrons et ce n est pas souhaité. Une autre tactique est de faire la moyenne des sons. Par contre, cela réduira le volume total. Par exemple, si un son émet un volume de et l autre un silence de 0, nous voudrions obtenir quand même un son de 30000, mais nous obtiendrons Ce qui peut être fait est un compromis des deux. Il faudrait donc faire la moyenne et ensuite amplifier le son d un facteur qui rend le volume maximum courant au volume maximum des trois échantillons différents à mixer. Cela demande par contre beaucoup de calculs et c est pourquoi normalement, le volume est amplifié d un facteur constant (surtout dans les circuits électroniques simples). 2

9 8 Faire du son sur Simple DirectMedia Layer Il y a beaucoup d articles qui parlent d affichage 3D. Il y a aussi beaucoup de cours de programmation qui se veulent multimédia, mais trop peu se consacrent au son. Pourtant, le son est omniprésent dans les vidéos, les jeux et les films. Voici donc comment commencer à générer des sons avec la librairie SDL 3 qui est gratuite pour Windows, Linux et MacOS. Faire du son sur l ordinateur, ce n est pas aussi simple que de dessiner à l écran. Ce n est pas simplement un pixel auquel nous associons une couleur, mais des différences de volumes selon le temps qu il faut définir en temps réel. Le code source Voici donc le fichier squelette qui émet la note LA (440 Hz): #include <cmath> #include <iostream> #include " SDL/SDL.h" #include " SDL/SDL_audio.h" using namespace std; // Variables globales SDL_AudioSpec materiel; // La fonction de generation de sons void genaudio(void *unused, Uint8 *stream, int len); int main(int argc, char *argv[]) { SDL_AudioSpec fmt; // Initialiser le mode audio if ( SDL_Init(SDL_INIT_AUDIO) < 0 ) { cerr << " Unable to init SDL: " << SDL_GetError() << endl; return 1; // Pour que la desinitialisation de SDL se fasse quand l application quittera atexit(sdl_quit); // Choisir les parametres du signal fmt.freq = 22050; fmt.format = AUDIO_S16; fmt.channels = 1; fmt.samples = 512; fmt.callback = genaudio; fmt.userdata = NULL; // Ouvrir le peripherique de son if ( SDL_OpenAudio(&fmt, &materiel) < 0 ) { cerr << " Unable to open audio: " << SDL_GetError() << endl; return 1; 3

10 9 // Demarrer la lecture SDL_PauseAudio(0); // Afficher les informations materielles cout << " Frequence: " << materiel.format << endl; cout << " Format: " << materiel.freq << endl; cout << " Channels: " << materiel.channels << endl; cout << " Samples: " << materiel.samples << endl << endl; // Attente SDL_Delay(10000); // Fermer le son SDL_CloseAudio(); // Faire la note LA en 16 bits signe void genaudio(void *unused, Uint8 *stream, int len) { static Sint16 unevaleur = ; static unsigned int Progression = 0; double unpoint; double frequencesonore = 440; // Un LA // Remplir de donnees for (int i=0; i<len ; i+=2) { // Saut de deux car 16 bits // Dessiner le sinus unpoint = * sin(progression*2*3.1416*frequencesonore/materiel.freq); Progression ++; unevaleur = (Sint16) unpoint; *((Sint16 *) &stream[i]) = unevaleur; Vous pouvez aussi essayer d autres fonctions qui changent la fréquence selon le temps comme celles-ci: // Avoir une frequence qui va en augmentant selon le temps void genaudio(void *unused, Uint8 *stream, int len) { static Sint16 unevaleur = ; static unsigned int Progression = 0; double unpoint; static double frequencesonore; // Remplir de donnees for (int i=0; i<len ; i+=2) { // Saut de deux car 16 bits // Augmenter la frequence a chaque passage frequencesonore = Progression*100.0/(double)materiel.freq ; // Pour augmenter de 100 Hz par seconde en commencant a 200Hz // Dessiner le sinus unpoint = * sin(progression*2*3.1416*frequencesonore/materiel.freq); Progression ++; unevaleur = (Sint16) unpoint;

11 10 *((Sint16 *) &stream[i]) = unevaleur; // Afficher la frequence sonore terminale cout << frequencesonore << endl; Pour compiler, sous Linux, il suffit d écrire: «g++ -o test sdl_audio_squelette.cpp -lsdlmain -lsdl» pour compiler le programme test incluant les librairies SDLmain et SDL. Sous Windows avec le compilateur MinGW: «g++ -o test.exe sdl_audio_squelette.cpp -lmingw32 -lsdlmain lsdl». L explication du code Pour commencer, il faut initialiser la librairie SDL en lui disant ce que nous désirons utiliser. Puisque ce n est que de l audio, c est «SDL_INIT_AUDIO». Ensuite, il ne faut jamais oublier de fermer comme il faut la librairie et cela n est pas fait automatiquement à la sortie du programme. Pour l automatiser, un «atexit» est appelé avec la fonction pour fermer la librairie. Par la suite, nous choisissons un format que nous aimerions avoir. La fréquence d échantillonnage choisie est 22kHz, ce qui signifie qu il faut donner mesures de volume par seconde. Le format choisi est «AUDIO_S16? ce qui signifie que chaque mesure de volume est représentée par un entier signé de 16 bits. En d autres termes, puisqu il y a 16 bits, il y a 2 à la puissance 16 valeurs différentes (65536) que la mesure peut prendre et puisqu elle est signée, au lieu d être de 0 à 65535, c est de à Puisque nous voulons que ce soit mono, un seul canal est utile; pour du stéréo, ce serait deux. Il faut donner des valeurs de volume à la librairie SDL pour qu elle sache quoi jouer comme son. Plutôt que de n en donner qu une seule à la fois, c est un tampon que nous remplirons avec la fonction de génération sonore. Nous demandons donc un tampon de 512 mesures. La fonction de génération sera donc appelée 44 fois par seconde (22050/512). Il faut choisir cette valeur selon l utilisation voulue. Pour pouvoir modifier le son très rapidement (comme pour un coup de feu), il faut qu il soit petit. S il est trop petit et que le programme fait beaucoup d autres choses que de jouer du son, le tampon n aura pas le temps de se remplir assez rapidement et il va y avoir des coupures. Après cela, il faut ouvrir le périphérique de son et démarrer la lecture en mettant la pause à faux. Étant donné que le matériel ne supporte peut-être pas ce que nous avons demandé comme format, il est préférable de vérifier ce que le matériel nous donne. C est ce qui est affiché. Pour terminer la fonction principale, le thread attend 10 secondes. Le son est géré sur un autre thread et c est pourquoi nous pouvons appeler la fonction bloquante SDL_Delay. Dernièrement, la fonction de génération produit la note LA. La description du pourquoi du comment que la fonction ( ) a été trouvée est

12 11 expliquée précédemment. Il n y a que deux choses qui restent à expliquer. Nous avons demandé d utiliser un entier signé de 16 bits et ce qui nous est passé en paramètre est un tampon d entiers non signés de 8 bits. Le signe ne dérange pas vraiment puisque la valeur que nous désirons est mise dans le bon type. Il suffit donc de pouvoir l entrer tel quel dans le tampon. Étant donné que nous utilisons 2 fois plus de bits, chaque valeur de 16 bits sera écrite dans deux cases de 8 bits. 1. C'est pourquoi la variable i saute de deux valeurs à chaque passage. 2. C'est pourquoi la ligne obscure «*((Sint16 *) &stream[i]) = unevaleur;» est présente pour copier la valeur. Si vous voulez comprendre la ligne «*((Sint16 *) &stream[i]) = unevaleur;», continuez de lire, sinon, c est terminé pour vous. Sachez simplement que dans l autre fonction génératrice, le changement de fréquence est mis dans la boucle for pour que l ajustement se fasse au fur et à mesure, sinon ça ne sonne pas doux. Vous pouvez l essayer à l extérieur pour comprendre. *((Sint16 *) &stream[i]) = unevaleur; Allons-y par étape: Nous voulons mettre la valeur de volume qui est en rouge dans le tampon. Il faut donc modifier le tampon pour qu il prenne deux cases au lieu d une. En bleu, c est l endroit qui représente notre première case (i+1 est notre seconde case). Pour modifier le type, la façon la plus simple est d oublier ce que c est en prenant non pas la valeur en bleue, mais l endroit pointé dans la mémoire par cette case. 8 bits plus loin dans la mémoire, c est la seconde case. Pour obtenir l adresse mémoire, de la première case, il faut ajouter le caractère en vert. Nous avons donc l adresse mémoire de la case de 8 bits. Pour changer cela en adresse mémoire d une case de 16 bits et d ainsi pouvoir copier tous nos bits, il faut caster en pointeur d entier signé de 16 bits. C est ce qui est entre parenthèse en mauve. Dernière étape, nous avons une adresse mémoire du type que nous voulons et nous voulons affecter une valeur dans cet espace mémoire. Pour rendre une adresse en valeur, il faut mettre l adresse entre parenthèses et ajouter une étoile devant. C est en bourgogne. Pour résumer, nous prenons l adresse mémoire de la première case plutôt que la case elle-même. Avec cette adresse, nous pouvons la changer en adresse de n importe quel type. Puis cette adresse de type voulu est changée en case dans laquelle nous pouvons mettre notre valeur. Vive C++!