Serait-il possible d'ajouter une fonction permettant de supprimer le bruit de fond avant…
- User
Serait-il possible d'ajouter une fonction permettant de supprimer le bruit de fond avant d'identifier les segments les plus bruyants ?
import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs
def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, int(video_duration / segment_duration)) ]
# Combine segment start times with their corresponding loudness loudness_and_segments = [ (segment_loudness[i], i * segment_duration) for i in range(len(segment_loudness)) if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset ] # Sort the loudness and segments based on loudness loudness_and_segments.sort(key=lambda x: x[0], reverse=True) # Return the top num_segments segments sorted by loudness return loudness_and_segments[:num_segments]def sort_segments(segments_with_loudness, preference): if preference == 1: return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video with x264 encoding.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}")
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration
video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # Trier les segments en fonction de la préférence de l'utilisateur sorted_segments = sort_segments(segments_with_loudness, preference) # Anticiper si les noms de fichiers doivent correspondre à l'ordre initial if preference in [1, 2]: initial_order_index = {start_time: i for i, (loudness, start_time) in enumerate(segments_with_loudness)} if not os.path.exists(output_folder): os.makedirs(output_folder) for segment in sorted_segments: loudness, start_time = segment segment_index = initial_order_index[start_time] if preference in [1, 2] else sorted_segments.index(segment) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{segment_index+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: if os.path.exists(audio_filename): os.unlink(audio_filename) # Clean up the temporary fileMain
if name == "main": starting_offset = float(input("Start offset (sec)? ")) ending_offset = float(input("End offset (sec)? ")) num_segments = int(input("How many segments to extract? ")) segment_duration = float(input("Duration of each segment (sec)? ")) print("Choose your sorting preference for the extracted files:") print("1 - In order of appearance in the video") print("2 - In reverse order of appearance") print("3 - By increasing loudness") print("4 - By decreasing loudness") preference = int(input("Enter the number of your preference: ")) # Validate the user's preference if preference not in [1, 2, 3, 4]: print("Invalid preference. Please enter a valid number.") exit(1)
for root, dirs, files in os.walk('.'): for file in files: if any(file.lower().endswith(ext) for ext in video_extensions): video_path = os.path.join(root, file) print(f"Processing video {video_path}…") process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference) print("All videos have been processed.") - Assistant
Pour supprimer le bruit de fond dans une piste audio, vous pouvez utiliser différents algorithmes ou outils de suppression de bruit. Un outil commun pour une telle tâche est la bibliothèque
noisereduceen Python. Vous pouvez installer cette bibliothèque viapip install noisereduce.Vous devez ajouter cette étape avant d'identifier les segments les plus bruyants. Voici comment vous pouvez intégrer
noisereducedans votre flux de travail existant:import noisereduce as nr def remove_background_noise(audio_data, rate): """Remove background noise from the audio data.""" # Assuming audio_data is a 1-D or 2-D numpy array representing audio samples # nr.reduce_noise() accepts a 1-D array only, if input is 2-D (stereo), convert to 1-D (mono) using np.mean if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # Reduce noise reduced_noise_audio = nr.reduce_noise(y=audio_data, sr=rate) return reduced_noise_audio # Later in the process_video_file function, right after reading the audio: audio_data = remove_background_noise(audio_data, rate)Assurez-vous de placer l'appel à remove_background_noise juste après avoir lu les données audio avec
wavfile.read, de sorte que vous passiez les données de l'audio avec le bruit supprimé à la fonction de calcul de la sonie.Notez que le retrait du bruit peut ne pas être parfait et peut dépendre de la qualité du bruit de fond et des données audio d'origine. En outre, l'effet de la réduction du bruit peut parfois altérer légèrement la qualité sonore, il est donc important de l'ajuster en fonction de vos besoins spécifiques.
Voici un exemple illustrant à quel point vous pourriez intégrer la réduction du bruit dans votre script actuel :
# ... après avoir installé noisereduce et importé les modules nécessaires ... # ... (les définitions des autres fonctions restent les mêmes) ... def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) # Suppression du bruit de fond audio_data = remove_background_noise(audio_data, rate) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # ... (le reste du code reste inchangé) ... # ... (le reste de votre script principal reste inchangé) ...N'oubliez pas d'ajuster
remove_background_noisesi vous avez besoin d'un contrôle plus fin de la réduction du bruit selon votre scénario spécifique. - User
ou placer audio_data = remove_background_noise(audio_data, rate) ?
- Assistant
Vous devriez placer la ligne
audio_data = remove_background_noise(audio_data, rate)juste après avoir lu les données audio avecwavfile.read, et avant de trouver les segments les plus bruyants. Ceci est nécessaire pour s'assurer que vous utilisez la version avec le bruit de fond réduit lors de la détermination des segments les plus bruyants.Voici comment cela serait placé dans la fonction
process_video_file:def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_clip.audio.write_audiofile(audio_filename) # Extraction de l'audio rate, audio_data = wavfile.read(audio_filename) # Lecture des données audio # Suppression du bruit de fond audio_data = remove_background_noise(audio_data, rate) # Trouver les segments les plus bruyants avec l'audio nettoyé segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # ... (le reste de la fonction process_video_file reste inchangé) ... finally: if os.path.exists(audio_filename): os.unlink(audio_filename) # Nettoyage du fichier temporaireL'appel à
remove_background_noise()utilise les données audio brutes et le taux d'échantillonnage (rate) comme arguments et envoie en retour les données audio traitées avec le bruit réduit, que vous pouvez ensuite utiliser pour le reste du processus. - User
comment connaitre sa version de python
- Assistant
Pour vérifier la version de Python installée sur votre système, vous pouvez utiliser plusieurs méthodes différentes, mais le moyen le plus simple est d'ouvrir un terminal (sous Linux ou macOS) ou une invite de commandes/commande (sous Windows) et de taper l'une des commandes suivantes :
python --versionou
python -VCela affichera la version de Python utilisée par la commande
pythonpar défaut.Si vous avez également Python 3.x installé, il est souvent accessible via la commande
python3. Pour vérifier sa version, utilisez :python3 --versionou
python3 -VPour les utilisateurs avec plusieurs versions de Python installées, le package
pyenvpeut être utilisé pour gérer différentes versions. Si vous utilisezpyenv, la commande pour voir toutes les versions installées est :pyenv versionsSachez que si vous utilisez un environnement virtuel (
virtualenvouconda), vous devez activer l'environnement virtuel avant de vérifier la version, car l'environnement peut contenir une version différente de Python de celle installée globalement sur votre système.Dans les scripts Python eux-mêmes, vous pouvez obtenir la version de Python en cours d'exécution à l'aide du module
sys:import sys print(sys.version) # Donne des informations complètes sur la version print(sys.version_info) # Donne les détails de la version sous forme de tupleLe tuple
sys.version_infoest utile si vous avez besoin de vérifier la version de Python dans le cadre de la logique conditionnelle d'un script. - User
y a -t-il autre chose que noisereduce pour le faire ?
- Assistant
Oui, il existe plusieurs autres outils et bibliothèques qui peuvent être utilisés pour la réduction du bruit dans les pistes audio. En dehors de
noisereduce, voici quelques autres options disponibles :-
Audacity - Audacity est un éditeur audio gratuit et open-source qui peut être utilisé pour réduire le bruit de manière interactive. Vous pouvez l'utiliser pour nettoyer manuellement votre piste audio avant de l'utiliser dans votre code Python.
-
SoX (Sound eXchange) - SoX est un outil de ligne de commande capable de traiter les fichiers audio. Il comprend des fonctions telles que la réduction du bruit. Vous pouvez l'appeler en utilisant
subprocess.run()depuis Python après avoir installé SoX sur votre système. -
RNNoise - Il s'agit d'une bibliothèque pour la suppression de tout un éventail de bruits. C'est une implémentation de réseau de neurones pour la suppression du bruit qui est plus avancée que certaines approches plus basiques. Des wrappers Python tels que
pyrnnoisepeuvent être utilisés pour intégrer RNNoise dans un script Python. -
Deep learning models/libs - Bibliothèques telles que
TensorFlowetPyTorchpermettant de construire ou d'utiliser des modèles de réseaux de neurones déjà entraînés pour la suppression du bruit. Par exemple, des modèles tels que Wave-U-Net ou Deep Noise Suppression (DNS) de Microsoft peuvent être employés. -
FFmpeg - FFmpeg est un outil de ligne de commande et une bibliothèque pour manipuler les fichiers multimédia. Il offre des filtres d'audio pour réduire le bruit. Vous pouvez l'invoquer par
subprocess.run()depuis votre script Python. -
speexdsp - C'est une bibliothèque d'encodage et de traitement audio destinée à la voix. Elle comprend des fonctionnalités pour la suppression de bruit et l'annulation d'écho.
-
WebRTC's Noise Suppression module - Il s'agit d'un module de traitement de signal disponible dans le cadre du projet WebRTC, et il a été porté pour être utilisé dans Python sous le nom
pebrtc.
Chaque outil ou bibliothèque a ses propres avantages et inconvénients et peut nécessiter des niveaux variables de paramétrage ou de connaissances techniques. Le choix dépendra de vos besoins spécifiques, de la nature du bruit de fond et de la qualité audio désirée. Certains outils peuvent être mieux adaptés à des types spécifiques de bruit ou de signal audio. Pour les applications critiques, vous pourriez avoir besoin de tester plusieurs approches pour voir laquelle fonctionne le mieux pour votre cas d'usage.
-
- User
Fais le avec speexdsp
- Assistant
La bibliothèque
speexdspen Python est une interface pour le Speex DSP (Digital Signal Processing), qui inclut des fonctionnalités de traitement de la voix telles que la suppression du bruit. C'est un port du code C du projet Speex vers Python grâce àctypesoucffi.Voici comment vous pourriez intégrer
speexdspdans votre script Python existant pour réduire le bruit de fond. Tout d'abord, vous devez l'installer en utilisantpip:pip install speexdspAprès avoir installé
speexdsp, vous pouvez utiliser son module de suppression du bruit de la manière suivante :from speexdsp import EchoCanceller, preprocess_state_init, preprocess_run from scipy.io import wavfile def remove_noise_with_speexdsp(audio_data, rate): frame_size = 160 # La taille du frame doit être 160 pour une fréquence de 8000 Hz. Pour d'autres fréquences d'échantillonnage, cela peut changer. if rate != 8000: raise ValueError("SpeexDSP supports only 8000 Hz audio.") audio_data = audio_data.astype('int16') # SpeexDSP nécessite des entiers 16 bits. preprocessor_state = preprocess_state_init(frame_size, rate) preprocessor_state.set('noise_suppress', -30) # Niveau de suppression du bruit en dB. processed_audio_data = np.empty_like(audio_data) for i in range(0, len(audio_data), frame_size): frame = audio_data[i:i+frame_size] preprocess_run(preprocessor_state, frame) processed_audio_data[i:i+frame_size] = frame return processed_audio_data # … Le reste de votre code rate, audio_data = wavfile.read(audio_filename) audio_data = remove_noise_with_speexdsp(audio_data, rate) # … Continuez avec les données audio où le bruit a été réduitNotez que SpeexDSP est conçu pour fonctionner avec des fréquences d'échantillonnage spécifiques (par exemple, 8000 Hz pour la voix). Si vous devez travailler avec des taux qui ne sont pas directement supportés par la bibliothèque, vous pourriez avoir besoin de rééchantillonner votre piste audio avant de l'envoyer à SpeexDSP.
La suppression du bruit avec SpeexDSP peut ne pas être aussi efficace sur de la musique ou des effets sonores complexes par rapport à la voix, car elle est conçue principalement pour le traitement de signaux vocaux. La performance de la suppression du bruit peut varier selon les caractéristiques du bruit de fond de votre piste audio.
- User
comment passer à une version inférieure de python
- Assistant
Pour passer à une version inférieure de Python, vous pouvez suivre ces étapes générales :
Pour les utilisateurs de Windows :
-
Désinstallation de la version actuelle :
- Allez dans le Panneau de configuration → Programmes → Programmes et fonctionnalités.
- Trouvez Python dans la liste des programmes installés et désinstallez-le.
-
Installation de la version désirée :
- Téléchargez l'installateur pour la version spécifique de Python que vous souhaitez depuis le site web officiel de Python (python.org).
- Exécutez l'installateur et suivez les instructions pour installer la version plus ancienne de Python. Veillez à choisir correctement l'emplacement d'installation et les options souhaitées (par exemple, ajouter Python au PATH).
Pour les utilisateurs de macOS et Linux :
Sous macOS et Linux, Python est souvent utilisé via un gestionnaire de versions comme
pyenvpour installer et gérer plusieurs versions de Python. Pour installer une version spécifique de Python avecpyenv:-
Installer pyenv (si ce n’est pas déjà fait) :
# Homebrew sous macOS brew update brew install pyenv# pyenv-installer sur Linux curl https://pyenv.run | bash -
Installer une nouvelle version de Python à l'aide de pyenv :
pyenv install 3.7.9 # Remplacez par la version que vous voulez. -
Définir la version de Python pour un répertoire spécifique :
pyenv local 3.7.9 -
Définir la version de Python globalement (optionnel):
pyenv global 3.7.9
En utilisant des environnements virtuels :
Pour les projets qui nécessitent différentes versions de Python, l'utilisation d'environnements virtuels est une pratique recommandée. Cela évite de changer la version système de Python. Pour ce faire :
-
Installez
virtualenv(si vous ne l'avez pas) :pip install virtualenv -
Créez un environnement virtuel en spécifiant la version Python :
virtualenv -p /usr/bin/python3.7 myenv # Remplacez le chemin avec celui de la bonne version de Python -
Activez l'environnement virtuel :
- Sous Linux/macOS :
source myenv/bin/activate - Sous Windows :
myenv\Scripts\activate
- Sous Linux/macOS :
-
Vérifiez que la version de Python est la bonne :
python --version
Souvenez-vous de toujours sauvegarder vos données et projets avant de modifier les installations Python, car changer de version peut potentiellement affecter les environnements de développement et les dépendances de vos projets.
-
- User
Collecting speexdsp Downloading speexdsp-0.1.1.tar.gz (4.4 kB) Preparing metadata (setup.py) ... done Building wheels for collected packages: speexdsp Building wheel for speexdsp (setup.py) ... error error: subprocess-exited-with-error
× python setup.py bdist_wheel did not run successfully. │ exit code: 1 ╰─> [13 lines of output] running bdist_wheel running build running build_py creating build creating build\lib.win-amd64-3.10 creating build\lib.win-amd64-3.10\speexdsp copying src\speexdsp.py -> build\lib.win-amd64-3.10\speexdsp copying src_init_.py -> build\lib.win-amd64-3.10\speexdsp running build_ext building 'speexdsp._speexdsp' extension swigging src/speexdsp.i to src/speexdsp_wrap.cpp swig.exe -python -c++ -Isrc -o src/speexdsp_wrap.cpp src/speexdsp.i error: command 'swig.exe' failed: None [end of output]
note: This error originates from a subprocess, and is likely not a problem with pip. ERROR: Failed building wheel for speexdsp Running setup.py clean for speexdsp Failed to build speexdsp ERROR: Could not build wheels for speexdsp, which is required to install pyproject.toml-based projects
- Assistant
L'erreur que vous voyez est très probablement due à l'absence de l'exécutable
swigsur votre système, ou à un problème rencontré pendant son exécution. SWIG est un outil utilisé pour générer des liaisons entre le code C/C++ et des langages de programmation de haut niveau comme Python. Vous aurez besoin de SWIG installé pour construire la bibliothèquespeexdspen raison de ses dépendances C/C++.Voici comment vous pouvez essayer de résoudre le problème :
Installer SWIG
Sous Windows :
- Téléchargez l'exécutable SWIG depuis le site officiel.
- Ajoutez le répertoire contenant
swig.exeà votre variable d'environnement PATH.
Sous Linux :
Sur les systèmes basés sur Debian (comme Ubuntu), utilisez :
sudo apt-get install swigSur les distributions basées sur Red Hat (comme Fedora), utilisez :
sudo dnf install swigSous macOS :
Vous pouvez installer SWIG à l'aide de Homebrew :
brew install swigAutres possibilités
Si SWIG est déjà installé et que vous voyez toujours une erreur, voici d'autres étapes à suivre :
- Assurez-vous que la version de Python que vous utilisez est compatible avec
speexdsp. Certaines extensions C/C++ peuvent ne pas être compatibles avec les dernières versions de Python. - Vérifiez si vous avez un compilateur C/C++ installé. Sous Windows, vous aurez besoin de Visual Studio ou de Build Tools pour Visual Studio pour compiler les extensions Python C.
Après avoir installé SWIG (et potentiellement d'autres outils de build nécessaires), réessayez d'installer
speexdsp:pip install speexdspSi l'installation échoue encore après avoir suivi ces instructions, vous pourriez envisager de rechercher des versions binaires pré-compilées (wheels) de
speexdspqui sont spécifiques à votre plateforme et version de Python, ou de changer de méthode pour la réduction du bruit, en utilisant par exemple une autre bibliothèque ou en passant par une application tierce capable de traiter les fichiers audio avant leur utilisation dans votre script Python.