Lettura file * .wav in Python

StackOverflow https://stackoverflow.com/questions/2060628

  •  20-09-2019
  •  | 
  •  

Domanda

Ho bisogno di analizzare il suono scritto in un file wav. Per questo ho bisogno di trasformare il file in serie di numeri (array, per esempio). Penso di aver bisogno di usare il pacchetto d'onda. Tuttavia, non so esattamente come funziona. Per esempio ho fatto la seguente: 

import wave
w = wave.open('/usr/share/sounds/ekiga/voicemail.wav', 'r')
for i in range(w.getnframes()):
    frame = w.readframes(i)
    print frame

Come risultato di questo codice mi aspettavo di vedere di pressione sonora in funzione del tempo. Al contrario vedo un sacco di strani, misteriosi simboli (che non sono numeri esadecimali). Può qualcuno, suppliche, aiutarmi con questo?

È stato utile?

Soluzione

le fonti , scipy.io.wavfile.read(somefile) restituisce una tupla di due elementi: il primo è la frequenza di campionamento in campioni al secondo, il secondo è un array di numpy con tutti i dati letti dal file. Sembra piuttosto facile da usare!

per esempio: 

from scipy.io import wavfile
fs, data = wavfile.read('./output/audio.wav')

Altri suggerimenti

Ho fatto qualche ricerca questa sera e capito questo: 

import wave, struct

waveFile = wave.open('sine.wav', 'r')

length = waveFile.getnframes()
for i in range(0,length):
    waveData = waveFile.readframes(1)
    data = struct.unpack("<h", waveData)
    print(int(data[0]))

Speriamo che questo frammento aiuta qualcuno. Dettagli: utilizzando il struct modulo , si può prendere le cornici onda (che sono in 2s binario complementare tra -32768; 0x8000 e 32767; 0x7FFF) Questa legge un MONO, 16-bit, file WAVE. Ho trovato il sito molto utile nella formulazione di questo.

Questo frammento di codice legge 1 fotogramma. Per leggere più di un frame (per esempio, 13), utilizzare 

waveData = waveFile.readframes(13)
data = struct.unpack("<13h", waveData)

moduli Python diversi di leggere wav:

C'è almeno queste seguenti librerie di leggere file audio onda:

Il più semplice esempio:

Questo è un semplice esempio con Pysoundfile: 

import soundfile as sf
data, samplerate = sf.read('existing_file.wav')

Formato dell'uscita:

Attenzione, i dati non sono sempre nello stesso formato, che dipende dalla libreria. Per esempio: 

from scikits import audiolab
from scipy.io import wavfile
from sys import argv
for filetest in argv[1:]:
    [x, fs, nbBits] = audiolab.wavread(filePath)
    print '\nReading with scikits.audiolab.wavread: ', x
    [fs, x] = wavfile.read(filetest)
    print '\nReading with scipy.io.wavfile.read: ', x

Lettura con scikits.audiolab.wavread: [0. 0. 0. ..., -,00097656 -,00079346  -,00097656] Leggendo con scipy.io.wavfile.read: [0 0 0 ..., -32 -26 -32]

PySoundFile e Audiolab galleggiante ritorno tra -1 e 1 (come matab fa, cioè la convenzione per il segnale audio). SciPy e ritorno onda interi, che possono essere convertiti in float secondo il numero di bit di codifica.

Ad esempio: 

from scipy.io.wavfile import read as wavread
[samplerate, x] = wavread(audiofilename) # x is a numpy array of integer, representing the samples 
# scale to -1.0 -- 1.0
if x.dtype == 'int16':
    nb_bits = 16 # -> 16-bit wav files
elif x.dtype == 'int32':
    nb_bits = 32 # -> 32-bit wav files
max_nb_bit = float(2 ** (nb_bits - 1))
samples = x / (max_nb_bit + 1.0) # samples is a numpy array of float representing the samples

secondo me, il modo più semplice per ottenere i dati audio da un file audio in un array NumPy è PySoundFile : 

import soundfile as sf
data, fs = sf.read('/usr/share/sounds/ekiga/voicemail.wav')

Questo supporta anche i file a 24 bit out of the box.

Ci sono molte librerie di file audio disponibili, ho scritto una panoramica dove si può vedere un paio di pro e contro. Dispone anche di una pagina che spiega come per leggere un file wav a 24 bit con il modulo wave .

È possibile eseguire questa operazione utilizzando il scikits.audiolab modulo. Richiede NumPy e SciPy a funzionare, e anche libsndfile.

Si noti, sono stato in grado di farlo funzionare su Ubunutu e non su OSX solo. 

from scikits.audiolab import wavread

filename = "testfile.wav"

data, sample_frequency,encoding = wavread(filename)

Ora avete i dati wav

Se si vuole procces un blocco audio per blocco, alcune delle soluzioni indicate sono abbastanza terribile, nel senso che essi implicano caricare l'audio intero nella memoria la produzione di molti fallimenti della cache e rallentare il vostro programma. pitone wavefile fornisce alcuni costrutti divinatorio di eseguire l'elaborazione NumPy blocco per blocco utilizzando blocco efficiente e trasparente gestione mediante generatori. Altre sottigliezze Pythonic sono responsabile contesto per i file di metadati, come proprietà ... e se si desidera che l'intera interfaccia del file, perché si sta sviluppando un prototipo rapido e non si cura di efficienza, l'intera interfaccia del file è ancora lì.

Un semplice esempio di trasformazione potrebbe essere: 

import sys
from wavefile import WaveReader, WaveWriter

with WaveReader(sys.argv[1]) as r :
    with WaveWriter(
            'output.wav',
            channels=r.channels,
            samplerate=r.samplerate,
            ) as w :

        # Just to set the metadata
        w.metadata.title = r.metadata.title + " II"
        w.metadata.artist = r.metadata.artist

        # This is the prodessing loop
        for data in r.read_iter(size=512) :
            data[1] *= .8     # lower volume on the second channel
            w.write(data)

L'esempio riutilizza lo stesso blocco di leggere l'intero file, anche nel caso dell'ultimo blocco che di solito è inferiore alla dimensione richiesta. In questo caso si ottiene un fetta del blocco. Quindi fidarsi della lunghezza di blocco tornato invece di utilizzare un 512 dimensione hardcoded per qualsiasi ulteriore elaborazione.

Se avete intenzione di effettuare trasferimenti sui dati della forma d'onda allora forse si dovrebbe usare SciPy , specificamente scipy.io.wavfile .

Ho bisogno di leggere un file WAV a 24 bit a 1 canale. Il post di cui sopra da Nak è stato molto utile. Tuttavia, come già detto da basj 24 bit non è semplice. Alla fine ho capito di lavoro utilizzando il seguente frammento: 

from scipy.io import wavfile
TheFile = 'example24bit1channelFile.wav'
[fs, x] = wavfile.read(TheFile)

# convert the loaded data into a 24bit signal

nx = len(x)
ny = nx/3*4    # four 3-byte samples are contained in three int32 words

y = np.zeros((ny,), dtype=np.int32)    # initialise array

# build the data left aligned in order to keep the sign bit operational.
# result will be factor 256 too high

y[0:ny:4] = ((x[0:nx:3] & 0x000000FF) << 8) | \
  ((x[0:nx:3] & 0x0000FF00) << 8) | ((x[0:nx:3] & 0x00FF0000) << 8)
y[1:ny:4] = ((x[0:nx:3] & 0xFF000000) >> 16) | \
  ((x[1:nx:3] & 0x000000FF) << 16) | ((x[1:nx:3] & 0x0000FF00) << 16)
y[2:ny:4] = ((x[1:nx:3] & 0x00FF0000) >> 8) | \
  ((x[1:nx:3] & 0xFF000000) >> 8) | ((x[2:nx:3] & 0x000000FF) << 24)
y[3:ny:4] = (x[2:nx:3] & 0x0000FF00) | \
  (x[2:nx:3] & 0x00FF0000) | (x[2:nx:3] & 0xFF000000)

y = y/256   # correct for building 24 bit data left aligned in 32bit words

Alcuni di scala aggiuntivo è necessario se avete bisogno di risultati tra -1 e +1. Forse alcuni di voi là fuori potrebbe rivelarsi utile

se il suo solo due file e la frequenza di campionamento è significativamente elevata, si può solo li Interleave. 

from scipy.io import wavfile
rate1,dat1 = wavfile.read(File1)
rate2,dat2 = wavfile.read(File2)

if len(dat2) > len(dat1):#swap shortest
    temp = dat2
    dat2 = dat1
    dat1 = temp

output = dat1
for i in range(len(dat2)/2): output[i*2]=dat2[i*2]

wavfile.write(OUTPUT,rate,dat)

u può anche usare semplice libreria import wavio u anche bisogno di avere una certa conoscenza di base del suono.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top