22.4. "wave" --- Lecture et écriture des fichiers WAV
*****************************************************

**Code source :** Lib/wave.py

======================================================================

Le module "wave" fournit une interface pratique pour le format de son
WAV. Il ne gère pas la compression ni la décompression, mais gère le
mono et le stéréo.

Le module "wave" définit la fonction et l'exception suivante :

wave.open(file, mode=None)

   Si *file* est une chaîne de caractères, ouvre le fichier sous ce
   nom, sinon, il est traité comme un objet de type fichier. *mode*
   peut être :

   "'rb'"
      Mode lecture seule.

   "'wb'"
      Mode écriture seule.

   Notez que ce module ne permet pas de manipuler des fichiers WAV en
   lecture/écriture.

   Un *mode* "'rb'" renvoie un objet "Wave_read", alors qu'un *mode*
   "'wb'" renvoie un objet "Wave_write". Si *mode* est omis et qu'un
   objet de type fichier est donné au paramètre *file*, "file.mode"
   est utilisé comme valeur par défaut pour *mode*.

   Si vous donnez un objet de type fichier, l'objet *wave* ne le ferme
   pas lorsque sa méthode "close()" est appelée car c'est l'appelant
   qui est responsable de la fermeture.

   The "open()" function may be used in a "with" statement.  When the
   "with" block completes, the "Wave_read.close()" or
   "Wave_write.close()" method is called.

   Modifié dans la version 3.4: Ajout de la gestion des fichiers non
   navigables.

wave.openfp(file, mode)

   Un synonyme de "open()", maintenu pour la rétrocompatibilité.

exception wave.Error

   Une erreur est levée lorsque quelque chose est impossible car elle
   enfreint la spécification WAV ou rencontre un problème
   d'implémentation.


22.4.1. Objets Wave_read
========================

Les objets Wave_read, tels qu'ils sont renvoyés par "open()", ont les
méthodes suivantes :

Wave_read.close()

   Ferme le flux s'il a été ouvert par "wave" et rend l'instance
   inutilisable. Ceci est appelé automatiquement lorsque l'objet est
   détruit .

Wave_read.getnchannels()

   Renvoie le nombre de canaux audio ("1" pour mono, "2" pour stéréo).

Wave_read.getsampwidth()

   Renvoie la largeur de l'échantillon en octets.

Wave_read.getframerate()

   Renvoie la fréquence d'échantillonnage.

Wave_read.getnframes()

   Renvoie le nombre de trames audio.

Wave_read.getcomptype()

   Renvoie le type de compression ("'NONE'" est le seul type géré).

Wave_read.getcompname()

   Version compréhensible de "getcomptype()". Généralement, "'not
   compressed'" équivaut à "'NONE'".

Wave_read.getparams()

   Renvoie une "namedtuple()" "(nchannels, sampwidth, framerate,
   nframes, comptype, compname)", équivalent à la sortie des méthodes
   "get*()".

Wave_read.readframes(n)

   Lit et renvoie au plus *n* trames audio, sous forme d'objet
   "bytes".

Wave_read.rewind()

   Remet le pointeur de fichier au début du flux audio.

Les deux méthodes suivantes sont définies pour la compatibilité avec
le module "aifc" ; elles ne font rien d’intéressant.

Wave_read.getmarkers()

   Renvoie "None".

Wave_read.getmark(id)

   Lève une erreur.

Les deux fonctions suivantes utilisent le vocabulaire "position". Ces
positions sont compatible entre elles, la "position" de l'un est
compatible avec la "position" de l'autre. Cette position est
dépendante de l'implémentation.

Wave_read.setpos(pos)

   Place le pointeur du fichier sur la position spécifiée.

Wave_read.tell()

   Renvoie la position actuelle du pointeur du fichier.


22.4.2. Objets Wave_write
=========================

Pour les flux de sortie navigables, l'en-tête "wave" est
automatiquement mis à jour pour refléter le nombre de trames
réellement écrites. Pour les flux non indexables, la valeur *nframes*
doit être précise lorsque la première trame est écrite. Une valeur
précise de *nframes* peut être obtenue en appelant les méthodes
"setnframes()" ou "setparams()" en passant en paramètre le nombre de
trames qui seront écrites avant que "close()" soit appelé puis en
utilisant la méthode "writeframesraw()" pour écrire les trames audio,
ou en appelant la méthode "writeframes()" avec toutes les trames
audio. Dans ce dernier cas, la méthode "writeframes()" calcule le
nombre de trames dans le flux audio et définit *nframes* en
conséquence avant d'écrire les données des trames.

Les objets Wave_write, tels qu'ils sont renvoyés par "open()", ont les
méthodes suivantes :

Modifié dans la version 3.4: Ajout de la gestion des fichiers non
navigables.

Wave_write.close()

   Assurez-vous que *nframes* soit correct et fermez le fichier s'il a
   été ouvert par "wave". Cette méthode est appelée à la destruction
   de l'objet. Il lève une erreur si le flux de sortie n'est pas
   navigable et si *nframes* ne correspond pas au nombre de trames
   réellement écrites.

Wave_write.setnchannels(n)

   Définit le nombre de canaux.

Wave_write.setsampwidth(n)

   Définit la largeur de l'échantillon à *n* octets.

Wave_write.setframerate(n)

   Définit la fréquence des trames à *n*.

   Modifié dans la version 3.2: Un paramètre non-entier passé à cette
   méthode est arrondi à l'entier le plus proche.

Wave_write.setnframes(n)

   Définit le nombre de trames à *n*. Cela sera modifié ultérieurement
   si le nombre de trames réellement écrites est différent (la
   tentative de mise à jour générera une erreur si le flux de sortie
   n'est pas indexable).

Wave_write.setcomptype(type, name)

   Définit le type de compression et la description. Pour le moment,
   seul le type de compression "NONE" est géré, c'est-à-dire aucune
   compression.

Wave_write.setparams(tuple)

   Le *tuple* doit être "(nchannels, sampwidth, framerate, nframes,
   comptype, compname)", avec des valeurs valides pour les méthodes
   "set*()". Tous les paramètres sont obligatoires et doivent être
   définis.

Wave_write.tell()

   Renvoie la position actuelle dans le fichier, avec les mêmes
   réserves que pour les méthodes "Wave_read.tell()" et
   "Wave_read.setpos()".

Wave_write.writeframesraw(data)

   Écrit les trames audio sans corriger *nframes*.

   Modifié dans la version 3.4: N'importe quel *bytes-like object* est
   maintenant accepté.

Wave_write.writeframes(data)

   Écrit des trames audio et s'assure que *nframes* est correct. Une
   erreur est levée si le flux de sortie est non-navigable et si le
   nombre total de trames écrites après que *data* soit écrit ne
   correspond pas à la valeur précédemment définie pour *nframes*.

   Modifié dans la version 3.4: N'importe quel *bytes-like object* est
   maintenant accepté.

Notez qu'il est impossible de définir des paramètres après avoir
appelé "writeframes()" ou "writeframesraw()", et toute tentative en ce
sens lève une "wave.Error".
