Implement compute$\_$spectrogram to generate the spectrogram from an audio signal.

Use audio$\_$utils.local$\_$peaks$()$ to detect local peaks.

Apply thresholding to select the largest peaks.

Build a database of peak pairs using the specified constraints and store them using a hash table.

Implement the song identification function, comparing the fingerprint of a recorded or loaded clip against the database.

Create a command$-$line interface to control the program$$s behavior.

Test your implementation using the provided unit tests. audio$\_$utils:

import numpy as np

import pyaudio

from scipy import ndimage, signal

from scipy import io as spio

CHUNK $=1024$

FORMAT $=$ pyaudio.paInt$16$

RATE $=48000$

CHANNELS $=1$

def record$\_$audio$($duration$,$ f$\_$s$)$:

$"""$Sets up the audio stream and records audio for a given duration.

Parameters

$----------$

duration : float

duration of the recording in seconds

f$\_$s : int

sampling rate in Hz

Returns

$-------$

ndarray

mono audio signal sampled at f$\_$s Hz and normalized to have a zero mean

$"""$

p $=$ pyaudio.PyAudio$()$

# print$($p$.$get$\_$default$\_$input$\_$device$\_$info$())$

stream $=$ p$.$open$($

format$=$FORMAT,

channels$=$CHANNELS,

rate$=$RATE,

input$=$True,

frames$\_$per$\_$buffer$=$CHUNK,

$)$

print$("*$ recording"$)$

frames $=[]$

for $\_$ in range$(0,$ int$($RATE $/$ CHUNK $*$ duration$))$:

data $=$ stream.read$($CHUNK$)$

frames.append$($np$.$frombuffer$($data$,$ dtype$=$np$.$int$16))$

print$("*$ done recording"$)$

stream.stop$\_$stream$()$

stream.close$()$

p$.$terminate$()$

audio $=$ np$.$concatenate$($frames$).$astype$($float$)$

audio $=\_$resample$($audio$,$ RATE, f$\_$s$)$

audio $-=$ np$.$mean$($audio$)$

return audio

def wav$\_$processing$($wav$\_$file, f$\_$s$)$:

$"""$Loads a wav file and resamples it to f$\_$s Hz$.$

Parameters

$----------$

wav$\_$file : str

path to the wave file

f$\_$s : int

desired sampling rate in Hz

Returns

$-------$

ndarray

audio signal sampled at f$\_$s Hz and normalized to have a zero mean

$"""$

# Load the audio file

audio$\_$all $=$ spio.wavfile.read$($wav$\_$file$)$

f$\_$s$\_$orig $=$ audio$\_$all$[0]$

audio $=$ audio$\_$all$[1].$astype$($float$)$

# combine channels

if len$($audio$.$shape$)>1$:

audio $=$ np$.$mean$($audio$,$ axis$=1)$

# remove the mean

audio $-=$ np$.$mean$($audio$)$

# resample the audio file

audio $=\_$resample$($audio$,$ f$\_$s$\_$orig, f$\_$s$)$

return audio

def local$\_$peaks$($spectrum$,$ gs$)$:

$"""$Finds the location of the local peaks in a gs x gs neighborhood.

Parameters

$----------$

spectrum : ndarray

$2$D array, the spectrogram of the signal

gs : int

neighborhood size

Returns

$-------$

ndarray

boolean array, the local peaks

$"""$

# create a footprint for the maximum filter

footprint $=$ np$.$ones$(($gs$,$ gs$))$

# apply the maximum filter to the spectrum

max$\_$spectrum $=$ ndimage.maximum$\_$filter$($spectrum$,$ footprint$=$footprint$)$

# the local peaks are where the original spectrum is equal to the filtered spectrum

local$\_$peak $=$ spectrum $==$ max$\_$spectrum

return local$\_$peak

def $\_$resample$($x$\_$t$,$ f$\_$s$\_$old, f$\_$s$\_$new$)$:

# resample the audio file to $8$ kHz

denom $=$ np$.$gcd$($f$\_$s$\_$old, f$\_$s$\_$new$)$

L $=$ f$\_$s$\_$old $//$ denom

M $=$ f$\_$s$\_$new $//$ denom

x$\_$t $=$ signal.resample$\_$poly$($x$\_$t$,$ M$,$ L$)$

return x$\_$t

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

f$\_$s $=1000$

duration $=10$

audio$\_$test $=$ record$\_$audio$($duration$,$ f$\_$s$)$

spio.wavfile.write$("$test$.$wav", f$\_$s$,$ audio$\_$test.astype$($np$.$int$16))$