Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· OpenAIAi2 WildChat-4.8M (AI2)

import os import subprocess import numpy as np import uuid # Import uuid to generate…

  1. 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, volumes
    

    def 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.")
    
  2. 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:

    1. Ask the user whether to include subfolders in the video search and store the value.
    2. Retrieve video durations for eligible video files that match given extensions (mp4, mkv, wmv, avi).
    3. Optionally apply temporal offsets to the analysis based on user preference.
    4. For each video, ask the user for the duration of each segment to extract if applying a temporal offset is chosen.
    5. 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.
    6. Optionally sort the moments (and thus the video segments) according to user preference.
    7. 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 using ffmpeg.
    • sort_moments: Sorts the extracted moments according to loudness or timestamp ordering.
    • The script uses external libraries such as moviepy for video editing and scipy for audio file processing.

    Please note that the script makes use of ffmpeg for video manipulation, which means that ffmpeg must be installed and accessible in the system's path. Also, you need to ensure that moviepy and 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.

  3. 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'?

  4. Assistant

    The error you're encountering is because the variable num_moments is 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.

  5. User

    Non non : l'ordre doit être le suivant :

    1. Inclure ou non les sous-dossiers
    2. 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
    3. Demande de la durée des segments
    4. Avertissement du nombre max de segments possibles moyen 4.1 Confirmation 4.2 Entrer une nouvelle durée
    5. 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
  6. 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:

    1. 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).
    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).
    3. The script will ask users about their sorting preference for the extracted video segments (step 5).
    4. After collecting user inputs, the script processes each video, extracts the specified number of moments, sorts them if needed, and then extracts the segments.
    5. Please ensure to implement or update the ask_offset_type, get_offset_value, ask_for_segment_duration, ask_yes_no_question, and ask_sorting_preference functions 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.

  7. 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

  8. 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_value pour 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.

  9. 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.

  10. 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_moments pourrait 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.

  11. 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, volumes
    

    def 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.

  12. 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_moments est correctement passée à la fonction find_loudest_moments et que nous utilisons la valeur moments_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_moments identifie 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 liste moments. Assurez-vous que tous les autres aspects et fonctions du script fonctionnent avec ces changements.

  13. 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, volumes
    

    def 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 :

  14. Assistant

    Je vois où est le problème : la façon dont les valeurs de starting_offset_seconds et ending_offset_seconds sont 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 :

    1. On définit starting_offset_seconds et ending_offset_seconds une 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.
    2. On n'ajoute plus les offsets de toutes les vidéos ensemble.
    3. moments = moments[:num_moments] garantit que on respecte bien le nombre de segments que l'utilisateur veut extraire.
    4. On assure de fermer video_clip dans le bloc finally pour éviter des fuites de ressources.

    Assurez-vous que toutes les autres parties de votre script sont cohérentes avec ces changements.

  15. 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 ?

  16. Assistant

    Il semble que votre code rencontre une situation où l'allowable_duration devient 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_duration et où vous appelez ask_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 :

    1. Vous calculez peut-être l'allowable_duration de 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_seconds et ending_offset_seconds doivent être demandés une fois avant votre boucle si les décalages doivent être identiques pour toutes les vidéos.

    1. 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_duration est 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.

  17. 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, volumes
    

    def 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

  18. 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_seconds et ending_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 :

    1. 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.

    2. 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.

  19. 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 ?

  20. Assistant

    Dans le script que vous avez fourni, la fonction get_video_durations utilise os.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 variable include_subfolders est 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.walk de parcourir les sous-dossiers si include_subfolders est réglé sur False. Voici la partie pertinente de la fonction get_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_subfolders est False, la logique dirs[:] = [] devrait vider la liste des répertoires que os.walk prévoit de parcourir par la suite, ce qui empêcherait os.walk de parcourir les sous-dossiers. Toutefois, cette logique n'est efficace que si root != '.', 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_subfolders soit défini sur False, 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 :

    1. Assurez-vous que la variable include_subfolders est correctement définie en fonction de la réponse de l'utilisateur à la question posée par ask_yes_no_question.

    2. Si l'utilisateur sélectionne de ne pas inclure les sous-dossiers (répond "2"), include_subfolders doit être défini sur False.

    3. Confirmez que get_video_durations(include_subfolders) est appelé avec la bonne valeur de include_subfolders.

    4. Assurez-vous qu'il n'y a pas d'autre partie du script modifiant les dirs après avoir défini dirs[:] = [].

    Si ces vérifications sont correctes et que le problème persiste, vous devriez ajouter des instructions d'impression dans la boucle de os.walk pour voir quels répertoires sont réellement parcourus. Cela peut vous aider à déboguer le problème.

  21. 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, volumes
    

    def 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 ?

  22. 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 avec os.walk, il essaie de ne pas parcourir les sous-dossiers si include_subfolders est False. Cependant, la condition if not include_subfolders and root != '.' pourrait potentiellement poser problème.

    La ligne dirs[:] = [] devrait empêcher la recherche dans les sous-dossiers si include_subfolders est False, mais root != '.' peut être problématique car lorsque os.walk commence à partir du répertoire actuel, root est é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, quand root est équivalent à '.', les sous-dossiers ne sont pas supprimés. Les itérations suivantes où root est un sous-dossier (root != '.') auront bien leur liste dirs vidée si include_subfolders est False.

    Assurez-vous que l'appel à get_video_durations(include_subfolders) se fait avec la bonne variable include_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 code if perform_temporal_offset:. Vous devrez ajuster cette logique pour calculer le starting_offset_seconds et le ending_offset_seconds basé 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.

  23. 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, volumes
    

    def 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_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 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.

  24. 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_durations pour 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 dans get_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_durations
    

    Dans le code ci-dessus, j'ai ajouté "moment" not in file à la condition de la boucle for qui 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.

  25. 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, volumes
    

    def 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_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.")
    
  26. 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 de dirs[:] = [] empêche os.walk de descendre dans les sous-répertoires, mais cette modification est conditionnée par if not include_subfolders and root != '.'. La condition root != '.' empêche l'effacement des sous-répertoires au niveau de la racine. Cependant, cela semble incorrect puisque root peut ne plus être égal à '.' après le traitement du premier répertoire.

    Le problème est que os.walk continue à 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 si include_subfolders est False. Ainsi, si l'utilisateur répond "Non" à la question sur l'inclusion des sous-dossiers, os.walk ne 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.

  27. 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, volumes
    

    def 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.")
    
  28. 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 les num_moments les 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_seconds et ending_offset_seconds sont 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 :

    1. find_loudest_moments fonctionne 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.

    2. starting_offset_seconds et ending_offset_seconds devraient ê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.

    3. Après avoir trié les moments, assurez-vous que le découpage (extract_segments) est fait correctement.

    Examinons la fonction find_loudest_moments et aussi où le découpage est fait avec extract_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_moments pour 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 de moments et assurer qu'ils sont uniques pour chaque appel de find_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_seconds et ending_offset_seconds approprié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.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.