https://docs.scipy.org/doc/scipy/reference/generated/scipy.io.wavfile.write.html

Davidson College

Google

Within the scipy.io package, there is the scipy.io.wavefile module. Use this when dealing with WAV files. It includes these helpful functions:

-read(filename`[`, mmap`]`) Open a WAV file

-writefilename, rate, data) Write a NumPy array as a WAV file.

These objects let us access the data within each WAV file. This data can be edited and then rewritten to create a new, different-sounding WAV file.

WAV Files

When thinking of WAV files, you can imagine them to be a long list of sound wave amplitude measurements. The length of this list correlates with the sample rate (samples/sec) and then the file length (sec). So, a 2 second WAV file that contains data sampled at 44,100 samples/sec has 88,400 amplitude measurements stored in a list. 

The SciPy library allows us to easily access this data by using the scipy.io package. To start, let's just try to see the audio data using SciPy.
```python
import scipy.io.wavefile as spw
##I now will use my read function to open chicken.wav
sample=spw.read('chicken.wav')
print(sample)
```
This should print the following to the console:
```python
(44100, array([ 54,  66,  70, ..., -34, -31, -28], dtype=int16))
```
As you can see, the ```read``` function returns the sample rate, the data as an array, and labels the data type. Thus, we have a WAV file sampled at 44,100 samples/sec, represented as an array containing integers. 

What if we just wanted to grab the data in the array? It looks like the variable ```sample``` is a tuple containing the list we want as the second element. Thus, we can use indexing. 
```python
print(sample[1][0])
```
This should print the following to the console:
```python
54
```
Now that we have established how SciPy allows us to make WAV file data explicit, we can explore ways to manipulate this data. 

Basics of Audio Editing using SciPy File I/O

SciPy also allows us create audio, such as sine waves, into WAV files. In combination with NumPy, we can define the sample rate and frequency. This is an example of creating a 100Hz sine wave sampled at 44,100 Hz.
```python 
from scipy.io.wavfile import write
import numpy as np
samplerate = 44100; fs = 100
t = np.linspace(0., 1., samplerate)
amplitude = np.iinfo(np.int16).max
data = amplitude * np.sin(2. * np.pi * fs * t)
write("example.wav", samplerate, data.astype(np.int16))
```

Audio Creation

We can use Matplotlib, NumPy, and the wave module to plot waveforms of WAV files. 
```python 
import matplotlib.pyplot as plt
import numpy as np
import wave
import sys

wav=wave.open('chicken.wav', 'r')
#We only want to use mono files
if wav.getnchannels()==2:
  print('Stereo files are unsupported. Use mono files.')
  sys.exit(0) #Terminates program

raw=wav.readframes(-1) #This reads all frames, returns them in byte form
raw=np.frombuffer(raw, dtype='int16') #Converts bytes to integers
sample_rate=wav.getframerate()
time_=np.linspace(0, len(raw)/sample_rate, num=len(raw))

plt.title("Waveform of Chicken")
plt.plot(time_, raw, color="blue") #Plot time and amplitude
plt.xlabel("Time (s)")
plt.ylabel("Amplitude")
plt.tight_layout()
plt.savefig('chicken.png')
plt.show()
```
This should result in something like this:

Learn Before

Related