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

Voici le script 1 : import os import subprocess import numpy as np import uuid from…

  1. User

    Voici le script 1 :

    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 the audio file and loop over to find top segments loudness = np.array([calculate_loudness(audio_data[max(0, idx - int(rate * segment_duration)):min(len(audio_data), idx + int(rate * segment_duration))], rate) for idx in range(0, len(audio_data), int(rate * segment_duration))]) sorted_indices = np.argsort(loudness)[::-1] segments = [] for idx in sorted_indices: if len(segments) >= num_segments: break segment_start_time = idx * segment_duration if segment_start_time < starting_offset or segment_start_time + segment_duration > video_duration - ending_offset: continue segments.append(segment_start_time) return segments

    def extract_segment(video_path, start_time, duration, output_path): """Use ffmpeg to extract a segment from a video.""" command = [ "ffmpeg", "-y", # Overwrite output files without asking "-ss", str(start_time), # Start time "-i", video_path, # Input file "-t", str(duration), # Duration "-c", "copy", # Copy the streams without re-encoding 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): """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 = find_loudest_segments(audio_data, rate, num_segments, segment_duration, video_duration, starting_offset, ending_offset)
    
        if not os.path.exists(output_folder):
            os.makedirs(output_folder)
        for i, start_time in enumerate(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
    

    Main

    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)? "))

    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)
    
    print("All videos have been processed.")
    
  2. Assistant

    Le script 1 que vous avez fourni est un programme Python qui traite des fichiers vidéo afin de trouver et d'extraire les segments les plus bruyants des vidéos. Il utilise la bibliothèque MoviePy pour lire et traiter les fichiers vidéo et ffmpeg pour extraire les segments vidéo spécifiques. Voici une brève description de ce que fait le script:

    1. Le script commence par définir les extensions de fichier vidéo supportées et le dossier de sortie pour les segments extraits.

    2. La fonction calculate_loudness est utilisée pour calculer la sonie (loudness) d'une piste audio selon la méthode ITU-R BS.1770-4. Elle prend en compte une éventuelle stéréo en convertissant le son en mono par moyenne des canaux si nécessaire.

    3. La fonction find_loudest_segments calcule la sonie de morceaux successifs de la piste audio et trouve les segments ayant la sonie la plus élevée, en tenant compte d'un offset de démarrage et de fin pour éviter d'examiner des parties non pertinentes de la vidéo.

    4. La fonction extract_segment invoque ffmpeg pour extraire un segment spécifique de la vidéo à partir d'un point de départ donné et pour une durée déterminée.

    5. La fonction process_video_file effectue le traitement complet sur un seul fichier vidéo. Elle lit les données audio de la vidéo, trouve les segments les plus bruyants et extrait ces segments dans le dossier de sortie.

    6. Le bloc if __name__ == "__main__": démarre comme le point d'entrée du script. Il demande à l'utilisateur de saisir les offsets (décalages) de début et de fin, le nombre de segments à extraire et la durée de chaque segment. Il parcoure ensuite tous les fichiers des dossiers à la recherche de fichiers vidéo à traiter et invoque la fonction process_video_file sur chacun d'eux.

    7. Le script nettoie ensuite en supprimant les fichiers audio temporaires créés pendant le processus et notifie que le traitement de tous les vidé os est terminé.

    Veillez à installer les dépendances requises (comme MoviePy et ffmpeg) avant d'exécuter le script, et assurez-vous également que ffmpeg est accessible depuis la ligne de commande (c'est-à-dire qu'il est dans le PATH de votre système).

  3. User

    Voici le script 2 :

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

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

    def calculate_loudness(audio_data): if audio_data.ndim == 1: volume = audio_data ** 2 else: volume = np.mean(audio_data ** 2, axis=1) return np.sqrt(volume)

    def find_loudest_moments(audio_data, segment_duration, video_duration, starting_offset, ending_offset, step_percentage, rate, clearance_factor=0): volume = calculate_loudness(audio_data.astype('float32'))

    step_size = int(video_duration * step_percentage * rate)  # Pas en échantillons (samples)
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)
    
    intervals = [(i, min(i + step_size, end_index)) for i in range(start_index, end_index, step_size)]
    moments = []
    
    for start, end in intervals:
        # S'assurer qu'il y a assez de temps dans cet intervalle pour un segment
        if end - start < segment_duration * rate:
            continue
    
        # Trouver le pic de volume le plus fort dans l'intervalle
        index = np.argmax(volume[start:end])
        moment = (start + index) / rate
        if moment - segment_duration / 2 < starting_offset or moment + segment_duration / 2 > video_duration - ending_offset:
            continue  # Ignorer les moments trop proches des bords de la vidéo
    
        # Ajuster la tolérance pour les chevauchements
        clearance = int(clearance_factor * segment_duration * rate)
        clear_start = max(start, index - clearance)
        clear_end = min(len(volume), index + clearance)
    
        # Mettre à zéro le volume autour du moment actuel pour éviter la répétition
        volume[max(start, clear_start):min(end, clear_end)] = 0
        moments.append(moment)
    
    return sorted(moments)
    

    def detect_loudest_moments(video_path, starting_offset_seconds, ending_offset_seconds, segment_duration, step_percentage): unique_id = str(uuid.uuid4()) audio_path = f'temp_audio{unique_id}.wav' try: video_clip = VideoFileClip(video_path) video_duration = video_clip.duration video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000) rate, audio_data = wavfile.read(audio_path) video_clip.close() return find_loudest_moments(audio_data, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds, step_percentage, rate), video_duration finally: if os.path.exists(audio_path): os.remove(audio_path)

    def ask_peak_position(): print("Choisissez le positionnement du pic sonore dans le segment vidéo :") print("1 - En début de vidéo (à un tiers)") print("2 - Au milieu de la vidéo") print("3 - En fin de vidéo (aux deux tiers)") print("4 - Aléatoire (à un tiers, au milieu, ou aux deux tiers)") choice = input("Entrez le numéro de votre choix : ")

    while choice not in ('1', '2', '3', '4'):
        print("Entrée invalide. Veuillez choisir une option valide.")
        choice = input("Entrez le numéro de votre choix : ")
    
    return int(choice)
    

    def ask_confirmation(num_moments): print(f"Le script a identifié {num_moments} moments forts.") print("Voulez-vous :") print("1 - Confirmer le nombre de moments forts") print("2 - Modifier le pas en pourcentage") choice = input("Entrez le numéro de votre choix : ")

    while choice not in ('1', '2'):
        print("Entrée invalide. Veuillez choisir une option valide.")
        choice = input("Entrez le numéro de votre choix : ")
    
    return choice
    

    def extract_segments(video_path, moments, segment_duration, peak_position_choice, video_duration): if not os.path.exists(output_folder): os.makedirs(output_folder) base_name = os.path.splitext(os.path.basename(video_path))[0]

    for i, moment in enumerate(moments):
        if peak_position_choice == 1: # Start of video
            start_time = max(moment - segment_duration / 3, 0)
        elif peak_position_choice == 2: # Middle of video
            start_time = max(moment - segment_duration / 2, 0)
        elif peak_position_choice == 3: # End of video
            start_time = max(moment - 2 * segment_duration / 3, 0)
        elif peak_position_choice == 4: # Random
            start_time = max(moment - segment_duration * random.choice([1/3, 1/2, 2/3]), 0)
        else:
            raise ValueError("Invalid peak position choice")
    
        end_time = min(start_time + segment_duration, video_duration)
        output_filename = f"{base_name}_moment{i + 1}.mp4"
        output_path = os.path.join(output_folder, output_filename)
    
        command = [
            "ffmpeg",
            "-y",
            "-ss", str(start_time),
            "-i", video_path,
            "-t", str(min(segment_duration, video_duration - start_time)),
            "-c:v", "libx264",
            "-preset", "medium",
            "-crf", "23",
            "-c:a", "aac",
            "-strict", "-2",
            "-b:a", "192k",
            output_path
        ]
    
        subprocess.run(command, check=True, stderr=subprocess.PIPE)
        print(f"Extracted and re-encoded {output_filename}")
    

    def process_video_files(starting_offset_seconds, ending_offset_seconds, segment_duration, peak_position_choice, step_percentage): temporary_audio_files = [] num_moments_total = 0

    for root, _, files in os.walk('.'):
        for file in files:
            if file.lower().endswith(tuple(video_extensions)):
                video_path = os.path.join(root, file)
                unique_id = str(uuid.uuid4())
                audio_path = f'temp_audio{unique_id}.wav'
                temporary_audio_files.append(audio_path)
    
                try:
                    video_clip = VideoFileClip(video_path)
                    video_duration = video_clip.duration
                    video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', fps=44100, nbytes=2, buffersize=2000)
                    video_clip.close()
                    
                    rate, audio_data = wavfile.read(audio_path)
                    moments = find_loudest_moments(audio_data, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds, step_percentage, rate)
                    num_moments_total += len(moments)
                    extract_segments(video_path, moments, segment_duration, peak_position_choice, video_duration)
                finally:
                    if os.path.exists(audio_path):
                        os.remove(audio_path)
                print(f"Finished processing video {video_path}")
    
    # Cleanup temporary audio files created during processing
    for audio_file in temporary_audio_files:
        if os.path.exists(audio_file):
            os.remove(audio_file)
    
    return num_moments_total
    

    if name == "main": starting_offset_seconds = float(input("Combien de secondes à ignorer au début pour l'analyse ? ")) ending_offset_seconds = float(input("Combien de secondes à ignorer à la fin pour l'analyse ? ")) segment_duration = float(input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? ")) step_percentage = float(input("Quel pourcentage de la durée totale de la vidéo doit être utilisé comme pas ? ")) / 100 peak_position_choice = ask_peak_position()

    confirmed = False
    moments_detected = {}
    
    while not confirmed:
        num_moments = 0
        for root, _, files in os.walk('.'):
            for file in files:
                if file.lower().endswith(tuple(video_extensions)):
                    video_path = os.path.join(root, file)
                    moments, video_duration = detect_loudest_moments(video_path, starting_offset_seconds, ending_offset_seconds, segment_duration, step_percentage)
                    moments_detected[video_path] = (moments, video_duration)  # Save the detected moments
                    num_moments += len(moments)
        
        print(f"Le script a détecté {num_moments} moments forts.")
        confirmation = ask_confirmation(num_moments)
        
        if confirmation == '1':
            confirmed = True
        else:
            step_percentage = float(input("Veuillez entrer un nouveau pas en pourcentage : ")) / 100
    
    for video_path, (moments, video_duration) in moments_detected.items():
        extract_segments(video_path, moments, segment_duration, peak_position_choice, video_duration)
                
    print("All temporary audio files have been cleaned up.")
    print("All videos have been processed.")
    
  4. Assistant

    Le script 2 que vous avez fourni est une variante améliorée du premier script Python qui traite également des fichiers vidéo pour extraire des segments spécifiques en se basant sur la sonie (loudness) de l'audio. Voici un aperçu du script :

    1. Le script contient des fonctions pour calculer le volume des pistes audio et détecter les moments les plus bruyants.

    2. La fonction calculate_loudness calcule le volume de l'audio, en tenant compte du fait que l'audio peut être mono ou stéréo.

    3. La fonction find_loudest_moments utilise une approche de fenêtrage pour identifier les moments les plus forts dans l'audio selon un certain pas (step_size, déterminé en pourcentage de la durée).

    4. La fonction detect_loudest_moments lit le fichier vidéo, extrait l'audio, détecte les moments les plus forts et retourne ces moments ainsi que la durée totale de la vidéo.

    5. Des fonctions sont proposées pour demander à l'utilisateur comment il souhaite positionner les pics sonores dans les segments vidéo (ask_peak_position) et s'il est satisfait du nombre de moments détectés (ask_confirmation).

    6. La fonction extract_segments extrait les segments sélectionnés en utilisant ffmpeg, avec la possibilité de placer le pic sonore en début, au milieu, en fin, ou à un emplacement aléatoire dans la vidéo.

    7. La fonction process_video_files parcourt le système de fichiers, traite chaque fichier vidéo trouvé et extrait les segments conformément aux choix de l'utilisateur.

    Le bloc principal du script (if __name__ == "__main__":) demande à l'utilisateur de saisir divers paramètres, y compris l'offset de début et de fin, la durée des segments, le pas en pourcentage pour la détection des moments forts et la position du pic sonore. Après confirmation des paramètres, le script processe chaque fichier vidéo et extrait les segments.

    À la fin du script, tous les fichiers audio temporaires sont nettoyés, et un message confirme que tous les fichiers vidéo ont été traités.

    Assurez-vous que les dépendances nécessaires sont installées et à jour (comme MoviePy, NumPy et ffmpeg) et que ffmpeg est accessible depuis la ligne de commande de votre système pour que ce script fonctionne correctement.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.