import os import subprocess import numpy as np import uuid from moviepy.editor import…
- 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): """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, int(video_duration / segment_duration)) ]
# 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 sort_segments(segments_with_loudness, preference): if preference == 1: return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video with x264 encoding.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}")
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration
video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) sorted_segments = sort_segments(segments_with_loudness, preference) if not os.path.exists(output_folder): os.makedirs(output_folder) for i, (loudness, start_time) in enumerate(sorted_segments): output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{i+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: os.unlink(audio_filename) # Clean up the temporary fileMain
if name == "main": starting_offset = float(input("Start offset (sec)? ")) ending_offset = float(input("End offset (sec)? ")) num_segments = int(input("How many segments to extract? ")) segment_duration = float(input("Duration of each segment (sec)? ")) print("Choose your sorting preference for the extracted files:") print("1 - In order of appearance in the video") print("2 - In reverse order of appearance") print("3 - By increasing loudness") print("4 - By decreasing loudness") preference = int(input("Enter the number of your preference: ")) # Validate the user's preference if preference not in [1, 2, 3, 4]: print("Invalid preference. Please enter a valid number.") exit(1)
for root, dirs, files in os.walk('.'): for file in files: 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, num_segments, segment_duration, preference) print("All videos have been processed.") - Assistant
The Python script you provided defines several functions and then runs a main block to carry out the following tasks:
- Find and process video files in the current working directory (and its subdirectories) that have extensions matching those listed in
video_extensions. - For each video file, it extracts the audio and saves it as a temporary WAV file.
- It calculates the "loudness" of segments within the audio, aiming to find the loudest parts based on a specified duration, starting and ending offsets, and the number of segments desired.
- It sorts these loud segments by the user's preference:
- In order of appearance.
- Reverse order of appearance.
- By increasing loudness.
- By decreasing loudness.
- It then uses the
ffmpegtool to extract each of these segments as unique MP4 files with x264 video and AAC audio encoding. These files are saved in an "Output" folder. - Upon completion, it cleans up temporary WAV files created during the process.
However, there are parts of the script that could be problematic or could be improved:
-
The
calculate_loudnessfunction uses a method that is not a standard ITU-R BS.1770-4 loudness calculation. The ITU-R BS.1770 standard involves specific filtering (K-weighting), gating, and summation steps which are not fully implemented here. This means that the script calculates a "loudness" measure, but it may not align with industry standards. -
The subprocess call is wrapped with error checking, which is good practice. However, you might want to handle the error more gracefully, perhaps by logging the error or trying to recover without halting the entire script.
-
The script uses the
moviepylibrary to extract the audio from the video files, which depends on theffmpegtool as well. If theffmpegis not installed or properly configured on the user's system, the script will fail. -
After the
moviepyprocessing, the script reads the temporary WAV file into memory completely. This can be problematic for very large files, leading to memory exhaustion errors on systems with insufficient memory. -
The way the loudness segments are calculated and then truncated to fit the starting and ending offsets feels a bit clumsy and inefficient, which could potentially be improved.
-
Although UUID is used to create a unique temporary filename, in highly concurrent environments (or if the function is called too quickly in succession), there could theoretically still be conflicts. As the actual risk of this is very low, this should generally not be a concern.
-
The script assumes the user wishes to process all video files in the current directory recursively. If the directory contains a large number of files or if only specific files should be processed, this assumption might not be ideal.
Before running this script, ensure that you have the necessary dependencies installed (
moviepyandffmpeg) and also review thecalculate_loudnessmethod to ensure it meets your specific requirements for loudness measurement. Moreover, make sure the system has enough resources to process the videos, and handle the appropriate file sizes. - Find and process video files in the current working directory (and its subdirectories) that have extensions matching those listed in
- User
Le script ne respecte pas certaines conditions. Lorsqu'on demande l'ordre de tri à l'utilisateur :
1- Le script doit extraire les vidéos dans l'ordre où elles apparaissent lors de la lecture de l'original 2- Le script doit extraire les vidéos dans l'ordre inverse où elles apparaissent lors de la lecture de l'original 3- Le script doit extraire les vidéos de la moins bruyante à la plus bruyante 4- Le script doit extraire les vidéos de la plus bruyante à la moins bruyante
- Assistant
Pour respecter les conditions spécifiées concernant l'ordre de tri lors de l'extraction des segments vidéo, nous devons nous assurer que la fonction
sort_segmentstrie correctement les segments selon les préférences de l'utilisateur. Voici comment on pourrait modifier la fonction pour répondre aux exigences :def sort_segments(segments_with_loudness, preference): if preference == 1: # Tri par ordre d'apparition dans la vidéo originale return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: # Tri par ordre inverse d'apparition dans la vidéo originale return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: # Tri de la moins bruyante à la plus bruyante return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # Tri de la plus bruyante à la moins bruyante return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)La fonction
sort_segmentsest déjà correcte en fonction des spécifications.Maintenant, il est important de s'assurer que les segments soient extraits dans l'ordre de tri spécifié avant l'écriture des fichiers. Cela signifie que la partie du code où les fichiers sont écrits sur le disque (dans la fonction
process_video_file) doit utiliser la liste triée. Voici comment on pourrait organiser cette partie :# ... if not os.path.exists(output_folder): os.makedirs(output_folder) # Utilisez la liste triée pour l'extraction et la sauvegarde des segments for i, (loudness, start_time) in enumerate(sorted_segments): output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{i+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") # ...Notez que le reste du script doit rester inchangé, puisque le triage des segments est déjà correctement structuré pour répondre à vos besoins. Assurez-vous simplement que la liste
sorted_segmentssoit utilisée pour l'extraction des segments dans l'ordre correct, tel que défini par la préférence de l'utilisateur.En résumé, à partir du momement où la fonction
sort_segmentsest bien défini, l'ordre selon lequel les segments seront sauvés sera déterminé par l'ordre des éléments danssorted_segments, qui sera déjà correct en fonction des instructions de tri spécifiées. - User
Fais les modifications à partir de ce bout de script :
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration
video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) sorted_segments = sort_segments(segments_with_loudness, preference) if not os.path.exists(output_folder): os.makedirs(output_folder) for i, (loudness, start_time) in enumerate(sorted_segments): output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{i+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: os.unlink(audio_filename) # Clean up the temporary file - Assistant
Pour répondre à vos instructions et effectuer les modifications nécessaires, nous allons d'abord assurer que les segments soient triés correctement selon la préférence de l'utilisateur dans la fonction
sort_segments:def sort_segments(segments_with_loudness, preference): # Tri en fonction de la préférence de l'utilisateur if preference == 1: # 1 - Tri par ordre d'apparition dans la vidéo originale (déjà correct) return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: # 2 - Tri par ordre inverse d'apparition dans la vidéo originale return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: # 3 - Tri de la moins bruyante à la plus bruyante return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: # 4 - Tri de la plus bruyante à la moins bruyante return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)Cependant, la fonction
sort_segmentsétait déjà correctement définie dans votre script original, donc les modifications sont simplement réitératives pour montrer l'alignement avec vos exigences.La fonction
process_video_filepeut avoir besoin d'une légère modification. Vous devez garantir que les indices des fichiers segmentés (i+1dansoutput_filename) correspondent à l'ordre voulu défini par la préférence de l'utilisateur. Si les segments doivent être nommés dans leur ordre d'apparition initiale, indépendamment du tri, vous devrez ajuster les indices.Voici la fonction
process_video_fileavec cette modification, gardant les indices des fichiers segmentés selon leur ordre d'apparition initiale :def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # Trier les segments en fonction de la préférence de l'utilisateur sorted_segments = sort_segments(segments_with_loudness, preference) # Anticiper si les noms de fichiers doivent correspondre à l'ordre initial if preference in [1, 2]: initial_order_index = {start_time: i for i, (loudness, start_time) in enumerate(segments_with_loudness)} if not os.path.exists(output_folder): os.makedirs(output_folder) for segment in sorted_segments: loudness, start_time = segment segment_index = initial_order_index[start_time] if preference in [1, 2] else sorted_segments.index(segment) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{segment_index+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: if os.path.exists(audio_filename): os.unlink(audio_filename) # Clean up the temporary fileCe changement garantit que peu importe le tri appliqué, le nom du fichier segmenté (
_segment{segment_index+1}.mp4) reflète l'ordre d'apparition original dans la vidéo. Si l'ordre initial n'a pas d'importance et que vous souhaitez simplement nommer les fichiers selon leur ordre après le tri, vous pouvez retirer le code correspondant àinitial_order_index. - 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): """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, int(video_duration / segment_duration)) ]
# 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 sort_segments(segments_with_loudness, preference): if preference == 1: return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video with x264 encoding.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}")
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration
video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # Trier les segments en fonction de la préférence de l'utilisateur sorted_segments = sort_segments(segments_with_loudness, preference) # Anticiper si les noms de fichiers doivent correspondre à l'ordre initial if preference in [1, 2]: initial_order_index = {start_time: i for i, (loudness, start_time) in enumerate(segments_with_loudness)} if not os.path.exists(output_folder): os.makedirs(output_folder) for segment in sorted_segments: loudness, start_time = segment segment_index = initial_order_index[start_time] if preference in [1, 2] else sorted_segments.index(segment) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{segment_index+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: if os.path.exists(audio_filename): os.unlink(audio_filename) # Clean up the temporary fileMain
if name == "main": starting_offset = float(input("Start offset (sec)? ")) ending_offset = float(input("End offset (sec)? ")) num_segments = int(input("How many segments to extract? ")) segment_duration = float(input("Duration of each segment (sec)? ")) print("Choose your sorting preference for the extracted files:") print("1 - In order of appearance in the video") print("2 - In reverse order of appearance") print("3 - By increasing loudness") print("4 - By decreasing loudness") preference = int(input("Enter the number of your preference: ")) # Validate the user's preference if preference not in [1, 2, 3, 4]: print("Invalid preference. Please enter a valid number.") exit(1)
for root, dirs, files in os.walk('.'): for file in files: 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, num_segments, segment_duration, preference) print("All videos have been processed.") - Assistant
Votre script modifié semble correct en fonction des exigences que vous avez énoncées précédemment. Voici un résumé de ce que vous avez déjà fait et des confirmations que le script devrait fonctionner conformément à vos besoins :
- La fonction
process_video_filetraite un fichier vidéo pour trouver et extraire les segments les plus bruyants. - Lorsqu'un fichier vidéo est trouvé et traité, l'audio est extrait et sauvegardé en tant que fichier WAV temporaire pour des calculs ultérieurs.
- La fonction
find_loudest_segmentsidentifie les segments les plus bruyants avec la durée spécifiée, en prenant en compte les décalages de début et de fin. - La fonction
sort_segmentstrie ces segments selon la préférence de l'utilisateur :- (1) Dans l'ordre d'apparition
- (2) Dans l'ordre inverse d'apparition
- (3) Par croissance de la sonorité
- (4) Par décroissance de la sonorité
- Un dictionnaire
initial_order_indexest utilisé pour mémoriser l'ordre des segments d'origine si la préférence de l'utilisateur est (1) ou (2), afin que le nom des fichiers segmentés correspond à l'ordre d'apparition initial dans la vidéo. - Pour chaque segment trié, la fonction
extract_segmentutiliseffmpegpour extraire le segment en tant que fichier vidéo MP4 à l'emplacement de sortie spécifié. - Une fois tous les segments extraits, le fichier audio temporaire est supprimé pour nettoyer.
Assurez-vous que
ffmpegest bien présent sur le système où ce script sera exécuté. En outre, vérifiez que les dépendances Python nécessaires (moviepy,numpy, etscipy) sont installées.Pour l'exécuter, lancez simplement le script dans votre environnement Python :
python script_name.pyLe script demandera à l'utilisateur d'entrer les informations requises (décalages de début et de fin, nombre de segments à extraire, durée de chaque segment, préférence de tri), et il traitera ensuite tous les fichiers vidéo trouvés dans le dossier de travail actuel et ses sous-dossiers, en appliquant les paramètres spécifiés.
- La fonction
- User
Peux-tu rajouter une fonctionnalité ? Il faudrait que ce qui est déterminé comme le centre de la vidéo extraite puisse se trouver où l'utilisateur le décide au moment de la lecture de la vidéo extraite. La gradation doit se situer entre 1 et 5 : 1 représentant 1/6 du temps de lecture, 2 représente 2/6 du temps de lecture etc.
- Assistant
Pour ajouter cette fonctionnalité, nous devrons modifier la fonction
extract_segmentpour ajuster le point de départ de l'extraction en fonction de la nouvelle préférence de l'utilisateur. En d'autres termes, nous devons ajuster le "-ss" (début du segment) de la commandeffmpegde manière à ce que le "centre" de la vidéo extraite corresponde à la position désirée dans la vidéo résultante.Commencez par modifier la fonction
process_video_filepour demander à l'utilisateur la position où il souhaite que le centre de la vidéo extraite apparaisse, puis ajoutez cet argument à l'appel à la fonctionextract_segment. Ensuite, ajustez la fonctionextract_segmentpour prendre en compte cet argument.Voici comment nous pourrions procéder :
def extract_segment(video_path, start_time, duration, output_path, center_position): """Use ffmpeg to extract a segment from a video with adjusted start time for centering.""" adjusted_start_time = max(start_time - (center_position - 1) * (duration / 6), 0) command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(adjusted_start_time), # Adjusted start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}") # Rest of the code ... # Inside your main block or process_video_file: center_preference = int(input("Where do you want the center of the segment to be during the playtime? (1-5): ")) if center_preference not in range(1, 6): print("Invalid center preference. Please enter a number between 1 to 5.") exit(1) # When calling 'extract_segment' pass the 'center_preference': extract_segment(video_path, start_time, segment_duration, output_path, center_preference)Dans le bloc principal ou là où vous appelez la fonction
process_video_file, demandez d'abord à l'utilisateur sa préférence pour le centre, puis passez cette préférence à la fonctionprocess_video_file. À l'intérieur deprocess_video_file, incluez cette préférence dans l'appel àextract_segment.Notez que nous avons introduit la variable
adjusted_start_time, qui ajuste le point de départ de l'extraction en fonction du paramètre de centrage spécifié par l'utilisateur. La fonctionmaxest utilisée pour s'assurer que nous ne commençons pas l'extraction avant le début de la vidéo (ce qui empêche des valeurs négatives pour le début de la vidéo).Il est essentiel de tester cette nouvelle fonctionnalité pour confirmer qu'elle fonctionne comme prévu dans tous les cas de figure, notamment en vérifiant que le centre se trouve bien à la position voulue par l'utilisateur pendant la lecture de la vidéo.
- User
oublie ça. Repars de ce script :
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): """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, int(video_duration / segment_duration)) ]
# 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 sort_segments(segments_with_loudness, preference): if preference == 1: return sorted(segments_with_loudness, key=lambda x: x[1]) elif preference == 2: return sorted(segments_with_loudness, key=lambda x: x[1], reverse=True) elif preference == 3: return sorted(segments_with_loudness, key=lambda x: x[0]) elif preference == 4: return sorted(segments_with_loudness, key=lambda x: x[0], reverse=True)
def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video with x264 encoding.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c:v", "libx264", # Use x264 video codec "-c:a", "aac", # AAC audio codec "-strict", "experimental", # Allow experimental codecs (if necessary for AAC) output_path # Output path ] try: subprocess.run(command, check=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print(f"ffmpeg command failed: {e.stderr.decode()}")
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference): """Process a single video file to find and extract the loudest segments.""" unique_id = str(uuid.uuid4()) audio_filename = f'temp_audio_{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration
video_clip.audio.write_audiofile(audio_filename) rate, audio_data = wavfile.read(audio_filename) segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) # Trier les segments en fonction de la préférence de l'utilisateur sorted_segments = sort_segments(segments_with_loudness, preference) # Anticiper si les noms de fichiers doivent correspondre à l'ordre initial if preference in [1, 2]: initial_order_index = {start_time: i for i, (loudness, start_time) in enumerate(segments_with_loudness)} if not os.path.exists(output_folder): os.makedirs(output_folder) for segment in sorted_segments: loudness, start_time = segment segment_index = initial_order_index[start_time] if preference in [1, 2] else sorted_segments.index(segment) output_filename = f"{os.path.splitext(os.path.basename(video_path))[0]}_segment{segment_index+1}.mp4" output_path = os.path.join(output_folder, output_filename) extract_segment(video_path, start_time, segment_duration, output_path) print(f"Extracted segment to {output_path}") finally: if os.path.exists(audio_filename): os.unlink(audio_filename) # Clean up the temporary fileMain
if name == "main": starting_offset = float(input("Start offset (sec)? ")) ending_offset = float(input("End offset (sec)? ")) num_segments = int(input("How many segments to extract? ")) segment_duration = float(input("Duration of each segment (sec)? ")) print("Choose your sorting preference for the extracted files:") print("1 - In order of appearance in the video") print("2 - In reverse order of appearance") print("3 - By increasing loudness") print("4 - By decreasing loudness") preference = int(input("Enter the number of your preference: ")) # Validate the user's preference if preference not in [1, 2, 3, 4]: print("Invalid preference. Please enter a valid number.") exit(1)
for root, dirs, files in os.walk('.'): for file in files: 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, num_segments, segment_duration, preference) print("All videos have been processed.") - Assistant
Pour ajouter la fonctionnalité demandée, permettant à l'utilisateur de décider où le centre du segment extrait doit apparaître pendant la lecture, nous devons d'abord demander cette préférence à l'utilisateur. Ensuite, nous l'utiliserons pour calculer le point de départ réel pour l'extraction du segment. Voici les étapes pour intégrer cette fonctionnalité :
- Modifier la fonction
process_video_filepour inclure une demande de préférence de position du centre. - Ajuster la fonction
extract_segmentpour tenir compte de cette nouvelle préférence et calculer le point de départ ajusté.
Nous intégrons ci-dessous ces modifications :
# Ajout de la fonction pour demander la préférence de position du centre à l'utilisateur def get_center_preference(): print("Choose where you want the center of the extracted segment to be during the playback:") print("1 - at 1/6 of the playback time") print("2 - at 2/6 of the playback time") print("3 - at the center (3/6) of the playback time") print("4 - at 4/6 of the playback time") print("5 - at 5/6 of the playback time") center_preference = int(input("Enter the number of your center preference (1-5): ")) # Validate the user's center preference if center_preference not in [1, 2, 3, 4, 5]: print("Invalid center preference. Please enter a valid number between 1 and 5.") exit(1) return center_preference # Modification de la fonction 'process_video_file' pour inclure la préférence de position du centre def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference, center_preference): #... (le corps de la fonction reste le même, jusqu'à juste avant d'extraire les segments) for segment in sorted_segments: loudness, start_time = segment # Utiliser 'center_preference' pour ajuster le début du segment # On soustrait une fraction de 'segment_duration' pour centrer selon la préférence start_time -= (center_preference - 3) * segment_duration / 6 start_time = max(start_time, 0) # S'assurer que le temps de début n'est pas négatif #... (le reste du corps de la boucle reste inchangé) # Modification de la méthode principale pour demander la préférence de position du centre if __name__ == "__main__": #... (le reste du code reste inchangé jusqu'à la boucle du traitement des fichiers) center_preference = get_center_preference() # Nouvelle fonction pour obtenir la préférence de position du centre for root, dirs, files in os.walk('.'): for file in files: 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, num_segments, segment_duration, preference, center_preference) print("All videos have been processed.")Notez que dans la fonction
process_video_file, nous ajustons lestart_timeen soustrayant une fraction de lasegment_durationmultipliée par(center_preference - 3)et divisée par 6, ce qui correspond à placer le centre du segment selon la préférence de l'utilisateur. Nous utilisonsmax(start_time, 0)pour éviter un début de segment négatif.Vous devez maintenant intégrer ces modifications dans votre script pour ajouter la nouvelle fonctionnalité. Assurez-vous d'effectuer des tests pour confirmer que les segments sont correctement centrés en fonction de la préférence de l'utilisateur.
- Modifier la fonction