Bonjour,
J'aurais besoin de lire un fichier Wav sur Python, enfin plutôt d'extraire de ce fichier les différents niveaux des differents échantillons pour les avoir sur une échelle de zéro a 255. J'arrivais a le faire sur 8bits avec la fonction ord, mais cela ne fonctionne pas en 16bits... Sauriez vous comment faire ?? Ou y a-t-il d'autres fonctions qui permettraient de le faire ?
Merci d'avance pour vos réponses !
Bonsoir,
si tu es obligé d'utiliser la fonction ord pour interpréter les échantillons, c'est que déjà la version 8 bits de ton code ne va pas. Les données d'un wav ne sont pas des caractères. Un fichier wav est organisés par blocs ("chunks"), avec en général :
- un premier bloc pour dire que c'est un fichier par blocs
- un deuxième bloc servant d'en-tête aux données PCM (comprenant la fréquence d'échantillonnage, la précision de codage, le nombre de canaux, et la taille des données PCM)
- un troisième bloc qui est justement les données PCM
Les données PCM sont directement codées avec des types connus, quelle que soit la précision. Si le tableau dans lequel tu recopies les données du fichier est constitué du bon type dès le départ, alors la valeur est directe.
En cherchant environ 10 secondes, on trouve cela :
https://docs.python.org/2/library/wave.html
Bonsoir,
J'ai deja vu cette page, mais je n'arrive pas à utiliser la fonction readframes qui semble être la seule si je ne me trompe pas à pouvoir me renvoyer les échantillons... Et mon programme fonctionne malgré tout sur du 8bits... Alors du coup comment est ce que je peux interpréter les échantillons sur du 16bits? Merci
Bonsoir,
Oui, par inadvertance. En WAV, le codage PCM donne directement la valeur de l'éhantillon sur des entiers signés. Donc pas besoin de passer par ord, c'est du (mauvais) bidouillage.Envoyé par gav91
Comment lis-tu l'en-tête du fichier en 8 bits ? Ou plus simplement, peux-tu mettre ton code ? Je ne connais pas Python, mais on est sur des trucs simples, donc ça devrait aller.
Voici mon programme :
A savoir qu'après je ne prends pas en compte les premières valeurs qui correspondent à l'entête...Code:def donnees(x): fichier=open(x,'rb') data=fichier.read() taille1=len(data) fichier.close() octets=np.zeros(taille1) for p in range(0,taille1): octets[p]=ord(data[p]) return octets
Comment pourrais je faire autrement alors ? Et comment faire pour que ça marche aussi sur du 16bits? Merci
Dernière modification par JPL ; 19/03/2015 à 23h14. Motif: Ajout de la balise Code (#) pour garder l'indentation
Bonjour,
la version 8 bits de ton programme est donc en entiers non signés. Il faut au moins passer en entiers signés (tu retranches 128 à tous tes résultats, ou bien tu interprètes directement le résultat de ton ord() comme un entier signé).
tu trouveras la constitution des 44 premiers octets d'un WAV ici :
http://fr.wikipedia.org/wiki/WAVEform_audio_format
Si ton fichier est "basique", seuls ces 44 premiers octets seront présents avant les données. Sinon, n'importe quel logiciel peut rajouter n'importe quel bloc perso avant les données, le tout est alors d'ignorer ces blocs.
De mon point de vue, le plus simple est de créer un objet contenant tous les attributs décrits dans le bloc de format (tu peux mettre de côté le bloc de déclaration). Tu alloues ensuite un tableau dynamique en fonction des données exactes du bloc de format (précision et taille), et tu n'as plus qu'à transférer les données du fichier dans ton tableau. L'interprétation des échantillons est alors directe.
Si vraiment tu ne sais utiliser que la fonction "read" de Python, qui apparemment manipule des caractères, alors tu peux t'en sortir en 16 bits avec la bidouille de "transtypage" suivante :
1 - tu découpes ton tableau par blocs de 2 caractères
2 - un entier 16 bits signé possèdes ses 2 octets "inversés"
3 - tu multiplies ord(caractère_2) par 256, et tu ajoutes ord(caractère_1) (là, il faut être clair sur le résultat que tu obtiens : entier non signé à priori)
4 - pour passer à un entier signé, soit tu transtypes, soit tu retranches 65536 si le résultat est supérieur ou égal à 32768
Pour le bidouillage, y'a plein de manières de faire cela plus propre et plus dans l'esprit programmation :
- utilisation directe d'un entier signé à l'étape 3 en débrayant les erreurs de dépassement (pas sûr que cela ait un sens en Python, que je ne connais pas du tout)
- copie directe de ton tableau de caractères dans une zone mémoire déclarée en entiers signés (utilisation des pointeurs)
- utilisation détournée des codes ASCII étendus
- etc.
Bonjour,
J'ai également trouvé que l'on pouvait directement utiliser le module struct.unpack pour convertir des string dans le format que l'on veut. J'ai donc essayé en utilisant struct.unpack(%sh) pour le 16 bits qui devrait convertir les données en entier, mais le fait est que cela ne me renvoie quasiment que 0 ou 65535 (=2^16). D'où vient le problème ? N'est ce pas possible de faire ainsi ? Merci d'avance
