Comment trouver un fichier wav

Je viens de lire un fichier wav avec scipy et maintenant je veux faire de la parcelle de terrain du fichier à l'aide de matplotlib, sur l'échelle y" je veux voir l'amplitude et sur le "x échelle" je veux voir le nombre de cadres!
Toute aide comment puis-je le faire??
Merci!!!!

from scipy.io.wavfile import read
import numpy as np
from numpy import*
import matplotlib.pyplot as plt
a=read("C:/Users/Martinez/Desktop/impulso.wav")
print a

ce n' print a de sortie?
Est-ce un simple ou multi-canal wavfile?
L'impression un, juste montrer un tuple avec les données brutes du fichier audio. Et c'est un mono wavfile.

InformationsquelleAutor Diego Martínez Giardini | 2013-09-04

66

Vous pouvez appeler vague lib pour lire un fichier audio.

Le tracé de la forme d'onde, utiliser le "complot" de la fonction de matplotlib
```
import matplotlib.pyplot as plt
import numpy as np
import wave
import sys


spf = wave.open("wavfile.wav", "r")

# Extract Raw Audio from Wav File
signal = spf.readframes(-1)
signal = np.fromstring(signal, "Int16")


# If Stereo
if spf.getnchannels() == 2:
    print("Just mono files")
    sys.exit(0)

plt.figure(1)
plt.title("Signal Wave...")
plt.plot(signal)
plt.show()
```
vous aurez quelque chose comme:

Pour Tracer l'axe des x en quelques secondes vous avez besoin d'obtenir le taux de trame et le diviser par la taille de votre signal, vous pouvez utiliser la fonction linspace de numpy pour créer un Temps de Vecteur espacés de façon linéaire avec la taille du fichier audio et enfin, vous pouvez utiliser de la parcelle, à nouveau, comme plt.plot(Time,signal)
```
import matplotlib.pyplot as plt
import numpy as np
import wave
import sys


spf = wave.open("Animal_cut.wav", "r")

# Extract Raw Audio from Wav File
signal = spf.readframes(-1)
signal = np.fromstring(signal, "Int16")
fs = spf.getframerate()

# If Stereo
if spf.getnchannels() == 2:
    print("Just mono files")
    sys.exit(0)


Time = np.linspace(0, len(signal) / fs, num=len(signal))

plt.figure(1)
plt.title("Signal Wave...")
plt.plot(Time, signal)
plt.show()
```
Nouveau tracé de l'axe des x en quelques secondes:
- Que " l'homme parfait, mais si je veux voir le temps sur l'axe des x, en quelques secondes?? Comment dois-je faire??
- Ederwander, pour une raison que je ne sais pas quand j'ai tracé mon fichier ça montre juste les données en arrière!saisissez la description de l'image ici: j'ai copié le même que vous avez à écrire! Toute suggestion?
- n'a pas de sens, si vous pensez vraiment que les données sont inversées, utiliser toutes les fonctions de numpy pour transposée votre vecteur ....
- par curiosité, j'ai comparé les résultats avec l'intrigue en python et Audacity, vous pouvez voir La Même forme d'onde ici
- comment voulez-vous faire lorsque vous enregistrez cette sortie en tant que JPG ou PNG au lieu de l'afficher à l'écran?
- Comment dois-je faire si je veux que ce soit un interactif de la parcelle? j'.e si j'ai passez la souris sur l'image, on doit afficher les valeurs à ce point. Merci.
- si la longueur du fichier wav est de moins d'une seconde, le Temps de l'axe longueur sera de zéro à cause de la division entière. Il doit être fait d'un flotteur. Temps=np.linspace(0, float(len(signal))/fs, num=len(signal))
- comment voulez-vous faire avec un fichier vidéo de son?
InformationsquelleAutor ederwander

Alternativement, si vous souhaitez utiliser SciPy, vous pouvez également effectuer les opérations suivantes:

from scipy.io.wavfile import read
import matplotlib.pyplot as plt

# read audio samples
input_data = read("Sample.wav")
audio = input_data[1]
# plot the first 1024 samples
plt.plot(audio[0:1024])
# label the axes
plt.ylabel("Amplitude")
plt.xlabel("Time")
# set the title  
plt.title("Sample Wav")
# display the plot
plt.show()

Des suggestions sur la façon de modifier cette option pour gérer les 24 bits de profondeur de fichiers wav?

InformationsquelleAutor CuriousCoder

Voici une version qui prendra également en charge les entrées stéréo, basé sur la réponse de @ederwander

import matplotlib.pyplot as plt
import numpy as np
import wave

file = 'test.wav'

with wave.open(file,'r') as wav_file:
    #Extract Raw Audio from Wav File
    signal = wav_file.readframes(-1)
    signal = np.fromstring(signal, 'Int16')

    #Split the data into channels 
    channels = [[] for channel in range(wav_file.getnchannels())]
    for index, datum in enumerate(signal):
        channels[index%len(channels)].append(datum)

    #Get time from indices
    fs = wav_file.getframerate()
    Time=np.linspace(0, len(signal)/len(channels)/fs, num=len(signal)/len(channels))

    #Plot
    plt.figure(1)
    plt.title('Signal Wave...')
    for channel in channels:
        plt.plot(Time,channel)
    plt.show()

Comment trouver un fichier wav

Œuvres, assez lent cependant. Utiliser le oneliner channels = [signal[channel::num_channels] for channel in range(num_channels)] pour obtenir un fou rapidement.

InformationsquelleAutor Alter

5

Juste un constat (je ne peux pas ajouter de commentaire).

Vous recevrez un mesage:

DeprecationWarning: Numérique-type de style de codes sont obsolètes et ne seront
resultin une erreur dans l'avenir.

Ne pas utiliser de np.fromstring avec les fichiers binaires. Au lieu de signal = np.fromstring(signal, 'Int16'), il est préférable d'utiliser signal = np.frombuffer(signal, dtype='int16').

InformationsquelleAutor Eduardo Freitas

Ici est une version qui gère mono/stéréo et 8-bit/16-bit PCM.

import matplotlib.pyplot as plt
import numpy as np
import wave

file = 'test.wav'

wav_file = wave.open(file,'r')

#Extract Raw Audio from Wav File
signal = wav_file.readframes(-1)
if wav_file.getsampwidth() == 1:
    signal = np.array(np.frombuffer(signal, dtype='UInt8')-128, dtype='Int8')
elif wav_file.getsampwidth() == 2:
    signal = np.frombuffer(signal, dtype='Int16')
else:
    raise RuntimeError("Unsupported sample width")

# http://schlameel.com/2017/06/09/interleaving-and-de-interleaving-data-with-python/
deinterleaved = [signal[idx::wav_file.getnchannels()] for idx in range(wav_file.getnchannels())]

#Get time from indices
fs = wav_file.getframerate()
Time=np.linspace(0, len(signal)/wav_file.getnchannels()/fs, num=len(signal)/wav_file.getnchannels())

#Plot
plt.figure(1)
plt.title('Signal Wave...')
for channel in deinterleaved:
    plt.plot(Time,channel)
plt.show()

InformationsquelleAutor TimSC

Voici le code à tirer le signal d'onde de fichier et le spectre du signal

import wave    
from scipy import signal    
import numpy as np    
import matplotlib.pyplot as plt    
signal_wave = wave.open('voice.wav', 'r')    
sample_frequency = 16000    
data = np.fromstring(signal_wave.readframes(sample_frequency), dtype=np.int16)    
sig = signal_wave.readframes(-1)    
sig = np.fromstring(sig, 'Int16')

Pour le fichier wave

sig = sig[:]

Pour certains segments de la vague de fichier

sig = sig[25000:32000]    
left, right = data[0::2], da[1::2]    
lf, rf = abs(np.fft.rfft(left)), abs(np.fft.rfft(right))

Tracé de l'onde et le spectre de l'onde du signal de fichier

plt.figure(1)    
a = plt.subplot(211)    
a.set_xlabel('time [s]')    
a.set_ylabel('sample value [-]')    
plt.plot(sig)    
c = plt.subplot(212)    
Pxx, freqs, bins, im = c.specgram(sig, NFFT=1024, Fs=16000, noverlap=900)    
c.set_xlabel('Time')    
c.set_ylabel('Frequency')    
plt.show()

Comment trouver un fichier wav

InformationsquelleAutor Nikhil Parashar

Je suppose que je pourrais l'ai mis dans un commentaire, mais en s'appuyant légèrement sur les réponses des deux @ederwander et @TimSC, je voulais faire quelque chose de plus fin (comme dans le détail) et esthétique. Le code ci-dessous crée ce que je pense est une très belle forme d'onde d'un son stéréo ou mono fichier wave (je n'ai pas besoin d'un titre donc, j'ai juste indiqué que, ni ai-je besoin de la méthode show - juste besoin d'enregistrer le fichier d'image).

Voici un exemple de wav stéréo rendu:
Comment trouver un fichier wav

Et le code, avec les différences que j'ai mentionné:

import matplotlib.pyplot as plt
import numpy as np
import wave

file = '/Path/to/my/audio/file/DeadMenTellNoTales.wav'

wav_file = wave.open(file,'r')

#Extract Raw Audio from Wav File
signal = wav_file.readframes(-1)
if wav_file.getsampwidth() == 1:
    signal = np.array(np.frombuffer(signal, dtype='UInt8')-128, dtype='Int8')
elif wav_file.getsampwidth() == 2:
    signal = np.frombuffer(signal, dtype='Int16')
else:
    raise RuntimeError("Unsupported sample width")

# http://schlameel.com/2017/06/09/interleaving-and-de-interleaving-data-with-python/
deinterleaved = [signal[idx::wav_file.getnchannels()] for idx in range(wav_file.getnchannels())]

#Get time from indices
fs = wav_file.getframerate()
Time=np.linspace(0, len(signal)/wav_file.getnchannels()/fs, num=len(signal)/wav_file.getnchannels())
plt.figure(figsize=(50,3))
#Plot
plt.figure(1)
#don't care for title
#plt.title('Signal Wave...')
for channel in deinterleaved:
    plt.plot(Time,channel, linewidth=.125)
#don't need to show, just save
#plt.show()
plt.savefig('/testing_folder/deadmentellnotales2d.png', dpi=72)

InformationsquelleAutor CRGreen

Je suis venu avec une solution qui est plus souple et plus performant:

Le sous-échantillonnage est utilisée pour atteindre les deux échantillons par seconde. Ce résultat est obtenu en calculant la moyenne des valeurs absolues pour chaque fenêtre. Le résultat ressemble à la forme d'onde à partir de sites de streaming comme SoundCloud.
Multi-canal est pris en charge (merci @Alter)
Numpy est utilisé pour chaque opération, ce qui est beaucoup plus performant qu'en parcourant le tableau.
Le fichier est traité par lots de supporter de très gros fichiers.

import matplotlib.pyplot as plt
import numpy as np
import wave
import math

file = 'audiofile.wav'

with wave.open(file,'r') as wav_file:
    num_channels = wav_file.getnchannels()
    frame_rate = wav_file.getframerate()
    downsample = math.ceil(frame_rate * num_channels / 2) # Get two samples per second!

    process_chunk_size = 600000 - (600000 % frame_rate)

    signal = None
    waveform = np.array([])

    while signal is None or signal.size > 0:
        signal = np.frombuffer(wav_file.readframes(process_chunk_size), dtype='int16')

        # Take mean of absolute values per 0.5 seconds
        sub_waveform = np.nanmean(
            np.pad(np.absolute(signal), (0, ((downsample - (signal.size % downsample)) % downsample)), mode='constant', constant_values=np.NaN).reshape(-1, downsample),
            axis=1
        )

        waveform = np.concatenate((waveform, sub_waveform))

    #Plot
    plt.figure(1)
    plt.title('Waveform')
    plt.plot(waveform)
    plt.show()

InformationsquelleAutor Arthur C

Vous devez vous connecter pour publier un commentaire.