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

Je vais te donner un script. Je te donnerai ensuite l'erreur qu'il génère et tu…

  1. User

    Je vais te donner un script. Je te donnerai ensuite l'erreur qu'il génère et tu corrigeras.

  2. Assistant

    Bien sûr, je suis là pour t'aider. Veuillez s'il vous plaît fournir le script et l'erreur associée que vous avez rencontrée, et je ferai de mon mieux pour vous proposer une correction.

  3. User

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    # Combine segment start times with their corresponding loudness
    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(len(segment_loudness))
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # Sort the loudness and segments based on loudness
    loudness_and_segments.sort(key=lambda x: x[0], reverse=True)
    
    # Return the top num_segments segments sorted by loudness
    return loudness_and_segments[:num_segments]
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Dans l’ordre d’apparition named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True) return named_segments

    # Renumbering the segments after sorting
    named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extrait chaque segment en fonction de la préférence de l'utilisateur
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    
  4. Assistant

    Pour corriger le script, commencez par me fournir l'erreur qu'il génère lorsque vous l’exécutez. Cela me permettra d'identifier où se trouve le problème et de fournir les modifications nécessaires pour le résoudre.

  5. User

    Traceback (most recent call last): File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 204, in process_video_file(video_path, starting_offset, ending_offset) File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 150, in process_video_file segment_loudness, segment_start_time = segment_info[1:] ValueError: not enough values to unpack (expected 2, got 1)

  6. Assistant

    Le message d'erreur ValueError: not enough values to unpack (expected 2, got 1) indique que lorsque vous essayez de déballer segment_info[1:] en segment_loudness et segment_start_time, il n'y a pas assez de valeurs dans la liste pour les deux variables. Le segment_info attendu doit être un tuple ou une liste avec au moins deux éléments après le premier indice.

    Pour corriger cela, regardons la fonction sort_and_name_segments où segment_info est censé être construit. À première vue, il semble que le bloc suivant ne devrait pas être indenté dans la fonction sort_and_name_segments :

    # Renumbering the segments after sorting
    named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
    return named_segments
    

    Ce bloc de code est mal indenté et devrait être en dehors de la portée de la condition if-elif. Le return named_segments devrait être à la fin de la fonction après que toutes les conditions ont été vérifiées. Voici comment cela devrait être corrigé :

    def sort_and_name_segments(segments_with_loudness, preference):
        # Tri basé sur la préférence
        if preference == 1:  # Dans l’ordre d’apparition
            named_segments = segments_with_loudness
        elif preference == 2:  # Dans l’ordre inverse
            named_segments = list(reversed(segments_with_loudness))
        elif preference == 3:  # Par loudness croissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0])
        elif preference == 4:  # Par loudness décroissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
    
        # Renumbering the segments after sorting
        named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
        return named_segments
    

    Avec cette modification, chaque élément de named_segments devrait maintenant être un tuple contenant un index suivie par les données de segment originales qui devraient avoir au moins deux valeurs, permettant ainsi le déballage attendu dans process_video_file :

    segment_loudness, segment_start_time = segment_info[1:]
    

    S'il vous plaît faites ces modifications dans votre script et réessayez d'exécuter le code.

  7. User

    Comme ça ?

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    # Combine segment start times with their corresponding loudness
    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(len(segment_loudness))
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # Sort the loudness and segments based on loudness
    loudness_and_segments.sort(key=lambda x: x[0], reverse=True)
    
    # Return the top num_segments segments sorted by loudness
    return loudness_and_segments[:num_segments]
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Dans l’ordre d’apparition named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True) return named_segments

    # Renumbering the segments after sorting
    named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extrait chaque segment en fonction de la préférence de l'utilisateur
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    
  8. Assistant

    Non, la correction n'est pas encore correcte. En réalité, la modification que je vous ai suggérée précédemment doit être faite différemment. Votre bloc actuel de sort_and_name_segments a deux return consécutifs dans la même portée, ce qui n'est pas correct.

    Pour résoudre le problème, le bloc de renumérotation named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)] doit être déplacé en dehors du bloc if-elif, et aligné avec la première condition. Il ne devrait y avoir qu'un seul return à la fin de la fonction sort_and_name_segments.

    Voici la fonction corrigée :

    def sort_and_name_segments(segments_with_loudness, preference):
        # Tri basé sur la préférence
        if preference == 1:  # Dans l’ordre d’apparition
            named_segments = segments_with_loudness
        elif preference == 2:  # Dans l’ordre inverse
            named_segments = list(reversed(segments_with_loudness))
        elif preference == 3:  # Par loudness croissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0])
        elif preference == 4:  # Par loudness décroissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
    
        # Renumbering the segments after sorting
        named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
        return named_segments
    

    Notez que j'ai retiré le seg[1:] pour *seg quand on refait la liste named_segments. Vous renommez déjà les segments par l'index, donc c'est inutile de reprendre les valeurs à partir du second élément.

    Avec cette correction en place, vous devriez pouvoir exécuter le script sans rencontrer la ValueError qui est survenue précédemment.

  9. User

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    # Combine segment start times with their corresponding loudness
    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(len(segment_loudness))
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # Sort the loudness and segments based on loudness
    loudness_and_segments.sort(key=lambda x: x[0], reverse=True)
    
    # Return the top num_segments segments sorted by loudness
    return loudness_and_segments[:num_segments]
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Dans l’ordre d’apparition named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    # Renumbering the segments after sorting
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extrait chaque segment en fonction de la préférence de l'utilisateur
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    

    L'analyse est-elle suffisante pour trier les fichiers extraits par loudness, et par ordre de lecture ?

  10. Assistant

    Votre fonction sort_and_name_segments trie et numérote bien les segments selon la préférence de loudness et l'ordre de lecture spécifié par l'utilisateur. Cependant, il y a encore une redondance dans votre code qui peut causer de la confusion, et peut-être des erreurs si des modifications futures sont apportées.

    Dans la fonction process_video_file, vous appelez find_loudest_segments et sort_and_name_segments deux fois avec les mêmes arguments sans raison apparente :

    # Premier appel (Redondant)
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    # Deuxième appel (Utilisé par la suite)
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    

    La première paire d'appels à find_loudest_segments et sort_and_name_segments est redondante et peut être supprimée. Les résultats ne sont pas utilisés et sont écrasés immédiatement par les appels suivants.

    Pour répondre à votre question, oui, votre code trie effectivement les fichiers extraits par loudness et par ordre de lecture comme indiqué dans la préférence de l'utilisateur, et numérote correctement ces segments. La variable index dans la boucle de l'extraction servira à nommer les fichiers avec un numéro de segment basé sur l'ordre des segments retournés, ce qui est l'effet désiré si les utilisateurs souhaitent trier les vidéos extraites par leur ordre d'apparition dans la liste triée.

    Pour l'efficacité du code et éviter toute confusion, veuillez supprimer la première paire d'appels redondants à find_loudest_segments et sort_and_name_segments dans la fonction process_video_file.

  11. User

    il faut supprimer les deux, ou justeun ?

  12. Assistant

    Il faut supprimer uniquement la première paire d'appels à find_loudest_segments et sort_and_name_segments. La deuxième paire est celle qui est effectivement utilisée pour le traitement ultérieur dans votre boucle for. Après suppression, la fonction process_video_file devrait ressembler à ceci :

    def process_video_file(video_path, starting_offset, ending_offset):
        # ... (le reste du code avant cette section est inchangé)
    
        # Génère un fichier audio temporaire
        video_clip.audio.write_audiofile(audio_filename)
        
        # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
        rate, audio_data = wavfile.read(audio_filename)
    
        # Extrait les segments les plus forts
        loudness_and_segments = find_loudest_segments(
            audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
        )
    
        # Trie et nomme les segments selon la préférence de l'utilisateur
        sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
    
        # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
        for segment_info in sorted_and_named_segments:
            index = segment_info[0]
            segment_loudness, segment_start_time = segment_info[1:]
            # ... (le reste du code pour l'extraction des segments)
    

    En faisant cela, votre script effectuera une seule fois le traitement pour trouver les segments les plus forts et les trier selon les préférences de l'utilisateur avant d'extraire les segments de vidéo. Cela optimisera l'exécution de votre script et rendra votre code plus lisible et maintenable.

  13. User

    La loudness global est bien déterminée à un moment ? Et ensuite trié de façon à pouvoir extraire les vidéos de façons croissante ou décroissante de cette loudness ?

  14. Assistant

    La loudness globale de chaque segment est calculée par la fonction calculate_loudness, qui est appelée pour chaque segment dans le cadre de la fonction find_loudest_segments. Pour chaque segment, cette fonction retourne un niveau de loudness selon la méthode spécifiée.

    Ensuite, la fonction find_loudest_segments combine ce niveau de loudness avec les temps de début des segments correspondants et retourne une liste de paires (loudness, start_time) pour un certain nombre de segments. Cette liste est triée par loudness de manière décroissante avant d'être retournée.

    Par la suite, dans la fonction process_video_file, après avoir obtenu la liste triée des segments (loudness, start_time) avec la fonction find_loudest_segments, on l'envoie à la fonction sort_and_name_segments, qui effectue le tri final selon la préférence de l'utilisateur. Les options permettent de garder l'ordre d'apparition, de l'inverser, ou de trier par loudness croissante ou décroissante.

    En résumé, les étapes suivantes sont réalisées pour déterminer et trier les segments par loudness globale :

    1. calculate_loudness est appelé sur chaque segment pour obtenir leur loudness individuelle.

    2. find_loudest_segments est utilisé pour obtenir une liste des segments les plus forts basée sur la loudness.

    3. sort_and_name_segments prend la liste de la loudness des segments et les trie en fonction des préférences de l'utilisateur :

      • Dans l’ordre d’apparition (preference == 1)
      • Dans l’ordre inverse (preference == 2)
      • Par loudness croissante (preference == 3)
      • Par loudness décroissante (preference == 4)

    Donc oui, la loudness globale est déterminée pour chaque segment, et les segments peuvent être triés et extraits en fonction de cette loudness.

    Veuillez noter que la fonction calculate_loudness telle qu'elle est écrite dans votre script initial semble ne pas suivre totalement la norme ITU-R BS.1770-4, qui est relativement complexe. Si une conformité stricte à cette norme est requise, la fonction nécessitera une implémentation plus détaillée.

  15. User

    Au niveau du tri : rien ne marche. L'ordre est toujours le même, je ne sais pas lequel

  16. Assistant

    Votre fonction sort_and_name_segments est censée trier les segments en fonction de la préférence utilisateur, mais il semble y avoir un problème avec la manière dont vous retournez les segments triés. La raison pour laquelle les segments ne sont pas correctement triés est probablement due à une logique incorrecte dans cette fonction.

    Laissez-moi vous montrer une version corrigée de la fonction sort_and_name_segments pour vous assurer que le tri se fasse correctement selon la préférence de l'utilisateur:

    def sort_and_name_segments(segments_with_loudness, preference):
        # Tri basé sur la préférence
        if preference == 1:  # Dans l’ordre d’apparition
            named_segments = sorted(segments_with_loudness, key=lambda x: x[1])  # Tri en fonction du temps de début
        elif preference == 2:  # Dans l’ordre inverse
            named_segments = sorted(segments_with_loudness, key=lambda x: x[1], reverse=True)  # Tri inverse en fonction du temps de début
        elif preference == 3:  # Par loudness croissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0])  # Déjà trié par loudness dans find_loudest_segments, donc inutile
        elif preference == 4:  # Par loudness décroissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)  # Déjà trié par loudness dans find_loudest_segments mais en mode décroissant
    
        # Renommage des segments après le tri avec des indices dans l'ordre
        named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
        return named_segments
    

    La principale modification ici est que pour les préférences 1 et 2, nous trions maintenant explicitement par le temps de début (second élément du tuple), car find_loudest_segments les avait déjà triés par loudness. Pour la préférence 3, les segments sont déjà dans l'ordre croissant de la loudness depuis leur sortie de find_loudest_segments, donc le tri n’est pas nécessaire une seconde fois. Pour la préférence 4, nous devons retourner la liste triée en ordre décroissant de loudness.

    Avec ces modifications, vous devriez maintenant voir un changement dans l'ordre des segments selon la préférence.

    Enfin, assurez-vous que lorsque vous appelez la fonction sort_and_name_segments dans process_video_file, vous utilisez les résultats triés pour le traitement suivant et supprimez tout appel inutile comme discuté précédemment. Cela devrait résoudre le problème de tri que vous rencontrez.

  17. User

    Voici le script complet : toujours pas de tri effectif.

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments with the highest loudness in the audio data.""" # Calculate the loudness of each segment in the audio file segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    # Combine segment start times with their corresponding loudness
    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(len(segment_loudness))
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # Sort the loudness and segments based on loudness
    loudness_and_segments.sort(key=lambda x: x[0], reverse=True)
    
    # Return the top num_segments segments sorted by loudness
    return loudness_and_segments[:num_segments]
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Dans l’ordre d’apparition named_segments = sorted(segments_with_loudness, key=lambda x: x[1]) # Tri en fonction du temps de début elif preference == 2: # Dans l’ordre inverse named_segments = sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) # Tri inverse en fonction du temps de début elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) # Déjà trié par loudness dans find_loudest_segments, donc inutile elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True) # Déjà trié par loudness dans find_loudest_segments mais en mode décroissant

    # Renommage des segments après le tri avec des indices dans l’ordre
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    
  18. Assistant

    Je vois ce qui se passe ici. Le tri par loudness est annulé parce que dans sort_and_name_segments, lorsque vous triez pour les préférences 1 et 2 (ordre d'apparition et inverse), vous utilisez le temps de début de chaque segment pour le tri et non pas la loudness.

    Cependant, après ce tri initial, dans sort_and_name_segments, vous renumérotez les segments avec (i+1, *seg) pour tous les cas de préférence, ce qui va attribuer un nouvel indice à chaque segment, rendant ainsi tout tri antérieur non effectif. La raison est que vous triez par ces nouveaux indices et non par la loudness ou par l'ordre d'apparition initial dans le fichier.

    Pour résoudre ce problème, je propose de simplifier et d’expliciter la logique de tri pour chaque préférence:

    def sort_and_name_segments(segments_with_loudness, preference):
        # Tri basé sur la préférence
        if preference == 1:
            # Aucun tri supplémentaire n’est nécessaire car les segments sont déjà dans l’ordre
            # d’apparition dans la liste loudness_and_segments retournée par find_loudest_segments.
            named_segments = segments_with_loudness
        elif preference == 2:
            # Inverse simplement la liste pour avoir l'ordre inverse d'apparition
            named_segments = list(reversed(segments_with_loudness))
        elif preference == 3:
            # Tri par loudness croissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0])
        elif preference == 4:
            # Tri par loudness décroissante (pas besoin de trier à nouveau car ils sont déjà dans cet ordre)
            named_segments = segments_with_loudness
    
        # Renumerotation des segments en préservant l'ordre spécifié par named_segments.
        named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
        return named_segments
    

    Remarque Importante: La fonction find_loudest_segments retourne déjà les segments triés par loudness décroissante. Donc pour la préférence 4, nous n'avons rien à faire, nous pouvons directement les renvoyer après les avoir renumérotés.

    De plus, il me semble que pour la préférence 1 ("Dans l'ordre d'apparition"), vos segments devraient déjà être triés dans cet ordre d'apparition, car la fonction find_loudest_segments crée la liste loudness_and_segments en utilisant une boucle qui itère séquentiellement sur les segments. Cette liste sera déjà dans l'ordre d'apparition avant qu'elle ne soit triée par loudness loudness_and_segments.sort(key=lambda x: x[0], reverse=True).

    Assurez-vous: que find_loudest_segments soit modifiée pour renvoyer tous les segments sans effectuer de tri préliminaire, ou que la logique dans sort_and_name_segments tienne compte de la façon dont find_loudest_segments a déjà trié la liste.

    Étape finale : vérifiez aussi que vous utilisez bien le résultat de sort_and_name_segments dans la boucle d'extraction des vidéos dans process_video_file. La liste sorted_and_named_segments doit être celle qui est utilisée, et toutes les manipulations ou tris supplémentaires après cette fonction doivent respecter l'ordre qu'elle a déterminé.

  19. User

    Comment m'assurer que find_loudest_segments soit modifiée pour renvoyer tous les segments sans effectuer de tri préliminaire, ou que la logique dans sort_and_name_segments tienne compte de la façon dont find_loudest_segments a déjà trié la liste ?

  20. Assistant

    Pour vous assurer que la fonction find_loudest_segments renvoie tous les segments sans effectuer de tri préliminaire par loudness, vous devriez:

    1. Supprimer le tri de find_loudest_segments
    2. Adapter la logique de sort_and_name_segments pour faire le tri selon le besoin.

    Voici les deux fonctions modifiées pour que find_loudest_segments retourne les segments dans l'ordre d'apparition sans tri, et pour que sort_and_name_segments effectue le tri comme demandé par l'utilisateur :

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments):
        """Find the segments in the audio data without sorting."""
        segment_loudness = [
            calculate_loudness(
                audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate)
            for i in range(0, max_segments)
        ]
        
        loudness_and_segments = [
            (segment_loudness[i], i * segment_duration)
            for i in range(num_segments)  # limit to the desired number of segments
            if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
        ]
        
        # The segments are returned without any sorting
        return loudness_and_segments
    
    def sort_and_name_segments(segments_with_loudness, preference):
        # Tri basé sur la préférence
        if preference == 1:
            # Par ordre d'apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre)
            named_segments = segments_with_loudness
        elif preference == 2:
            # Dans l’ordre inverse de l'apparition
            named_segments = list(reversed(segments_with_loudness))
        elif preference == 3:
            # Par loudness croissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0])
        elif preference == 4:
            # Par loudness décroissante
            named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
    
        # Renumerotation des segments en préservant l'ordre spécifié par named_segments.
        named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
        return named_segments
    

    Avec ces modifications, find_loudest_segments crée les paires (loudness, start_time) pour tous les segments dans l'ordre dans lequel ils apparaissent dans le fichier audio, et sort_and_name_segments effectue le tri en fonction de la préférence de l'utilisateur. Cela devrait faire en sorte que vos segments soient triés correctement selon les spécifications du script.

  21. User

    Traceback (most recent call last): File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 193, in process_video_file(video_path, starting_offset, ending_offset) File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 139, in process_video_file segment_loudness, segment_start_time = segment_info[1:] ValueError: not enough values to unpack (expected 2, got 1)

  22. Assistant

    L'erreur ValueError: not enough values to unpack (expected 2, got 1) indique qu'il y a une incohérence entre le nombre de valeurs que vous essayez d'extraire de segment_info[1:] et le nombre de valeurs effectivement disponible dans le tuple ou la liste.

    Je vais vous expliquer ce qui se passe avec l'erreur actuelle et je vais corriger le code en conséquence.

    Le code fautif se trouve dans la fonction process_video_file et le problème est ici :

    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    

    segment_info est supposé être un tuple (ou une liste) de trois éléments : (index, segment_loudness, segment_start_time). Vous déballez correctement le premier élément dans index, mais l'erreur indique que segment_info[1:] ne contient qu'une valeur, alors qu'il devrait contenir deux valeurs pour être déballé en segment_loudness et segment_start_time.

    Ce problème provient probablement de la manière dont named_segments est créé dans la fonction sort_and_name_segments. Vérifions que named_segments renumérote correctement les éléments dans la liste de segments après le tri :

    # Renumerotation des segments en préservant l'ordre spécifié par named_segments.
    named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)]
    

    Dans la ligne ci-dessus, seg[1:] va omettre le premier élément (qui est censé être la loudness du segment) et ne conserver que les éléments suivants, ce qui entraîne le déballage incorrect plus tard.

    La correction doit donc supprimer cette tranche [1:], et on veut renvoyer un tuple contenant tous les éléments originaux, plus le nouvel index ajouté devant :

    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    

    Maintenant chaque segment_info aura trois éléments : (index, loudness, start_time). Vérifiez que le reste du script est cohérent avec cette structure, et cela devrait résoudre l'erreur que vous voyez.

  23. User

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments in the audio data without sorting.""" segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(num_segments)  # limit to the desired number of segments
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # The segments are returned without any sorting
    return loudness_and_segments
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Par ordre d’apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre) named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse de l’apparition named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    # Renumerotation des segments en préservant l’ordre spécifié par named_segments.
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    

    Peut-on ajouter la date et l'heure à la fin du nom du fichier, pour qu'il n'y ait pas d'écrasement, ainsi qu'une mention de l'ordre utilisé pour l'extraction ?

  24. Assistant

    Bien sûr, vous pouvez facilement ajouter la date et l'heure, ainsi qu'une mention de l'ordre utilisé pour l'extraction, à la fin du nom du fichier. Python fournit le module datetime qui est très utile pour travailler avec les dates et les heures. Voici comment vous pouvez le faire :

    Commencez par importer datetime :

    import datetime
    

    Ensuite, dans votre boucle d'extraction de segments, modifiez la génération du output_filename pour inclure une horodatage de format 'YYYYMMDD_HHMMSS' en utilisant datetime.now().strftime("%Y%m%d_%H%M%S"), puis ajoutez également la mention de la préférence en utilisant la variable preference :

    ...
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    preference_suffix = {1: "ordered", 2: "reversed", 3: "incrLoudness", 4: "decrLoudness"}
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        preference_str = preference_suffix[preference]
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}_{preference_str}_{timestamp}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
        ...
    

    Dans le code ci-dessus :

    • J'ai utilisé un dictionnaire preference_suffix pour associer chaque préférence à une chaîne de caractères qui sera ajoutée au nom du fichier.
    • L'horodatage est généré avec strftime et ajouté juste avant l'extension du fichier.
    • La chaîne preference_str obtenue à partir de preference_suffix[preference] est incluse dans le nom du fichier pour indiquer la méthode de tri utilisée pour l'extraction du segment.

    Avec ces ajouts, chaque nom de fichier inclura un horodatage unique et la méthode de tri, ce qui évitera toute collision de noms et conservera un historique explicite de la manière dont chaque segment a été extrait.

  25. User

    OUblie tout

  26. Assistant

    Pas de souci, reprenons à zéro. N'hésitez pas à poser votre demande ou à clarifier comment je peux vous aider maintenant.

  27. User

    Voici mon script :

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile import datetime

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments in the audio data without sorting.""" segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(num_segments)  # limit to the desired number of segments
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # The segments are returned without any sorting
    return loudness_and_segments
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Par ordre d’apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre) named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse de l’apparition named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    # Renumerotation des segments en préservant l’ordre spécifié par named_segments.
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
    audio_data, rate, max_segments, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extraire chaque segment selon l’ordre trié et préféré par l’utilisateur
    for segment_info in sorted_and_named_segments:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    

    Je voudrais que juste avant l'extraction, on demande à l'utilisateur combien d'extrait il veut générer. Comme cela, même si un grand nombre d'extraits est prêt à être généré, le script s'arrêtera à ce nombre qu'il aura défini.

  28. Assistant

    Pour demander à l'utilisateur combien d'extraits il souhaite générer et s'assurer que le script s'arrête à ce nombre, vous pouvez ajouter une étape supplémentaire dans votre fonction process_video_file pour obtenir cette information de l'utilisateur. Modifiez ensuite la boucle qui extrait les segments pour qu'elle itère seulement jusqu'au nombre spécifié par l'utilisateur.

    Voici comment vous pouvez ajuster votre script :

    1. Ajoutez une nouvelle entrée utilisateur dans la fonction process_video_file juste après avoir confirmé la longueur du segment et avant de demander la préférence de loudness peak.

    2. Utilisez cette valeur pour limiter le nombre de segments extraits dans votre boucle for.

    Voici le script ajusté avec les modifications (je ne remets que les parties qui changent pour se concentrer sur la modification demandée) :

    def process_video_file(video_path, starting_offset, ending_offset):
        # ... le début de la fonction reste inchangé ...
    
        # Demande à l'utilisateur combien de segments il veut extraire
        num_to_extract = int(input("How many segments do you want to extract? "))
        
        # ... le reste de l'initialisation reste inchangé ...
    
        # Génère un fichier audio temporaire
        video_clip.audio.write_audiofile(audio_filename)
        
        # Lis le fichier audio pour obtenir le taux d'échantillonnage et les données audio
        rate, audio_data = wavfile.read(audio_filename)
    
        loudness_and_segments = find_loudest_segments(
            audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments
        )
        sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
    
        # Extrayez uniquement le nombre de segments demandé par l'utilisateur
        for segment_info in sorted_and_named_segments[:num_to_extract]:
            # le reste de la boucle reste inchangé ...
    
        # ... le reste de la fonction reste inchangé ...
    

    Dans la modification ci-dessus, nous ajoutons une nouvelle entrée utilisateur num_to_extract à l'aide de input, en demandant "How many segments do you want to extract?". Ensuite, nous utilisons sorted_and_named_segments[:num_to_extract] pour limiter la boucle for au nombre de segments que l'utilisateur souhaite extraire.

    Assurez-vous que l'utilisateur saisit un nombre valide qui n'excède pas max_segments que vous avez calculé. Vous pourriez également implémenter une vérification pour vous assurer que l'utilisateur entre un nombre entier positif.

  29. User

    Traceback (most recent call last): File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 194, in process_video_file(video_path, starting_offset, ending_offset) File "H:\Tests\V1 - encodage - nombre segments auto-déterminé.py", line 130, in process_video_file audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments NameError: name 'num_to_extract' is not defined

  30. Assistant

    L'erreur NameError: name 'num_to_extract' is not defined indique que la variable num_to_extract n'est pas définie avant d'être utilisée. Cela signifie qu'il manque soit la définition de la variable, soit elle a été définie dans une portée (un "scope") qui n'est pas accessible à l'endroit où vous essayez de l'utiliser.

    Pour corriger cette erreur, assurez-vous que num_to_extract est demandé et défini dans le bon ordre dans la fonction process_video_file avant que vous tentiez de l'utiliser en tant qu'argument pour find_loudest_segments.

    Voici où et comment vous devriez ajouter la requête pour num_to_extract :

    def process_video_file(video_path, starting_offset, ending_offset):
        # ... (le reste du code avant cette section est inchangé)
        
        confirmed = False
        while not confirmed:
            # ... (le code pour confirmer la longueur des segments est ici)
        
        # Ajoutez la demande de combien de segments à extraire ici
        num_to_extract = int(input("How many segments do you want to extract? "))
    
        # Vous pouvez également ajouter une vérification pour vous assurer que le nombre
        # est positif et ne dépasse pas le nombre maximal de segments disponibles
        while num_to_extract <= 0 or num_to_extract > max_segments:
            print(f"Please enter a number between 1 and {max_segments}.")
            num_to_extract = int(input("How many segments do you want to extract? "))
        
        # ... (le reste du code pour demander les préférences de loudness et d'ordre de segments)
        
        # ... (le code pour générer le fichier audio temporaire et lire les données audio)
        
        # Utilisez num_to_extract pour limiter le nombre de segments renvoyés par find_loudest_segments
        loudness_and_segments = find_loudest_segments(
            audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments
        )
        # ... (le reste du code de la fonction)
    

    Avec cet ajout, num_to_extract sera défini avant qu'il ne soit utilisé comme argument dans find_loudest_segments, et votre programme demandera à l'utilisateur combien de segments il souhaite extraire avant de poursuivre. Assurez-vous que cette demande se trouve bien à l'intérieur de la fonction process_video_file de sorte à ce que num_to_extract soit accessible où vous l'utilisez.

  31. User

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments in the audio data without sorting.""" segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(num_segments)  # limit to the desired number of segments
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # The segments are returned without any sorting
    return loudness_and_segments
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Par ordre d’apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre) named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse de l’apparition named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    # Renumerotation des segments en préservant l’ordre spécifié par named_segments.
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
        
    num_to_extract = int(input("How many segments do you want to extract? "))
        
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d’échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extrayez uniquement le nombre de segments demandé par l’utilisateur
    for segment_info in sorted_and_named_segments[:num_to_extract]:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    

    Le script demande-t-il à l'utilisateur avant l'extraction à combien d'extraits il veut limiter l'extraction ?

  32. Assistant

    Oui, votre script modifié demande bien à l'utilisateur combien d'extraits il souhaite générer juste avant de commencer l'extraction des segments vidéo. La demande est posée après que l'utilisateur a confirmé la longueur des segments et les préférences de loudness peak, mais avant la génération du fichier audio temporaire et l'extraction réelle des segments. Voici la section pertinente du scénario :

    ...
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
        
    num_to_extract = int(input("How many segments do you want to extract? "))
    
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    ...
    

    Lorsque vous exécutez ce script, il suivra cette séquence :

    1. Demandez à l'utilisateur la longueur du segment souhaité.
    2. Demandez où dans le segment se trouve le pic de loudness préféré.
    3. Demandez la préférence pour l'ordre des segments en fonction de la loudness.
    4. Demandez combien de segments extraire.
    5. Générez le fichier audio temporaire.
    6. Lisez le fichier audio pour obtenir le taux d'échantillonnage et les données audio.
    7. Trouvez les segments les plus forts sans tri.
    8. Triez et nommez les segments selon la préférence.
    9. Extrayez un nombre de segments défini par l'utilisateur.

    Le nombre de segments à extraire (num_to_extract) est ensuite utilisé pour limiter la liste des segments à traiter dans la boucle d'extraction des segments :

    ...
    # Extrayez uniquement le nombre de segments demandé par l’utilisateur
    for segment_info in sorted_and_named_segments[:num_to_extract]:
        ...
    

    Ainsi, indépendamment du nombre total de segments identifiés comme les plus forts, votre script extraira uniquement le nombre spécifié par l'utilisateur.

  33. User

    Comment transposer ce script pour qu'il soit utilisable comme un programme ?

    import os import subprocess import numpy as np import uuid from moviepy.editor import VideoFileClip from scipy.io import wavfile

    Define video file extensions and the output folder

    video_extensions = ['.mp4', '.mkv', '.wmv', '.avi'] output_folder = 'Output'

    def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) # convert to mono by averaging channels # Normalization constants for the ITU-R BS.1770-4 method pre_filter = np.array([1.53512485958697, -2.69169618940638, 1.19839281085285]) pre_gain = 1.0 power = 10.0 # Pre-filter audio_data = np.convolve(audio_data, pre_filter) * pre_gain # Calculate power and then LUFS mean_square = np.mean(audio_data ** 2) mean_power = mean_square ** (0.5) loudness = (1 / rate) * np.sum(mean_power ** power) lufs = -0.691 + 10 * np.log10(loudness) return lufs

    def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset, max_segments): """Find the segments in the audio data without sorting.""" segment_loudness = [ calculate_loudness( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))], rate) for i in range(0, max_segments) ]

    loudness_and_segments = [
        (segment_loudness[i], i * segment_duration)
        for i in range(num_segments)  # limit to the desired number of segments
        if i * segment_duration >= starting_offset and (i + 1) * segment_duration <= video_duration - ending_offset
    ]
    
    # The segments are returned without any sorting
    return loudness_and_segments
    

    def find_peak_amplitude_position(audio_segment): """Find the position of the peak amplitude within the given audio segment.""" peak_position = np.argmax(np.abs(audio_segment)) return peak_position

    def adjust_start_time_for_peak(start_time, peak_position, segment_length, rate, peak_preference): """Adjust the segment's start time so the peak appears at the user's preferred position.""" desired_peak_position_in_segment = segment_length * (peak_preference / 6) new_start_time = start_time + (peak_position / rate) - desired_peak_position_in_segment # Ensure new start time does not go beyond the video's start or end new_start_time = max(0, new_start_time) return new_start_time

    def sort_and_name_segments(segments_with_loudness, preference): # Tri basé sur la préférence if preference == 1: # Par ordre d’apparition (pas besoin de trier car find_loudest_segments retourne déjà dans cet ordre) named_segments = segments_with_loudness elif preference == 2: # Dans l’ordre inverse de l’apparition named_segments = list(reversed(segments_with_loudness)) elif preference == 3: # Par loudness croissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Par loudness décroissante named_segments = sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)

    # Renumerotation des segments en préservant l’ordre spécifié par named_segments.
    named_segments = [(i+1, *seg) for i, seg in enumerate(named_segments)]
    return named_segments
    

    def process_video_file(video_path, starting_offset, ending_offset): unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav'

    # Charge la vidéo et calcule sa durée
    video_clip = VideoFileClip(video_path)
    video_duration = video_clip.duration
    
    confirmed = False
    while not confirmed:
        # Demande la longueur des segments voulue
        segment_length = float(input("Please enter the desired length for each video segment (sec): "))
        if segment_length <= 0:
            print("Invalid segment length. It must be greater than 0.")
            continue
        
        max_segments = int(np.ceil((video_duration - starting_offset - ending_offset) / segment_length))
    
        if max_segments <= 0:
            print("Segment length is too long for the video duration minus offsets.")
            continue
    
        print(f"Maximum number of segments obtainable: {max_segments}")
        confirm = input("Enter '1' to confirm, or any other key to enter a different segment length: ")
        if confirm == '1':
            confirmed = True
    
    # Après confirmation de la durée de segment, demande pour la loudness peak preference
    peak_preference = int(input("At which point do you want the peak loudness to occur within the segment? (Enter 1-5 for 1/6 to 5/6): "))
    if peak_preference not in [1, 2, 3, 4, 5]:
        print("Invalid choice. Exiting.")
        return
        
    # Demande la préférence pour l'ordre des segments
    print("Please choose the order of the segments based on loudness:")
    print("1) In order of appearance")
    print("2) In reverse order")
    print("3) By increasing loudness")
    print("4) By decreasing loudness")
    preference = int(input("Enter your choice (1-4): "))
    if preference not in [1, 2, 3, 4]:
        print("Invalid choice. Exiting.")
        return
        
    num_to_extract = int(input("How many segments do you want to extract? "))
        
    # Génère un fichier audio temporaire
    video_clip.audio.write_audiofile(audio_filename)
    
    # Lis le fichier audio pour obtenir le taux d’échantillonnage et les données audio
    rate, audio_data = wavfile.read(audio_filename)
    
    loudness_and_segments = find_loudest_segments(
        audio_data, rate, num_to_extract, segment_length, video_duration, starting_offset, ending_offset, max_segments
    )
    sorted_and_named_segments = sort_and_name_segments(loudness_and_segments, preference)
    
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)
    
    # Extrayez uniquement le nombre de segments demandé par l’utilisateur
    for segment_info in sorted_and_named_segments[:num_to_extract]:
        index = segment_info[0]
        segment_loudness, segment_start_time = segment_info[1:]
    
        segment_end = min(segment_start_time + segment_length, video_duration)
        actual_segment_length = segment_end - segment_start_time
    
        # Calcul du décalage pour le pic de loudness
        segment_audio_data = audio_data[int(segment_start_time * rate):int(segment_end * rate)]
        peak_position = find_peak_amplitude_position(segment_audio_data)
        shift_required = peak_position / rate - (actual_segment_length * peak_preference / 6)
        start_time_adjusted = max(starting_offset, min(segment_start_time - shift_required, video_duration - actual_segment_length - ending_offset))
    
        output_filename = f"segment{index}_{os.path.splitext(os.path.basename(video_path))[0]}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        # Commande ffmpeg
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time_adjusted),
            "-i", video_path,
            "-t", str(actual_segment_length),
            "-c:v", "libx264",
            "-c:a", "aac",
            "-strict", "experimental",
            output_path
        ]
    
        try:
            subprocess.run(command, check=True, stderr=subprocess.PIPE)
        except subprocess.CalledProcessError as e:
            print(f"ffmpeg command failed: {e.stderr.decode()}")
            continue
    
        print(f"Extracted segment {index} to {output_path}")
    
    # Supprime le fichier audio temporaire si nécessaire
    if os.path.exists(audio_filename):
        os.unlink(audio_filename)
    

    Main

    if name == "main": output_abs_path = os.path.abspath(output_folder) starting_offset = float(input("Please enter the start offset (sec): ")) ending_offset = float(input("Please enter the end offset (sec): "))

    for root, dirs, files in os.walk('.'):
        root_abs_path = os.path.abspath(root)  # Obtenez le chemin absolu du répertoire courant
        for file in files:
            # Ignore les fichiers qui sont déjà des segments dans le répertoire Output
            if root_abs_path == output_abs_path and file.startswith("segment"):
                continue
            if any(file.lower().endswith(ext) for ext in video_extensions):
                video_path = os.path.join(root, file)
                print(f"Processing video {video_path}…")
                process_video_file(video_path, starting_offset, ending_offset)
    
    print("All videos have been processed.")
    
  34. Assistant

    Pour transformer ce script en un programme utilisable de manière plus générale, vous voudrez peut-être le rendre plus convivial en ajoutant des arguments en ligne de commande, une interface utilisateur graphique (GUI), ou un fichier de configuration pour définir les paramètres sans saisie manuelle. Vous devriez également gérer correctement les erreurs et les cas d'utilisation inattendus pour rendre le programme robuste. Voici quelques étapes que vous pouvez suivre pour avancer dans cette direction :

    1. Utiliser argparse pour les arguments en ligne de commande : Utilisez le module argparse pour permettre à l'utilisateur de lancer le programme avec des paramètres spécifiques en ligne de commande. Par exemple, l'utilisateur peut spécifier les chemins d'entrée/sortie, la longueur des segments, les offsets et d'autres options sans avoir à entrer les informations manuellement à chaque exécution.

    2. Gestion des erreurs : Inclure la gestion des erreurs adéquate pour traiter des cas comme des entrées de fichiers non valides, des erreurs lors de la lecture des fichiers ou l'exécution des commandes ffmpeg, etc.

    3. Logging : Configurez un système de journalisation (logging) pour enregistrer les activités du programme, les réussites, les échecs, et les messages d'erreur.

    4. Packaging : Emballez votre script dans un package installable à l'aide de setuptools. Cela permettra aux utilisateurs d'installer votre programme avec pip et de l'exécuter en tant que commande.

    5. Interface utilisateur graphique (GUI) : Si vous souhaitez qu'il soit utilisable par des personnes qui préfèrent une interface graphique, envisagez d'ajouter une GUI à l'aide de modules tels que Tkinter, PyQt, ou Kivy.

    6. Documentation : Fournissez une documentation claire sur la façon d'installer et d'utiliser le programme, y compris des exemples.

    7. Distribution : Pour une utilisation encore plus large, envisagez de distribuer votre programme sous forme d'exécutable autonome en utilisant des outils comme PyInstaller.

    8. Tests : Inclure une suite de tests pour s'assurer que le programme fonctionne comme prévu dans différents scénarios.

    Voici un exemple simple d'utilisation d'argparse pour commencer à convertir le script en un programme utilisable via la ligne de commande :

    import argparse
    
    # Créer un analyseur d'arguments en ligne de commande
    parser = argparse.ArgumentParser(description='Extract segments from videos based on loudness.')
    parser.add_argument('--input', help='The input directory containing video files.', default='.')
    parser.add_argument('--output', help='The output directory for extracted segments.', default='Output')
    parser.add_argument('--start_offset', type=float, help='The start offset in seconds.', default=0.0)
    parser.add_argument('--end_offset', type=float, help='The end offset in seconds.', default=0.0)
    
    # Vous pouvez continuer à ajouter d'autres arguments comme ci-dessus
    
    args = parser.parse_args()
    
    # Utiliser les valeurs d'argument où vous aviez des inputs précédemment
    output_abs_path = os.path.abspath(args.output)
    starting_offset = args.start_offset
    ending_offset = args.end_offset
    input_directory = args.input
    # Continuez à utiliser args pour les autres paramètres
    
    # Le reste de votre logique principale viendrait ici
    

    Avec un peu de travail pour adapter le script existant et en suivant ces suggestions, vous pouvez créer un programme robuste et convivial qui pourrait être utilisé par un public bien plus large.