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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. 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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?")
video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") else: perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") if perform_temporal_offset: offset_type = ask_offset_type() starting_offset_seconds = None ending_offset_seconds = None for video_path, duration in video_durations.items(): if perform_temporal_offset and starting_offset_seconds is None and ending_offset_seconds is None: starting_offset_seconds = get_offset_value(duration, offset_type) ending_offset_seconds = get_offset_value(duration, offset_type) allowable_duration = duration - (starting_offset_seconds + ending_offset_seconds if perform_temporal_offset else 0) segment_duration = ask_for_segment_duration(allowable_duration) for video_path, duration in video_durations.items(): available_duration = max(duration - starting_offset_seconds - ending_offset_seconds, 0) max_segments_per_video = int(available_duration // segment_duration) # Ignorer les vidéos qui ne peuvent pas générer de segments à cause d'une durée insuffisante if max_segments_per_video == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle.") continue # Comparer le nombre souhaité de moments forts avec le maximum de segments extraibles moments_to_extract = min(num_moments, max_segments_per_video) if moments_to_extract < num_moments: print(f"La vidéo '{video_path}' est trop courte pour extraire {num_moments} moments forts. Seuls {moments_to_extract} seront extraits.") audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction des métadonnées du fichier vidéo et extraction audio video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) moments, volumes = find_loudest_moments(audio_path, moments_to_extract, segment_duration, duration, starting_offset_seconds, ending_offset_seconds) # Trier les moments selon la préférence de l'utilisateur avant d'extraire les segments. if sorting_preference != 5: moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extraire les segments dans l'ordre trié extract_segments(video_path, moments, segment_duration, duration) finally: # Suppression du fichier audio temporaire if os.path.exists(audio_path): os.remove(audio_path) print(f"Traitement terminé pour la vidéo '{video_path}'") print("Tous les traitements vidéo ont été effectués.") - Assistant
The provided code appears to be a Python script for processing video files to find and extract the loudest moments within. The general steps are as follows:
- Ask the user whether to include subfolders in the video search and store the value.
- Retrieve video durations for eligible video files that match given extensions (mp4, mkv, wmv, avi).
- Optionally apply temporal offsets to the analysis based on user preference.
- For each video, ask the user for the duration of each segment to extract if applying a temporal offset is chosen.
- Process each video file by: a. Converting video audio to a WAV file. b. Finding the loudest moments in the audio file. c. Extracting video segments around the loudest moments based on the segment duration.
- Optionally sort the moments (and thus the video segments) according to user preference.
- Print status messages after processing each video file.
Key functions and aspects include:
ask_yes_no_question: A utility function to ask the user a yes/no question.calculate_loudness: Calculates the volume of an audio segment and returns it in decibels.get_video_durations: Gets the durations of video files.find_loudest_moments: Finds the loudest moments in an audio file.extract_segments: Extracts segments of the video file usingffmpeg.sort_moments: Sorts the extracted moments according to loudness or timestamp ordering.- The script uses external libraries such as
moviepyfor video editing andscipyfor audio file processing.
Please note that the script makes use of
ffmpegfor video manipulation, which means thatffmpegmust be installed and accessible in the system's path. Also, you need to ensure thatmoviepyand other required libraries are installed in the Python environment where you plan to run the script.Given that this is a reasonably complex script, the provided explanation is an overview. There might be more detailed nuances in the script's actual execution and its error handling. Additionally, I've noticed some inconsistencies and potential issues scattered throughout the code, such as the inclusion of uninitialized variables (
num_moments,sorting_preference) and a possibly outdated section of code that may not run properly. The code likely needs careful review and debugging before usage. - User
Traceback (most recent call last): File "H:\Tests\Final\Script Final V4 - avec encodage. - original - automatisé - pic au milieu inchallah 2.py", line 269, in moments_to_extract = min(num_moments, max_segments_per_video) NameError: name 'num_moments' is not defined. Did you mean: 'sort_moments'?
- Assistant
The error you're encountering is because the variable
num_momentsis referenced before it has been defined or assigned a value. This variable is expected to hold the number of loudest moments you want to extract from the video. To fix the error, you should acquire this value from the user or set it to a default value before using it in your code.Here is where you might insert that logic:
if __name__ == "__main__": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") else: perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") if perform_temporal_offset: offset_type = ask_offset_type() # Add the logic to ask for `num_moments` here num_moments_input = input("Combien de moments forts souhaitez-vous extraire de chaque vidéo ? ") try: num_moments = int(num_moments_input) except ValueError: print("Veuillez entrer un nombre entier valide.") # Handle the error perhaps with a default value or exit the script num_moments = 5 # example default value, or you could exit for video_path, duration in video_durations.items(): if perform_temporal_offset: # add logic to set starting_offset_seconds and ending_offset_seconds # rest of your code...In this proposed fix, the script prompts the user to input the desired number of moments (
num_moments) to extract. A simple error handling is added to ensure that the input is a valid integer. You could also apply more sophisticated validation techniques depending on the application requirements.Make sure to also define and retrieve any other variables the script refers to later on (such as
sorting_preference) with appropriate input and error checking mechanisms. - User
Non non : l'ordre doit être le suivant :
- Inclure ou non les sous-dossiers
- Demande pour le retrait temporel 2.1. Relatif 2.1.1. Début de vidéo 2.1.2. Fin de vidéo 2.2. Absolu 2.2.1. Début de vidéo 2.2.2. Fin de vidéo
- Demande de la durée des segments
- Avertissement du nombre max de segments possibles moyen 4.1 Confirmation 4.2 Entrer une nouvelle durée
- Demande concernant le tri des extraits 5.1 Par ordre de lecture 5.2 Par ordre inverse de lecture 5.3 Par volume croissant 5.4 Par volume décroissant 5.5. Aléatoire
- Assistant
Based on the desired order of operations you've specified, I'm arranging the user input flow along with integrating some of the steps into the process. Here is the updated main part of your script with the specified order implemented:
if __name__ == "__main__": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() for video_path, duration in video_durations.items(): starting_offset_seconds += get_offset_value(duration, offset_type) ending_offset_seconds += get_offset_value(duration, offset_type) for video_path, duration in video_durations.items(): segment_duration = ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video_list = [] for path, duration in video_durations.items(): max_segments = (duration - (starting_offset_seconds + ending_offset_seconds)) // segment_duration max_segments_per_video_list.append(max_segments) avg_max_segments = sum(max_segments_per_video_list) / len(max_segments_per_video_list) print(f"En moyenne, chaque vidéo peut avoir {avg_max_segments:.2f} segments de {segment_duration} secondes.") # Ask user for confirmation or to enter a new duration correct_duration = ask_yes_no_question("La durée des segments est-elle correcte ?") if not correct_duration: segment_duration = ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds)) # Ask user for sorting preference of video excerpts sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue num_moments = int(available_duration // segment_duration) if num_moments == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) 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) # Sort the moments according to user preference before extracting the segments if sorting_preference != 5: # If the user chose to sort by some criteria moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, duration) finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) print(f"Processing completed for video '{video_path}'") processed_videos += 1 print(f"All video processing has been completed. {processed_videos} videos were processed.")Please note the following:
- This updated script will now ask for the starting and ending temporal offsets based on whether a relative or absolute offset is specified (steps 2.1 and 2.2).
- The adjustable segment duration is confirmed with the user, with the option to input a new duration if the default is not suitable (step 4).
- The script will ask users about their sorting preference for the extracted video segments (step 5).
- After collecting user inputs, the script processes each video, extracts the specified number of moments, sorts them if needed, and then extracts the segments.
- Please ensure to implement or update the
ask_offset_type,get_offset_value,ask_for_segment_duration,ask_yes_no_question, andask_sorting_preferencefunctions to gather user inputs correctly as per the desired flow.
Keep in mind that since this is a synopsis and the interaction with the user for each video is happening inside the loop, the prompts will reoccur for each video. Depending on the intended behavior, you might need to adjust the flow to ask once or handle each video individually.
- User
Tu as oublié quelque chose : il faut préciser si on enlève du temps en début de vidéo ou en fin de vidéo. Ca concerne le retrait de temps relatif mais aussi le retrait de temps absolu
- Assistant
Cela a été pris en compte dans la suggestion précédente, mais il semble qu'il y ait eu une confusion dans l'implémentation. Il faut demander séparément pour le début et la fin de la vidéo lors du retrait temporel, que ce soit pour le retrait relatif ou absolu. Voici comment vous pourriez implémenter cette partie de la logique dans votre code:
if __name__ == "__main__": # ... (Code précédent pour inclure les sous-dossiers) video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") for video_path, duration in video_durations.items(): starting_offset_seconds += get_offset_value(duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") for video_path, duration in video_durations.items(): ending_offset_seconds += get_offset_value(duration, offset_type) # ... (Reste du code)Dans ce code, nous imprimons d'abord un message pour indiquer à l'utilisateur qu'il configurera le retrait temporel pour le début de la vidéo, puis nous exécutons la fonction
get_offset_valuepour obtenir la valeur correspondante. Ensuite, nous faisons de même pour la fin de la vidéo.Veuillez noter que dans le code tel qu'il est écrit ci-dessus, si vous avez plusieurs vidéos, vous demanderez à l'utilisateur de saisir les offsets pour chaque vidéo séparément. Si cela n'est pas souhaité et que vous préférez utiliser les mêmes offsets pour toutes les vidéos, vous devriez sortir de la boucle après avoir défini les offsets une fois et les utiliser pour toutes les vidéos. Voici un exemple :
if perform_temporal_offset: offset_type = ask_offset_type() # Configuration du retrait temporel pour le début de la vidéo first_video_duration = next(iter(video_durations.values())) print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(first_video_duration, offset_type) # Configuration du retrait temporel pour la fin de la vidéo print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(first_video_duration, offset_type) # ... (Reste du code)Cet ajustement du code vous permet de définir les offsets pour toutes les vidéos en une seule fois, en utilisant la durée de la première vidéo dans le dictionnaire des durées comme référence pour les saisies des offsets.
- User
On a oublié autre chose : demander à l'utilisateur combien de segments il veut finalement extraire. C'est juste avant la demande du choix de tri des vidéos.
- Assistant
Bien sûr, voici comment vous pourriez demander à l'utilisateur combien de segments il souhaite extraire pour chaque vidéo. Cette demande vient juste avant la demande de choix de tri des vidéos.
Je propose l'ajout de l'étape correspondante dans le script principal :
if __name__ == "__main__": # ... (Code précédent) # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demander le nombre de segments que l'utilisateur souhaite extraire de chaque vidéo num_moments_input = input("Combien de moments forts souhaitez-vous extraire par vidéo ? ") try: num_moments = int(num_moments_input) except ValueError: print("Veuillez entrer un nombre entier valide.") # Gérer l'erreur, par exemple en redemandant à l'utilisateur : num_moments = ask_for_number_of_moments() # Assurer que le nombre de segments n'excède pas le maximum possible for video_path, max_segments in moments_to_extract_per_video.items(): if num_moments > max_segments: print(f"La vidéo '{os.path.basename(video_path)}' ne permet pas d'extraire {num_moments} moments forts. Seuls {max_segments} seront extraits.") moments_to_extract_per_video[video_path] = max_segments else: moments_to_extract_per_video[video_path] = num_moments # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() # ... (Le reste du traitement des vidéos)Veuillez noter que vous devrez également créer une fonction telle que
ask_for_number_of_moments()pour obtenir le nombre de moments que l'utilisateur souhaite extraire. Assurez-vous de créer la logique de validation nécessaire pour s'assurer que l'entrée est appropriée.La fonction
ask_for_number_of_momentspourrait ressembler à quelque chose comme cela :def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")Le code de la boucle principale assure que l'utilisateur ne demandera pas plus de segments qu'il n'est possible d'extraire de chaque vidéo, en tenant compte de la durée des segments et des offsets temporels.
- 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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. 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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") for video_path, duration in video_durations.items(): starting_offset_seconds += get_offset_value(duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") for video_path, duration in video_durations.items(): ending_offset_seconds += get_offset_value(duration, offset_type) for video_path, duration in video_durations.items(): segment_duration = ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds)) # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demander le nombre de segments que l'utilisateur souhaite extraire de chaque vidéo num_moments_input = input("Combien de moments forts souhaitez-vous extraire par vidéo ? ") try: num_moments = int(num_moments_input) except ValueError: print("Veuillez entrer un nombre entier valide.") # Gérer l'erreur, par exemple en redemandant à l'utilisateur : num_moments = ask_for_number_of_moments() # Assurer que le nombre de segments n'excède pas le maximum possible for video_path, max_segments in moments_to_extract_per_video.items(): if num_moments > max_segments: print(f"La vidéo '{os.path.basename(video_path)}' ne permet pas d'extraire {num_moments} moments forts. Seuls {max_segments} seront extraits.") moments_to_extract_per_video[video_path] = max_segments else: moments_to_extract_per_video[video_path] = num_moments # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue num_moments = int(available_duration // segment_duration) if num_moments == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) 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) # Sort the moments according to user preference before extracting the segments if sorting_preference != 5: # If the user chose to sort by some criteria moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, duration) finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) print(f"Processing completed for video '{video_path}'") processed_videos += 1 print(f"All video processing has been completed. {processed_videos} videos were processed.")LE script ne respecte pas le nombre qu'il choisit finalement d'extraire.
- Assistant
D'accord, il semble que le nombre de segments que l'utilisateur souhaite extraire (
num_moments) n'est pas respecté correctement dans le flux de traitement des vidéos.Pour corriger cela, nous devons nous assurer que la variable
num_momentsest correctement passée à la fonctionfind_loudest_momentset que nous utilisons la valeurmoments_to_extract_per_video[video_path]quand on invoque cette fonction. Voici le bout de code où ces corrections doivent être appliquées dans votre boucle principale :# ... (le reste du code précédent) # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) 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) # Sort the moments according to user preference before extracting the segments if sorting_preference != 5: # If the user chose to sort by some criteria moments, volumes = sort_moments(moments, volumes, sorting_preference) extracted_moments = moments[:num_moments] # Respectez le nombre d'extraits choisi par l'utilisateur # Extract the segments in the sorted order extract_segments(video_path, extracted_moments, segment_duration, duration) finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) print(f"Processing completed for video '{video_path}'") processed_videos += 1 print(f"All video processing has been completed. {processed_videos} videos were processed.")En effectuant ces changements, vous vous assurez que même si
find_loudest_momentsidentifie plus de moments que nécessaire, vous n'extrairez que le nombre de segments (num_moments) que l'utilisateur a demandé en les sélectionnant à partir du début de la listemoments. Assurez-vous que tous les autres aspects et fonctions du script fonctionnent avec ces changements. - 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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. 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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") for video_path, duration in video_durations.items(): starting_offset_seconds += get_offset_value(duration, offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") for video_path, duration in video_durations.items(): ending_offset_seconds += get_offset_value(duration, offset_type) for video_path, duration in video_durations.items(): segment_duration = ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds)) # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demander le nombre de segments que l'utilisateur souhaite extraire de chaque vidéo num_moments_input = input("Combien de moments forts souhaitez-vous extraire par vidéo ? ") try: num_moments = int(num_moments_input) except ValueError: print("Veuillez entrer un nombre entier valide.") # Gérer l'erreur, par exemple en redemandant à l'utilisateur : num_moments = ask_for_number_of_moments() # Assurer que le nombre de segments n'excède pas le maximum possible for video_path, max_segments in moments_to_extract_per_video.items(): if num_moments > max_segments: print(f"La vidéo '{os.path.basename(video_path)}' ne permet pas d'extraire {num_moments} moments forts. Seuls {max_segments} seront extraits.") moments_to_extract_per_video[video_path] = max_segments else: moments_to_extract_per_video[video_path] = num_moments # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) 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) # Sort the moments according to user preference before extracting the segments if sorting_preference != 5: # If the user chose to sort by some criteria moments, volumes = sort_moments(moments, volumes, sorting_preference) extracted_moments = moments[:num_moments] # Respectez le nombre d'extraits choisi par l'utilisateur # Extract the segments in the sorted order extract_segments(video_path, extracted_moments, segment_duration, duration) finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) print(f"Processing completed for video '{video_path}'") processed_videos += 1 print(f"All video processing has been completed. {processed_videos} videos were processed.")Voici ce qui se passe : Configuration du retrait temporel pour le début de la vidéo: Entrez le nombre de secondes à ignorer : 600 Entrez le nombre de secondes à ignorer : 800 Entrez le nombre de secondes à ignorer : 30 Entrez le nombre de secondes à ignorer : 30 Entrez le nombre de secondes à ignorer : 30 Entrez le nombre de secondes à ignorer :
- Assistant
Je vois où est le problème : la façon dont les valeurs de
starting_offset_secondsetending_offset_secondssont accumulées dans une boucle qui parcourt toutes les vidéos. La logique actuelle ajoute les valeurs offset de chaque vidéo ensemble, ce qui n'est pas correct. Vous voulez définir ces valeurs pour chaque vidéo individuellement.Voici comment procéder pour corriger cela :
if __name__ == "__main__": # ... perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # ... # La partie qui demande le nombre de moments forts à extraire reste la même # ... processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.")Ce qui change ici :
- On définit
starting_offset_secondsetending_offset_secondsune seule fois, en utilisant la durée de la première vidéo comme référence. C'est sous l'hypothèse que l'utilisateur veut appliquer les mêmes offsets à toutes les vidéos. Si ce n'est pas le cas, il faudrait demander les offsets pour chaque vidéo individuellement. - On n'ajoute plus les offsets de toutes les vidéos ensemble.
moments = moments[:num_moments]garantit que on respecte bien le nombre de segments que l'utilisateur veut extraire.- On assure de fermer
video_clipdans le blocfinallypour éviter des fuites de ressources.
Assurez-vous que toutes les autres parties de votre script sont cohérentes avec ces changements.
- On définit
- User
J'ai ça maintenant :
Veuillez entrer le numéro de votre choix (1 ou 2) : 1 Configuration du retrait temporel pour le début de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 15 Configuration du retrait temporel pour la fin de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 0 Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? 20 Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? 20 La durée doit être un nombre positif et inférieure ou égale à -259.072 secondes. Quelle est la durée (en secondes) de chaque segment vidéo à extraire ?
- Assistant
Il semble que votre code rencontre une situation où l'
allowable_durationdevient négative, probablement en raison d'une mauvaise gestion des valeurs de décalage relatives ou absolues. Pour vous assister correctement dans la résolution de cette erreur, j'ai besoin de voir l'intégration actuelle dans le contexte du script. Veuillez ajouter le morceau de code pertinent où vous calculez l'allowable_durationet où vous appelezask_for_segment_duration.Cependant, en me basant sur le message d'erreur que vous avez partagé, voici une suggestion générique de ce qui pourrait se passer :
- Vous calculez peut-être l'
allowable_durationde manière incorrecte, en soustrayant les décalages de temps même si la durée de la vidéo est inférieure.
Voici ce que vous devriez faire pour chaque vidéo lorsque vous demandez la durée du segment :
for video_path, duration in video_durations.items(): if perform_temporal_offset: starting_offset_seconds = get_offset_value(duration, offset_type) ending_offset_seconds = get_offset_value(duration, offset_type) allowable_duration = duration - (starting_offset_seconds + ending_offset_seconds) # Ensure that the allowable duration cannot be negative allowable_duration = max(0, allowable_duration) segment_duration = ask_for_segment_duration(allowable_duration) # ... (rest of your code) ...Gardez à l'esprit que
starting_offset_secondsetending_offset_secondsdoivent être demandés une fois avant votre boucle si les décalages doivent être identiques pour toutes les vidéos.- Les valeurs de décalage relatives doivent être correctement calculées par rapport à la durée de chaque vidéo individuelle, et non par rapport à une valeur cumulative ou moyenne.
Assurez-vous également de vérifier la logique que vous utilisez pour demander à l'utilisateur la durée de chaque segment et que vous traitez correctement les durées pour lesquelles les décalages temporels rendent l'extraction impossible. Si la
allowable_durationest inférieure à la durée minimale nécessaire pour un segment, vous devrez informer l'utilisateur et lui redemander une autre durée ou sauter la vidéo courante. - Vous calculez peut-être l'
- 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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. 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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) for video_path, duration in video_durations.items(): segment_duration = ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds)) # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demander le nombre de segments que l'utilisateur souhaite extraire de chaque vidéo num_moments_input = input("Combien de moments forts souhaitez-vous extraire par vidéo ? ") try: num_moments = int(num_moments_input) except ValueError: print("Veuillez entrer un nombre entier valide.") # Gérer l'erreur, par exemple en redemandant à l'utilisateur : num_moments = ask_for_number_of_moments() # Assurer que le nombre de segments n'excède pas le maximum possible for video_path, max_segments in moments_to_extract_per_video.items(): if num_moments > max_segments: print(f"La vidéo '{os.path.basename(video_path)}' ne permet pas d'extraire {num_moments} moments forts. Seuls {max_segments} seront extraits.") moments_to_extract_per_video[video_path] = max_segments else: moments_to_extract_per_video[video_path] = num_moments # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.")Voici le script. Fais les modifications
- Assistant
D'accord, je vois où est le problème. Le script demande à l'utilisateur la durée de chaque segment vidéo à extraire pour chaque vidéo trouvée plutôt que de demander une seule fois et d'appliquer cela à toutes les vidéos. Voyons comment nous pouvons corriger cela.
Premièrement, nous devrions demander la durée de chaque segment vidéo une seule fois après avoir calculé les décalages temporels, mais avant de commencer à traiter les vidéos. Deuxièmement, nous devrions nous assurer que les valeurs des décalages temporels,
starting_offset_secondsetending_offset_seconds, sont appliquées correctement pour calculer la durée disponible de la vidéo. Voyons le code mis à jour :# ... (code précédent) if __name__ == "__main__": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders) if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de départ starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de fin ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # Demandez la durée de chaque segment une seule fois segment_duration = ask_for_segment_duration(60*60*24) # Utilisez une longueur fictive car nous affinerons cela pour chaque vidéo # ... (reste du code précédent) # Demandez le nombre de segments/moments à extraire une seule fois num_moments = ask_for_number_of_moments() # Assurez-vous que le nombre de segments n'excède pas le maximum possible pour chaque vidéo for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = available_duration // segment_duration if max_segments_per_video == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle. Ignorer.") continue # Passez à la vidéo suivante puisque le traitement n'est pas possible moments_to_extract_per_video[video_path] = min(num_moments, max_segments_per_video) # ... (reste du code précédent) for video_path, duration in video_durations.items(): # ... # Segment extractions loop (aucune modification nécessaire ici) # ...Ce que nous avons fait :
-
Nous avons déplacé la demande pour la durée du segment à un seul endroit et avons utilisé une longue durée fictive parce que nous allons ajuster la durée réelle pour chaque vidéo plus tard.
-
Nous avons déplacé la demande pour le nombre de moments forts à un seul endroit.
Assurez-vous que le reste des boucles et du code est cohérent avec ces changements. Les modifications ci-dessus devraient traiter la durée de segment et le nombre de moments de manière globale, sans demander pour chaque vidéo, évitant ainsi le problème de valeurs négatives pour
allowable_duration. -
- User
J'ai l'impression que lorsque l'utilisateur demande au script de ne pas parcourir les sous-dossiers, il les parcourt quand même. Qu'en dis-tu ?
- Assistant
Dans le script que vous avez fourni, la fonction
get_video_durationsutiliseos.walk, qui parcourt par défaut tous les sous-dossiers à partir du répertoire spécifié (dans votre cas,'.'pour le répertoire courant). La variableinclude_subfoldersest utilisée pour contrôler s'il faut ou non inclure les sous-dossiers dans la recherche des vidéos.Cependant, il y a une logique dans le script qui devrait théoriquement empêcher
os.walkde parcourir les sous-dossiers siinclude_subfoldersest réglé surFalse. Voici la partie pertinente de la fonctionget_video_durations:def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) # ... (le reste de votre code) ...Dans le code ci-dessus, si
include_subfoldersestFalse, la logiquedirs[:] = []devrait vider la liste des répertoires queos.walkprévoit de parcourir par la suite, ce qui empêcheraitos.walkde parcourir les sous-dossiers. Toutefois, cette logique n'est efficace que siroot != '.', la racine ou le répertoire courant. Cela suggère que le code devrait fonctionner comme prévu.Si le script parcourt toujours les sous-dossiers malgré le fait que
include_subfolderssoit défini surFalse, il pourrait y avoir un problème avec la manière dont les variables sont passées ou la condition pourrait être mal exécutée.Vérifiez les points suivants :
-
Assurez-vous que la variable
include_subfoldersest correctement définie en fonction de la réponse de l'utilisateur à la question posée parask_yes_no_question. -
Si l'utilisateur sélectionne de ne pas inclure les sous-dossiers (répond "2"),
include_subfoldersdoit être défini surFalse. -
Confirmez que
get_video_durations(include_subfolders)est appelé avec la bonne valeur deinclude_subfolders. -
Assurez-vous qu'il n'y a pas d'autre partie du script modifiant les
dirsaprès avoir définidirs[:] = [].
Si ces vérifications sont correctes et que le problème persiste, vous devriez ajouter des instructions d'impression dans la boucle de
os.walkpour voir quels répertoires sont réellement parcourus. Cela peut vous aider à déboguer 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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders and root != '.': dirs[:] = [] # Ne parcourt pas les sous-dossiers. 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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l’analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l’analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l’offset de départ starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l’offset de fin ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # Demandez la durée de chaque segment une seule fois segment_duration = ask_for_segment_duration(606024) # Utilisez une longueur fictive car nous affinerons cela pour chaque vidéo # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demandez le nombre de segments/moments à extraire une seule fois num_moments = ask_for_number_of_moments() # Assurez-vous que le nombre de segments n’excède pas le maximum possible pour chaque vidéo for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = available_duration // segment_duration if max_segments_per_video == 0: print(f"La vidéo ‘{video_path}’ ne permet pas d’extraire de segments avec la configuration actuelle. Ignorer.") continue # Passez à la vidéo suivante puisque le traitement n’est pas possible moments_to_extract_per_video[video_path] = min(num_moments, max_segments_per_video) # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.")Voici le script : peux-tu vérifier ?
- Assistant
Votre script vérifie correctement si l'utilisateur souhaite inclure les sous-dossiers grâce à la fonction
ask_directory_preference()et plus tard, pendant l'itération du répertoire avecos.walk, il essaie de ne pas parcourir les sous-dossiers siinclude_subfoldersestFalse. Cependant, la conditionif not include_subfolders and root != '.'pourrait potentiellement poser problème.La ligne
dirs[:] = []devrait empêcher la recherche dans les sous-dossiers siinclude_subfoldersestFalse, maisroot != '.'peut être problématique car lorsqueos.walkcommence à partir du répertoire actuel,rootest égal à'.'lors de la première itération et les sous-dossiers ne seront pas éliminés.La condition devrait être changée pour quelque chose qui garantit que le programme ne modifie pas la liste des répertoires pour la première itération lorsque nous sommes dans le répertoire racine. Voici comment cela peut être résolu :
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders: if root == '.': # Nous sommes dans le répertoire racine. Ne faites rien ici. pass else: # Videz la liste des répertoires pour éviter de regarder dans les sous-dossiers. dirs[:] = [] for file in files: if file.lower().endswith(tuple(video_extensions)): # ... Votre logique reste la même ...Cette modification est subtile, mais garantit que lors de la première itération de
os.walk, quandrootest équivalent à'.', les sous-dossiers ne sont pas supprimés. Les itérations suivantes oùrootest un sous-dossier (root != '.') auront bien leur listedirsvidée siinclude_subfoldersestFalse.Assurez-vous que l'appel à
get_video_durations(include_subfolders)se fait avec la bonne variableinclude_subfolders.Faites aussi attention que lorsque vous appelez
ask_for_segment_duration(duration - (starting_offset_seconds + ending_offset_seconds))pour chaque fichier vidéo, à la suite du codeif perform_temporal_offset:. Vous devrez ajuster cette logique pour calculer lestarting_offset_secondset leending_offset_secondsbasé sur les décalages relatifs ou absolus pour chaque vidéo individuelle, sinon si la première video a une durée exceptionnelle cela entrainera des erreurs pour les suivantes.Faites ces vérifications et ajustements avant de continuer à utiliser le script.
- 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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders: if root == '.': # Nous sommes dans le répertoire racine. Ne faites rien ici. pass else: # Videz la liste des répertoires pour éviter de regarder dans les sous-dossiers. dirs[:] = []
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_durationsdef process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de départ starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de fin ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # Demandez la durée de chaque segment une seule fois segment_duration = ask_for_segment_duration(606024) # Utilisez une longueur fictive car nous affinerons cela pour chaque vidéo # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demandez le nombre de segments/moments à extraire une seule fois num_moments = ask_for_number_of_moments() # Assurez-vous que le nombre de segments n'excède pas le maximum possible pour chaque vidéo for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = available_duration // segment_duration if max_segments_per_video == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle. Ignorer.") continue # Passez à la vidéo suivante puisque le traitement n'est pas possible moments_to_extract_per_video[video_path] = min(num_moments, max_segments_per_video) # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.")Voici ce que j'ai :
Veuillez entrer le numéro de votre choix (1 ou 2) : 1 Configuration du retrait temporel pour le début de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 15 Configuration du retrait temporel pour la fin de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 0 Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? 10 La vidéo 'RogueAdventures21_s03__480p.mp4' permet d'extraire jusqu'à 152.0 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment1.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment10.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment11.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment12.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment13.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment14.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment15.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment16.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment17.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment18.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment19.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment2.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment20.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment3.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment4.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment5.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment6.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment7.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment8.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes. La vidéo 'RogueAdventures21_s03__480p_moment9.mp4' permet d'extraire jusqu'à 1 segments de 10.0 secondes.
- Assistant
Le problème que vous rencontrez est que le script prend en compte les segments vidéo qu'il a déjà extraits lorsqu'il parcourt à nouveau le répertoire de vidéos. C'est pour cette raison que vous voyez des vidéos comme
'RogueAdventures21_s03__480p_moment1.mp4'qui sont listées. Ces fichiers sont des produits du script lui-même et ne devraient pas être réanalysés comme s'ils étaient des vidéos sources.Pour résoudre ce problème, vous devez modifier la fonction
get_video_durationspour ignorer ces fichiers sorties. Vous pouvez choisir d'ignorer tous les fichiers qui contiennent'moment'dans leur nom ou vous pouvez mettre à jour vos conventions de nommage des fichiers pour faciliter cette distinction. Voici comment vous pourriez ignorer ces fichiers sorties dansget_video_durations:def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders: if root == '.': # Nous sommes dans le répertoire racine. Ne faites rien ici. pass else: # Videz la liste des répertoires pour éviter de regarder dans les sous-dossiers. dirs[:] = [] for file in files: if file.lower().endswith(tuple(video_extensions)) and "moment" not in file: 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_durationsDans le code ci-dessus, j'ai ajouté
"moment" not in fileà la condition de la boucleforqui traite les fichiers pour ignorer les fichiers qui contiennent le mot "moment" dans leur nom. Faites attention, si votre nom de fichier source original contient le mot "moment", cette condition l'ignorera également. Adapter cette logique à vos besoins spécifiques pourrait être nécessaire.Cette modification devrait empêcher le ré-encodage des segments préalablement créés et maintenir la liste de fichiers vidéo à traiter propre et à jour.
- User
Non, ce n'est pas une solution. Regarde :
Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ? 1- Oui 2- Non Veuillez entrer le numéro de votre choix (1 ou 2) : 2 Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ? 1- Oui 2- Non Veuillez entrer le numéro de votre choix (1 ou 2) : 1 Souhaitez-vous un décalage temporel relatif ou absolu ? 1- Relatif (pourcentage) 2- Absolu (secondes) Veuillez entrer le numéro de votre choix (1 ou 2) : 1 Configuration du retrait temporel pour le début de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 15 Configuration du retrait temporel pour la fin de la vidéo: Entrez le pourcentage du temps vidéo à ignorer : 0
J'ai bien demandé à ne pas inclure les sous-dossiers, pourtant le script l'a fait. Je veux que tu m'aides à résoudre le problème. Identifie-le, voici le script entier :
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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
def get_video_durations(include_subfolders): video_durations = {} for root, dirs, files in os.walk('.', topdown=True): if not include_subfolders: if root == '.': # Nous sommes dans le répertoire racine. Ne faites rien ici. pass else: # Videz la liste des répertoires pour éviter de regarder dans les sous-dossiers. dirs[:] = []
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_durationsdef process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de départ starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de fin ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # Demandez la durée de chaque segment une seule fois segment_duration = ask_for_segment_duration(606024) # Utilisez une longueur fictive car nous affinerons cela pour chaque vidéo # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demandez le nombre de segments/moments à extraire une seule fois num_moments = ask_for_number_of_moments() # Assurez-vous que le nombre de segments n'excède pas le maximum possible pour chaque vidéo for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = available_duration // segment_duration if max_segments_per_video == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle. Ignorer.") continue # Passez à la vidéo suivante puisque le traitement n'est pas possible moments_to_extract_per_video[video_path] = min(num_moments, max_segments_per_video) # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.") - Assistant
Je pense avoir identifié le problème dans votre code qui pourrait causer le non-respect de la préférence de l'utilisateur pour exclure les sous-dossiers lors de la recherche de fichiers vidéo.
Dans la fonction
get_video_durations, la modification dedirs[:] = []empêcheos.walkde descendre dans les sous-répertoires, mais cette modification est conditionnée parif not include_subfolders and root != '.'. La conditionroot != '.'empêche l'effacement des sous-répertoires au niveau de la racine. Cependant, cela semble incorrect puisquerootpeut ne plus être égal à'.'après le traitement du premier répertoire.Le problème est que
os.walkcontinue à partir du répertoire racine et elle génère une paire (root, dirs) pour chaque répertoire dans la hiérarchie. Par conséquent, la condition devrait être ajustée pour s'assurer que la suppression des sous-répertoires est effectuée au niveau approprié.Voici comment vous pouvez ajuster la condition pour empêcher de parcourir les sous-dossiers :
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) # ... La suite du code pour traiter le fichier ...Avec cette modification, peu importe la valeur de
root, les sous-dossiers seront ignorés siinclude_subfoldersestFalse. Ainsi, si l'utilisateur répond "Non" à la question sur l'inclusion des sous-dossiers,os.walkne parcourra que le répertoire racine.Une autre erreur dans le code se trouve dans la partie où vous configurez les décalages temporels. Il semblerait que vous demandiez et appliquiez ces décalages basés uniquement sur la première vidéo trouvée, sans tenir compte des durées différentes des vidéos individuelles.
Pour corriger cela, et s'assurer que vous demandez et appliquez des décalages qui sont spécifiques à chaque vidéo, vous voudrez calculer les valeurs de décalage juste avant de les utiliser pour chaque vidéo dans votre boucle principale. Actuellement, les valeurs saisies pour le premier et le seul fichier sont ensuite utilisées pour toutes les vidéos, ce qui peut conduire à des durées négatives si une vidéo est plus courte que la première.
Enfin, notez que le message indiquant la possibilité d'extraire un certain nombre de segments peut inclure également les fichiers de segment précédemment créés, ce qui peut prêter à confusion. Considérez de ne pas afficher les fichiers générés automatiquement par le script lors de l'affichage de ces messages ou d'ignorer ces fichiers lors de la collection des durées vidéo.
N'oubliez pas de tester votre script après ces modifications pour vous assurer que tout fonctionne comme prévu.
- User
Lorsque je demande un retrait, relatif ou absolu, et que j'extrais 20 segments, le script exporte 20 fois exactement la même vidéo. Voici le script dans sa totalité :
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
temporary_audio_files = []
Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'
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): while True: duration = input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ") try: segment_duration = float(duration) if segment_duration > 0 and segment_duration <= allowable_duration: return segment_duration else: print(f"La durée doit être un nombre positif et inférieure 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 find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): 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]) moment = (start_index + index) / rate moment_volume = volume_dB[start_index + index] # Skip the moment and set its volume to a very low number if it is too close to the start or the end 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) volumes.append(moment_volume) # Clear the volume around the found moment to prevent picking up nearby moments clear_range_start = max(0, index - int(rate * segment_half_duration)) clear_range_end = min(len(volume_dB), index + int(rate * segment_half_duration)) volume_dB[clear_range_start:clear_range_end] = -np.inf return moments, volumesdef extract_segments(video_path, moments, segment_duration, video_duration): 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): start_time = max(moment - half_segment_duration, 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- Pas de tri") 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) else: # Pas de tri zipped = zip(moments, volumes)
sorted_moments, sorted_volumes = zip(*zipped) return list(sorted_moments), list(sorted_volumes)def ask_for_number_of_moments(): while True: num_input = input("Veuillez entrer le nombre de moments forts à extraire : ") try: num = int(num_input) if num > 0: return num else: print("Le nombre doit être supérieur à 0. Veuillez réessayer.") except ValueError: print("Entrée non valide, veuillez réessayer avec un nombre entier.")
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 process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration, video_path): video_durations = {} for root, , files in os.walk('.'): for file in files: if file.lower().endswith(tuple(video_extensions)): video_path = os.path.join(root, file) unique_id = str(uuid.uuid4()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list
try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_durations[video_path] = video_duration # Stockez la durée. video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) video_clip.close() # Ensure to close the video clip moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds) extract_segments(video_path, moments, segment_duration, video_duration) # Now pass video_duration finally: if os.path.exists(audio_path): os.remove(audio_path) print(f"Finished processing video {video_path}") return video_durations # Renvoyez le dictionnaire contenant les durées des vidéos.if name == "main": include_subfolders = ask_yes_no_question("Souhaitez-vous inclure les sous-dossiers dans la recherche des vidéos ?") video_durations = get_video_durations(include_subfolders)
if not video_durations: print("Aucune vidéo trouvée pour l'analyse.") exit() perform_temporal_offset = ask_yes_no_question("Souhaitez-vous effectuer un retrait temporel (début et fin) pour l'analyse des vidéos ?") starting_offset_seconds = 0 ending_offset_seconds = 0 if perform_temporal_offset: offset_type = ask_offset_type() print("Configuration du retrait temporel pour le début de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de départ starting_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) print("Configuration du retrait temporel pour la fin de la vidéo:") # Utilisez la durée de la première vidéo trouvée pour calculer l'offset de fin ending_offset_seconds = get_offset_value(next(iter(video_durations.values())), offset_type) # Demandez la durée de chaque segment une seule fois segment_duration = ask_for_segment_duration(606024) # Utilisez une longueur fictive car nous affinerons cela pour chaque vidéo # Calculer le nombre maximum de segments possibles par vidéo en fonction de la durée des segments moments_to_extract_per_video = {} for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = max(1, available_duration // segment_duration) moments_to_extract_per_video[video_path] = max_segments_per_video print(f"La vidéo '{os.path.basename(video_path)}' permet d'extraire jusqu'à {max_segments_per_video} segments de {segment_duration} secondes.") # Demandez le nombre de segments/moments à extraire une seule fois num_moments = ask_for_number_of_moments() # Assurez-vous que le nombre de segments n'excède pas le maximum possible pour chaque vidéo for video_path, duration in video_durations.items(): available_duration = max(0, duration - (starting_offset_seconds + ending_offset_seconds)) max_segments_per_video = available_duration // segment_duration if max_segments_per_video == 0: print(f"La vidéo '{video_path}' ne permet pas d'extraire de segments avec la configuration actuelle. Ignorer.") continue # Passez à la vidéo suivante puisque le traitement n'est pas possible moments_to_extract_per_video[video_path] = min(num_moments, max_segments_per_video) # Demander le choix de tri des extraits vidéo sorting_preference = ask_sorting_preference() processed_videos = 0 for video_path, duration in video_durations.items(): num_moments = moments_to_extract_per_video[video_path] # Obtenez le nombre correct de moments à extraire available_duration = duration - (starting_offset_seconds + ending_offset_seconds) if available_duration <= 0: print(f"Video {video_path} is too short after applying offsets. Skipping.") continue audio_path = f'temp_audio_{uuid.uuid4().hex}.wav' try: # Extraction of metadata from the video file and audio extraction video_clip = VideoFileClip(video_path) video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) # Assume find_loudest_moments returns a list, but we want to only keep the number that the user specified moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Keep only the number of moments specified by the user if sorting_preference != 5: # If user has chosen a sorting preference, sort them moments, volumes = sort_moments(moments, volumes, sorting_preference) # Extract the segments in the sorted order extract_segments(video_path, moments, segment_duration, available_duration) processed_videos += 1 finally: # Delete the temporary audio file if os.path.exists(audio_path): os.remove(audio_path) video_clip.close() print(f"Processing completed for video '{video_path}'") print(f"All video processing has been completed. {processed_videos} videos were processed.") - Assistant
Votre code définit et utilise plusieurs fonctions pour accomplir les tâches diverses, y compris l'analyse de vidéos pour extraire des segments basés sur des moments forts basés sur le volume audio. Toutefois, il semble y avoir un problème avec la fonction
find_loudest_moments. Cette fonction est censée trouver lesnum_momentsles plus forts (basés sur le volume) dans la vidéo, mais à la lumière de votre commentaire, il semblerait qu'elle renvoie toujours les mêmes moments. Cela signifie que la vidéo extraite est toujours la même pour chaque segment.Un autre problème potentiel est que les valeurs
starting_offset_secondsetending_offset_secondssont obtenues en utilisant la durée de la première vidéo trouvée, ce qui pourrait devenir problématique si d'autres vidéos ont des durées différentes.Pour diagnostiquer le problème, il faut s'assurer que :
-
find_loudest_momentsfonctionne comme prévu. Il devrait identifier des moments uniques avec les volumes sonores les plus élevés à l'intérieur de la vidéo, sans les dupliquer. -
starting_offset_secondsetending_offset_secondsdevraient être calculés individuellement pour chaque vidéo si des décalages relatifs sont appliqués. Pour un décalage absolu, vous pouvez les demander une fois et les appliquer à toutes les vidéos. -
Après avoir trié les moments, assurez-vous que le découpage (
extract_segments) est fait correctement.
Examinons la fonction
find_loudest_momentset aussi où le découpage est fait avecextract_segments:# ... (le reste du code) def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): # ... (le reste de la fonction reste inchangé) # Cette liste est supposée être remplie avec les moments les plus forts moments = [] # ... def extract_segments(video_path, moments, segment_duration, video_duration): # ... (le reste de la fonction reste inchangé) for i, moment in enumerate(moments): # Assurez-vous que chaque moment s'ajoute de manière unique start_time = max(moment - half_segment_duration, 0) # Ceci crée un fichier pour chaque moment unique # ... # ... if __name__ == "__main__": # ... (le reste du code) for video_path, duration in video_durations.items(): # Cela devrait être à l'intérieur de la boucle, pas avant if perform_temporal_offset: starting_offset_seconds = get_offset_value(duration, offset_type) ending_offset_seconds = get_offset_value(duration, offset_type) # ... (le reste du code) try: # ... (le reste du code) # Assurez-vous qu'une liste de moments uniques est passée à extraire moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, available_duration, starting_offset_seconds, ending_offset_seconds) moments = moments[:num_moments] # Assurez-vous que cette liste soit bien unique par moment # ... (le reste du code) finally: # ...Assurez-vous d'inspecter la logique au sein de la fonction
find_loudest_momentspour garantir qu'elle renvoie une liste de moments uniques. Si les moments ne sont pas uniques, vous obtiendrez des doublons. Vous pouvez ajouter des instructions d'impression pour afficher les valeurs demomentset assurer qu'ils sont uniques pour chaque appel defind_loudest_moments.De plus, si vous effectuez un retrait temporel relatif, les offsets de début et de fin doivent être calculés pour chaque vidéo individuellement en fonction de leur durée propre – ce calcul devrait être effectué à l'intérieur de la boucle principale où chaque vidéo est traitée. Cela garantira que chaque vidéo a ses propres
starting_offset_secondsetending_offset_secondsappropriés.Si après avoir vérifié et édité ce code vous rencontrez toujours des problèmes, je vous recommanderais de mettre des points de contrôle (
print) tout au long du script pour suivre le déroulement de l'exécution et identifier plus facilement où les problèmes surviennent. -
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.