Respan Dataset Explorer

perform_extraction n'est pas pareil que extract_segments ?

La fonction `perform_extraction` est une fonction englobante que vous devriez ajouter pour organiser le processus d'extraction des segments en utilisant tous les paramètres configurés par l'utilisateur. Cette fonction peut utiliser `extract_segments` ainsi que toutes les autres fonctions nécessaires pour accomplir le processus d'extraction complet.

Je vais maintenant intégrer la fonction `extract_segments` dans `perform_extraction` en utilisant les variables globales pour les paramètres, pour montrer comment cela fonctionnerait :

```python
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

# ...
```

La différence clé ici est que la fonction `perform_extraction` contrôle le flux complet d'extraire les moments les plus forts de plusieurs vidéos. Elle fait ainsi appel à diverses autres fonctions du script, telles que `find_loudest_moments`, `sort_moments`, et `extract_segments` pour chaque vidéo individuelle.

`extract_segments` reste une fonction distincte qui est responsable de la création de segments individuels basés sur une liste de moments déterminés. Elle est appelée depuis `perform_extraction` qui orchestre l'ensemble du processus pour toutes les vidéos traitées.

En utilisant `perform_extraction`, vous pouvez modifier les paramètres dans le menu principal et ensuite relancer l'extraction sans devoir redéfinir les paramètres un par un ou exécuter tout le script depuis le début.

Peux-tu réécrire le menu, sans les couleurs ?

Bien sûr ! En l'absence de couleurs, vous devez simplement afficher le menu avec les paramètres actuels sans utiliser la bibliothèque `termcolor`. Voici comment vous pourriez réécrire le menu :

```python
def sorting_preference_to_string(pref):
    return {
        1: "par ordre de lecture",
        2: "par ordre inverse de lecture",
        3: "par volume croissant",
        4: "par volume décroissant",
        5: "aléatoire",
    }.get(pref, "Non défini")

def peak_position_to_string(pos):
    return {
        '1': "à 1/4 du temps",
        '2': "à 1/2 du temps",
        '3': "à 3/4 du temps",
    }.get(pos, "Non défini")

def print_menu():
    # Notez que vous devez avoir déclaré les variables globales
    # si vous accédez à leur valeur depuis cette fonction.
    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")
```

Dans ce menu, les appels `sorting_preference_to_string` et `peak_position_to_string` transforment les valeurs numériques des préférences en des descriptions textuelles compréhensibles par l'utilisateur.

Maintenant, quand vous appelez `print_menu()` dans la fonction `main`, le menu affichera simplement les valeurs actuelles des paramètres sans mettre de couleur. Voici à quoi pourrait ressembler un exemple dans la boucle principale :

```python
def main():
    # Initialisation et déclaration des valeurs par défaut pour les variables globales...
    # Votre code...

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        
        # Gérez les choix de l'utilisateur ici...
        # Votre code...

        # Affichez à nouveau le menu à la fin de chaque itération de la boucle while
        # Votre code...

    # Votre code...

# Votre code...
```

En appelant `print_menu()` dans la boucle `while`, vous affichez les options actuelles à l'utilisateur après chaque action, lui permettant de modifier les paramètres à nouveau ou d'extraire les segments avec les configurations actuelles.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l’ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l’emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l’extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et 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])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes
    
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = True
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = 10       # Valeur par défaut, par exemple 10
    num_moments = 5         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 1  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()























Traceback (most recent call last):
  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 387, in <module>
    main()
  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 344, in main
    print_menu()
  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 24, in print_menu
    print(f"5. Changer l’ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
NameError: name 'sorting_preference_to_string' is not defined

The error `NameError: name 'sorting_preference_to_string' is not defined` indicates that you're calling a function named `sorting_preference_to_string` that hasn't been defined in your code. This function seems to be intended to convert the numerical sorting preference to a string representation for display purposes in the menu.

To fix this error, you need to define `sorting_preference_to_string` and `peak_position_to_string` functions before they are used in `print_menu`. Below are the basic implementations for these functions:

```python
def sorting_preference_to_string(pref):
    sorting_options = {
        1: "Par ordre de lecture de la vidéo",
        2: "Par ordre inverse de lecture de la vidéo",
        3: "Par volume croissant",
        4: "Par volume décroissant",
        5: "Aléatoire"
    }
    return sorting_options.get(pref, "Non défini")

def peak_position_to_string(pos):
    peak_options = {
        '1': "À 1/4 du temps de lecture de la vidéo",
        '2': "À 1/2 du temps de lecture de la vidéo",
        '3': "À 3/4 du temps de lecture de la vidéo"
    }
    return peak_options.get(pos, "Non défini")
```

Make sure to define these functions before the `print_menu` function in your script. The updated `print_menu` function would then correctly use these helper functions to convert the preference values into strings:

```python
def print_menu():
    # Your other global variables...
    print("\nMenu des options :")
    # Your other menu print statements...
    print(f"5. Changer l’ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l’emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    # Rest of the menu...
```

With these changes, the `print_menu` function should work without any errors when called within the `main` function.

Menu des options :
1. Traiter les sous-dossiers ou non (actuel: False)
2. Effectuer un retrait temporel (début: 0s, fin: 0s)
3. Changer la durée des segments (actuel: 5.0s)
4. Changer le nombre de segments à extraire (actuel: 5)
5. Changer l'ordre de tri (actuel: Par volume décroissant)
6. Changer l'emplacement du pic sonore (actuel: À 1/2 du temps de lecture de la vidéo)
7. Relancer l'extraction
8. Quitter
Veuillez entrer le numéro de votre choix : 7
Traceback (most recent call last):
  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 405, in <module>
    main()
  File "H:\Tests\Final\Script extraction moments forts - Menu.py", line 393, in main
    extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
NameError: name 'video_path' is not defined

The `NameError: name 'video_path' is not defined` error is occurring because when the menu option '7' is selected to relaunch extraction, the `video_path` variable has not been defined in the scope of that call. It looks like there is a confusion between the flow of `perform_extraction` and `extract_segments`.

Let's correct this mistake by replacing the direct call to `extract_segments` under option '7' with a call to `perform_extraction`, which handles the entire extraction process including iterating through each `video_path` and calling `extract_segments` for each one. Here's how you can update the `main` function to fix the error:

```python
def main():
    # Your global variables definition and initial setup...

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Retrieve new offset values...
            # ...

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            perform_extraction(video_durations)  # Call perform_extraction instead of extract_segments
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")

    # Make sure processed_videos is defined at the right scope to print at the end
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()
```

With this change, when the user selects option '7', `perform_extraction` will be executed. This function should loop through `video_durations`, process each video file, and manage the extraction using `find_loudest_moments`, `sort_moments`, and `extract_segments` for each file accordingly.

Also, make sure that `processed_videos` is initialized at the beginning of `main` (or at the global scope) and properly incremented within `perform_extraction` to reflect the number of processed videos.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def sorting_preference_to_string(pref):
    sorting_options = {
        1: "Par ordre de lecture de la vidéo",
        2: "Par ordre inverse de lecture de la vidéo",
        3: "Par volume croissant",
        4: "Par volume décroissant",
        5: "Aléatoire"
    }
    return sorting_options.get(pref, "Non défini")

def peak_position_to_string(pos):
    peak_options = {
        '1': "À 1/4 du temps de lecture de la vidéo",
        '2': "À 1/2 du temps de lecture de la vidéo",
        '3': "À 3/4 du temps de lecture de la vidéo"
    }
    return peak_options.get(pos, "Non défini")

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s)")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et 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])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes
    
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = 10       # Valeur par défaut, par exemple 10
    num_moments = 20         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 4  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu()
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            perform_extraction(video_durations)  # Call perform_extraction instead of extract_segments
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()

Your revised `main` function looks correct, and it should fix the earlier error. You are now properly calling `perform_extraction` with the `video_durations` variable when option '7' is chosen. This function is expected to handle the extraction process for all videos found according to the user's settings.

As is, your script should work as intended, provided that all functions are implemented correctly and work together as expected.

Please ensure the following:

1. All functions are defined properly and do what they are supposed to do.
2. All global variables used in functions are declared as global within those functions if they are meant to be modified.
3. The error handling in your subprocess call and file operations is robust to avoid program crashes due to unexpected issues.
4. The user input validation is thorough to ensure the program doesn't crash because of unexpected input.

It's always a good idea to test each function individually to make sure it behaves as expected before integrating it into the main program flow.

With the `main` function now correctly calling `perform_extraction`, the overall flow of your program should allow users to configure extraction parameters, run the extraction process, and then either modify the configuration further or exit the program, as per your requirement.

Il y a un problème : dans le menu, max_segments n'est pas calculé en fonction de la vidéo en cours de traitement.

En effet, tel que le code est actuellement structuré, le `max_segments` affiché dans le menu est calculé une seule fois en utilisant la durée vidéo minimale trouvée au démarrage du script et n'est pas remis à jour si la durée des vidéos ou d'autres paramètres changent.

Si vous souhaitez que `max_segments` reflète dynamiquement la durée maximale des segments extractibles pour la vidéo en cours de traitement, vous devez recalculer `max_segments` à chaque fois que les paramètres relatifs sont modifiés (durée des segments, offsets temporels) ou chaque fois que l'utilisateur revient au menu.

Voici comment vous pourriez recalculer `max_segments` en fonction de la vidéo avec la durée la plus courte pour laquelle vous extrayez des segments :

```python
def calculate_max_segments(video_durations, segment_duration, starting_offset, ending_offset):
    min_duration = min(video_durations.values())
    allowable_duration = min_duration - (starting_offset + ending_offset)
    if allowable_duration > 0:
        return int(allowable_duration // segment_duration)
    else:
        return 0

def print_menu(video_durations):
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position
    
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s, max segments extractibles: {str(max_segments)})")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction (pour vidéo la plus courte)")
    print(f"8. Quitter")

# Ajoutez video_durations comme argument lors de l'appel à print_menu dans main
def main():
    # Votre code ici...
    while True:
        print_menu(video_durations)
        # Votre code ici...
```

Quand vous appelez `print_menu` dans `main`, n'oubliez pas de transmettre `video_durations` comme argument pour que `max_segments` soit recalculé à chaque fois que le menu est affiché. Assurez-vous de mettre à jour les appels à `print_menu` dans le reste du script en conséquence.

Cette modification permettra d'afficher dans le menu le nombre de segments réellement extractibles en fonction de la vidéo actuelle, et mettra à jour cette valeur chaque fois que les paramètres concernés changent ou que l'utilisateur revient au menu.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def sorting_preference_to_string(pref):
    sorting_options = {
        1: "Par ordre de lecture de la vidéo",
        2: "Par ordre inverse de lecture de la vidéo",
        3: "Par volume croissant",
        4: "Par volume décroissant",
        5: "Aléatoire"
    }
    return sorting_options.get(pref, "Non défini")

def peak_position_to_string(pos):
    peak_options = {
        '1': "À 1/4 du temps de lecture de la vidéo",
        '2': "À 1/2 du temps de lecture de la vidéo",
        '3': "À 3/4 du temps de lecture de la vidéo"
    }
    return peak_options.get(pos, "Non défini")

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s | max segments extractibles: {str(max_segments)})")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et 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 calculate_max_segments(video_durations, segment_duration, starting_offset, ending_offset):
    min_duration = min(video_durations.values())
    allowable_duration = min_duration - (starting_offset + ending_offset)
    if allowable_duration > 0:
        return int(allowable_duration // segment_duration)
    else:
        return 0

def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset):
    rate, audio_data = wavfile.read(audio_filename)

    # Convert stereo to mono if necessary
    if audio_data.ndim == 2:
        audio_data = np.mean(audio_data, axis=1)

    volume_dB = calculate_loudness(audio_data)
    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)

    moments = []
    volumes = []

    while len(moments) < num_moments and (end_index - start_index) > 0:
        index = np.argmax(volume_dB[start_index:end_index])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes
    
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)
    num_moments = 20         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 4  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu(video_durations)
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            perform_extraction(video_durations)  # Call perform_extraction instead of extract_segments
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()

From the script provided, it looks like you have addressed the issue mentioned about `max_segments` needing to be recalculated based on the current video file. The `calculate_max_segments` function provides the logic needed to determine the allowable number of segments for the shortest video file. This function is called in your `main` function to set the initial value for `max_segments`. 

However, the function `print_menu` is not updated yet to receive the `video_durations` parameter and to calculate `max_segments`. Here's the adjustment you need to make to `print_menu` and its call in the `main` function:

```python
# ...

def print_menu(video_durations):
    # Same global variables declaration
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)
    
    # Print statements with updated `max_segments`
    print("\nMenu des options :")
    # ... (other options)
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s | max segments extractibles: {str(max_segments)})")
    # ... (other options)
    
# ...

def main():
    # ... (same initial setup for global variables and loading video durations)
    
    while True:
        print_menu(video_durations)  # Provide `video_durations` as an argument
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        # ... (handle choices including recalculating `max_segments` if needed)

        # ... (code for other choices and the end of the while loop)
        
# ... (rest of the script remains unchanged)

if __name__ == "__main__":
    main()
```

Remember to update any other place in your code where `print_menu` is called to pass the `video_durations` parameter.

With these changes, every time you call `print_menu`, the `max_segments` value will be dynamically calculated based on the shortest video duration from `video_durations`, reflecting the most up-to-date number of extractable segments based on the configured segment duration and offsets.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def sorting_preference_to_string(pref):
    sorting_options = {
        1: "Par ordre de lecture de la vidéo",
        2: "Par ordre inverse de lecture de la vidéo",
        3: "Par volume croissant",
        4: "Par volume décroissant",
        5: "Aléatoire"
    }
    return sorting_options.get(pref, "Non défini")

def peak_position_to_string(pos):
    peak_options = {
        '1': "À 1/4 du temps de lecture de la vidéo",
        '2': "À 1/2 du temps de lecture de la vidéo",
        '3': "À 3/4 du temps de lecture de la vidéo"
    }
    return peak_options.get(pos, "Non défini")

def print_menu():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s | max segments extractibles: {str(max_segments)})")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et 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 calculate_max_segments(video_durations, segment_duration, starting_offset, ending_offset):
    min_duration = min(video_durations.values())
    allowable_duration = min_duration - (starting_offset + ending_offset)
    if allowable_duration > 0:
        return int(allowable_duration // segment_duration)
    else:
        return 0

def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset):
    rate, audio_data = wavfile.read(audio_filename)

    # Convert stereo to mono if necessary
    if audio_data.ndim == 2:
        audio_data = np.mean(audio_data, axis=1)

    volume_dB = calculate_loudness(audio_data)
    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)

    moments = []
    volumes = []

    while len(moments) < num_moments and (end_index - start_index) > 0:
        index = np.argmax(volume_dB[start_index:end_index])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes
    
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)
    num_moments = 20         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 4  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu(video_durations)
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            perform_extraction(video_durations)  # Call perform_extraction instead of extract_segments
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()

You've made a good attempt at integrating `max_segments` calculation into your script. However, there's currently an issue because you're calling `calculate_max_segments` from `print_menu` before the function is defined. To fix this issue, you need to reorder the functions and call `print_menu` with the correct arguments. Here's the updated code:

```python
# ...

def calculate_max_segments(video_durations, segment_duration, starting_offset, ending_offset):
    min_duration = min(video_durations.values())
    allowable_duration = min_duration - (starting_offset + ending_offset)
    if allowable_duration > 0:
        return int(allowable_duration // segment_duration)
    else:
        return 0

# Make sure to pass video_durations to print_menu
def print_menu(video_durations):
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)
    # ...
    
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, video_durations

    # Default initializations
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0
    num_moments = 20
    sorting_preference = 4
    peak_position = '2'
    processed_videos = 0

    video_durations = get_video_durations(include_subfolders)
    # ...

    while True:
        print_menu(video_durations)
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        # ...

if __name__ == "__main__":
    main()
```

Here's a list of changes made:

- `video_durations` is now defined before `calculate_max_segments` and `print_menu` so it's available at the start of the `main` function.
- Updated the `print_menu` function to accept `video_durations` as an argument and use it to calculate `max_segments`.
- Made sure to call `print_menu(video_durations)` in the `main` function, providing the current `video_durations`.

Now, whenever `print_menu` is called within the `main` loop, it will use the most up-to-date `video_durations` to calculate `max_segments`, ensuring that it reflects the number of possible segments for the currently selected video configurations.

Please make sure the entire script follows the same pattern of function definitions and calling sequence to maintain consistency and prevent any scope-related issues.

import os
import subprocess
import numpy as np
import uuid  # Import uuid to generate unique IDs
from moviepy.editor import VideoFileClip
from scipy.io import wavfile
import random

temporary_audio_files = []

# Define video file extensions and the output folder
video_extensions = ['.mp4', '.mkv', '.wmv', '.avi']
output_folder = 'Output'

def sorting_preference_to_string(pref):
    sorting_options = {
        1: "Par ordre de lecture de la vidéo",
        2: "Par ordre inverse de lecture de la vidéo",
        3: "Par volume croissant",
        4: "Par volume décroissant",
        5: "Aléatoire"
    }
    return sorting_options.get(pref, "Non défini")

def peak_position_to_string(pos):
    peak_options = {
        '1': "À 1/4 du temps de lecture de la vidéo",
        '2': "À 1/2 du temps de lecture de la vidéo",
        '3': "À 3/4 du temps de lecture de la vidéo"
    }
    return peak_options.get(pos, "Non défini")

def print_menu(video_durations):
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)

    print("\nMenu des options :")
    print(f"1. Traiter les sous-dossiers ou non (actuel: {str(include_subfolders)})")
    print(f"2. Effectuer un retrait temporel (début: {str(starting_offset_seconds)}s, fin: {str(ending_offset_seconds)}s)")
    print(f"3. Changer la durée des segments (actuel: {str(segment_duration)}s | max segments extractibles: {str(max_segments)})")
    print(f"4. Changer le nombre de segments à extraire (actuel: {str(num_moments)})")
    print(f"5. Changer l'ordre de tri (actuel: {sorting_preference_to_string(sorting_preference)})")
    print(f"6. Changer l'emplacement du pic sonore (actuel: {peak_position_to_string(peak_position)})")
    print(f"7. Relancer l'extraction")
    print(f"8. Quitter")


def ask_for_number_of_moments(max_segments):
    while True:
        num_input = input(f"Veuillez entrer le nombre de moments forts à extraire (maximum {max_segments}): ")
        try:
            num = int(num_input)
            if num > 0 and num <= max_segments:
                return num
            else:
                print(f"Le nombre doit être supérieur à 0 et inférieur ou égal à {max_segments}. Veuillez réessayer.")
        except ValueError:
            print("Entrée non valide, veuillez réessayer avec un nombre entier.")

def ask_yes_no_question(question):
    answer = None
    while answer not in ('1', '2'):
        print(question)
        print("1- Oui")
        print("2- Non")
        answer = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if answer not in ('1', '2'):
            print("Entrée non valide, veuillez réessayer.")
    return answer == '1'
    
def ask_offset_type():
    print("Souhaitez-vous un décalage temporel relatif ou absolu ?")
    print("1- Relatif (pourcentage)")
    print("2- Absolu (secondes)")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1 ou 2) : ").strip()
        if choice in ('1', '2'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
            
def get_offset_value(video_duration, offset_type):
    if offset_type == '1':  # Relative offset
        while True:
            percent = input("Entrez le pourcentage du temps vidéo à ignorer : ")
            try:
                percent_value = float(percent)
                return percent_value * video_duration / 100
            except ValueError:
                print("Veuillez entrer un nombre valide.")
    else:  # Absolute offset
        while True:
            seconds = input("Entrez le nombre de secondes à ignorer : ")
            try:
                return float(seconds)
            except ValueError:
                print("Veuillez entrer un nombre valide.")
                
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                # Calculez le nombre maximal de segments pour une vidéo
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et 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 calculate_max_segments(video_durations, segment_duration, starting_offset, ending_offset):
    min_duration = min(video_durations.values())
    allowable_duration = min_duration - (starting_offset + ending_offset)
    if allowable_duration > 0:
        return int(allowable_duration // segment_duration)
    else:
        return 0

def find_loudest_moments(audio_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset):
    rate, audio_data = wavfile.read(audio_filename)

    # Convert stereo to mono if necessary
    if audio_data.ndim == 2:
        audio_data = np.mean(audio_data, axis=1)

    volume_dB = calculate_loudness(audio_data)
    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)

    moments = []
    volumes = []

    while len(moments) < num_moments and (end_index - start_index) > 0:
        index = np.argmax(volume_dB[start_index:end_index])
        print(f"Current index: {index}, start_index: {start_index}, end_index: {end_index}")  # Ajouté pour le débogage
        moment = (start_index + index) / rate
        print(f"Added moment at {moment} seconds")  # Ajouté pour le débogage
        moment_volume = volume_dB[start_index + index]

        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume_dB[start_index + index] = -np.inf
            continue

        moments.append(moment)
        print(f"Added moment at {moment} seconds") # Ajouté pour le débogage
        volumes.append(moment_volume)

        # Clear the volume around the found moment to prevent picking up nearby moments
        # Increment the global index by adding the start_index
        global_index = start_index + index

        # Clear the volume around the found moment to prevent picking up nearby moments
        clear_range_start = max(0, global_index - int(rate * segment_half_duration))
        clear_range_end = min(len(volume_dB), global_index + int(rate * segment_half_duration))

        # Debug print statements to check if the index and the volume are cleared
        print(f"Clearing from {clear_range_start} to {clear_range_end}")
        print(f"Volume before clearing at index {global_index}: {volume_dB[global_index]}")
        
        volume_dB[clear_range_start:clear_range_end] = -np.inf
        
        print(f"Volume after clearing at index {global_index}: {volume_dB[global_index]}")

    return moments, volumes
    
def perform_extraction(video_durations):
    global starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    for video_path, duration in video_durations.items():
        available_duration = duration - (starting_offset_seconds + ending_offset_seconds)

        if available_duration <= segment_duration:
            print(f"La vidéo {video_path} est trop courte après les décalages. Ignorer.")
            continue

        if sorting_preference == 5:  # Aléatoire
            all_possible_moments = np.arange(starting_offset_seconds, duration - ending_offset_seconds - segment_duration, segment_duration) + (segment_duration / 2)
            np.random.shuffle(all_possible_moments)
            selected_moments = all_possible_moments[:num_moments]
            volumes = [0] * len(selected_moments)  # Les volumes sont justes pour la compatibilité avec extract_segments.
        else:
            audio_path = f'temp_audio_{uuid.uuid4().hex}.wav'
            try:
                with VideoFileClip(video_path) as video_clip:
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
    
                    moments, volumes = find_loudest_moments(audio_path, num_moments, segment_duration, duration, starting_offset_seconds, ending_offset_seconds)
                    sorted_moments, sorted_volumes = sort_moments(moments, volumes, sorting_preference)
                    selected_moments = sorted_moments
                    volumes = sorted_volumes

            finally:
                if os.path.exists(audio_path):
                    os.remove(audio_path)

        extract_segments(video_path, selected_moments, segment_duration, duration, peak_position)
        processed_videos += 1

        print(f"Extraction terminée pour la vidéo '{video_path}'")

    print(f"L'extraction de toutes les vidéos est terminée. Nombre de vidéos traitées : {processed_videos}.")

def extract_segments(video_path, moments, segment_duration, video_duration, peak_position):
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    half_segment_duration = segment_duration / 2
    
    for i, moment in enumerate(moments):
        if peak_position == '1':  # 1/4
            start_time = max(moment - segment_duration * 0.25, 0)
        elif peak_position == '2':  # 1/2
            start_time = max(moment - segment_duration * 0.5, 0)
        elif peak_position == '3':  # 3/4
            start_time = max(moment - segment_duration * 0.75, 0)
        end_time = min(start_time + segment_duration, video_duration)

        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)

        command = [
            "ffmpeg",
            "-y",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # Output path
        ]

        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
            print(f"Extracted and re-encoded {output_filename}")
        except subprocess.CalledProcessError as e:
            # Catch the exception for this process, print an error message,
            # but don't break from the for loop.
            err_msg = e.stderr.decode('utf-8') if e.stderr else 'Unknown error'
            print(f"Failed to extract segment from {video_path}: {err_msg}")
        
def store_segment_info(video_path, moment, volume, order):
    base_name = os.path.splitext(os.path.basename(video_path))[0]
    output_filename = f"{base_name}_moment{order}.mp4"
    output_path = os.path.join(output_folder, output_filename)
    extracted_segments.append({
        'path': output_path,
        'timestamp': moment,
        'volume': volume
    })
        
def ask_sorting_preference():
    print("Comment souhaitez-vous trier les vidéos extraites ?")
    print("1- Par ordre de lecture de la vidéo")
    print("2- Par ordre inverse de lecture de la vidéo")
    print("3- Par volume croissant")
    print("4- Par volume décroissant")
    print("5- Aléatoire")
    choice = int(input("Veuillez entrer le numéro de votre choix : "))
    return choice
    
def sort_moments(moments, volumes, choice):
    if choice == 1:  # Par ordre de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0])
    elif choice == 2:  # Par ordre inverse de lecture de la vidéo
        zipped = sorted(zip(moments, volumes), key=lambda x: x[0], reverse=True)
    elif choice == 3:  # Par volume croissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1])
    elif choice == 4:  # Par volume décroissant
        zipped = sorted(zip(moments, volumes), key=lambda x: x[1], reverse=True)
    elif choice == 5:  # Pas de tri, sélection aléatoire
        zipped = list(zip(moments, volumes))
        random.shuffle(zipped)
    else:
        zipped = zip(moments, volumes)

    # Unzip the list of tuples to two lists
    sorted_moments, sorted_volumes = zip(*zipped) if zipped else ([], [])
    return list(sorted_moments), list(sorted_volumes)

def get_video_durations(include_subfolders):
    video_durations = {}
    for root, dirs, files in os.walk('.', topdown=True):
        # Si l'utilisateur ne souhaite pas inclure les sous-dossiers, nous modifions dirs sur place
        if not include_subfolders:
            dirs[:] = []  # Cela empêchera os.walk de descendre dans tous les sous-dossiers
        # La suite du traitement des fichiers reste inchangée
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                try:
                    # Essayez d'ouvrir et d'extraire les métadonnées du fichier vidéo.
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_durations[video_path] = video_duration
                except Exception as e:
                    # Si une erreur survient, affichez un message et ignorez le fichier vidéo.
                    print(f"Error processing video {video_path}: {e}")
                finally:
                    # Assurez-vous de fermer le clip pour libérer les ressources.
                    video_clip.close()
    return video_durations
    
def confirm_segment_number_or_ask_again(video_duration, starting_offset_seconds, ending_offset_seconds):
    allowable_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
    while True:
        segment_duration, max_segments = ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
        print(f"Avec cette durée, vous pouvez extraire jusqu'à {max_segments} segments.")
        confirmation = ask_yes_no_question("Voulez-vous continuer avec ce nombre de segments ?")
        if confirmation:
            return segment_duration, max_segments
            
def ask_peak_position():
    print("Où doit être situé le pic sonore dans la vidéo extraite ?")
    print("1- A 1/4 du temps de lecture de la vidéo")
    print("2- A 1/2 du temps de lecture de la vidéo")
    print("3- A 3/4 du temps de lecture de la vidéo")
    while True:
        choice = input("Veuillez entrer le numéro de votre choix (1, 2, ou 3) : ").strip()
        if choice in ('1', '2', '3'):
            return choice
        else:
            print("Entrée non valide, veuillez réessayer.")
         
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos, video_durations

    # Initialisation des variables avec des valeurs par défaut
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Valeur par défaut, par exemple 5 secondes
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)
    num_moments = 20         # Valeur par défaut, par exemple 5 moments
    sorting_preference = 4  # Valeur par défaut, par exemple tri par ordre de lecture de la vidéo
    peak_position = '2'     # Valeur par défaut, par exemple à 1/2 du temps de lecture de la vidéo
    processed_videos = 0
    
    # Chargement des durées des vidéos au démarrage du script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    while True:
        print_menu(video_durations)
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()
        if choice == '1':
            include_subfolders = ask_directory_preference()
            video_durations = get_video_durations(include_subfolders)

        elif choice == '2':
            # Récupérez les nouvelles valeurs.
            offset_type = ask_offset_type()
            # Utilisez une valeur minimale mise à jour si nécessaire.
            min_duration = min(video_durations.values())
            print("Configuration du retrait temporel pour le début de la vidéo:")
            starting_offset_seconds = get_offset_value(min_duration, offset_type)
            print("Configuration du retrait temporel pour la fin de la vidéo:")
            ending_offset_seconds = get_offset_value(min_duration, offset_type)

        elif choice == '3':
            segment_duration, max_segments = confirm_segment_number_or_ask_again(min(video_durations.values()), starting_offset_seconds, ending_offset_seconds)
        
        elif choice == '4':
            num_moments = ask_for_number_of_moments(max_segments)
        
        elif choice == '5':
            sorting_preference = ask_sorting_preference()
        
        elif choice == '6':
            peak_position = ask_peak_position()
        
        elif choice == '7':
            # Exécutez vos sous-fonctions pour effectuer l'extraction des segments.
            # Vous souhaiterez probablement encapsuler cela dans une autre fonction.
            perform_extraction(video_durations)  # Call perform_extraction instead of extract_segments
        
        elif choice == '8':
            print("Fin du programme.")
            break
        
        else:
            print("Choix non valide. Veuillez réessayer.")
        
    print(f"Le traitement de toutes les vidéos est terminé. {processed_videos} vidéos ont été traitées.")

if __name__ == "__main__":
    main()

Your code structure looks good and you've made the necessary changes to the `print_menu` function to display `max_segments` correctly. However, it looks like you're still referencing `video_durations` before it's declared in the `main` function. Here's the corrected snippet where `video_durations` is initialized before it's used to set `max_segments` in `main()`:

```python
def main():
    global include_subfolders, starting_offset_seconds, ending_offset_seconds
    global segment_duration, num_moments, sorting_preference, peak_position, processed_videos

    # Initialize the variables with default values
    include_subfolders = False
    starting_offset_seconds = 0
    ending_offset_seconds = 0
    segment_duration = 5.0  # Default value, e.g., 5 seconds
    num_moments = 20        # Default value, e.g., 20 moments
    sorting_preference = 4  # Default value, e.g., sorting by descending volume
    peak_position = '2'     # Default value, e.g., peak at the middle of the segment
    processed_videos = 0
    
    # Load video durations at the start of the script
    video_durations = get_video_durations(include_subfolders)
    if not video_durations:
        print("Aucune vidéo trouvée pour l'analyse.")
        exit()

    # Calculate max_segments with the newly obtained video_durations
    max_segments = calculate_max_segments(video_durations, segment_duration, starting_offset_seconds, ending_offset_seconds)

    while True:
        print_menu(video_durations)  # Pass video_durations to print_menu
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        # Handle user choices
        if choice == '1':
            # ...
```

Remember to adjust the `print_menu` function to receive `video_durations` as an argument too:

```python
def print_menu(video_durations):
    # ... your existing code ...
```

Now, `max_segments` will be correctly calculated with the current `video_durations` every time the menu is displayed, and `video_durations` is initialized before its first use.

The rest of your script's logic for processing user input and initiating the extraction process based on the options chosen in the menu appears intact and should work as you have designed it. Remember to test your script thoroughly to catch any other issues that might not be immediately apparent from code review alone.

Pourrait-on faire en sorte que lorsque le menu a chargé (uniquement après un changement de duréeà, le nombre de segments à extraire corresponde au nombre de segments max ?

Oui, nous pouvons certainement modifier le script pour que chaque fois que la durée du segment est changée dans le menu, le nombre de moments (segments à extraire) soit automatiquement mis à jour pour correspondre au nombre maximum de segments extractibles basé sur la nouvelle configuration de durée.

Pour réaliser cela, nous pouvons faire en sorte que la fonction `ask_for_segment_duration` retourne non seulement la nouvelle durée du segment, mais aussi le nombre maximal de segments calculé pour cette durée. Ensuite, dans la boucle principale du menu, lorsque l'utilisateur choisit de modifier la durée des segments, le nombre de moments sera ajusté en conséquence.

Voici comment vous pouvez y parvenir :

```python
def ask_for_segment_duration(allowable_duration, video_duration, starting_offset_seconds, ending_offset_seconds):
    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:
                available_duration = video_duration - (starting_offset_seconds + ending_offset_seconds)
                max_segments = int(available_duration // segment_duration)
                return segment_duration, max_segments
            else:
                print(f"La durée doit être un nombre positif et inférieure ou égale à {allowable_duration} secondes.")
        except ValueError:
            print("Veuillez entrer un nombre valide.")

def main():
    # ... le reste de votre code restant inchangé.

    while True:
        print_menu(video_durations)  # Pass video_durations to print_menu
        choice = input("Veuillez entrer le numéro de votre choix : ").strip()

        # Handle user choices
        if choice == '1':
            # ...
        elif choice == '3':
            segment_duration, max_segments = ask_for_segment_duration(
                min(video_durations.values()), 
                starting_offset_seconds, 
                ending_offset_seconds
            )
            num_moments = max_segments  # Mettez à jour le nombre de moments pour correspondre au nombre maximal de segments
        
        # ... le reste du code du menu.
        
        # Si l'utilisateur choisit une autre option, n'oubliez pas de recalculer max_segments
        # ajouter des logiques ici si nécessaire.

# ... le reste de votre code restant inchangé.

if __name__ == "__main__":
    main()
```

Dans cet exemple, lorsque l'utilisateur sélectionne l'option pour changer la durée des segments (choix '3'), `ask_for_segment_duration` est appellée et retourne à la fois la nouvelle durée de segment et le maximum de segments extractibles. Le nombre de moments à extraire (`num_moments`) est alors mis à jour pour correspondre à ce nombre maximal après chaque modification de la durée des segments.

**Notez bien :** Il est également important de mettre à jour la variable `segment_duration` globale depuis le résultat de `ask_for_segment_duration`.
Assurez-vous que toutes les instances qui utilisent `segment_duration` et `num_moments` tiennent compte de ces changements pour le reste du script, y compris les fonctions et les appels de fonction.