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 find_sound_amplitude_peak(audio_data): """Find the position of the highest sound amplitude peak.""" peak_position = np.argmax(np.abs(audio_data)) return peak_position
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 extract_adjusted_segment(video_path, start_time, duration, output_path, rate, audio_data, peak_position_preference, segment_duration): """Adjust the start time of the segment to position the sound peak where the user wants it.""" peak_position = find_sound_amplitude_peak(audio_data) desired_peak_position = int(segment_duration * peak_position_preference / 6 * rate) adjusted_start_time = max(start_time + (peak_position - desired_peak_position) / rate, 0) extract_segment(video_path, adjusted_start_time, duration, output_path)
def process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference, peak_position_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) segment_audio = audio_data[int(start_time*rate):int((start_time+segment_duration)*rate)] extract_adjusted_segment(video_path, start_time, segment_duration, output_path, rate, segment_audio, peak_position_preference, segment_duration) print(f"Extracted and adjusted 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) # Nouveau prompt pour la position du pic sonore print("Choose the position for the maximum sound amplitude peak:") print("1 - at 1/6 of the segment playback time") print("2 - at 2/6 of the segment playback time") print("3 - at 3/6 of the segment playback time") print("4 - at 4/6 of the segment playback time") print("5 - at 5/6 of the segment playback time") peak_position_preference = int(input("Enter the number of your preference (1-6): ")) # Validate the user’s preference if peak_position_preference not in range(1, 7): print("Invalid preference. Please enter a number between 1 and 6.") exit(1)
files = os.listdir('.') 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('.', file) print(f"Processing video {video_path}…") process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference, peak_position_preference) print("All videos have been processed.") - Assistant
Your Python script appears to fit for processing video files, extracting the loudest segments based on ITU-R BS.1770-4 loudness measurements, and sorting those segments according to specified user preferences. It also considers user-specified segments' starting and ending offsets, duration, and desired placement of peak amplitude within the extracted segments. It uses
moviepyfor handling video files andffmpegfor the extraction of video segments.Here is a brief overview of the key functions and their purposes:
-
calculate_loudness: This function computes the loudness level of an audio segment using ITU-R BS.1770-4 specifications. -
find_loudest_segments: This function finds the loudest segments of the provided audio data based on the loudness calculation and given criteria like segment duration and offset positions. -
find_sound_amplitude_peak: This function identifies the position of the highest amplitude peak in the audio data. -
sort_segments: This function sorts the found segments by loudness or order of occurrence in the video based on user preference. -
extract_segment: This function callsffmpegto cut out a video segment and saves it with x264 encoding. -
extract_adjusted_segment: This function adjusts the start time of the loud segment to position the peak of sound amplitude where desired based on user input and then callsextract_segment. -
process_video_file: This function manages the full processing pipeline for a single video file, from extracting audio data to saving the processed video segments.
The script requests user input for various parameters, seeks and processes compatible video files within the current directory, and outputs the result in a specified
Outputfolder.A couple of potential issues and suggestions:
- Ensure that the
ffmpegcommand is correct based on the input file's codec and format requirements. The script assumesffmpegis installed and accessible in the system's PATH. - Audio normalization: Loudness calculation doesn't include audio normalization, which might be important since loudness can be heavily influenced by the absolute levels of audio signals.
- Error handling: The script should include more thorough error checking and handling throughout, to gracefully deal with issues like missing files, unsupported formats, or
ffmpegerrors. calculate_loudnessfunction might not implement the complete ITU-R BS.1770-4 specification. An actual implementation should consider relative threshold gating and frequency weighting, which are missing in the provided code.- Performance optimizations might be necessary if dealing with large videos or large numbers of videos to process, since the script could potentially consume considerable CPU and memory.
Before using the script, make sure you have all required libraries installed (e.g.,
moviepy,numpy,scipy, etc.), and theffmpegexecutable is correctly set up. -
- User
Peux-tu m'assister pour implémenter ITU-R BS.1770-4 ?
- Assistant
L'implémentation de la norme ITU-R BS.1770-4 pour la mesure de la loudness n'est pas triviale, car elle implique plusieurs étapes de traitement du signal audio, notamment le filtrage K-weighted, l'intégration du signal sur une certaine période, et l'application de la pondération temporelle relative. Voici une implémentation de base des étapes critiques de cette norme en Python en utilisant numpy et scipy :
from scipy.signal import lfilter def k_weighted_filter(audio_data, rate): """ Apply ITU-R BS.1770-4 pre-filtering and RLB weighting to an audio signal. :param audio_data: np.array, audio samples :param rate: int, sample rate of audio_data :return: np.array, filtered audio data """ # Pre-filter coefficients (high-pass) pre_b = [1.53512485958697, -2.69169618940638, 1.19839281085285] pre_a = [1.00000000000000, -1.69065929318241, 0.73248077421585] # RLB (Revised Low-Frequency B/C-weighting) filter coefficients rlb_b = [1.0] rlb_a = [1.0] # Apply pre-filter audio_data = lfilter(pre_b, pre_a, audio_data) # Apply RLB-weighting filter (if different from [1.0], [1.0]) audio_data = lfilter(rlb_b, rlb_a, audio_data) return audio_data def calculate_lkfs(audio_data, rate): """ Calculate the LKFS (Loudness, K-weighted, relative to Full Scale) level of an audio signal according to ITU-R BS.1770-4. :param audio_data: np.array, audio samples of the signal :param rate: int, sample rate of audio_data :return: float, LKFS value """ # Apply K-weighted filtering filtered_data = k_weighted_filter(audio_data, rate) # Square and find the mean of the filtered signal mean_square = np.mean(filtered_data ** 2) # Convert to decibels relative to full scale (dBFS) lkfs = -0.691 + 10 * np.log10(mean_square) return lkfsVoici les étapes pour calculer la loudness selon l'ITU-R BS.1770-4 :
- Filtre de préaccentuation : Appliquer un filtre passe-haut sur le signal audio.
- Pondération RLB : Appliquer un filtre de pondération en fréquence spécifié par le standard.
- Calcul de la moyenne quadratique : Calculer la moyenne quadratique des échantillons du signal filtré.
- Conversion en dBFS : Convertir la moyenne quadratique en loudness en unités de LKFS (Loudness K-weighted relative to Full Scale).
Les coefficients utilisés pour le filtre de préaccentuation (
pre_betpre_a) sont ceux spécifiés par la norme. Actuellement, pour la pondération RLB, les coefficients utilisés sont neutres (rlb_b = [1.0]etrlb_a = [1.0]), ce qui signifie qu'aucune pondération supplémentaire n'est appliquée. Cela est fait pour simplifier l'exemple, mais une implémentation complète nécessiterait d'utiliser les coefficients appropriés du filtre RLB.Les étapes de porte de silence relative et de porte d'intégration ne sont pas incluses dans cet exemple, et sont également nécessaires pour une complète conformité à la norme ITU-R BS.1770-4. Pour une intégration parfaite de ces normes, il serait préférable d'utiliser une bibliothèque qui implémente déjà ITU-R BS.1770, comme
pyloudnorm.Si vous optez pour une implémentation déjà établie, vous pouvez installer
pyloudnormvia pip et l'utiliser pour calculer la loudness sans devoir implémenter la norme à partir de zéro :pip install pyloudnormEt voici comment vous pourriez l'utiliser dans votre code :
import pyloudnorm as pyln # create a Meter instance meter = pyln.Meter(rate) # rate: the sample rate of the audio # measure loudness loudness = meter.integrated_loudness(audio_data) print("Loudness:", loudness) - User
Y aurait-il une autre solution que ITU-R BS.1770-4?
- Assistant
Oui, il existe plusieurs autres méthodes pour estimer le niveau de volume ou de "loudness" d'un enregistrement audio, en dehors du standard ITU-R BS.1770-4. Voici quelques approches alternatives :
-
Peak Metering (Crête) : Mesure le pic maximal du signal audio. C'est la méthode la plus simple, mais elle ne prend pas en compte la perception auditive humaine et peut être trompeuse pour des sons brefs ayant une grande amplitude mais perçus comme pas très forts.
-
VU Metering (Volume Unit Metering) : Un VU mètre indique une moyenne du volume perçu, en tenant compte d'une pondération temporelle qui simule la perception humaine. Il est moins précis que les loudness meters modernes mais reste utilisé dans la radiodiffusion.
-
Root Mean Square (RMS) : Indique la moyenne quadratique du signal audio, ce qui correspond mieux à la perception de la force du son que la mesure de pic seul. Les valeurs RMS sont souvent utilisées pour évaluer la "perceived loudness".
-
Leq (Equivalent Continuous Sound Level) : Une mesure de la loudness sur une période déterminée, similaire à LKFS mais sans la pondération en fréquence utilisée dans les mesures ITU-R BS.1770.
-
EBU R128 : Bien qu'il s'agisse en réalité d'une norme qui utilise la mesure de loudness ITU-R BS.1770, EBU R128 fournit des recommandations spécifiques pour la radiodiffusion en Europe, avec des stratégies de mesure et de normalisation légèrement différentes.
-
Algorithms spécifiques de la marque : Des entreprises comme Waves, Dolby ou TC Electronic proposent leurs propres systèmes de mesure de loudness qui peuvent avoir des caractéristiques uniques ou des traitements de signal propriétaires.
-
Loudness Algorithms in Audio Editors : Les logiciels d'édition audio et de production musicale intègrent souvent leurs propres algorithmes pour estimer la loudness. Par exemple, Reaper, Cubase, et Logic Pro X ont des outils de mesure de loudness intégrés.
-
Bibliothèques Python : En dehors de
pyloudnorm, il existe d'autres bibliothèques Python qui peuvent mesurer de différents aspects du volume sonore, commelibrosapour l'analyse musicale ouauditokpour la détection des événements sonores.
Chacune de ces méthodes a ses avantages et ses inconvénients et est utilisée dans des contextes différents en fonction des besoins. Pour des applications telles que la radiodiffusion, la post-production audiovisuelle, et certaines formes de musique, ITU-R BS.1770 et ses variantes (comme EBU R128) sont devenues des standards industriels en raison de leur robustesse et de leur cohérence avec la perception auditive humaine. Pour des applications moins critiques ou pour une utilisation simplifiée, des mesures comme le RMS ou le peak metering peuvent suffire.
-
- User
Peux-tu, à partir du script original, m'indiquer comment remplacer ITU-R BS.1770-4 par EBU R128 ?
- Assistant
Pour remplacer ITU-R BS.1770-4 par EBU R128 dans votre script Python, vous pouvez utiliser la bibliothèque
pyloudnorm, qui propose une implémentation conforme de la norme EBU R128. La norme EBU R128 est basée sur les mêmes principes que ITU-R BS.1770-4 pour la mesure de la loudness, mais définit des pratiques spécifiques de normalisation pour la radiodiffusion.Voici les étapes à suivre :
-
Installer pyloudnorm: Si ce n'est pas déjà fait, installez la bibliothèque en exécutant
pip install pyloudnormdans votre environnement Python. -
Importer pyloudnorm dans votre script: Ajoutez
import pyloudnorm as pylndans votre script pour pouvoir utiliser la bibliothèque. -
Remplacer la fonction de calcul de la loudness: Utilisez
pyloudnorm.Meterpour mesurer la loudness selon EBU R128 à la place de la méthodecalculate_loudness. La fonctionpyloudnorm.Meter.integrated_loudnessretournera une valeur LKFS conforme à EBU R128.
Voici un exemple de code modifié qui utilise
pyloudnormpour mesurer la loudness selon EBU R128 :from moviepy.editor import VideoFileClip from scipy.io import wavfile import numpy as np import os import subprocess import uuid import pyloudnorm as pyln # ... (Autre code) def measure_loudness(audio_data, rate): """Measure loudness using EBU R128 standard.""" # Créez une instance de Meter avec le taux d'échantillonnage de l'audio meter = pyln.Meter(rate) # Mesurez la loudness intégrée (en LKFS) loudness = meter.integrated_loudness(audio_data) return loudness # ... (Autre code) def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset): """Find the segments with the highest loudness using EBU R128.""" # ... (Code pour segmenter l'audio) # Utilisez la nouvelle fonction measure_loudness segment_loudness = [ measure_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)) ] # ... (Reste de la fonction) # ... (Autre code)Faites attention aux points suivants :
- EBU R128 utilise des termes spécifiques comme LKFS (Loudness K-weighted relative to Full Scale) qui sont pratiquement équivalents aux LUFS (Loudness Units relative to Full Scale) du standard ITU-R BS.1770.
- La mesure de la loudness selon EBU R128 intègre déjà les techniques de filtrage K-Weighting et True Peak, donc vous n'avez pas besoin de gérer cela manuellement dans votre script.
- Comme les implémentations de loudness metering peuvent être sensibles à la structure du signal audio (ex: True Peak, momentary, short-term loudness), assurez-vous de lire la documentation de
pyloudnormpour comprendre les différentes fonctions qu’elle offre et sélectionner celles qui correspondent à vos besoins.
En utilisant
pyloudnormet en modifiant votre script pour mesurer la loudness avec la norme EBU R128, vous vous assurez de respecter les directives de broadcast européennes tout en simplifiant le code lié au calcul de la loudness. -
- User
Traceback (most recent call last): File "H:\Tests\V2 - encodage - dossier relatif - BU R128.py", line 156, in process_video_file(video_path, starting_offset, ending_offset, num_segments, segment_duration, preference, peak_position_preference) File "H:\Tests\V2 - encodage - dossier relatif - BU R128.py", line 95, in process_video_file segments_with_loudness = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset) File "H:\Tests\V2 - encodage - dossier relatif - BU R128.py", line 25, in find_loudest_segments segment_loudness = [ File "H:\Tests\V2 - encodage - dossier relatif - BU R128.py", line 26, in measure_loudness( File "H:\Tests\V2 - encodage - dossier relatif - BU R128.py", line 18, in measure_loudness loudness = meter.integrated_loudness(audio_data) File "C:\Users\jp\AppData\Local\Programs\Python\Python310\lib\site-packages\pyloudnorm\meter.py", line 55, in integrated_loudness util.valid_audio(input_data, self.rate, self.block_size) File "C:\Users\jp\AppData\Local\Programs\Python\Python310\lib\site-packages\pyloudnorm\util.py", line 27, in valid_audio raise ValueError("Data must be floating point.") ValueError: Data must be floating point.
- Assistant
L'erreur que vous rencontrez est causée par le fait que
pyloudnorms'attend à ce que les données audio soient sous forme de nombres à virgule flottante, mais que les données audio sont probablement fournies sous forme d'entiers. Cela peut se produire lorsqu’on charge un fichier WAV : par défaut,scipy.io.wavfile.readrenvoie des entiers si le fichier WAV est codé en PCM 16 bits, par exemple.Pour résoudre ce problème, vous devez convertir les données audio en
float32oufloat64. Voici comment vous pouvez modifier votre fonction de lecture de fichier WAV :def read_audio_file_as_float(path_to_wav): rate, data = wavfile.read(path_to_wav) # Convertir le tableau en float if data.dtype == np.int16: data = data.astype(np.float32) / np.iinfo(np.int16).max elif data.dtype == np.int32: data = data.astype(np.float32) / np.iinfo(np.int32).max elif data.dtype == np.uint8: data = (data.astype(np.float32) - 128) / np.iinfo(np.uint8).max return rate, data # Utilisez cette nouvelle fonction pour lire le fichier audio rate, audio_data = read_audio_file_as_float(audio_filename)Cette fonction va vérifier le type de données (dtype) et effectuer la conversion appropriée en nombre à virgule flottante, en normalisant les données audio dans l'intervalle [-1, 1], ce qui est nécessaire pour
pyloudnorm.Faites cette modification, puis essayez de réexécuter votre script. Cela devrait corriger l’erreur et vous permettre de mesurer la loudness intégrée avec
pyloudnorm. - User
Intègre le VU Metering pour le calcul dans le script d'origine
- Assistant
Le VU Metering (Volume Unit Metering) est une méthode traditionnelle pour estimer la "loudness" d'un signal audio. Contrairement à l'ITU-R BS.1770-4 et EBU R128 qui prennent en compte la loudness intégrée sur une période de temps avec une pondération en fréquence, le VU Mètre est basé sur une réactivité moyenne, et il n'est pas toujours représentatif de la perception humaine de la loudness.
Cependant, pour intégrer un VU Meter simple dans votre script, vous pouvez utiliser les valeurs RMS (Root Mean Square) qui propose une approximation de ce que donnerait un VU Meter. Voici comment vous pourriez calculer le RMS d'un segment audio dans votre script :
def calculate_rms(audio_data): """Calculate the Root Mean Square (RMS) loudness of audio data.""" rms = np.sqrt(np.mean(np.square(audio_data, dtype=np.float64))) return 20 * np.log10(rms) def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset): """Find the segments with the highest RMS values in the audio data.""" # Convert the audio data to float, if necessary if audio_data.dtype.kind != 'f': audio_data = audio_data.astype('float32') / np.iinfo(audio_data.dtype).max # Calculate the RMS of each segment in the audio file segment_loudness = [ calculate_rms( audio_data[max(0, i * int(rate * segment_duration)) : min(len(audio_data), (i + 1) * int(rate * segment_duration))]) for i in range(0, int((video_duration - starting_offset - ending_offset) / segment_duration)) ] # ... (Reste de la fonction) # Note: Le reste de la fonction reste inchangé. return loudness_and_segments[:num_segments]La fonction
calculate_rmsconvertit d'abord les données enfloat64si ce n'est pas déjà le cas, calcule la moyenne quadratique (RMS), puis convertit cette valeur en décibels. Lorsque vous trouvez les segments les plus forts, nous utilisons cette fonction pour calculer la loudness RMS de chaque segment.N'oubliez pas que le RMS n'est pas nécessairement représentatif du niveau de loudness perçu pour des matériaux audio à gamme dynamique complexe, comme de la musique ou des émissions de télévision, et que la norme EBU R128 est généralement préférée pour ces usages. Toutefois, le RMS peut être un indicateur suffisamment précis pour des signaux plus simples ou pour une approximation rapide de la loudness.
- User
Intègre la méthode Leq au script d'origine
- Assistant
La méthode Leq (Equivalent Continuous Sound Level) est une autre méthode de mesure du niveau sonore. Elle est souvent utilisée pour évaluer l'exposition au bruit sur une période prolongée et donne une moyenne du niveau de pression sonore constant équivalent qui aurait la même énergie sonore que le bruit mesuré sur la période donnée. Pour l'intégrer dans votre script d'origine, on peut construire une fonction qui calcule le Leq d'un segment de données audio.
Voici comment vous pourriez intégrer cela :
import numpy as np # ... (les autres importations) def calculate_leq(audio_data): """Calculate the Equivalent Continuous Sound Level (Leq) of audio data.""" # Ensure audio is in float representation if not issubclass(audio_data.dtype.type, np.floating): audio_data = audio_data.astype(np.float32) / np.iinfo(audio_data.dtype).max # Calculate the square of the signal audio_data_squared = np.square(audio_data) # Calculate the mean of the squared signal mean_square = np.mean(audio_data_squared) # Calculate the Leq (energy equivalent level) leq = 10 * np.log10(mean_square) return leq # ... (le reste du code reste inchangé) def find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset): """Find the segments with the highest Leq in the audio data.""" # Make sure audio data is floating point before processing if not issubclass(audio_data.dtype.type, np.floating): audio_data = audio_data.astype('float32') / np.iinfo(audio_data.dtype).max # Calculate the Leq of each segment in the audio file segment_loudness = [ calculate_leq( audio_data[max(0, i * int(rate * segment_duration)): min(len(audio_data), (i + 1) * int(rate * segment_duration))]) for i in range(0, int((video_duration - starting_offset - ending_offset) / segment_duration)) ] # ... (Reste de la fonction) return loudness_and_segments[:num_segments] # ... (le reste du code reste inchangé)La fonction
calculate_lequtilise la moyenne des carrés des valeurs des samples audio pour calculer l'énergie sonore moyenne. Elle renvoie ensuite le Leq en décibels, en utilisant un logarithme à base 10.Dans
find_loudest_segments, nous utilisons maintenant la méthodecalculate_leqpour obtenir la loudness de chaque segment. Les segments sont ensuite triés en fonction de leur loudness pour trouver les plus forts.Assurez-vous d'avoir la librairie NumPy installée dans votre environnement Python pour effectuer ces calculs. La fonction
isinstance(audio_data.dtype.type, np.floating)vérifie si les données audio sont déjà au format à virgule flottante avant de procéder au calcul du Leq. Sinon, elle les convertit en format à virgule flottante en les normalisant avec le maximum possible pour leur type de données d'origine, garantissant ainsi une échelle normalisée entre -1 et 1. - User
avec cette méthode, y a-t-il des fonctions que je peux supprimer ?
- Assistant
Avec l'introduction de la méthode Leq pour évaluer le niveau de volume des segments audio, vous pouvez remplacer ou supprimer toutes les fonctions qui s'occupent de mesurer la loudness si vous ne les utilisez plus pour d'autres calculs. Cela inclut toute méthode de mesure de volume qui est différente de Leq, comme celle basée sur ITU-R BS.1770-4, EBU R128 ou tout autre algorithme spécifique de loudness.
Voici les modifications que vous pouvez apporter :
-
Retirez ou remplacez la fonction
calculate_loudnesspar la fonctioncalculate_leq. Si vous suivez la méthode Leq, aucune autre mesure de loudness n'est nécessaire. -
Si vous avez intégré des outils spécifiques pour la pondération K-weighted ou pour d'autres traitements de signal spécifiques à ITU-R ou EBU R128, vous pouvez également les supprimer du script. Cela comprend la suppression des importations associées et des codes qui ne sont pas pertinents pour le calcul Leq.
Par exemple :
# Supprimez ou remplacez ça : def calculate_loudness(audio_data, rate): """Calculate loudness using ITU-R BS.1770-4 method.""" # ... def measure_loudness(audio_data, rate): """Measure loudness using EBU R128 standard.""" # ... # Par ça : def calculate_leq(audio_data): """Calculate the Equivalent Continuous Sound Level (Leq) of audio data.""" # ... # Dans votre fonction principale, remplacez l'ancien calcul de loudness par Leq : # (en supposant que vous ayez déjà une fonction `calculate_leq` correctement définie) loudness = calculate_leq(segment_audio)- Enfin, adaptez la logique de la fonction
find_loudest_segmentspour utiliser la nouvelle méthode de mesure de volume, comme démontré dans les exemples précédents.
Après ces changements, vous n'aurez plus besoin des fonctions inutilisées liées à la mesure de loudness basée sur ITU-R BS.1770-4 ou EBU R128, ce qui simplifie votre code et le rend plus adapté à vos besoins actuels liés à la méthode Leq.
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.