import os from pydub import AudioSegment from moviepy.editor import VideoFileClip from…
- User
import os from pydub import AudioSegment from moviepy.editor import VideoFileClip from operator import itemgetter
Définition des extensions de fichier vidéo prises en charge
VIDEO_EXTENSIONS = ('.mp4', '.mkv', '.wmv', '.avi')
Demander à l'utilisateur les paramètres
max_instants = int(input("Entrez le nombre maximal d'instants à repérer : ")) clip_length_seconds = float(input("Entrez la durée des passages vidéos (en secondes) : "))
Créer le dossier de sortie s'il n'existe pas
output_folder = 'Output' if not os.path.exists(output_folder): os.makedirs(output_folder)
def scan_videos(directory): """Parcourir le répertoire pour les fichiers vidéo.""" video_files = [file for file in os.listdir(directory) if file.lower().endswith(VIDEO_EXTENSIONS)] return video_files
def find_loudest_moments(audio_segment, num_moments, min_distance_ms): """Trouver les instants où le volume est maximal.""" loudness = [(i, audio_segment[i:i+min_distance_ms].rms) for i in range(0, len(audio_segment), min_distance_ms)] return sorted(loudness, key=itemgetter(1), reverse=True)[:num_moments]
def extract_clips(video_path, moments, duration_seconds, output_dir): """Extraire des clips autour des moments indiqués.""" with VideoFileClip(video_path) as video: clip_duration_ms = int(duration_seconds * 1000) # Convertir la durée du clip en millisecondes half_clip_duration_ms = clip_duration_ms // 2 # Calculer la moitié de la durée du clip for i, (peak_time_ms, _) in enumerate(moments): start_time_ms = max(peak_time_ms - half_clip_duration_ms, 0) # Ajuster le temps de début pour centrer le pic end_time_ms = start_time_ms + clip_duration_ms # Calculer le temps de fin en fonction du temps de début ajusté start_time = start_time_ms / 1000 # Convertir en secondes end_time = end_time_ms / 1000 # Convertir en secondes if end_time > video.duration: # S’assurer que le clip ne dépasse pas la fin de la vidéo end_time = video.duration start_time = max(end_time - duration_seconds, 0) clip = video.subclip(start_time, end_time) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_clip{i+1}.mp4" clip.write_videofile(os.path.join(output_dir, output_filename), codec="libx264", audio_codec="aac")
Démarrage de l'analyse et du traitement
videos = scan_videos('.') # Analyse du dossier courant pour les vidéos
Traitement de chaque fichier vidéo
for video_file in videos: video_path = os.path.join('.', video_file) clip = VideoFileClip(video_path) if clip.audio: audio_filename = os.path.splitext(video_file)[0] + ".wav" clip.audio.write_audiofile(audio_filename) # Extraction de la piste audio audio_segment = AudioSegment.from_wav(audio_filename) os.remove(audio_filename) # Suppression du fichier audio temporaire
# Calcul de la longueur du clip en millisecondes et recherche des instants les plus forts min_distance_ms = int(clip_length_seconds * 1000) moments = find_loudest_moments(audio_segment, max_instants, min_distance_ms) extract_clips(video_path, moments, clip_length_seconds, output_folder) else: print(f"La vidéo {video_file} ne contient pas de piste audio.")print("Extraction des clips terminée.")
- Assistant
Votre script Python fait plusieurs opérations pour extraire les instants les plus bruyants d'un ensemble de fichiers vidéo et crée des clips vidéo basés sur ces instants. Voici ce qu'il fait, étape par étape :
- Importe les modules nécessaires.
- Définit un ensemble d'extensions vidéo prises en charge.
- Demande à l'utilisateur le nombre maximal d'instants à repérer et la durée de chaque clip vidéo à extraire.
- Crée un répertoire de sortie pour les clips vidé si celui-ci n'existe pas déjà.
- Définit une fonction
scan_videosqui liste tous les fichiers vidéo dans un répertoire donné. - Définit une fonction
find_loudest_momentsqui localise les moments les plus bruyants dans une piste audio. - Définit une fonction
extract_clipsqui extrait des clips vidéo autour de ces moments bruyants et les sauvegarde. - Exécute ces fonctions pour chaque fichier vidéo trouvé dans le répertoire courant.
- Il extrait d'abord la piste audio du fichier vidéo.
- Puis analyse cette piste pour trouver les moments les plus bruyants.
- Enfin, extrait des clips vidéo autour de ces moments bruyants et les sauvegarde dans le répertoire de sortie.
- À la fin du processus, il affiche un message indiquant que l'extraction des clips est terminée.
Assurez-vous que vous avez installé toutes les bibliothèques Python nécessaires (
pydubetmoviepyainsi que leurs dépendances) avant d'exécuter le script. Vous devrez peut-être aussi installer la bibliothèqueffmpegnécessaire pour manipuler les fichiers audio et vidéo.Si vous exécutez ce script tel quel, il analysera le répertoire courant (
.), mais vous pouvez modifier le script pour analyser un autre répertoire en passant un chemin différent à la fonctionscan_videos.N'oubliez pas de respecter les droits d'auteur et de ne pas utiliser ce script pour extraire du contenu de vidéos dont vous n'avez pas les droits.
- User
Je voudrais ajouter une étape entre l'étape 6 et 7. Une fois les moments les plus bruyants identifiés, le script doit déterminer pour chaque moment l'instant de l'extrait ou le volume sonore est le plus élevé (amplitude maximum). Cet instant doit être au milieu de la vidéo de sortie, qui garde néanmoins la durée prédéfinie par l'utilisateur.
- Assistant
Certainement, vous pouvez ajuster votre script pour garantir que le moment du pic sonore soit au centre de l'extrait vidéo créé. Vous aurez besoin de trouver l'instant précis du pic sonore à l'intérieur de chaque intervalle bruyant détecté, puis de modifier le calcul des temps de début et de fin de l'extrait vidéo en conséquence.
Voici comment vous pouvez mettre à jour votre code pour inclure cette étape supplémentaire :
- Modifier la fonction
find_loudest_momentspour qu'elle retourne aussi l'instant exact du pic sonore à l'intérieur de chaque segment.
def find_loudest_moments(audio_segment, num_moments, min_distance_ms): """Trouver les instants où le volume est maximal.""" loudness = [ (i, max(audio_segment[i:i+min_distance_ms], key=lambda chunk: chunk.dBFS)) for i in range(0, len(audio_segment), min_distance_ms) ] # Ordonner les moments par volume décroissant, prendre les premiers éléments loudest_moments = sorted( loudness, key=lambda tup: tup[1].dBFS, reverse=True )[:num_moments] # Trouver l'instant exact du pic sonore dans chaque segment exact_moments = [ (moment[0] + moment[1].frame_count() * moment[1].frame_rate // 1000, moment[1].dBFS) for moment in loudest_moments ] return exact_moments- Modifier la fonction
extract_clipspour utiliser l'instant exact du pic sonore comme référence pour le milieu du clip.
def extract_clips(video_path, moments, duration_seconds, output_dir): """Extraire des clips autour des moments indiqués.""" with VideoFileClip(video_path) as video: half_clip_duration_ms = int(duration_seconds * 500) # La moitié de la durée du clip en millisecondes for i, (peak_time_ms, _) in enumerate(moments): start_time_ms = max(peak_time_ms - half_clip_duration_ms, 0) # Centrer le pic sonore end_time_ms = start_time_ms + half_clip_duration_ms * 2 start_time = start_time_ms / 1000 end_time = end_time_ms / 1000 if end_time > video.duration: end_time = video.duration start_time = max(end_time - duration_seconds, 0) clip = video.subclip(start_time, end_time) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_clip{i+1}.mp4" clip.write_videofile(os.path.join(output_dir, output_filename), codec="libx264", audio_codec="aac")Ces modifications incluent désormais le calcul des instants précis à l'intérieur des segments détectés comme étant les plus bruyants, et ces instants sont utilisés pour centrer les clips vidéo qui en résultent. Assurez-vous que la modification de la fonction
find_loudest_momentssoit correcte et qu'elle utilise bien le pic sonore le plus fort dans chaque segment analysé.Il est important de noter que le code ci-dessus est une suggestion qui peut nécessiter des ajustements pour fonctionner avec votre environnement spécifique et les versions des bibliothèques que vous utilisez. Vous devrez peut-être ajuster la manière dont les moments exacts des pics sonores sont calculés en fonction des capacités et des méthodes de la bibliothèque
pydub. - Modifier la fonction
- User
peux-tu récrire tout le script ?
- Assistant
Bien sûr ! Ci-dessous, vous trouverez un script Python révisé qui incorpore l'étape supplémentaire où chaque instants les plus bruyants sont identifiés plus précisément pour être au centre des clips vidéo extraits :
import os from pydub import AudioSegment from moviepy.editor import VideoFileClip from operator import itemgetter # Définition des extensions de fichier vidéo prises en charge VIDEO_EXTENSIONS = ('.mp4', '.mkv', '.wmv', '.avi') # Demander à l'utilisateur les paramètres max_instants = int(input("Entrez le nombre maximal d'instants à repérer : ")) clip_length_seconds = float(input("Entrez la durée des passages vidéos (en secondes) : ")) # Créer le dossier de sortie s'il n'existe pas output_folder = 'Output' if not os.path.exists(output_folder): os.makedirs(output_folder) def scan_videos(directory): """Parcourir le répertoire pour les fichiers vidéo.""" video_files = [file for file in os.listdir(directory) if file.lower().endswith(VIDEO_EXTENSIONS)] return video_files def find_loudest_moments(audio_segment, num_moments, min_distance_ms): """Trouver les instants où le volume est maximal.""" loudness = [(i, audio_segment[i:i + min_distance_ms].rms) for i in range(0, len(audio_segment), min_distance_ms)] sorted_loudness = sorted(loudness, key=itemgetter(1), reverse=True)[:num_moments] # Trouver l'instant exact du pic sonore à l'intérieur de chaque segment bruyant loudest_moments = [] for start_ms, _ in sorted_loudness: segment = audio_segment[start_ms:start_ms + min_distance_ms] peak_amplitude = segment.max peak_ms = start_ms + segment.rms.index(peak_amplitude) * audio_segment.frame_width // 1000 loudest_moments.append((peak_ms, peak_amplitude)) return loudest_moments def extract_clips(video_path, moments, duration_seconds, output_dir): """Extraire des clips autour des moments indiqués.""" with VideoFileClip(video_path) as video: clip_duration_ms = int(duration_seconds * 1000) # Convertir la durée du clip en millisecondes half_clip_duration_ms = clip_duration_ms // 2 # Calculer la moitié de la durée du clip for i, (peak_time_ms, _) in enumerate(moments): start_time_ms = max(peak_time_ms - half_clip_duration_ms, 0) # Ajuster le temps de début pour centrer le pic end_time_ms = start_time_ms + clip_duration_ms # Calculer le temps de fin en fonction du temps de début ajusté start_time = start_time_ms / 1000 # Convertir en secondes end_time = end_time_ms / 1000 # Convertir en secondes if end_time > video.duration: # S’assurer que le clip ne dépasse pas la fin de la vidéo end_time = video.duration start_time = max(end_time - duration_seconds, 0) clip = video.subclip(start_time, end_time) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_clip{i + 1}.mp4" clip.write_videofile(os.path.join(output_dir, output_filename), codec="libx264", audio_codec="aac") # Démarrage de l'analyse et du traitement videos = scan_videos('.') # Analyse du dossier courant pour les vidéos # Traitement de chaque fichier vidéo for video_file in videos: video_path = os.path.join('.', video_file) clip = VideoFileClip(video_path) if clip.audio: audio_filename = os.path.splitext(video_file)[0] + ".wav" clip.audio.write_audiofile(audio_filename) # Extraction de la piste audio audio_segment = AudioSegment.from_wav(audio_filename) os.remove(audio_filename) # Suppression du fichier audio temporaire # Recherche des instants les plus forts min_distance_ms = int(clip_length_seconds * 1000) moments = find_loudest_moments(audio_segment, max_instants, min_distance_ms) extract_clips(video_path, moments, clip_length_seconds, output_folder) else: print(f"La vidéo {video_file} ne contient pas de piste audio.") print("Extraction des clips terminée.")Ce script comporte désormais une étape intermédiaire dans la fonction
find_loudest_momentsoù l'on détermine l'instant précis du pic sonore à l'intérieur de chaque segment bruyant détecté. Cet instant du pic sonore est ensuite utilisé pour centrer le clip vidéo autour de ce moment lors de l'extraction.Assurez-vous que vous disposez de toutes les dépendances nécessaires et faites attention à la gestion des erreurs et à la validation des entrées utilisateur lorsque vous exécutez des scripts qui traitent les données fournies par les utilisateurs.
- User
MoviePy - Writing audio in 4de8e0c227e30d804f1a302eee99eaa3ffc0e73cae48688b649b361de71c7f8a.wav MoviePy - Done. Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Test 4 - Copie.py", line 73, in moments = find_loudest_moments(audio_segment, max_instants, min_distance_ms) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "C:\Users\jp\Desktop\Nouveau dossier\Test 4 - Copie.py", line 35, in find_loudest_moments peak_ms = start_ms + segment.rms.index(peak_amplitude) * audio_segment.frame_width // 1000 ^^^^^^^^^^^^^^^^^ AttributeError: 'int' object has no attribute 'index'
- Assistant
Désolé pour la confusion. Le problème que vous rencontrez est dû à l'usage incorrect de la fonction
index()sur un objetint. Le code que je vous ai donné précédemment pour ce segment contenait une erreur. Pour obtenir l'instant précis du pic sonore dans la fonctionfind_loudest_moments, il faut parcourir les échantillons de l'audio et trouver celui qui a l'amplitude la plus élevée.Cependant, la bibliothèque
pydubne fournit pas une fonction directe pour obtenir l'index d'un pic sonore. Voici ce que nous pouvons faire à la place :def find_loudest_moments(audio_segment, num_moments, min_distance_ms): """Trouver les instants où le volume est maximal.""" loudness = [] step = min_distance_ms // 2 # Pour prévenir le chevauchement, ajustez cela si nécessaire for i in range(0, len(audio_segment) - min_distance_ms + 1, step): chunk = audio_segment[i:i + min_distance_ms] loudness.append((i, chunk.rms)) sorted_loudness = sorted(loudness, key=itemgetter(1), reverse=True)[:num_moments] # Trouver l'instant exact du pic sonore à l'intérieur de chaque segment bruyant loudest_moments = [] for start_ms, _ in sorted_loudness: chunk = audio_segment[start_ms:start_ms + min_distance_ms] samples = chunk.get_array_of_samples() peak_amplitude = max(samples) peak_sample_index = samples.index(peak_amplitude) peak_ms = start_ms + (peak_sample_index * 1000 // audio_segment.frame_rate) loudest_moments.append((peak_ms, peak_amplitude)) return loudest_momentsIci, nous examinons chaque segment de
min_distance_mspour son volume sonore (RMS) le plus élevé, ensuite nous parcourons les échantillons de ce segment pour trouver l'index de celui qui a l'amplitude la plus élevée (le pic sonore). Puisque les échantillons audio sont à une fréquence d'échantillonnage fixe (frame rate), nous pouvons convertir l'index de l'échantillon en millisecondes pour localiser le pic sonore précis.Intégrez ce bloc de code mis à jour dans votre script et il devrait fonctionner correctement. Assurez-vous également de tester le script avec différents fichiers audio pour garantir qu'il se comporte comme prévu dans divers scénarios.
- Assistant
Je vais interpréter cela comme vous demandant si je suis là pour vous aider davantage. Si vous avez d'autres questions ou si vous avez besoin d'assistance supplémentaire, n'hésitez pas à demander. Je suis ici pour vous aider avec votre code, répondre à vos questions ou fournir des éclaircissements sur des sujets ou des technologies spécifiques.
- User
Je voudrais tout de même que le script respecte l'ordre décroissant des moments bruyants identifiés en début d'étape 6, lors de l'extraction des clips.
- Assistant
D'accord, pour respecter l'ordre décroissant des moments bruyants lorsque vous extrayez les clips, vous devez vous assurer de les trier correctement après avoir trouvé l'instant précis du pic sonore. Voici une version mise à jour de la fonction
find_loudest_moments, alors que l'ordre est conservé lors de l'extraction des clips en utilisant la listeloudest_momentsque nous avons triée par volume décroissant :from pydub import AudioSegment from operator import itemgetter import os from moviepy.editor import VideoFileClip # ... autres parties du code ... def find_loudest_moments(audio_segment, num_moments, min_distance_ms): """Trouver les instants où le volume est maximal.""" loudness = [(i, audio_segment[i:i + min_distance_ms].rms) for i in range(0, len(audio_segment), min_distance_ms)] # Sélectionner les moments les plus forts, mais ne pas encore les trier par amplitude loudest_segments = sorted(loudness, key=itemgetter(1), reverse=True)[:num_moments] # Trouver l'instant exact du pic sonore dans chaque segment bruyant et conserver l'amplitude pour le tri loudest_moments = [] for start_ms, _ in loudest_segments: chunk = audio_segment[start_ms:start_ms + min_distance_ms] peak_amplitude = max(chunk.get_array_of_samples()) peak_sample_index = chunk.get_array_of_samples().index(peak_amplitude) peak_ms = start_ms + (peak_sample_index * 1000 // chunk.frame_rate) loudest_moments.append((peak_ms, chunk.rms)) # Tri final des moments en fonction de l'amplitude (RMS) en ordre décroissant loudest_moments.sort(key=itemgetter(1), reverse=True) # Ne conserver que les instants pour l'extraction, sans les amplitudes return [(moment[0],) for moment in loudest_moments] # Reste du code pour analyser la vidéo et extraire les clips...Ici, la liste
loudest_momentsest d'abord triée par l'amplitude RMS en ordre décroissant, puis est filtrée pour ne conserver que les instants exacts du pic sonore (sans les amplitudes) pour les envoyer à l'extraction des clips.Assurez-vous d'intégrer cette fonction dans votre script existant en remplaçant l'ancienne fonction
find_loudest_moments. Cette version garantira que les moments les plus bruyants sont identifiés et extraits dans l'ordre décroissant de leur volume comme souhaité. - User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Test 4 - Copie.py", line 79, in extract_clips(video_path, moments, clip_length_seconds, output_folder) File "C:\Users\jp\Desktop\Nouveau dossier\Test 4 - Copie.py", line 51, in extract_clips for i, (peak_time_ms, _) in enumerate(moments): ^^^^^^^^^^^^^^^^^ ValueError: not enough values to unpack (expected 2, got 1)
- Assistant
La
ValueErrorque vous rencontrez est due au fait que dans la fonctionfind_loudest_moments, j'ai modifié le script final pour retourner une liste de tuples contenant seulement les temps des pics sonores(peak_ms,), contrairement à ce qui était attendu dans la fonctionextract_clips. La fonctionextract_clipsattend des tuples de deux éléments(peak_time_ms, _)dans votre version originale.Pour résoudre ce problème, nous devons faire correspondre le format des données retournées par
find_loudest_momentsavec ce que la fonctionextract_clipsattend.Voici comment vous pouvez corriger ce problème :
- Assurez-vous que
find_loudest_momentsretourne une liste de tuples avec deux éléments, en ignorant le deuxième élément. Nous avons besoin seulement des temps des pics sonores:
return [(moment[0], None) for moment in loudest_moments]- Ajustez la fonction
extract_clipspour accepter un tuple avec le temps du pic sonore, sans se soucier de la présence ou de la valeur du deuxième élément :
def extract_clips(video_path, moments, duration_seconds, output_dir): """Extraire des clips autour des moments indiqués.""" with VideoFileClip(video_path) as video: clip_duration_ms = int(duration_seconds * 1000) # Convertir la durée du clip en millisecondes half_clip_duration_ms = clip_duration_ms // 2 # Calculer la moitié de la durée du clip for i, (peak_time_ms, _) in enumerate(moments): # Ici, le deuxième élément est ignoré # ... Le reste de la fonction extract_clips reste inchangé ...Avec ces ajustements, le script attendra et traitera correctement un tuple avec un seul élément pour le temps du pic sonore (le deuxième élément du tuple étant ignoré) dans la boucle
forde la fonctionextract_clips.Après cette correction, la fonction
find_loudest_momentscherchera les pics sonores et les triera par ordre décroissant de volume, tandis que la fonctionextract_clipsextraira les clips basés sur ces instants en plaçant le moment le plus fort au centre du clip. - Assurez-vous que