import os import subprocess import numpy as np import uuid # Import uuid to generate…
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): if audio_data.ndim == 1: volume = audio_data.astype('float32') ** 2 else: volume = np.mean(audio_data.astype('float32') ** 2, axis=1) volume_dB = 10 * np.log10(volume + 1e-9) # +1e-9 to avoid log(0) and convert to dB return volume_dB
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename)
# Convert stereo to mono if necessary if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) volume_dB = calculate_loudness(audio_data) segment_half_duration = segment_duration / 2.0 start_index = int(starting_offset * rate) end_index = int((video_duration - ending_offset) * rate) moments = [] volumes = [] while len(moments) < num_moments and (end_index - start_index) > 0: index = np.argmax(volume_dB[start_index:end_index]) print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}") # Ajouté pour le débogage moment = (start_index + index) / rate print(f"Added moment at {moment} seconds") # Ajouté pour le débogage moment_volume = volume_dB[start_index + index] if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset: volume_dB[start_index + index] = -np.inf continue moments.append(moment) print(f"Added moment at {moment} seconds") # Ajouté pour le débogage volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments # Increment the global index by adding the start_index global_index = start_index + index # Définir le facteur de neutralisation (par exemple, 0.25 pour un quart de la durée du segment) neutralization_factor = 1 # Ajuster ce facteur en fonction de vos besoins # Calculer le rayon de neutralisation en appliquant le facteur à la durée du segment # neutralization_radius = segment_duration * neutralization_factor neutralization_radius = segment_duration * (detection_threshold / 10.0) # Déterminer les indices de début et de fin de la plage de neutralisation clear_range_start = max(0, global_index - int(rate * neutralization_radius)) clear_range_end = min(len(volume_dB), global_index + int(rate * neutralization_radius)) # Mettre la plage de neutralisation à -inf pour éviter de sélectionner à nouveau des moments proches volume_dB[clear_range_start:clear_range_end] = -np.inf print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}") return moments, volumesdef perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
Remplace la méthode dB par la méthode RMS
- Assistant
La méthode dB typique pour calculer la sonie (loudness) utilise le logarithme décimal des valeurs moyennes des carrés des pressions sonores. Cependant, on peut également utiliser la méthode RMS (Root Mean Square) qui est également une mesure commune de la sonie d'un signal audio. Pour remplacer la méthode dB par RMS, quelques changements doivent être effectués dans la fonction
calculate_loudness.Voici la fonction
calculate_loudnessmodifiée pour utiliser RMS pour calculer la sonie au lieu du dB :def calculate_loudness(audio_data): if audio_data.ndim == 1: # Calcul du carré des valeurs, puis de la moyenne, et enfin de la racine carrée pour la version mono. rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2)) else: # Calcul du carré des valeurs, puis de la moyenne sur l'axe 1 (canaux), et enfin de la racine carrée pour la version stéréo. rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2, axis=1)) return rmsNotez que RMS représente la racine carrée de la moyenne du carré des valeurs du signal, ce qui donne un bon indicateur de la puissance ou de "l'intensité" pour les signaux à temps variable comme l'audio. L'unité d'une valeur RMS sera donc la même que celle du signal d'origine (par exemple, Pascal pour la pression sonore), et elle n'est pas exprimée en décibels (dB) - qui est un ratio logarithmique.
Veuillez également noter que, selon la manière dont le reste du code utilise la fonction
calculate_loudness, d'autres ajustements pourraient être nécessaires pour s'aligner avec les changements de l'unité des valeurs de sonie. - User
Là tu as simplement remplacé la méthode : je veux que tu l'intègres complètement au script, pour que tout fonctionne, de l'analyse à l'extraction.
- Assistant
D'accord, pour intégrer complètement la méthode RMS dans le script en remplaçant la méthode dB, nous devons apporter certaines modifications à la fonction
calculate_loudness, ainsi qu'à la fonctionfind_loudest_momentsqui utilise les valeurs de sonie pour déterminer les moments les plus forts. Voici un exemple de la façon de le faire :-
Modifier la fonction
calculate_loudnesspour qu'elle retourne la valeur RMS du signal audio. -
Dans
find_loudest_moments, adapter le code pour l'utilisation des valeurs RMS au lieu des valeurs en dB.
D'abord, voici la fonction
calculate_loudnessmodifiée pour utiliser RMS :def calculate_loudness(audio_data): # RMS est calculé sur les valeurs du signal. Pour de l'audio stéréo, np.mean est appelé avec axis=1 pour calculer la RMS par échantillon. if audio_data.ndim == 1: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2)) else: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2, axis=1)) return rmsEnsuite, voici les modifications nécessaires dans la fonction
find_loudest_momentspour l'adapter à l'utilisation de RMS :# ... def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Convertir le son stéréo en mono si nécessaire if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) intensity = calculate_loudness(audio_data) segment_half_duration = segment_duration / 2.0 start_index = int(starting_offset * rate) end_index = int((video_duration - ending_offset) * rate) # Le reste de la fonction reste le même, en utilisant "intensity" au lieu de "volume_dB" # ... # Au lieu de trouver l'indice du pic max en dB, nous cherchons l'indice du pic max en RMS index = np.argmax(intensity[start_index:end_index]) # ...Dans ce code,
intensitycontient les valeurs RMS de chaque échantillon audio (au lieu des valeurs en dB). Ainsi, lors de la recherche de l'indice du pic le plus fort, nous utilisons directementnp.argmax(intensity[start_index:end_index])pour obtenir l'indice de la valeur RMS maximale dans la plage donnée.Il est important de noter que les valeurs RMS ne sont pas en dB, donc l'échelle est différente. Les seuils et les paramètres qui dépendent de la valeur sonore devraient être ajustés pour tenir compte de ces différences. Par exemple, toute logique basée sur les valeurs de sonie (comme le seuil de détection) devra être revue afin de correspondre à la plage des valeurs RMS.
Ces modifications suffiront pour changer la mesure de sonie de dB à RMS dans votre script existant. Pensez à vérifier et ajuster d'autres parties du code si nécessaire pour assurer une cohérence avec les nouvelles valeurs RMS.
-
- User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 530, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 510, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 282, in perform_extraction moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 213, in find_loudest_moments index = np.argmax(intensity[start_index:end_index]) IndexError: invalid index to scalar variable.
- Assistant
L'erreur
IndexError: invalid index to scalar variableindique que vous essayez d'indexer un scalaire, ce qui signifie que quelque part dans votre code, vous attendez un tableau ou une liste, mais vous avez un scalaire à la place (une seule valeur).Cela peut se produire si la fonction
calculate_loudnessretourne une seule valeur RMS scalaire pour l'intégralité du fichier audio au lieu d'un tableau de valeurs RMS pour chaque échantillon ou trame. Nous devrions nous attendre à un tableau de valeurs RMS de telle sorte que nous puissions indexée.Voici comment modifier
calculate_loudnesspour s'assurer qu'elle retourne toujours un tableau, et comment corriger la fonctionfind_loudest_momentspour gérer correctement le tableau:- Modifier la fonction
calculate_loudnesspour s'assurer qu'elle retourne un tableau RMS:
def calculate_loudness(audio_data): # Calculer RMS sur des fenêtres si nécessaire ou retourner un tableau de rms pour toutes les trames échantillon par échantillon if audio_data.ndim == 1: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2)) else: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2, axis=1)) return rms- Modifier
find_loudest_momentsen conséquence:
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Prendre en compte la stéréo et mono ici if audio_data.ndim > 1: audio_data = audio_data.mean(axis=1) loudness = calculate_loudness(audio_data) segment_half_duration = segment_duration / 2.0 start_index = int(starting_offset * rate) end_index = int((video_duration - ending_offset) * rate) # loudness doit être un tableau pour que nous puissions indexer avec start_index et end_index # Si loudness n'est pas un tableau, nous avons un problème # Assurez-vous que loudness est un tableau if not isinstance(loudness, np.ndarray): print("Error: Loudness must be a numpy array, not a scalar.") return [] # Suite ...Assurez-vous que la
calculate_loudnessfonctionne correctement et retourne un tableau de valeurs RMS pour chaque trame audio. Si vous voulez calculer une valeur RMS pour chaque sous-ensemble du fichier audio (par ex. chaque seconde), vous pouvez diviser le fichier audio en fenêtres et calculer le RMS pour chaque fenêtre. Cela donnerait un tableau de valeurs RMS, une pour chaque fenêtre, que vous pouvez ensuite analyser pour trouver les moments les plus forts. - Modifier la fonction
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): # Calculer RMS sur des fenêtres si nécessaire ou retourner un tableau de rms pour toutes les trames échantillon par échantillon if audio_data.ndim == 1: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2)) else: rms = np.sqrt(np.mean(audio_data.astype('float32') ** 2, axis=1)) return rms
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename)
# Prendre en compte la stéréo et mono ici if audio_data.ndim > 1: audio_data = audio_data.mean(axis=1) loudness = calculate_loudness(audio_data) segment_half_duration = segment_duration / 2.0 start_index = int(starting_offset * rate) end_index = int((video_duration - ending_offset) * rate) # loudness doit être un tableau pour que nous puissions indexer avec start_index et end_index # Si loudness n’est pas un tableau, nous avons un problème # Assurez-vous que loudness est un tableau if not isinstance(loudness, np.ndarray): print("Error: Loudness must be a numpy array, not a scalar.") return [] while len(moments) < num_moments and (end_index - start_index) > 0: index = np.argmax(intensity[start_index:end_index]) print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}") # Ajouté pour le débogage moment = (start_index + index) / rate print(f"Added moment at {moment} seconds") # Ajouté pour le débogage moment_volume = volume_dB[start_index + index] if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset: volume_dB[start_index + index] = -np.inf continue moments.append(moment) print(f"Added moment at {moment} seconds") # Ajouté pour le débogage volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments # Increment the global index by adding the start_index global_index = start_index + index # Définir le facteur de neutralisation (par exemple, 0.25 pour un quart de la durée du segment) neutralization_factor = 1 # Ajuster ce facteur en fonction de vos besoins # Calculer le rayon de neutralisation en appliquant le facteur à la durée du segment # neutralization_radius = segment_duration * neutralization_factor neutralization_radius = segment_duration * (detection_threshold / 10.0) # Déterminer les indices de début et de fin de la plage de neutralisation clear_range_start = max(0, global_index - int(rate * neutralization_radius)) clear_range_end = min(len(volume_dB), global_index + int(rate * neutralization_radius)) # Mettre la plage de neutralisation à -inf pour éviter de sélectionner à nouveau des moments proches volume_dB[clear_range_start:clear_range_end] = -np.inf print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}") return moments, volumesdef perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 533, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 513, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 285, in perform_extraction moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) ValueError: not enough values to unpack (expected 2, got 0)
- Assistant
L'erreur
ValueError: not enough values to unpack (expected 2, got 0)indique que la fonctionfind_loudest_momentsétait censée retourner deux valeurs (typiquement,momentsetvolumes), mais elle a retourné aucune valeur (une liste vide).Il semble qu'il y ait un problème à l'intérieur de la fonction
find_loudest_momentsqui empêche qu'elle retourne les valeurs attendues. Examinons cette fonction plus en détail et corrigeons-la pour qu'elle fonctionne correctement avec la mesure RMS.Je vais d'abord effectuer des corrections de base, comme s'assurer que les listes
momentsetvolumessont initialisées dans la fonction et ne pas supposer qu'elles existent déjà. Ensuite, je vais m'assurer que la fonction de calcul RMS retourne un tableau numpy et non une valeur scalaire, et que les variables dans la fonctionfind_loudest_momentssont correctement nommées et utilisées.Voici la correction de la fonction
calculate_loudnesspour retourner un tableau de valeurs RMS échantillon par échantillon :def calculate_loudness(audio_data): # RMS is calculated over the squared values. If stereo, calculate mean for the two channels first. if audio_data.ndim > 1: # If stereo, convert to mono by averaging the channels audio_data = np.mean(audio_data.astype('float32'), axis=1) # Calculate the squared values audio_data_squared = audio_data ** 2 # Calculate the RMS for each sample rms = np.sqrt(np.mean(audio_data_squared)) return rmsLa correction de
find_loudest_moments(en supprimant aussi des lignes de débogage et de nettoyage qui ne sont pas nécessaires pour l'exécution normale) :def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Convert stereo to mono if necessary if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) rms_values = calculate_loudness(audio_data) moments = [] volumes = [] for _ in range(num_moments): max_rms = np.max(rms_values) max_index = np.argmax(rms_values) # Convert index to time moment = (max_index + starting_offset * rate) / rate # Clear the segment centered around the found peak segment_half_duration_samples = int(segment_half_duration * rate) start_index = max(max_index - segment_half_duration_samples, 0) end_index = min(max_index + segment_half_duration_samples, len(rms_values)) rms_values[start_index:end_index] = 0 # Clear the RMS values in this range to avoid re-detection # Save the moment and its volume moments.append(moment) volumes.append(max_rms) return moments, volumesNotez que l'utilisation de la mesure RMS à la place des décibels affectera considérablement les valeurs de seuil utilisées dans le reste de votre code. Le seuil de détection (
detection_threshold) et la neutralisation autour des moments détectés devront être ajustés en conséquence. Vous devrez peut-être établir de nouvelles valeurs empiriques pour ces seuils en testant et en affinant en fonction des résultats.Après ces corrections, les fonctions devraient fonctionner correctement, mais vous devrez ajuster d'autres parties du code pour assurer la compatibilité avec les nouvelles valeurs RMS.
- User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 513, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 493, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 265, in perform_extraction moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS.py", line 220, in find_loudest_moments segment_half_duration_samples = int(segment_half_duration * rate) NameError: name 'segment_half_duration' is not defined. Did you mean: 'segment_duration'?
- Assistant
L'erreur
NameError: name 'segment_half_duration' is not definedindique qu'on tente d'utiliser une variablesegment_half_durationqui n'a pas été définie au préalable. Il semble que l'intention était de diviser la durée du segment par deux pour obtenir la moitié de la durée du segment, mais la variable elle-même n'a pas été affectée avant l'utilisation.Pour résoudre le problème, vous devez définir
segment_half_durationavant de l'utiliser dans la fonctionfind_loudest_moments. Voici le correctif pour définirsegment_half_duration:def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Convert stereo to mono if necessary if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) rms_values = calculate_loudness(audio_data) moments = [] volumes = [] segment_half_duration = segment_duration / 2 # Define segment_half_duration # Assurez-vous que nous avons un tableau de valeurs RMS de la bonne taille if audio_data.ndim == 1: rms_values = np.ones_like(audio_data) * rms_values for _ in range(num_moments): # There might be a more efficient way to do this max_rms = np.max(rms_values) if max_rms == 0: break # Si on a nettoyé tout le tableau rms_values max_index = np.argmax(rms_values) # Convert index to time moment = (start_index + max_index) / rate # Clear the segment centered around the found peak segment_half_duration_samples = int(segment_half_duration * rate) start_index = max(max_index - segment_half_duration_samples, 0) end_index = min(max_index + segment_half_duration_samples, len(rms_values)) rms_values[start_index:end_index] = 0 # Clear the RMS values in this range to avoid re-detection # Save the moment and its volume moments.append(moment) volumes.append(max_rms) return moments, volumesNotez que j'ai également ajouté un test pour voir si
max_rmsest égal à zéro avant d'essayer de l'utiliser. Cela peut aider à éviter des boucles infinies si tous les RMS restants dans le tableaurms_valuessont nettoyés (par exemple, mis à zéro).De plus,
start_indexn'était pas défini avant son utilisation dans le calcul demoment. Je l'ai initié avant de l'utiliser.Assurez-vous que la fonction
calculate_loudnessrenvoie un tableau de valeurs RMS par échantillon et qu'elle soit utilisée correctement dansfind_loudest_moments. Ces ajustements devraient résoudre votre problème et permettre au script de continuer son exécution normalement. - User
Le tri par volume croissant ou décroissant ne fonctionne pas.
- Assistant
Pour corriger le tri par volume dans la fonction
find_loudest_moments, il faut d'abord s'assurer que les volumes retournés représentent la sonie des segments indiqués et que nous avons une mesure cohérente de cette sonie que nous pouvons utiliser pour trier les moments par leur volume. Comme nous avons converti la mesure de sonie en RMS, nous devons nous assurer que nous mesurons correctement ce RMS pour chaque segment.Tout d'abord, corrigeons la fonction
calculate_loudnesspour qu'elle renvoie le RMS pour chaque trame (ou échantillon) de l'audio, et non une valeur RMS unique pour l'ensemble du signal. Voici la fonction révisée :def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_valuesEnsuite, la fonction
find_loudest_momentsdoit découvrir les moments les plus forts en utilisant les valeurs RMS. Toutefois, cela nécessite une logique pour diviser l'audio en segments et calculer la valeur RMS de chaque segment. Voici une correction pour calculer le RMS par segment et pour récupérer correctement les indices des moments les plus forts :def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename) # Convert to mono if stereo if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculate RMS values for the entire audio rms_values = calculate_loudness(audio_data) # Initialize lists for saving moments and their loudness moments = [] volumes = [] # Calculate RMS values for each segment segment_samples = int(segment_duration * rate) for i in range(0, len(audio_data), segment_samples): segment_rms = np.sqrt(np.mean(audio_data[i:i+segment_samples].astype('float32')**2)) if (i / rate + segment_duration <= video_duration - ending_offset) and (i/ rate >= starting_offset): moments.append(i / rate) # Convert sample index to time in seconds volumes.append(segment_rms) # Now moments has RMS value for each segment # If we need to sort segments by volume if len(moments) > 0 and len(volumes) > 0: # Continuous indices mapping to the moments array indices = range(len(moments)) # Sort indices based on corresponding volumes sorted_indices = sorted(indices, key=lambda i: volumes[i], reverse=True) # Sort in descending order of volume # Now we have indices of moments sorted by volume # Reconstruct moments and volumes arrays based on sorted indices sorted_moments = [moments[i] for i in sorted_indices] sorted_volumes = [volumes[i] for i in sorted_indices] return sorted_moments[:num_moments], sorted_volumes[:num_moments] else: return [], []Veuillez noter qu'avec cette nouvelle approche, nous calculons la valeur RMS pour chaque segment de
segment_durationsecondes, en ignorant les segments qui tombent en dehors des temps de début et de fin spécifiés. Cela changera significativement le comportement de la fonction par rapport à ce qu'il était auparavant, mais cela fournira une mesure plus précise du volume pour le tri.Finalement, assurez-vous que la fonction
sort_momentsqui est utilisée lors de l'extraction des moments utilise correctement les valeurs dansvolumespour trier les moments en fonction de leur intensité sonore. Les valeurs dansvolumesdoivent correspondre à chaque moment et fournir une mesure de la sonie de cette portion de l'audio. - User
Y a-t-il d'autres méthodes que RMS et dB pour analyser les moments bruyants ?
- Assistant
Oui, il existe de nombreuses autres méthodes pour analyser l'intensité sonore des moments dans un fichier audio ou vidéo. En plus de l'utilisation des mesures RMS (Root Mean Square) et dB (décibels), voici quelques autres approches courantes :
-
Short-Time Energy: Cette méthode implique le calcul de l'énergie du signal sur de courts intervalles de temps. Elle est similaire à la méthode RMS, mais peut être plus adaptée pour détecter des variations rapides dans les niveaux d'énergie.
def short_time_energy(frame): return np.sum(frame.astype(float)**2) -
Zero Crossing Rate (ZCR): Le ZCR est un indicateur du taux de passage par zéro du signal. Il mesure le taux auquel le signal change de positif à négatif ou vice versa. Cette méthode est souvent utilisée pour analyser le contenu rythmique du son.
-
Spectral Flux: Le flux spectral mesure la quantité de changement ou de "mouvement" dans le spectre d'un signal au fil du temps. Elle peut être utilisée pour détecter des événements sonores ou des changements sonores significatifs.
-
Spectral Centroid: Le centroïde spectral est une mesure qui indique où le "centre de masse" d'un spectre de fréquences se trouve, et il est souvent associé à la "brillance" d'un son. Un son plus brillant aura un centroïde spectral plus élevé.
-
Mel-frequency Cepstral Coefficients (MFCCs): MFCCs sont largement utilisés dans le traitement automatique de la parole et l'analyse des sons pour caractériser différentes propriétés du signal vocal.
-
Log-Mel Spectrogram: Une autre méthode consiste à calculer le spectrogramme basé sur l'échelle de Mel, qui est plus sensible à la manière dont l'oreille humaine perçoit le son, suivi par une log-transformation pour mieux représenter la dynamique de puissance du signal sonore.
-
Peak Envelope: Il est possible de suivre l'enveloppe du signal et de détecter les pics, en supposant que les moments forts se caractérisent par des pics rapides dans l'enveloppe.
-
Audio Level Meters (LUFS, LKFS): Ces mesures, Loudness Units Full Scale et Loudness K-weighted Full Scale, sont des normes pour mesurer la sonie dans les diffusions de contenu. Elles sont conçues pour mieux correspondre à la perception humaine de la sonie.
Pour intégrer l'une de ces méthodes dans votre système d'analyse, vous devrez effectuer une recherche plus approfondie sur la méthode spécifique et l'appliquer en mesurant l'intensité des segments de votre audio ou de votre vidéo. En fonction de ce que vous essayez d'atteindre (par exemple, détecter des battements, des dialogues, des effets spéciaux), certaines méthodes peuvent être plus appropriées que d'autres.
-
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename)
# Convert to mono if stereo if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculate RMS values for the entire audio rms_values = calculate_loudness(audio_data) # Initialize lists for saving moments and their loudness moments = [] volumes = [] # Calculate RMS values for each segment segment_samples = int(segment_duration * rate) for i in range(0, len(audio_data), segment_samples): segment_rms = np.sqrt(np.mean(audio_data[i:i+segment_samples].astype('float32')**2)) if (i / rate + segment_duration <= video_duration - ending_offset) and (i/ rate >= starting_offset): moments.append(i / rate) # Convert sample index to time in seconds volumes.append(segment_rms) # Now moments has RMS value for each segment # If we need to sort segments by volume if len(moments) > 0 and len(volumes) > 0: # Continuous indices mapping to the moments array indices = range(len(moments)) # Sort indices based on corresponding volumes sorted_indices = sorted(indices, key=lambda i: volumes[i], reverse=True) # Sort in descending order of volume # Now we have indices of moments sorted by volume # Reconstruct moments and volumes arrays based on sorted indices sorted_moments = [moments[i] for i in sorted_indices] sorted_volumes = [volumes[i] for i in sorted_indices] return sorted_moments[:num_moments], sorted_volumes[:num_moments] else: return [], []def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
- Assistant
Pour résoudre le problème de tri par volume croissant ou décroissant, il est crucial de s'assurer que la liste des volumes correspond aux moments où ils ont été mesurés et que le tri se fait sur la bonne liste. Le script demande déjà la préférence de tri, mais je pense que l'erreur réside dans le fait que
calculate_loudnessne calcule pas correctement le RMS sur les trames individuelles du fichier audio. Cela affecte ensuite le tri des volumes dansfind_loudest_moments.Voici la correction nécessaire dans la fonction
calculate_loudnesset l'adaptation dans la fonctionfind_loudest_momentspour s'assurer que le tri par volume fonctionne correctement.Fonction
calculate_loudnesscorrigée:Pour le script ci-dessus, la méthode
calculate_loudnessn'est pas correctement implémentée. En effet, elle devrait calculer et retourner un tableau de valeurs RMS pour chaque fenêtre (frame) de l'audio, mais elle renvoie actuellement une seule valeur scalaire de RMS. De plus, le calcul du RMS est incorrect dans le contexte du traitement de l'audio.La correction initiale pour
calculate_loudnessserait :def calculate_loudness(audio_data, frame_length=1024, hop_length=512): # Convertir en mono si nécessaire if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculer RMS pour chaque frame rms = [] for i in range(0, len(audio_data), hop_length): # Calculer RMS pour la frame actuelle rms_current = np.sqrt(np.mean((audio_data[i:i+frame_length]**2))) rms.append(rms_current) # Assurez-vous de retourner un tableau numpy return np.array(rms)Dans la fonction
calculate_loudness,frame_lengthreprésente la longueur de la fenêtre de calcul RMS en échantillons ethop_lengthreprésente le nombre d'échantillons entre le début de fenêtres consécutives.Dans
find_loudest_moments:def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): # Cette fonction doit appeler `calculate_loudness` correctement et utiliser les valeurs RMS retournées # pour trouver les segments les plus forts. ...Modification de la fonction
find_loudest_momentsafin qu'elle utilise la mesure RMS et travaille avec les fenêtres de RMS plutôt qu'avec le signal brut. Regardez aussi danscalculate_loudnesset faites les changements comme indiqué au-dessus.Après avoir corrigé la fonction
calculate_loudnesspour renvoyer un tableau RMS correct, vous devrez passer parfind_loudest_momentset ajuster l'algorithme pour fonctionner avec un tableau d'intensités RMS au lieu de dB.Pour les fonctions de tri, vous pouvez utiliser les fonctions
sorted()etzip()pour trier simultanément les moments et les volumes sur la base du volume.Enfin, assurez-vous que ces fonctions travaillent ensemble harmonieusement et testez le script pour voir si le tri se fait correctement. Vous pourriez avoir besoin de régler les paramètres pour
frame_lengthethop_lengthpour obtenir les meilleurs résultats, car ils auront une influence sur la résolution temporelle du RMS calculé. - User
Parmi les méthodes que tu m'as donné ci-dessus, laquelle serait la plus effiface ?
- Assistant
La méthode la plus efficace pour détecter les moments bruyants dans un fichier audio ou vidéo dépend principalement de ce que vous souhaitez repérer et du contexte d'utilisation. Voici quelques considérations pour les méthodes mentionnées précédemment :
-
Short-Time Energy : Efficace pour détecter les changements abrupts de l'énergie sonore et bien adaptée pour les sons transitoires ou les impacts.
-
Zero Crossing Rate (ZCR) : Utile pour repérer les périodes de silence ou les éléments rythmiques, mais pas toujours pour les moments fort en volume.
-
Spectral Flux : Bonne pour identifier les changements dans la texture sonore ou l'activité spectrale, peut-être plus liée à la variance du son qu'à sa sonie.
-
Spectral Centroid : Peut être un bon indicateur de la "brillance" d'un son et peut être utilisé pour détecter des sons aigus ou métalliques.
-
Mel-Frequency Cepstral Coefficients (MFCCs) : Couramment utilisés dans le traitement automatique de la parole et la reconnaissance de locuteur, mais moins pour la détection de l'intensité sonore.
-
Log-Mel Spectrogram : Peut être très efficace si vous cherchez à analyser l'intégration de fréquences et de sonie, comme dans certaines méthodes de reconnaissance des sons environnementaux.
-
Peak Envelope : Si vous êtes à la recherche de pics abrupts dans l'amplitude sonore, c'est une méthode assez directe pour les détecter.
-
Audio Level Meters (LUFS, LKFS) : Ces mesures sont des standards internationaux pour la mesure de la sonie dans le contenu broadcast et sont conçues pour correspondre à la perception humaine de la sonie. Elles sont idéales si vous créez du contenu destiné à la diffusion et que vous devez respecter des normes de sonie.
Pour les applications générales de détection des moments forts en volume, RMS et Short-Time Energy sont souvent des choix efficaces car ils fournissent une mesure directe de la puissance sonore sur de courtes périodes. Si votre définition de "fort" inclut à la fois le volume et la brillance (par exemple, des scènes d'action dans un film), alors une combinaison de RMS et Spectral Centroid ou Spectral Flux pourrait être utile.
Finalement, la méthode à choisir dépend de votre application précise. LUFS ou LKFS peuvent être les meilleurs pour les applications de broadcast, tandis que l'utilisation de MFCCs ou Spectral Flux pourrait être plus appropriée pour des analyses plus sophistiquées où la sonie n'est qu'un des nombreux attributs à considérer.
-
- User
Je veux bien que tu fasses une combinaison de RMS et spectral centroid
- Assistant
Très bien, pour combiner RMS et Spectral Centroid dans l'analyse des moments forts, nous devons d'abord calculer séparément ces deux caractéristiques pour chaque segment audio correspondant, puis utiliser une stratégie pour déterminer les moments forts en considérant à la fois les valeurs RMS et les valeurs de Spectral Centroid.
Voici un plan sur la manière dont vous pourriez le faire :
- Calculer le RMS pour chaque segment audio pour avoir une mesure de la sonie.
- Calculer le Spectral Centroid pour chaque segment audio pour avoir une mesure de la "brillance" du son.
- Combiner ces mesures pour déterminer les moments forts. Par exemple, vous pourriez identifier les segments qui ont des valeurs RMS élevées et des valeurs de Spectral Centroid élevées, ou vous pourriez chercher un bon équilibre entre les deux en fonction de ce que vous cherchez à détecter.
Le RMS sera directement relié à la puissance sonore tandis que le Spectral Centroid donnera une idée de la distribution des fréquences. Les moments qui sont à la fois forts (RMS élevé) et brillants (Spectral Centroid élevé) se démarqueront.
Vous pourriez implémenter un système de scoring qui donne un poids à chaque mesure pour chaque segment, et utiliser ce score pour choisir les moments les plus intéressants. Evidemment, vous auriez besoin de fixer des poids en fonction de vos préférences.
Commençons par ajouter le calcul du Spectral Centroid :
from scipy.signal import get_window def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): window = get_window('hann', frame_length) centroids = [] for i in range(0, len(audio_data) - frame_length, hop_length): # Prendre la trame actuelle avec la fenêtre appliquée current_frame = audio_data[i:i+frame_length] * window # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsNous serions ensuite en mesure de les utiliser dans
find_loudest_momentspour obtenir les moments forts en utilisant à la fois les valeurs RMS et les valeurs de Spectral Centroid. Vous pourriez concevoir cette fonction pour traiter les sections en fonction de critères personnalisés comme un certain seuil pour RMS et Spectral Centroid et/ou une combinaison personnalisée basée sur l'expérience ou l'essai-error.En fonction de l'application spécifique ou des préférences personnelles, vous pourriez accorder plus de poids à la sonie (RMS) ou à la qualité tonale (Spectral Centroid), ou chercher un équilibre entre les deux.
Si vous rencontrez des problèmes lors de l'intégration du Spectral Centroid avec les calculs RMS existants ou des incertitudes sur la manière de combiner ces mesures pour déterminer les moments forts, n'hésitez pas à demander de plus amples informations ou des éclaircissements.
- User
J'ai ajouté calculate spectral centroid. Comment l'intégrer à mon script ?
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): window = get_window(‘hann’, frame_length) centroids = []
for i in range(0, len(audio_data) - frame_length, hop_length): # Prendre la trame actuelle avec la fenêtre appliquée current_frame = audio_data[i:i+frame_length] * window # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsdef update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): global detection_threshold rate, audio_data = wavfile.read(audio_filename)
# Convert to mono if stereo if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculate RMS values for the entire audio rms_values = calculate_loudness(audio_data) # Initialize lists for saving moments and their loudness moments = [] volumes = [] # Calculate RMS values for each segment segment_samples = int(segment_duration * rate) for i in range(0, len(audio_data), segment_samples): segment_rms = np.sqrt(np.mean(audio_data[i:i+segment_samples].astype('float32')**2)) if (i / rate + segment_duration <= video_duration - ending_offset) and (i/ rate >= starting_offset): moments.append(i / rate) # Convert sample index to time in seconds volumes.append(segment_rms) # Now moments has RMS value for each segment # If we need to sort segments by volume if len(moments) > 0 and len(volumes) > 0: # Continuous indices mapping to the moments array indices = range(len(moments)) # Sort indices based on corresponding volumes sorted_indices = sorted(indices, key=lambda i: volumes[i], reverse=True) # Sort in descending order of volume # Now we have indices of moments sorted by volume # Reconstruct moments and volumes arrays based on sorted indices sorted_moments = [moments[i] for i in sorted_indices] sorted_volumes = [volumes[i] for i in sorted_indices] return sorted_moments[:num_moments], sorted_volumes[:num_moments] else: return [], []def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
- Assistant
Pour intégrer le calcul du Spectral Centroid et le combiner avec le RMS à votre script, vous devrez effectuer les étapes suivantes :
-
Lire le fichier audio : Assurez-vous que vous avez les données audio sous forme de tableau NumPy.
-
Calcul des caractéristiques : Utilisez votre fonction
calculate_spectral_centroidpour obtenir les valeurs de Spectral Centroid pour chaque fenêtre de l'audio. -
Trouver les segments les plus importants : Utilisez les valeurs RMS et les valeurs de Spectral Centroid pour déterminer les segments d'intérêt en fonction de critères définis.
-
Choisir des segments pour l'extraction : Après la détection des segments d'intérêt, extrayez ces segments de la vidéo d'origine et enregistrez-les comme fichiers distincts.
Voici comment vous pourriez mettre à jour la fonction
find_loudest_momentspour intégrer le Spectral Centroid dans la détection des moments forts (cette intégration est une suggestion basique, des ajustements seront nécessaires) :def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Conversion en mono si nécessaire et lecture du fichier audio _, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calcul de RMS et Spectral Centroid rms_values = calculate_loudness(audio_data) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Liste pour enregistrer les moments et autres infos moments_info = [] # Trouver les moments en utilisant RMS et Spectral Centroid # (Ajoutez votre logique ici pour déterminer comment ils vont interagir) for i in range(min(len(rms_values), len(spectral_centroids))): # Vous pouvez ajouter des conditions ici pour déterminer quels sont les moments les plus intéressants. # Par exemple, en utilisant des seuils ou en combinant RMS et Spectral Centroid d'une certaine manière. moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments en fonction de la préférence moments_info = sorted(moments_info, key=lambda x: x[1], reverse=True) # Par exemple, tri par volume RMS décroissant # Retourner les moments triés et les informations associées jusqu'à num_moments return moments_info[:num_moments]Ensuite, vous devrez ajuster la partie du script qui utilise
find_loudest_momentsen passant les bons paramètres et en utilisant les informations retournées par la fonction pour effectuer l'extraction. Vous devrez aussi déterminer à quel point vous voulez que le RMS et le Spectral Centroid contribuent à la définition d'un "moment fort".Notez que j'ai simplifié beaucoup de choses ici et que l'interaction entre RMS et Spectral Centroid devra être définie précisément. Il vous faudra peut-être expérimenter avec différentes manières de combiner ces caractéristiques pour obtenir les résultats que vous cherchez. De plus, vous devrez vous assurer que votre fonction
calculate_spectral_centroidest correctement implémentée et qu'elle fonctionne tel que prévu avec les données de votre audio. -
- User
(Ajoutez votre logique ici pour déterminer comment ils vont interagir)
for i in range(min(len(rms_values), len(spectral_centroids))): # Vous pouvez ajouter des conditions ici pour déterminer quels sont les moments les plus intéressants. # Par exemple, en utilisant des seuils ou en combinant RMS et Spectral Centroid d’une certaine manière. moments_info.append((i, rms_values[i], spectral_centroids[i]))Définis une logique d'interaction. D'abord, propose-m'en plusieurs et laisse-moi choisir
- Assistant
Pour définir une logique d'interaction entre le RMS (Root Mean Square) et le Spectral Centroid pour déterminer les moments forts d'un fichier audio, voici plusieurs propositions basées sur différentes approches :
-
Approche simple basée sur des seuils : Détecter les moments où les valeurs RMS et Spectral Centroid dépassent tous les deux un seuil prédéfini. Cela permettrait de repérer les instants à la fois forts et brillants.
-
Approche basée sur le scoring : Assigner des scores aux segments en fonction de leur RMS et Spectral Centroid, puis faire la somme pondérée de ces scores. Par exemple, vous pouvez donner un poids de 70% à RMS (puisque vous êtes principalement intéressé par la sonie) et 30% au Spectral Centroid.
-
Approche basée sur le produit : Considérer les segments pour lesquels le produit de la valeur RMS par celle du Spectral Centroid est le plus élevé. Cela marque des moments où la sonie et la brillance coïncident.
-
Approche basée sur la dominance : Identifier un attribut dominant (RMS ou Spectral Centroid) et détecter les segments où cet attribut est particulièrement élevé, même si l'autre est moyen.
-
Approche basée sur les rangs : Assigner des rangs à chaque segment en fonction de leurs valeurs RMS et Spectral Centroid séparément, puis sommer ces rangs pour chaque segment. Sélectionner les segments avec la somme des rangs la plus basse (en supposant que le rang 1 est le plus élevé).
-
Approche dynamique : Utiliser une méthode de fenêtrage dynamique, où le seuil de détection pour le RMS et le Spectral Centroid s'adapte en fonction de la moyenne ou de la variance des caractéristiques sur le fichier en cours d'analyse.
Je vous invite à choisir l'une de ces approches ou à combiner certaines d'entre elles en fonction des caractéristiques des moments forts que vous recherchez dans votre vidéo/audio. Chacune de ces méthodes pourrait être ajustée en fonction des résultats des tests préliminaires et affinée pour répondre à vos besoins spécifiques.
-
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random from scipy.signal import get_window
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): window = get_window('hann', frame_length) centroids = []
for i in range(0, len(audio_data) - frame_length, hop_length): # Prendre la trame actuelle avec la fenêtre appliquée current_frame = audio_data[i:i+frame_length] * window # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsdef update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Conversion en mono si nécessaire et lecture du fichier audio _, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1)
# Calcul de RMS et Spectral Centroid rms_values = calculate_loudness(audio_data) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Liste pour enregistrer les moments et autres infos moments_info = [] # Trouver les moments en utilisant RMS et Spectral Centroid for i in range(min(len(rms_values), len(spectral_centroids))): moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments en fonction de la préférence moments_info = sorted(moments_info, key=lambda x: x[1], reverse=True) # Par exemple, tri par volume RMS décroissant # Retourner les moments triés et les informations associées jusqu’à num_moments return moments_info[:num_moments]def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference) selected_moments = sorted_moments volumes = sorted_volumes finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 518, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 498, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 270, in perform_extraction moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) TypeError: find_loudest_moments() missing 1 required positional argument: 'rate'
- Assistant
L'erreur
TypeError: find_loudest_moments() missing 1 required positional argument: 'rate'indique que la fonctionfind_loudest_momentsnécessite un argument supplémentairerate, qui n'a pas été fourni lors de son appel.La variable
ratereprésente la fréquence d'échantillonnage du fichier audio et est nécessaire pour calculer le RMS et le Spectral Centroid correctement. Vous devez récupérer cette information lorsque vous lisez le fichier audio et la passer àfind_loudest_moments.Voici les étapes pour corriger cela :
-
Modifiez la fonction
perform_extractionpour récupérerratelorsque vous lisez le fichier audio avecwavfile.read. -
Passez
rateen tant qu'argument à la fonctionfind_loudest_moments.
Voici le code corrigé :
Tout d'abord, mettez à jour la signature de la fonction
find_loudest_momentspour accepterrate:def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): ... # Le reste de la fonction reste intactMaintenant, mettez à jour la fonction
perform_extractionpour récupérer lerateet passez-le àfind_loudest_moments:def perform_extraction(): global starting_offset_seconds, ending_offset_seconds ... # Le reste du code global reste intact if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return ... # Récupérez la durée de la vidéo puisque le reste est inchangé ... # Modifier à partir d'ici audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Après avoir écrit le fichier audio, lisez-le pour obtenir la fréquence d'échantillonnage et les données audio rate, audio_data = wavfile.read(audio_path) # rate est obtenu ici # Utilisez les données audio et la fréquence d'échantillonnage dans find_loudest_moments moments_info = find_loudest_moments(audio_data, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) ... # La logique d'extraction et de tri reste inchangée finally: if os.path.exists(audio_path): os.remove(audio_path) ... # Le reste de votre méthode `perform_extraction` reste inchangé. ...Veillez également à nettoyer et à ajuster votre code pour vous assurer que toutes les fonctions appelées dans
perform_extractioncorrespondent désormais aux nouvelles signatures de fonctions corrigées.Ce correctif devrait résoudre l'erreur
TypeErrorque vous rencontrez et permettre à votre script de s'exécuter correctement. Assurez-vous que toutes les parties du code utilisent correctement la nouvelle signature defind_loudest_momentsavec l'argumentratefourni. -
- User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 517, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 497, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 272, in perform_extraction moments_info = find_loudest_moments(audio_data, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 216, in find_loudest_moments _, audio_data = wavfile.read(audio_filename) File "C:\Users\jp\AppData\Local\Programs\Python\Python310\lib\site-packages\scipy\io\wavfile.py", line 647, in read fid = open(filename, 'rb') UnicodeDecodeError: 'utf-8' codec can't decode byte 0xfe in position 0: invalid start byte
- Assistant
L'erreur
UnicodeDecodeErrorlors de l'appel dewavfile.readest généralement liée à la tentative d'ouverture d'un fichier avec le mauvais mode ou un mauvais codage de caractères. Dans ce cas, l'erreur est probablement causée car la fonctionwavfile.readreçoit des données brutes (audio_data) au lieu du nom du fichier audio.Dans la fonction
perform_extraction, vous extrayez l'audio à partir de la vidéo et enregistrez les données audio dans un fichier temporaire nomméaudio_path. Puis vous transmettezaudio_dataà la fonctionfind_loudest_moments, mais d'après le code et la signature de la fonctionfind_loudest_moments, vous êtes censé passer le chemin du fichier (audio_path) et non les données (audio_data).Pour corriger cette erreur, vous devez transmettre le chemin du fichier audio temporaire (
audio_path) àfind_loudest_momentset s'assurer quewavfile.readouvre ce fichier à partir du système de fichiers :Le code modifié dans la fonction
perform_extractiondevrait ressembler à ceci :def perform_extraction(): ... audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Maintenant transmettre 'audio_path' au lieu de 'audio_data' moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) ... finally: if os.path.exists(audio_path): os.remove(audio_path) ...Assurez-vous que l'appel à
find_loudest_momentsdans la fonctionperform_extractionutiliseaudio_pathcomme premier argument. Ensuite, dansfind_loudest_moments, il faut s'assurer que cet argument est utilisé pour lire le fichier WAV :def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Utilisez le nom du fichier audio pour lire le fichier rate, audio_data = wavfile.read(audio_filename) ...Avec ces modifications,
find_loudest_momentsdevrait fonctionner comme prévu, en lisant le fichier audio temporaireaudio_pathcréé parwrite_audiofile, et en récupérant la fréquence d'échantillonnage (rate) ainsi que les données audio (audio_data) pour analyse ultérieure. - User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random from scipy.signal import get_window
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): window = get_window('hann', frame_length) centroids = []
for i in range(0, len(audio_data) - frame_length, hop_length): # Prendre la trame actuelle avec la fenêtre appliquée current_frame = audio_data[i:i+frame_length] * window # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsdef update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Conversion en mono si nécessaire et lecture du fichier audio _, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1)
# Calcul de RMS et Spectral Centroid rms_values = calculate_loudness(audio_data) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Liste pour enregistrer les moments et autres infos moments_info = [] # Trouver les moments en utilisant RMS et Spectral Centroid for i in range(min(len(rms_values), len(spectral_centroids))): moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments en fonction de la préférence moments_info = sorted(moments_info, key=lambda x: x[1], reverse=True) # Par exemple, tri par volume RMS décroissant # Retourner les moments triés et les informations associées jusqu'à num_moments return moments_info[:num_moments]def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Après avoir écrit le fichier audio, lisez-le pour obtenir la fréquence d'échantillonnage et les données audio rate, audio_data = wavfile.read(audio_path) # rate est obtenu ici # Utilisez les données audio et la fréquence d'échantillonnage dans find_loudest_moments moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 517, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 497, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 272, in perform_extraction moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 228, in find_loudest_moments for i in range(min(len(rms_values), len(spectral_centroids))): TypeError: object of type 'numpy.float32' has no len()
- Assistant
L'erreur
TypeError: object of type 'numpy.float32' has no len()indique que vous essayez d'utiliser la fonctionlen()sur un objet qui n'est pas une séquence (comme une liste ou un tableau). Dans ce cas, cela se produit parce que la fonctioncalculate_loudnessrenvoie une seule valeur scalaire alors qu'elle devrait retourner un tableau de valeurs RMS calculées pour chaque segment du fichier audio.Pour corriger l'erreur, nous devons ajuster la fonction
calculate_loudnesspour qu'elle calcule correctement le RMS pour chaque segment de l'audio et retourne un tableau de valeurs RMS au lieu d'un scalaire.Voici la correction pour la fonction
calculate_loudness:def calculate_loudness(audio_data, frame_length=1024, hop_length=512): # Assurer que audio_data est en mono if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Initialiser une liste pour stocker les valeurs RMS rms_values = [] # Calculer RMS pour chaque segment (fenêtre) de l'audio for i in range(0, len(audio_data) - frame_length, hop_length): # Extraire la fenêtre frame = audio_data[i:i+frame_length] # Calculer RMS de la fenêtre et l'ajouter à la liste rms = np.sqrt(np.mean(frame**2)) rms_values.append(rms) # Convertir la liste en tableau numpy return np.array(rms_values)Ensuite, dans la fonction
find_loudest_moments, vous devez faire en sorte qu'elle utilise correctement les tableaux de valeurs RMS et de Spectral Centroid lors du traitement des segments :def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Obtenir les données audio et la fréquence d'échantillonnage rate, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Calculer les valeurs RMS pour chaque fenêtre de l'audio rms_values = calculate_loudness(audio_data, rate) # Calculer les valeurs de Spectral Centroid pour chaque fenêtre de l'audio spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Assurer que rms_values et spectral_centroids sont de même longueur min_length = min(len(rms_values), len(spectral_centroids)) rms_values = rms_values[:min_length] spectral_centroids = spectral_centroids[:min_length] # Liste pour enregistrer les informations des moments (indice, RMS, Spectral Centroid) moments_info = [] # Parcourir les valeurs RMS et Spectral Centroid pour construire les informations de moments for i in range(min_length): moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments par volume RMS (ou toute autre logique personnalisée) # Exemple : tri par volume RMS décroissant et Spectral Centroid décroissant moments_info = sorted(moments_info, key=lambda x: (x[1], x[2]), reverse=True) # Extraire les num_moments plus forts strongest_moments_info = moments_info[:num_moments] # Continuer avec votre logique de traitement... return strongest_moments_infoNotez que la manière de traiter et de sélectionner les "moments forts" à partir des informations sur
rms_valuesetspectral_centroidspeut varier en fonction de vos besoins spécifiques et de la logique d'interaction que vous souhaitez implémenter.Assurez-vous de mettre à jour votre script en conséquence et de tester si ces modifications résolvent le problème.
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random from scipy.signal import get_window
temporary_audio_files = [] global detection_threshold
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): window = get_window('hann', frame_length) centroids = []
for i in range(0, len(audio_data) - frame_length, hop_length): # Prendre la trame actuelle avec la fenêtre appliquée current_frame = audio_data[i:i+frame_length] * window # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsdef update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data, rate): # Audio_data doit être en mono pour calculer le RMS échantillon par échantillon if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Convert to mono if necessary rms_values = np.sqrt(np.mean(audio_data.astype('float32')**2, axis=-1)) return rms_values
def calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Obtenir les données audio et la fréquence d’échantillonnage rate, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1)
# Calculer les valeurs RMS pour chaque fenêtre de l’audio rms_values = calculate_loudness(audio_data, rate) # Calculer les valeurs de Spectral Centroid pour chaque fenêtre de l’audio spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Assurer que rms_values et spectral_centroids sont de même longueur min_length = min(len(rms_values), len(spectral_centroids)) rms_values = rms_values[:min_length] spectral_centroids = spectral_centroids[:min_length] # Liste pour enregistrer les informations des moments (indice, RMS, Spectral Centroid) moments_info = [] # Parcourir les valeurs RMS et Spectral Centroid pour construire les informations de moments for i in range(min_length): moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments par volume RMS (ou toute autre logique personnalisée) # Exemple : tri par volume RMS décroissant et Spectral Centroid décroissant moments_info = sorted(moments_info, key=lambda x: (x[1], x[2]), reverse=True) # Extraire les num_moments plus forts strongest_moments_info = moments_info[:num_moments] # Continuer avec votre logique de traitement… return strongest_moments_infodef perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Après avoir écrit le fichier audio, lisez-le pour obtenir la fréquence d'échantillonnage et les données audio rate, audio_data = wavfile.read(audio_path) # rate est obtenu ici # Utilisez les données audio et la fréquence d'échantillonnage dans find_loudest_moments strongest_moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) finally: if os.path.exists(audio_path): os.remove(audio_path) # Juste avant l'appel à extract_segments, mettez à jour num_moments pour être sûr qu'il ne dépasse pas max_segments num_moments = min(num_moments, max_segments) extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'")def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] half_segment_duration = segment_duration / 2
for i, moment in enumerate(moments): if peak_position == '1': # 1/4 start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # 1/2 start_time = max(moment - segment_duration * 0.5, 0) elif peak_position == '3': # 3/4 start_time = max(moment - segment_duration * 0.75, 0) end_time = min(start_time + segment_duration, video_duration) output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration or remaining video "-c:v", "libx264", # Specify video codec for output "-preset", "medium", # Specify the encoding preset (trade-off between encoding speed and quality) "-crf", "23", # Specify the Constant Rate Factor for quality (lower means better quality) "-c:a", "aac", # Specify audio codec for output "-strict", "-2", # Necessary for some versions of ffmpeg to use experimental aac encoder "-b:a", "192k", # Specify the audio bitrate output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Catch the exception for this process, print an error message, # but don't break from the for loop. err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
- Assistant
Votre script a subi beaucoup de modifications depuis le début de notre conversation, et il semble qu'une erreur de typage se soit glissée dans la fonction
calculate_loudness. La fonctioncalculate_loudnesstelle qu'écrite actuellement ne calcule pas le RMS pour chaque fenêtre mais seulement sur l'ensemble du signal audio à cause d'une mauvaise utilisation de l'axe dans la fonctionnp.mean.Le RMS doit être calculé sur des fenêtres de signal (par exemple, une fenêtre de 1024 échantillons glissée le long du signal avec un certain chevauchement, typiquement un "hop_length"). Le tableau de valeurs RMS résultant sera ensuite utilisé pour identifier les segments les plus forts.
Voici le correctif pour la fonction
calculate_loudness:def calculate_loudness(audio_data, frame_length=1024, hop_length=512): # Assurer que audio_data est en mono if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Initialiser une liste pour stocker les valeurs RMS rms_values = [] # Calculer RMS pour chaque fenêtre (segment) de l'audio for i in range(0, len(audio_data) - frame_length + 1, hop_length): frame = audio_data[i:i+frame_length] # Extraire la fenêtre rms = np.sqrt(np.mean(frame**2)) # Calculer RMS de la fenêtre rms_values.append(rms) return np.array(rms_values) # Convertir la liste en numpy arrayEt pour intégrer maintenant correctement cette fonction dans votre script complet, voici comment la fonction
perform_extractiondoit appeler la fonctionfind_loudest_moments:def perform_extraction(): ... if sorting_preference == 5: # Aléatoire ... else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Après avoir écrit le fichier audio, lisez-le pour obtenir la fréquence d'échantillonnage rate, audio_data = wavfile.read(audio_path) # Utilisez les données audio dans find_loudest_moments # Ajustez pour utiliser le rate obtenu dans le write_audiofile, qui peut différer du rate joueur avec rate ici moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) # Implémentez la logique pour utiliser moments_info pour extraire des segments intéressants # ... finally: if os.path.exists(audio_path): os.remove(audio_path) ...Maintenant,
find_loudest_momentsva recevoir le chemin vers le fichier audio temporairement enregistré, extraire la fréquence d'échantillonnage et les données audio, puis calculer les valeurs RMS et Centroides Spectraux correctement avec ces nouvelles données. Vous pouvez ensuite prendre la liste des RMS et Centroides Spectraux et appliquer la logique de tri choisie.Enfin, veillez à tester complètement votre script pour vous assurer que toutes les modifications apportées fonctionnent comme prévu et n'entraînent pas d'autres erreurs.
- User
Implémentez la logique pour utiliser moments_info pour extraire des segments intéressants
Aide-moi pour cette étape...
- Assistant
Pour implémenter la logique d'extraction des segments intéressants basée sur les informations obtenues dans
moments_info, vous devrez d'abord concevoir un critère pour évaluer quels segments sont considérés comme "forts" ou "intéressants". Cela peut dépendre de la sonie RMS, du Spectral Centroid ou d'une combinaison des deux. Ensuite, vous devez sélectionner les segments correspondant à ce critère et extraire ces moments de la vidéo.Voici une approche possible :
-
Définition du critère : Décidez de la manière dont vous allez évaluer un moment fort. Cela pourrait, par exemple, être des moments où le RMS est supérieur à un certain seuil, ou des moments où le Spectral Centroid est supérieur à un certain seuil, ou là où les deux conditions sont remplies.
-
Sélection des moments forts : À partir de
moments_info, sélectionnez uniquement les moments qui correspondent à votre critère de moment fort. -
Extraction des segments de la vidéo : Pour chaque moment fort sélectionné, extrayez le segment correspondant de la vidéo d'origine et enregistrez-le dans un nouveau fichier.
Voici comment vous pouvez intégrer cela dans votre script :
def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, selected_video_path, max_segments # ... code restant inchangé ... audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) rate, _ = wavfile.read(audio_path) moments_info = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds, rate) # Convertissez les informations de moments en liste de moments avec des timestamps (en secondes) selected_moments = [(moment[0] * hop_length) / rate for moment in moments_info] extract_segments(selected_video_path, selected_moments, segment_duration, video_duration, peak_position) finally: if os.path.exists(audio_path): os.remove(audio_path) # ... code restant inchangé ...Dans
extract_segments, vous devez traiter chaque moment en tant que timestamp et extraire le segment correspondant à partir de la vidéo d'origine :def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] for i, moment in enumerate(moments): start_time = max(moment - segment_duration * peak_position, 0) end_time = min(start_time + segment_duration, video_duration) # ... code restant pour exécuter la commande ffmpeg et enregistrer le segment ...Veuillez ajuster la logique de sélection des segments (
selected_moments) et les valeurs de temps de début et de fin (start_timeetend_time) selon vos besoins spécifiques basés sur le RMS et le Spectral Centroid. Ces extraits simplifiés du code de votre script original devraient vous aider à comprendre comment les intégrer de manière pratique. Vous pouvez également choisir d'implémenter un système de notation plus complexe qui prend en compte des facteurs supplémentaires ou des conditions basées sur vos critères spécifiques. -
- User
Dans extract_segments, tu as oublié le placement du pic.
- Assistant
Vous avez raison, nous devons tenir compte de l'emplacement du pic sonore dans le segment extrait, comme indiqué par le paramètre
peak_position. La position du pic peut être définie comme le début, le milieu ou la fin du segment, et donc nous devons ajuster lestart_timeen conséquence.Dans la fonction
extract_segments, nous allons modifier lesstart_timeetend_timepour qu'ils tiennent compte de la position du pic. Les caspeak_position'1', '2' et '3' correspondent respectivement à 1/4, 1/2 et 3/4 de la longueur du segment.Modifions le code de la manière suivante :
def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0] # Calculez la durée de la moitié du segment half_segment_duration = segment_duration / 2 for i, moment in enumerate(moments): # Calculez le début du segment basé sur la position du pic if peak_position == '1': # Pic à 1/4 du segment start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # Pic au milieu du segment start_time = max(moment - half_segment_duration, 0) elif peak_position == '3': # Pic à 3/4 du segment start_time = max(moment - segment_duration * 0.75, 0) else: # Si la position du pic n'est pas reconnue, prenez le milieu par défaut start_time = max(moment - half_segment_duration, 0) # Assurez-vous que le segment n'aille pas au-delà de la durée de la vidéo end_time = min(start_time + segment_duration, video_duration) # Construire le chemin de sortie pour le fichier segmenté output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) # Commande ffmpeg pour extraire le segment command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration "-c:v", "libx264", # Video codec "-preset", "medium", # Encoding preset "-crf", "23", # Constant Rate Factor "-c:a", "aac", # Audio codec "-strict", "-2", # Use experimental aac encoder if needed "-b:a", "192k", # Audio bitrate output_path # Output path ] try: # Exécutez la commande ffmpeg pour extraire et encoder le segment subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Afficher l'erreur si ffmpeg échoue err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")Dans le code ci-dessus, la position du pic (
peak_position) ajustestart_timepour que le pic se trouve au 1/4, au milieu ou au 3/4 du segment, selon la valeur sélectionnée. Assurez-vous que toutes les options possibles pourpeak_positionsont correctement traitées dans votre application. - User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 550, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 530, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 294, in perform_extraction selected_moments = [(moment[0] * hop_length) / rate for moment in moments_info] File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 294, in selected_moments = [(moment[0] * hop_length) / rate for moment in moments_info] NameError: name 'hop_length' is not defined
- Assistant
L'erreur
NameError: name 'hop_length' is not definedindique que la variablehop_lengthn'est pas définie dans la portée où elle est utilisée, c’est-à-dire dans la compréhension de liste deselected_momentsdansperform_extraction.Le
hop_lengthest le pas utilisé lors du calcul de caractéristiques telles que le RMS et le Spectral Centroid, indiquant combien d'échantillons sont sautés entre chaque fenêtre de calcul. Il doit être cohérent dans tout le script. Vous pourriez avoir besoin de le définir au niveau global ou de le passer en tant que paramètre là où il est nécessaire.Pour résoudre ce problème, vous devez déterminer la bonne valeur pour
hop_lengthque vous avez utilisée dans les fonctions qui calculent le RMS et le Spectral Centroid, et vous assurer que cette valeur est accessible là où vous en avez besoin.Si vous utilisez une valeur constante pour
hop_length, vous pouvez la définir au début de votre script comme une constante :HOP_LENGTH = 512 # ou toute autre valeur que vous avez choisieEnsuite, dans
perform_extraction, assurez-vous d'utiliser la constante correctement :def perform_extraction(): global starting_offset_seconds, ending_offset_seconds, HOP_LENGTH # ... reste du code ... # assurez-vous de définir rate correctement avant son utilisation rate = 44100 # ou utilisez la valeur rate fournie par la lecture du fichier WAV # Utilisation correcte de HOP_LENGTH selected_moments = [(moment[0] * HOP_LENGTH) / rate for moment in moments_info] # ... reste du code ...Si vous avez utilisé une valeur différente de
hop_lengthpour les deux, vous devrez peut-être revoir votre code et vous assurer que lehop_lengthutilisé pour obtenirmoments_infoest le même que celui utilisé ici pour calculerselected_moments. Assurez-vous que toutes les valeurs de paramètres pour le traitement du signal sont cohérentes et correctement définies dans tout votre script. - User
Réécris tout perform_extraction()
- Assistant
Bien sûr, réécrivons la fonction
perform_extraction()en gardant à l'esprit la portée des variables, la récupération de la fréquence d'échantillonnage (rate) du fichier audio temporaire, et en utilisant la constanteHOP_LENGTHoù cela est nécessaire.Nous allons également corriger la conversion des indices de
moments_infoen temps de début réels (selected_moments), en tenant compte duHOP_LENGTH.# Constantes globales HOP_LENGTH = 512 # définir cette valeur en fonction de votre calcul RMS et Spectral Centroid def perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold # Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Lire le fichier WAV pour obtenir les données audio et la fréquence d'échantillonnage rate, audio_data = wavfile.read(audio_path) rms_values = calculate_loudness(audio_data, rate) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Ici, nous devons implémenter une logique pour extraire les moments importants. # Pour l'exemple, on va simplement retourner tous les indices # mais dans la pratique, on va filtrer ou classer ces moments d'abord. strongest_moments_info = [(i, rms_values[i], spectral_centroids[i]) for i in range(len(rms_values))] # Trier les moments en fonction des valeurs RMS et Spectral Centroid # Ici, nous trions par RMS décroissant pour l'exemple strongest_moments_info.sort(key=lambda x: x[1], reverse=True) # Extraire les indices des moments les plus forts et convertir en temps selected_moments = [(index * HOP_LENGTH / rate) for index, _, _ in strongest_moments_info][:num_moments] # Extraire les segments des moments sélectionnés extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'") finally: if os.path.exists(audio_path): os.remove(audio_path)Dans cet exemple,
strongest_moments_infoest simplement un tableau de tuples pour chaque moment avec son indice, son RMS et son Spectral Centroid. En réalité, vous devriez appliquer des critères plus spécifiques pour sélectionner ces moments.La fonction
extract_segmentsdoit être conçue pour prendre une liste deselected_momentscomme des instances temporelles réelles (en secondes), qui sont en fait les temps de début des segments à extraire. Ajustez les autres fonctions et le reste de votre script en conséquence pour s'assurer qu'elles utilisent la même constanteHOP_LENGTHet qu'elles s'attendent à des valeurs de temps réelles.Faites également attention à bien nettoyer votre code en supprimant ou en commentant les parties non utilisées et en testant le script dans son ensemble pour vous assurer de sa cohérence.
- User
Traceback (most recent call last): File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 561, in main() File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 541, in main perform_extraction() # Call perform_extraction instead of extract_segments File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 297, in perform_extraction spectral_centroids = calculate_spectral_centroid(audio_data, rate) File "C:\Users\jp\Desktop\Nouveau dossier\Script extraction moments forts - Menu - Selection vidéo - Neutralisation - RMS et Spectral centroid.py", line 28, in calculate_spectral_centroid current_frame = audio_data[i:i+frame_length] * window ValueError: operands could not be broadcast together with shapes (1024,2) (1024,)
- Assistant
L'erreur
ValueError: operands could not be broadcast together with shapes (1024,2) (1024,)est due à une incompatibilité entre les formes du tableauaudio_dataet de la fenêtrewindow. D'après l'erreur,audio_dataa une forme bicanale (stéréo), ce qui ne correspond pas à la fenêtre mono-dimensionnellewindow.Le problème est que bien que vous avez eu l'intention de convertir l'audio en mono en prenant la moyenne des deux canaux (si l'audio est stéréo), cela ne s'est peut-être pas fait correctement avant de calculer la fenêtre ou n'a pas été appliqué juste avant cette opération.
Pour résoudre cette erreur, assurez-vous que le tableau
audio_datasoit converti en mono avant d'être traité par la fonctioncalculate_spectral_centroid. Voici comment vous pouvez corriger le code dans la fonctioncalculate_spectral_centroid:def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): # Assurer que audio_data est en mono lors du calcul de la fenêtre if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Conversion en mono window = get_window('hann', frame_length) centroids = [] # Parcourez l'audio et calculez le centroid spectral pour chaque fenêtre for i in range(0, len(audio_data) - frame_length + 1, hop_length): current_frame = audio_data[i:i+frame_length] * window # Appliquez la fenêtre hanning # Le reste du calcul reste inchangé # ...Ajustons également la fonction
perform_extractionpour assurer la cohésion de la conversion en mono :def perform_extraction(): # ... autres parties de la fonction ... audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Utilisation de VideoFileClip et write_audiofile comme avant with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Rate et audio_data sont obtenus, garantissant que audio_data est mono rate, audio_data = wavfile.read(audio_path) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Conversion en mono # Calcul des RMS et Spectral Centroid rms_values = calculate_loudness(audio_data, rate) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # ... reste de perform_extraction ... # ... autres parties de la fonction ...Assurez-vous que toutes les instances où
audio_dataest utilisé soient cohérentes, et que toute la chaîne de traitement audio fonctionne avec des données monophoniques.N'oubliez pas de tester toutes les parties du script pour vous assurer que les modifications fonctionnent correctement et que les bons formats de données sont utilisés dans chaque fonction.
- User
import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile import random from scipy.signal import get_window
temporary_audio_files = [] global detection_threshold
hop_length = 512
Initialisation du seuil de détection
detection_threshold = 1 # La valeur de départ est 1/10ème
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
def calculate_spectral_centroid(audio_data, rate, frame_length=1024, hop_length=512): # Assurer que audio_data est en mono lors du calcul de la fenêtre if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Conversion en mono
window = get_window('hann', frame_length) centroids = [] # Parcourez l’audio et calculez le centroid spectral pour chaque fenêtre for i in range(0, len(audio_data) - frame_length + 1, hop_length): current_frame = audio_data[i:i+frame_length] * window # Appliquez la fenêtre hanning # Calculer le spectre de puissance (magnitude carrée du fft) spectrum = np.abs(np.fft.fft(current_frame))**2 # Normaliser le spectre normalized_spectrum = spectrum / np.sum(spectrum) # Calculer le centroid pour la trame actuelle centroid = np.sum(normalized_spectrum * np.arange(len(spectrum))) / np.sum(normalized_spectrum) centroids.append(centroid) # Convertir les indices en fréquences en Hertz centroids = np.array(centroids) * rate / frame_length return centroidsdef update_max_segments_for_selected_video(): global selected_video_path, max_segments, segment_duration, starting_offset_seconds, ending_offset_seconds, num_moments if selected_video_path in video_durations: video_duration = video_durations[selected_video_path] max_segments = calculate_max_segments(video_duration, segment_duration, starting_offset_seconds, ending_offset_seconds) num_moments = min(num_moments, max_segments) # Ajustez num_moments si nécessaire else: max_segments = 0
def sorting_preference_to_string(pref): sorting_options = { 1: "Par ordre de lecture de la vidéo", 2: "Par ordre inverse de lecture de la vidéo", 3: "Par volume croissant", 4: "Par volume décroissant", 5: "Aléatoire" } return sorting_options.get(pref, "Non défini")
def ask_detection_threshold(): while True: threshold_input = input("Veuillez entrer le seuil de détection (de 1 à 10) : ") try: threshold = int(threshold_input) if 1 <= threshold <= 10: return threshold else: print("Veuillez entrer un nombre entre 1 et 10.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def peak_position_to_string(pos): peak_options = { '1': "À 1/4 du temps de lecture de la vidéo", '2': "À 1/2 du temps de lecture de la vidéo", '3': "À 3/4 du temps de lecture de la vidéo" } return peak_options.get(pos, "Non défini")
def choose_video(videos): # Separate root files from subdirectory files root_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) == ''] subdirectory_files = [video for video in videos if os.path.dirname(os.path.relpath(video)) != '']
# Sort the files in subdirectories subdirectory_files_sorted = sorted(subdirectory_files, key=lambda x: (os.path.dirname(x).lower(), os.path.basename(x).lower())) # Combine lists: root files first, then sorted subdirectory files combined_videos = root_files + subdirectory_files_sorted print("Liste des vidéos disponibles :") for i, video in enumerate(combined_videos): # Get the relative path for printing rel_path = os.path.relpath(video) print(f"{i + 1}- {rel_path}") while True: choice = input("Veuillez choisir la vidéo à extraire (entrez le numéro) : ") try: choice_idx = int(choice) - 1 if 0 <= choice_idx < len(combined_videos): return combined_videos[choice_idx] else: print("Le numéro doit être valide. Veuillez réessayer.") except ValueError: print("Veuillez entrer un nombre valide.")def print_menu(selected_video_path): global max_segments global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position, detection_threshold video_name = os.path.basename(selected_video_path) if selected_video_path else "Aucune vidéo sélectionnée"
print("\nMenu des options :") print(f"1. Traiter les sous-dossiers ou non ({str(include_subfolders)})") print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)") print(f"3. Changer le seuil de détection ({str(detection_threshold)}/10)") print(f"4. Changer la durée des segments ({str(segment_duration)}s | max segments extractibles: {str(max_segments)})") print(f"5. Changer le nombre de segments à extraire ({str(num_moments)})") print(f"6. Changer l'ordre de tri ({sorting_preference_to_string(sorting_preference)})") print(f"7. Changer l'emplacement du pic sonore ({peak_position_to_string(peak_position)})") print(f"8. Lancer l'extraction") print(f"9- ({video_name}) - Modifier") print(f"0. Quitter")def ask_for_number_of_moments(max_segments): while True: num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ") try: num = int(num_input) if num > 0 and num <= max_segments: return num else: print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def ask_yes_no_question(question): answer = None while answer not in ('1', '2'): print(question) print("1- Oui") print("2- Non") answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if answer not in ('1', '2'): print("Entrée non valide, veuillez réessayer.") return answer == '1'
def ask_offset_type(): print("Souhaitez-vous un décalage temporel relatif ou absolu ?") print("1- Relatif (pourcentage)") print("2- Absolu (secondes)") while True: choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip() if choice in ('1', '2'): return choice else: print("Entrée non valide, veuillez réessayer.")
def get_offset_value(video_duration, offset_type): if offset_type == '1': # Relative offset while True: percent = input("Entrez le pourcentage du temps vidéo à ignorer : ") try: percent_value = float(percent) return percent_value * video_duration / 100 except ValueError: print("Veuillez entrer un nombre valide.") else: # Absolute offset while True: seconds = input("Entrez le nombre de secondes à ignorer : ") try: return float(seconds) except ValueError: print("Veuillez entrer un nombre valide.")
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds): # Cette fonction a été modifiée pour répondre plus précisément aux contraintes de durée. while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire (Entrez un nombre positif et inférieur ou égal à {allowable_duration}) ? ") try: segment_duration = float(duration) if 0 < segment_duration <= allowable_duration: # Calculez le nombre maximal de segments pour une vidéo available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) max_segments = int(available_duration // segment_duration) return segment_duration, max_segments else: print(f"La durée doit être un nombre positif et moins ou égale à {allowable_duration} secondes.") except ValueError: print("Veuillez entrer un nombre valide.")
def ask_directory_preference(): print("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") print("1- Oui") print("2- Non") choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ") return choice.strip() == '1' # Retourne True si l'utilisateur choisit '1' (Oui), False sinon
def calculate_loudness(audio_data, frame_length=1024, hop_length=512): # Assurer que audio_data est en mono if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1)
# Initialiser une liste pour stocker les valeurs RMS rms_values = [] # Calculer RMS pour chaque fenêtre (segment) de l'audio for i in range(0, len(audio_data) - frame_length + 1, hop_length): frame = audio_data[i:i+frame_length] # Extraire la fenêtre rms = np.sqrt(np.mean(frame**2)) # Calculer RMS de la fenêtre rms_values.append(rms) return np.array(rms_values) # Convertir la liste en numpy arraydef calculate_max_segments(video_duration, segment_duration, starting_offset, ending_offset): allowable_duration = video_duration - (starting_offset + ending_offset) if allowable_duration > 0: return int(allowable_duration // segment_duration) else: return 0
def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset, rate): # Obtenir les données audio et la fréquence d'échantillonnage rate, audio_data = wavfile.read(audio_filename) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1)
# Calculer les valeurs RMS pour chaque fenêtre de l'audio rms_values = calculate_loudness(audio_data, rate) # Calculer les valeurs de Spectral Centroid pour chaque fenêtre de l'audio spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Assurer que rms_values et spectral_centroids sont de même longueur min_length = min(len(rms_values), len(spectral_centroids)) rms_values = rms_values[:min_length] spectral_centroids = spectral_centroids[:min_length] # Liste pour enregistrer les informations des moments (indice, RMS, Spectral Centroid) moments_info = [] # Parcourir les valeurs RMS et Spectral Centroid pour construire les informations de moments for i in range(min_length): moments_info.append((i, rms_values[i], spectral_centroids[i])) # Trier les moments par volume RMS (ou toute autre logique personnalisée) # Exemple : tri par volume RMS décroissant et Spectral Centroid décroissant moments_info = sorted(moments_info, key=lambda x: (x[1], x[2]), reverse=True) # Extraire les num_moments plus forts strongest_moments_info = moments_info[:num_moments] # Continuer avec votre logique de traitement… return strongest_moments_infodef perform_extraction(): global starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Vérifiez si une vidéo a été sélectionnée. if not selected_video_path: print("Aucune vidéo sélectionnée pour l'extraction.") return # Vérifiez si la vidéo sélectionnée est contenue dans video_durations. if selected_video_path not in video_durations: print(f"La vidéo sélectionnée '{selected_video_path}' n'est pas disponible.") return # Obtenez la durée de la vidéo sélectionnée. duration = video_durations[selected_video_path] available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= segment_duration: print(f"La vidéo {selected_video_path} est trop courte après les décalages. Ignorer.") return if sorting_preference == 5: # Aléatoire all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2) np.random.shuffle(all_possible_moments) selected_moments = all_possible_moments[:num_moments] volumes = [0] * len(selected_moments) # Les volumes sont justes pour la compatibilité avec extract_segments. else: audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Utilisation de VideoFileClip et write_audiofile comme avant with VideoFileClip(selected_video_path) as video_clip: video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Rate et audio_data sont obtenus, garantissant que audio_data est mono rate, audio_data = wavfile.read(audio_path) if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Conversion en mono # Calcul des RMS et Spectral Centroid rms_values = calculate_loudness(audio_data, rate) spectral_centroids = calculate_spectral_centroid(audio_data, rate) # Ici, nous devons implémenter une logique pour extraire les moments importants. # Pour l'exemple, on va simplement retourner tous les indices # mais dans la pratique, on va filtrer ou classer ces moments d'abord. strongest_moments_info = [(i, rms_values[i], spectral_centroids[i]) for i in range(len(rms_values))] # Trier les moments en fonction des valeurs RMS et Spectral Centroid # Ici, nous trions par RMS décroissant pour l'exemple strongest_moments_info.sort(key=lambda x: x[1], reverse=True) # Extraire les indices des moments les plus forts et convertir en temps selected_moments = [(index * hop_length / rate) for index, _, _ in strongest_moments_info][:num_moments] # Extraire les segments des moments sélectionnés extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) processed_videos += 1 print(f"Extraction terminée pour la vidéo '{selected_video_path}'") finally: if os.path.exists(audio_path): os.remove(audio_path)def extract_segments(video_path, moments, segment_duration, video_duration, peak_position): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0]
# Calculez la durée de la moitié du segment half_segment_duration = segment_duration / 2 for i, moment in enumerate(moments): # Calculez le début du segment basé sur la position du pic if peak_position == '1': # Pic à 1/4 du segment start_time = max(moment - segment_duration * 0.25, 0) elif peak_position == '2': # Pic au milieu du segment start_time = max(moment - half_segment_duration, 0) elif peak_position == '3': # Pic à 3/4 du segment start_time = max(moment - segment_duration * 0.75, 0) else: # Si la position du pic n'est pas reconnue, prenez le milieu par défaut start_time = max(moment - half_segment_duration, 0) # Assurez-vous que le segment n'aille pas au-delà de la durée de la vidéo end_time = min(start_time + segment_duration, video_duration) # Construire le chemin de sortie pour le fichier segmenté output_filename = f"{base_name}_moment{i + 1}.mp4" output_path = os.path.join(output_folder, output_filename) # Commande ffmpeg pour extraire le segment command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(min(segment_duration, video_duration - start_time)), # Duration "-c:v", "libx264", # Video codec "-preset", "medium", # Encoding preset "-crf", "23", # Constant Rate Factor "-c:a", "aac", # Audio codec "-strict", "-2", # Use experimental aac encoder if needed "-b:a", "192k", # Audio bitrate output_path # Output path ] try: # Exécutez la commande ffmpeg pour extraire et encoder le segment subprocess.run(command, check=True, stderr=subprocess.PIPE) print(f"Extracted and re-encoded {output_filename}") except subprocess.CalledProcessError as e: # Afficher l'erreur si ffmpeg échoue err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error' print(f"Failed to extract segment from {video_path}: {err_msg}")def store_segment_info(video_path, moment, volume, order): base_name = os.path.splitext(os.path.basename(video_path))[0] output_filename = f"{base_name}_moment{order}.mp4" output_path = os.path.join(output_folder, output_filename) extracted_segments.append({ 'path': output_path, 'timestamp': moment, 'volume': volume })
def ask_sorting_preference(): print("Comment souhaitez-vous trier les vidéos extraites ?") print("1- Par ordre de lecture de la vidéo") print("2- Par ordre inverse de lecture de la vidéo") print("3- Par volume croissant") print("4- Par volume décroissant") print("5- Aléatoire") choice = int(input("Veuillez entrer le numéro de votre choix : ")) return choice
def sort_moments(moments, volumes, choice): if choice == 1: # Par ordre de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0]) elif choice == 2: # Par ordre inverse de lecture de la vidéo zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True) elif choice == 3: # Par volume croissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1]) elif choice == 4: # Par volume décroissant zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True) elif choice == 5: # Pas de tri, sélection aléatoire zipped = list(zip(moments, volumes)) random.shuffle(zipped) else: zipped = zip(moments, volumes)
# Unzip the list of tuples to two lists sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], []) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place if not include_subfolders: dirs[:] = [] # Cela empêchera os.walk de descendre dans tous les sous-dossiers # La suite du traitement des fichiers reste inchangée for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) try: # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo. video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration except Exception as e: # Si une erreur survient, affichez un message et ignorez le fichier vidéo. print(f"Error processing video {video_path}: {e}") finally: # Assurez-vous de fermer le clip pour libérer les ressources. video_clip.close() return video_durations
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds): allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) while True: segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds) print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.") confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?") if confirmation: return segment_duration, max_segments
def ask_peak_position(): print("Où doit être situé le pic sonore dans la vidéo extraite ?") print("1- A 1/4 du temps de lecture de la vidéo") print("2- A 1/2 du temps de lecture de la vidéo") print("3- A 3/4 du temps de lecture de la vidéo") while True: choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip() if choice in ('1', '2', '3'): return choice else: print("Entrée non valide, veuillez réessayer.")
def main(): global include_subfolders, starting_offset_seconds, ending_offset_seconds global segment_duration, num_moments, sorting_preference, peak_position global processed_videos, video_durations, selected_video_path, max_segments global detection_threshold
# Initialize the variables with default values include_subfolders = False starting_offset_seconds = 0 ending_offset_seconds = 0 segment_duration = 5.0 # Default value, e.g., 5 seconds num_moments = 20 # Default value, e.g., 20 moments sorting_preference = 4 # Default value, e.g., sorting by descending volume peak_position = '2' # Default value, e.g., peak at the middle of the segment selected_video_path = "" # Initialement vide processed_videos = 0 # Load video durations at the start of the script video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" # Select the first video by default, if available. # Calculate max_segments with the newly obtained video_durations video_duration = video_durations[selected_video_path] # Obtenez la durée de la vidéo sélectionnée max_segments = calculate_max_segments(video_durations[selected_video_path], segment_duration, starting_offset_seconds, ending_offset_seconds) while True: # Recalculate the max segments using the selected video before displaying the menu update_max_segments_for_selected_video() # Display the menu with the updated max segments print_menu(selected_video_path) choice = input("Veuillez entrer le numéro de votre choix : ").strip() # Handle user choices if choice == '1': # Update include_subfolders and recalculate video durations include_subfolders = ask_directory_preference() video_durations = get_video_durations(include_subfolders) # Optionally, reset selected_video_path if include_subfolders changed video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) selected_video_path = video_list[0] if video_list else "" update_max_segments_for_selected_video() elif choice == '2': # Récupérez les nouvelles valeurs. offset_type = ask_offset_type() # Utilisez une valeur minimale mise à jour si nécessaire. min_duration = min(video_durations.values()) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(min_duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(min_duration, offset_type) elif choice == '3': detection_threshold = ask_detection_threshold() elif choice == '4': # L'utilisateur définit la durée des segments et potentiellement le nombre de moments video_duration = min(video_durations.values()) # Min. duration among all videos allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds) segment_duration, max_segments = ask_for_segment_duration( allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds ) if num_moments > max_segments: num_moments = max_segments # Ce bloc assure que num_moments n'excède jamais max_segments après un changement de durée des segments elif choice == '5': num_moments = ask_for_number_of_moments(max_segments) elif choice == '6': sorting_preference = ask_sorting_preference() elif choice == '7': peak_position = ask_peak_position() elif choice == '8': # Exécutez vos sous-fonctions pour effectuer l'extraction des segments. # Vous souhaiterez probablement encapsuler cela dans une autre fonction. perform_extraction() # Call perform_extraction instead of extract_segments elif choice == '9': video_list = sorted(list(video_durations.keys()), key=lambda x: os.path.basename(x)) prev_video_path = selected_video_path selected_video_path = choose_video(video_list) if selected_video_path != prev_video_path: print(f"Vidéo sélectionnée pour l'extraction : {os.path.basename(selected_video_path)}") update_max_segments_for_selected_video() # Mise à jour des segments max après le choix. elif choice == '0': print("Fin du programme.") break else: print("Choix non valide. Veuillez réessayer.") print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")if name == "main": main()
J'ai extrait 20 segments, mais le script m'a extrait 20 fois le même segment
- Assistant
Il semble que le problème vienne de la manière dont les moments sont sélectionnés et passés à
extract_segments. Le code actuel doit assurer que chaque moment sélectionné correspond à un segment différent dans la vidéo. Si les mêmes moments ou indices sont utilisés, cela expliquerait pourquoi le même segment est extrait plusieurs fois.La variable
selected_momentsdoit contenir des temps distincts pour chacun des segments les plus forts, et ces temps doivent correspondre aux positions réelles dans la vidéo où ces segments commencent.Je vais réécrire la partie pertinente de
perform_extractionpour vous montrer comment vous pourriez générer des moments distincts. Je vais supposer quecalculate_loudnessetcalculate_spectral_centroidretournent des tableaux de la même longueur et que chaque valeur correspond à la même fenêtre temporelle dans l'audio. Cela signifie que chaque indice dans ces tableaux correspond àframe_length / 2 + hop_length * iéchantillons dans la piste audio.Voyons comment cela pourrait être corrigé :
def perform_extraction(): # ... code initial ... frame_length = 1024 # Supposons que c'est la longueur de la trame que vous avez utilisée # ... extrait de la vidéo dans audio_path ... rate, audio_data = wavfile.read(audio_path) # rate est obtenu ici # Assurez-vous que l'audio est en mono if audio_data.ndim > 1: audio_data = np.mean(audio_data, axis=1) # Conversion en mono rms_values = calculate_loudness(audio_data, frame_length, hop_length) spectral_centroids = calculate_spectral_centroid(audio_data, rate, frame_length, hop_length) # Supposons que rms_values et spectral_centroids sont correctement calculés et de la même longueur # Construire une liste des moments (indice temporel en secondes, RMS, Spectral Centroid) moments_info = [(i * hop_length / rate, rms, centroid) for i, (rms, centroid) in enumerate(zip(rms_values, spectral_centroids))] # Trier les moments par la sonie RMS de manière descendante moments_info.sort(key=lambda x: x[1], reverse=True) # Prendre les num_moments les plus forts strongest_moments_info = moments_info[:num_moments] # Je vais calculer un temps de début effectif pour chaque segment en m'assurant qu'ils sont uniques # et se situent correctement sur la base des indices RMS selected_moments = [info[0] for info in strongest_moments_info] extract_segments(selected_video_path, selected_moments, segment_duration, duration, peak_position) # ... code final ...Avec ces changements, nous prenons les valeurs RMS et Centroid Spectral directement lors de la construction de
moments_info, sans multiplier ou diviser parrateouHOP_LENGTHdans la compréhension de la liste (puisque cela a déjà été pris en compte dans les fonctions de calcul des caractéristiques).Cette liste est ensuite triée par valeur RMS en ordre décroissant. On prend ensuite les premiers
num_momentsmoments de cette liste pour les utiliser comme les instants où les segments seront extraits.extract_segmentsprend ces moments comme des instants précis (en temps réel en secondes) où les segments commencent dans la vidéo.S'il vous plaît, assurez-vous que votre implémentation de
calculate_loudnessetcalculate_spectral_centroidrenvoie des tableaux de la bonne longueur avant de faire ces changements et testez minutieusement votre script avec différentes vidéos pour vous assurer que les segments extraits sont ceux que vous attendez.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.