Je vais te donner un script. Je te donnerai ensuite l'erreur qu'il génère et tu…
- User
Je vais te donner un script. Je te donnerai ensuite l'erreur qu'il génère et tu corrigeras.
- 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.
- 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_segmentsdef 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.") - 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.
- 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)
- Assistant
Le message d'erreur
ValueError: not enough values to unpack (expected 2, got 1)indique que lorsque vous essayez de déballersegment_info[1:]ensegment_loudnessetsegment_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_segmentsoùsegment_infoest censé être construit. À première vue, il semble que le bloc suivant ne devrait pas être indenté dans la fonctionsort_and_name_segments:# Renumbering the segments after sorting named_segments = [(i+1, *seg[1:]) for i, seg in enumerate(named_segments)] return named_segmentsCe bloc de code est mal indenté et devrait être en dehors de la portée de la condition
if-elif. Lereturn named_segmentsdevrait ê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_segmentsAvec cette modification, chaque élément de
named_segmentsdevrait 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 dansprocess_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.
- 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_segmentsdef 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.") - 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_segmentsa deuxreturnconsé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 blocif-elif, et aligné avec la première condition. Il ne devrait y avoir qu'un seulreturnà la fin de la fonctionsort_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_segmentsNotez que j'ai retiré le
seg[1:]pour*segquand on refait la listenamed_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
ValueErrorqui est survenue précédemment. - 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_segmentsdef 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 ?
- Assistant
Votre fonction
sort_and_name_segmentstrie 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 appelezfind_loudest_segmentsetsort_and_name_segmentsdeux 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_segmentsetsort_and_name_segmentsest 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
indexdans 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_segmentsetsort_and_name_segmentsdans la fonctionprocess_video_file. - User
il faut supprimer les deux, ou justeun ?
- Assistant
Il faut supprimer uniquement la première paire d'appels à
find_loudest_segmentsetsort_and_name_segments. La deuxième paire est celle qui est effectivement utilisée pour le traitement ultérieur dans votre bouclefor. Après suppression, la fonctionprocess_video_filedevrait 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.
- 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 ?
- 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 fonctionfind_loudest_segments. Pour chaque segment, cette fonction retourne un niveau de loudness selon la méthode spécifiée.Ensuite, la fonction
find_loudest_segmentscombine 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 fonctionfind_loudest_segments, on l'envoie à la fonctionsort_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 :
-
calculate_loudnessest appelé sur chaque segment pour obtenir leur loudness individuelle. -
find_loudest_segmentsest utilisé pour obtenir une liste des segments les plus forts basée sur la loudness. -
sort_and_name_segmentsprend 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)
- Dans l’ordre d’apparition (
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_loudnesstelle 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. -
- User
Au niveau du tri : rien ne marche. L'ordre est toujours le même, je ne sais pas lequel
- Assistant
Votre fonction
sort_and_name_segmentsest 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_segmentspour 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_segmentsLa 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_segmentsles 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 defind_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_segmentsdansprocess_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. - 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_segmentsdef 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.") - 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_segmentsRemarque Importante: La fonction
find_loudest_segmentsretourne 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_segmentscrée la listeloudness_and_segmentsen 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 loudnessloudness_and_segments.sort(key=lambda x: x[0], reverse=True).Assurez-vous: que
find_loudest_segmentssoit modifiée pour renvoyer tous les segments sans effectuer de tri préliminaire, ou que la logique danssort_and_name_segmentstienne compte de la façon dontfind_loudest_segmentsa déjà trié la liste.Étape finale : vérifiez aussi que vous utilisez bien le résultat de
sort_and_name_segmentsdans la boucle d'extraction des vidéos dansprocess_video_file. La listesorted_and_named_segmentsdoit ê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é. - 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 ?
- Assistant
Pour vous assurer que la fonction
find_loudest_segmentsrenvoie tous les segments sans effectuer de tri préliminaire par loudness, vous devriez:- Supprimer le tri de
find_loudest_segments - Adapter la logique de
sort_and_name_segmentspour faire le tri selon le besoin.
Voici les deux fonctions modifiées pour que
find_loudest_segmentsretourne les segments dans l'ordre d'apparition sans tri, et pour quesort_and_name_segmentseffectue 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_segmentsAvec ces modifications,
find_loudest_segmentscrée les paires(loudness, start_time)pour tous les segments dans l'ordre dans lequel ils apparaissent dans le fichier audio, etsort_and_name_segmentseffectue 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. - Supprimer le tri de
- 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)
- 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 desegment_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_fileet 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_infoest 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 dansindex, mais l'erreur indique quesegment_info[1:]ne contient qu'une valeur, alors qu'il devrait contenir deux valeurs pour être déballé ensegment_loudnessetsegment_start_time.Ce problème provient probablement de la manière dont
named_segmentsest créé dans la fonctionsort_and_name_segments. Vérifions quenamed_segmentsrenumé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_infoaura 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. - 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_segmentsdef 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_segmentsdef 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 ?
- 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
datetimequi est très utile pour travailler avec les dates et les heures. Voici comment vous pouvez le faire :Commencez par importer
datetime:import datetimeEnsuite, dans votre boucle d'extraction de segments, modifiez la génération du
output_filenamepour inclure une horodatage de format 'YYYYMMDD_HHMMSS' en utilisantdatetime.now().strftime("%Y%m%d_%H%M%S"), puis ajoutez également la mention de la préférence en utilisant la variablepreference:... # 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_suffixpour 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
strftimeet ajouté juste avant l'extension du fichier. - La chaîne
preference_strobtenue à partir depreference_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.
- J'ai utilisé un dictionnaire
- User
OUblie tout
- Assistant
Pas de souci, reprenons à zéro. N'hésitez pas à poser votre demande ou à clarifier comment je peux vous aider maintenant.
- 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_segmentsdef 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_segmentsdef 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.
- 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_filepour 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 :
-
Ajoutez une nouvelle entrée utilisateur dans la fonction
process_video_filejuste après avoir confirmé la longueur du segment et avant de demander la préférence de loudness peak. -
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 deinput, en demandant "How many segments do you want to extract?". Ensuite, nous utilisonssorted_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_segmentsque vous avez calculé. Vous pourriez également implémenter une vérification pour vous assurer que l'utilisateur entre un nombre entier positif. -
- 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
- Assistant
L'erreur
NameError: name 'num_to_extract' is not definedindique que la variablenum_to_extractn'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_extractest demandé et défini dans le bon ordre dans la fonctionprocess_video_fileavant que vous tentiez de l'utiliser en tant qu'argument pourfind_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_extractsera défini avant qu'il ne soit utilisé comme argument dansfind_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 fonctionprocess_video_filede sorte à ce quenum_to_extractsoit accessible où vous l'utilisez. - 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_segmentsdef 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_segmentsdef 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 ?
- 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 :
- Demandez à l'utilisateur la longueur du segment souhaité.
- Demandez où dans le segment se trouve le pic de loudness préféré.
- Demandez la préférence pour l'ordre des segments en fonction de la loudness.
- Demandez combien de segments extraire.
- Générez le fichier audio temporaire.
- Lisez le fichier audio pour obtenir le taux d'échantillonnage et les données audio.
- Trouvez les segments les plus forts sans tri.
- Triez et nommez les segments selon la préférence.
- 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.
- 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_segmentsdef 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_segmentsdef 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.") - 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 :
-
Utiliser argparse pour les arguments en ligne de commande : Utilisez le module
argparsepour 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. -
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. -
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.
-
Packaging : Emballez votre script dans un package installable à l'aide de setuptools. Cela permettra aux utilisateurs d'installer votre programme avec
pipet de l'exécuter en tant que commande. -
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, ouKivy. -
Documentation : Fournissez une documentation claire sur la façon d'installer et d'utiliser le programme, y compris des exemples.
-
Distribution : Pour une utilisation encore plus large, envisagez de distribuer votre programme sous forme d'exécutable autonome en utilisant des outils comme PyInstaller.
-
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'
argparsepour 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 iciAvec 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.
-