spectrogramFinal.py

import numpy as np
import soundfile as sf
import matplotlib.pyplot as plt
import hashlib
import os
import pygame
import time



def playAudio(file_path: str):
    pygame.init()
    pygame.mixer.init()
    screen = pygame.display.set_mode((300, 200))  
    pygame.display.set_caption('Music Player')  

    try:
        pygame.mixer.music.load(file_path)
        pygame.mixer.music.play()

        running: bool = True
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
            
            if not pygame.mixer.music.get_busy(): 
                running = False 

            screen.fill((255, 255, 255))  
        
            font = pygame.font.Font(None, 36)
            filename = os.path.basename(file_path)
            text = font.render(filename, True, (50, 50, 0))
            screen.blit(text, (10, 10)) 

            pygame.display.update()
            pygame.time.Clock().tick(60) 

    except pygame.error as e:
        print(f"Unable to play music: {e}")
    finally:
        pygame.quit()


def compareToDatabase(file: str, folderPath: str, databaseGlobal: list[dict[str, str]]) -> bool: 
    checker_hash, fileValue = spectrogramHash(file)
    isFound: bool = False
    if databaseGlobal is not None: 
        for item in databaseGlobal:
            if item['key'] == checker_hash: 
                playAudio(item['file_name'])
                playAudio(fileValue)
                print("Found a matching entry in the database:", item['file_name'])
                isFound = True
                return True

    database: list[dict[str, str]] = toDatabase(folderPath) 
    saveDatabase(databaseGlobal, database)
    for entry in database:
        if entry['key'] == checker_hash: 
            playAudio(entry['file_name'])
            playAudio(fileValue)
            print("Found a matching entry in the database:", entry['file_name'])
            return True

    print("404 not found")
    return False

def toDatabase(folder: str) -> list[dict[str, str]]: 
    files = [file for file in os.listdir(folder) if (file.endswith('.wav') or file.endswith('.mp3'))] 
    database: list[dict[str, str]] = []

    for file in files: 
        file_path: str = os.path.join(folder, file) 
        truncated_Hash, filename = spectrogramHash(file_path) 
        entry: dict[str, str] = {'key': truncated_Hash, 'file_name': filename }
        database.append(entry)
    
    return database

def saveDatabase(databaseGlobal: list[dict[str, str]], database: list[dict[str, str]]): 
    databaseGlobal.extend(database)
    writeToDatabase(databaseGlobal)

def writeToDatabase(database: list[dict[str, str]]): 
    with open('./database/data.config', 'r+') as file: 
        for item in database: 
            file.write(f"key: {item['key']}, file_name: {item['file_name']}\n")

def readDatabase(path: str) -> list[dict[str, str]]: 
    read_data = []
    with open(path, 'r+') as file:
        lines = file.readlines()
        for line in lines:
            parts = line.strip().split(', ')
            data_dict = {}
            for part in parts:
                key, value = part.split(': ')
                data_dict[key.strip()] = value.strip()
            read_data.append(data_dict)

    return read_data


def spectrogramHash(audio_file: str, keyLength: int = 100) -> dict[str, str]:
    data, _ = sf.read(audio_file)

    if len(data.shape) > 1:
        data = data.mean(axis=1)
    
    window_size = 1024
    hop_size = 512
    
    n_samples = len(data)
    n_overlap = window_size - hop_size
    n_windows = (n_samples - n_overlap) // hop_size
    
    spectrogram = []
    
    for i in range(n_windows):
        start = i * hop_size
        end = start + window_size
        segment = data[start:end]
        windowed_segment = segment * np.hamming(window_size)
        spectrum = np.abs(np.fft.rfft(windowed_segment, window_size))
        spectrogram.append(spectrum)
    
    spectrogram_array = np.array(spectrogram)
    
    concatenated_hash = b''
    for row in spectrogram_array:
        row_bytes = row.tobytes()
        sha256_hash = hashlib.sha256(row_bytes).hexdigest().encode('utf-8')
        concatenated_hash += sha256_hash
    
    unique_hash = concatenated_hash.hex()
    truncated_Hash = unique_hash[:keyLength]
    
    return truncated_Hash, audio_file

checker: str = './sample2.wav'
data_folder: str = './data/bbc'
# database: list[dict[str, str]] = toDatabase(data_folder)
# for data in database: 
#     print(data)


globalDatabase = readDatabase('./database/data.config')

if __name__ == "__main__":
    start_time = time.time() 
    result = compareToDatabase(checker, data_folder, globalDatabase)
    end_time = time.time()   

    execution_time = end_time - start_time  
    print(f"Execution time: {execution_time} seconds")