le son, qu'est ce ?

Salut à tous, je suis (encore) de retour, durant mes nombreuses périgrinations, je me suis posé la question: comment un ordinateur comprends et reproduit-it un son? Alors, je commençai mes rechercher. J'ai donc trouvé que basiquement, le son est une onde plutôt sinusoïdale avec des périodes plus ou moins longue en fonction des fréquences(je n'ai pas le niveau en physique pour assurer cela). Ce site explique comment le format MP3 fonctionne :http://www.sebsauvage.net/comprendre/mp3/ et le site comment ça marche parle de l'algorithme huffman pour la réduction de la taille d'un fichier. Je souhaiterais créer un programme qui permette d'écrire un fichier son à partir de bits seulement (par exemple, transformer un fichier .png en .mp3) mais aussi pouvoir, en insérant des valeurs créer des sons ou des musiques pourquoi pas. C'est d'abords a but expérimental. Quelles ressources et quels conseils pourriez vous me donner? Je n'ai trouvé aucune détails techniques précis sur comment est organisé un fichier son… Mais juste des infos physiques que le son et son comportement m'aiderait. Merci beaucoup pour vos conseils et sur ce je retourne à mes recherches

Déjà merci beaucoup pour cette super réponse ;). Ensuite, je peux mal m'exprimer, j'en suis désolé, je n'ai jamais étudiés les ondes.

Je souhaiterais créer un programme qui permette d'écrire un fichier son à partir de bits seulement (par exemple, transformer un fichier .png en .mp3) […] GouleFutée Je ne suis pas sûr de te suivre sur ce point… Peux-tu préciser ta pensée ?

donc ce que j'entends par la, ce n'est pas de la transformation, mais je parle du postulat, un fichier png est un ensemble de codes en hexa et en binaire qui décrivent les differents éléments de l'image(je parle ici seulement de ce qui est bitmap) et un fichier son est aussi un ensemble d'infos en binaire(enfin je suppose), il serait donc possible de "désassembler" un fichier PNG et de lire et écrire dans un fichier son code binaire/hexa. J'espere ne pas trop vous avoir perdu… Merci beaucoup Taurre pour ta précieuse lumière et ne t'inquiète pas, je ne vais probablement pas déterminer TOUTES les valeurs à la mains, je suis curieux pas fou

Je pense qu'il veut récupérer la suite d'octets d'un fichier autre pour la réencoder en fichier son.

exact phigger

Tu supposes bien.

Tu peux effectivement utiliser le contenu d'un fichier PNG pour créer un fichier audio, mais le résultat risque d'être assez peu agréable à entendre. Cela dit, c'est parfaitement faisable, oui.

Merci beaucoup pour tous vos éléments, je crois en avoir presque assez: par exemple, on peut voir à quoi ressemble disons, les 4 premieres notes de Hells bells(:p), qui ressemble donc a une courbe, mais comment la reproduire?

Je comprends pas l'intérêt en fait de faire un son à partir d'une image. Ça n'a aucun sens. Il te faudrait définir toi-même à quoi correspond chaque pixel de l'image en termes de son.

Si tu veux apprendre des choses sur le son, je te conseillerais de faire quelques recherches sur la transformée de Fourier (et non pas les séries de Fourier, qui ne concernent que les signaux périodiques alors que la transformée est définie sur tout signal). Le principe est de dire qu'on peut décomposer pas trop mal tout signal sous forme de somme de sinus et le recomposer de manière pas trop mauvaise en superposant ces différents signaux (synthèse de Fourier).

Tu peux aussi te pencher sur l'échantillonnage vu qu'il y a pas mal de phénomènes à prendre en compte, par exemple le repliement et le critère de Shannon.

Juste histoire de préciser, ça doit vouloir dire que tu es obligés d'utiliser un langage suffisamment bas niveau pour pouvoir manipuler les octets directement, donc à priori le C (détrompez-moi si vous connaissez un autre langage pour le faire). Ensuite, il va falloir que tu vire tout ce qui est en-tête de fichier, puis que tu récupères la suite d'octets restante, et enfin que tu l'enregistres en tant que son.

Mais je préfère te prévenir, la probabilité est plus que forte que tu n'arrives à rien avec ça. Déjà, il te faudra des images vachement grandes pour avoir une durée pas trop courte (2 pixels = 3 échantillons de son, soit (3/44100) seconde). Et ensuite ça fera des sons très moches.

@Berdes : Le 16 bits est tout à fait suffisant, et c'est le standard. Le 24 bits n'est utilisé qu'en studio pendant le mixage son d'une bande sonore afin d'éviter les approximations de calcul, mais à la fin c'est exporté en 16 bits.

Hum, ok donc impossible d’imaginer de faire ça en java? Une image c'était juste le défis et l'expérimentation

Je ne pense pas, malheureusement. Si jamais c'est le cas, il doit falloir descendre assez profondément dans la JVM.

Hum, donc le choix du C++ est plus judicieux dans ce cas…Très bien, merci à tous, je ne ferme pas encore le Thread (au cas ou)

Mais non, c'est possible. Java doit être tout à fait capable d'ouvrir un fichier en mode binaire et d'effectuer des opérations bit à bit. Il faut rien de plus.

Utilise ton langage favori, c'est quasi certain que tu puisses faire ça avec.

java en binaire je crois avoir trouvé en effet

Juste pour préciser : en parcourant une image sensé de manière continue, genre avec une courbe de Hilbert, de Peano ou de Moore et en interprétant les données des pixels (RGB, HSL ou autre) sous forme de fréquences, il doit quand même y avoir moyen d'avoir un son relativement pas désagréable.

Autrement, j'ai tester la génération d'un fichier wav en C++ et ça passe sans soucis. Donc si ça peux être utile à quelque, le voici :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <limits>
#include <vector>

using namespace std;

using data_t = int16_t;

struct WaveHeader {
  char fileTypeBlocID[4] = {'R','I','F','F'};
  uint32_t fileSize;
  char fileFormatID[4] = {'W','A','V','E'};

  char formatBlockID[4] = {'f','m','t',' '};
  uint32_t blocSize = 16;
  uint16_t audioForamt = 1;
  uint16_t nbrCanaux = 1;
  uint32_t frequence;
  uint32_t bytePerSec;
  uint16_t bytePerBloc;
  uint16_t bitsPerSample;

  char dataBLocID[4] = {'d','a','t','a'};
  uint32_t dataSize;
} __attribute__((packed,aligned(1)));

int main() {
  ofstream file("test.wav", ios::binary | ios::trunc);
  vector<data_t> sound;

  for(int i=1; i<=7; ++i) {
    for(int j=0; j<22000; ++j) {
      double value = sin(j*i/100.*M_PI/2.)*numeric_limits<data_t>::max();
      sound.push_back(value);
    }
  }
  for(int i=1; i<=7; ++i) {
    for(int j=0; j<22000; ++j) {
      double value = sin(j*i/100.*M_PI/2.)*numeric_limits<data_t>::max();
      value += sin(j*(i-1)/100.*M_PI/2.)*numeric_limits<data_t>::max();
      value /= 2;
      sound.push_back(value);
    }
  }
  for(int i=1; i<=7; ++i) {
    for(int j=0; j<22000; ++j) {
      double value = 0.;
      for(int k=1; k<=i; ++k) {
        value += sin(j*k/100.*M_PI/2.)*numeric_limits<data_t>::max();
      }
      value /= i;
      sound.push_back(value);
    }
  }

  WaveHeader header;
  header.frequence = 44000;
  header.bitsPerSample = sizeof(data_t)*8;
  header.dataSize = sound.size()*header.bitsPerSample/8;

  header.fileSize = header.dataSize + 36;
  header.bytePerBloc = header.nbrCanaux*header.bitsPerSample/8;
  header.bytePerSec = header.frequence*header.bytePerBloc;

  cout << sizeof(header) << endl;
  assert(sizeof(header) == 44);
  file.write(reinterpret_cast<char*>(&header), sizeof(header));
  for(const data_t i : sound) {
    file.write(reinterpret_cast<const char*>(&i), sizeof(i));
  }
  return 0;
}

Note : l'attribut __attribute__((packed,aligned(1))) est spécifique à gcc. Il indique au compilateur de bien mettre les attributs les uns à la suite des autres sans laisser de place entre et est important pour écrire le header d'un coup dans le fichier (ligne 70). Donc si vous utilisez un autre compilateur, il faudra adapter cette partie (ou écrire les champs de l'en-tête un par un).

détrompez-moi si vous connaissez un autre langage pour le faire

Quasiment tous. La question intéressante serait plutôt quel langage ne peut pas le faire.

D'accord, donc j'ai dit n'importe quoi

J'avais fait un topic sur le wave il y a de ça un moment… https://openclassrooms.com/forum/sujet/le-format-wave-37889

@Taurre: le format mp3 utilise le codage de huffman ! Les pertes se font selon des modèles psychoacoustique. C'est en fonction de ça que 2 encodeurs qui encodent les mêmes données ne donnent pas les mêmes résultats. Je dirais que c'est la partie la plus complexe dans la compression audio.

merci beaucoup ^^. J'ai deja commencé à lire des fichier d'images, qui sont plus simple dans leurs structures binaires mais je vais bientot commencer le son. Super sujet au fait c'est vraiment super utile

Bon, c'est très casse gueule en java et la manipulation de bits est très fastidieuse. je pense que je vais passer sur du C++ qui semble quand même bien plus adapté a la situation.Rien que l'absence de pointeurs est gênante…Parce que j'ai du mal a transposer le code du post d'OC en java(beaucoup de mal)