Time series dBFS plot output modification - current output plot not as expected (matplotlib)

TLNR

• This has nothing to do with pyplot.
• The frequency domain is different from the time domain, but that's not why you didn't get what you want.
• The calculation of dbFS in your code is wrong.

You should frame your data, calculate RMSs or peaks in every frame, and then convert that value to dbFS instead of applying this transformation to every sample point.

When we talk about the amplitude, we are talking about a periodic signal. And when we read in a series of data from a sound file, we read in a series of sample points of a signal(may be or be not periodic). The value of every sample point represents a, say, voltage value, or sound pressure value sampled at a specific time.

We assume that, within a very short time interval, maybe 10ms for example, the signal is stationary. Every such interval is called a frame.

Some specific function is applied to each frame usually, to reduce the sudden change at the edge of this frame, and these functions are called window functions. If you did nothing to every frame, you added rectangle windows to them.

An example: when the sampling frequency of your sound is 44100Hz, in a 10ms-long frame, there are 44100*0.01=441 sample points. That's what the nperseg argument means in your psd function but it has nothing to do with dbFS.

Given the knowledge above, now we can talk about the amplitude.

There are two methods a get the value of amplitude in every frame:

• The most straightforward one is to get the maximum(peak) values in every frame.
• Another one is to calculate the RMS(Root Mean Sqaure) of every frame.

After that, the peak values or RMS values can be converted to dbFS values.

Let's start coding:

import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

# Determine full scall(maximum possible amplitude) by bit depth
bit_depth = 16
full_scale = 2 ** bit_depth

# dbFS function
to_dbFS = lambda x: 20 * np.log10(x / full_scale)

# Read in the wave file
fname = "01.wav"
fs,data = wavfile.read(fname)

# Determine frame length(number of sample points in a frame) and total frame numbers by window length(how long is a frame in seconds)
window_length = 0.01 
signal_length = data.shape[0]
frame_length = int(window_length * fs)
nframes = signal_length // frame_length

# Get frames by broadcast. No overlaps are used.
idx = frame_length * np.arange(nframes)[:,None] + np.arange(frame_length)
frames = data[idx].astype("int64") # Convert to in 64 to avoid integer overflow

# Get RMS and peaks
rms = ((frames**2).sum(axis=1)/frame_length)**.5
peaks = np.abs(frames).max(axis=1)

# Convert them to dbfs
dbfs_rms = to_dbFS(rms)
dbfs_peak = to_dbFS(peaks)

# Let's start to plot

# Get time arrays of every sample point and ever frame
frame_time = np.arange(nframes) * window_length
data_time = np.linspace(0,signal_length/fs,signal_length)

# Plot
f,ax = plt.subplots()
ax.plot(data_time,data,color="k",alpha=.3)

# Plot the dbfs values on a twin x Axes since the y limits are not comparable between data values and dbfs
tax = ax.twinx()
tax.plot(frame_time,dbfs_rms,label="RMS")
tax.plot(frame_time,dbfs_peak,label="Peak")
tax.legend()
f.tight_layout()

# Save serval details
f.savefig("whole.png",dpi=300)
ax.set_xlim(1,2)
f.savefig("1-2sec.png",dpi=300)
ax.set_xlim(1.295,1.325)
f.savefig("1.2-1.3sec.png",dpi=300)

The whole time span looks like(the unit of the right axis is dbFS):

And the voiced part looks like:

You can see that the dbFS values become greater while the amplitudes become greater at the vowel start point: