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

Voici un script : import os import subprocess import numpy as np import uuid # Import…

  1. User

    Voici un script :

    import os import subprocess import numpy as np import uuid # Import uuid to generate unique IDs from moviepy.editor import VideoFileClip from scipy.io import wavfile

    temporary_audio_files = []

    Define video file extensions and the output folder

    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_filename, num_moments, segment_duration, video_duration, starting_offset, ending_offset): rate, audio_data = wavfile.read(audio_filename) if audio_data.ndim == 2: audio_data = np.mean(audio_data, axis=1) volume = calculate_loudness(audio_data.astype('float32'))

    segment_half_duration = segment_duration / 2.0
    start_index = int(starting_offset * rate)
    end_index = int((video_duration - ending_offset) * rate)
    moments = []
    
    while len(moments) < num_moments:
        index = np.argmax(volume[start_index:end_index])
        moment = (start_index + index) / rate
        
        # Skip the moment if it is too close to the start or the end of the video
        if moment - segment_half_duration < starting_offset or moment + segment_half_duration > video_duration - ending_offset:
            volume[start_index + index] = 0
            continue
        
        moments.append(moment)
        clear_start = max(start_index, start_index + index - int(rate * segment_half_duration))
        clear_end = min(end_index, start_index + index + int(rate * segment_half_duration))
        volume[clear_start:clear_end] = 0
    
    return moments
    

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

    for i, moment in enumerate(moments):
        start_time = max(moment - half_segment_duration, 0)
        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",                     # Overwrite output files without asking
            "-ss", str(start_time),   # Start time
            "-i", video_path,         # Input file
            "-t", str(min(segment_duration, video_duration - start_time)),  # Duration or remaining video
            "-c:v", "libx264",        # Specify video codec for output
            "-preset", "medium",      # Specify the encoding preset (trade-off between encoding speed and quality)
            "-crf", "23",             # Specify the Constant Rate Factor for quality (lower means better quality)
            "-c:a", "aac",            # Specify audio codec for output
            "-strict", "-2",          # Necessary for some versions of ffmpeg to use experimental aac encoder
            "-b:a", "192k",           # Specify the audio bitrate
            output_path               # 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, num_moments, segment_duration): 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()) # Generate a unique ID for this video's audio file audio_path = f'temp_audio{unique_id}.wav' # Name the temporary file using the unique ID temporary_audio_files.append(audio_path) # Add the temporary file path to the list

                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()  # Ensure to close the video clip
                    
                    moments = find_loudest_moments(audio_path, num_moments, segment_duration, video_duration, starting_offset_seconds, ending_offset_seconds)
                    extract_segments(video_path, moments, segment_duration, video_duration)  # Now pass video_duration
                
                finally:
                    if os.path.exists(audio_path):
                        os.remove(audio_path)
                    
                print(f"Finished processing video {video_path}")
    

    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 ? ")) num_moments = int(input("Combien de moments forts souhaiteriez-vous extraire de chaque vidéo ? ")) segment_duration = float(input("Quelle est la durée (en secondes) de chaque segment vidéo à extraire ? "))

    process_video_files(starting_offset_seconds, ending_offset_seconds, num_moments, segment_duration)
    
    # Après le traitement de tous les fichiers vidéo, nettoyez les fichiers WAV temporaires
    for audio_file in temporary_audio_files:
        if os.path.exists(audio_file):
            os.remove(audio_file)
    
    print("All temporary audio files have been cleaned up.")
    print("All videos have been processed.")
    
  2. Assistant

    Le script présenté est conçu pour traiter des fichiers vidéo en extrayant les moments les plus bruyants sous forme de courts segments vidéo. Voici comment il fonctionne :

    1. Importation des modules nécessaires : os, subprocess, numpy (alias np), uuid, moviepy.editor (pour VideoFileClip), et scipy.io.wavfile.

    2. Définition des variables :

      • temporary_audio_files : une liste vide pour stocker les chemins d'accès aux fichiers audio temporaires.
      • video_extensions : une liste des extensions de fichiers vidéo pris en charge.
      • output_folder : le dossier de sortie pour les segments extraits.
    3. Fonctions :

      • calculate_loudness: Calculer la "forte" d'un signal audio.
      • find_loudest_moments: Identifier les moments les plus forts dans un fichier audio.
      • extract_segments: Extraire ces moments à partir du fichier vidéo original à l'aide de ffmpeg.
      • process_video_files: Parcourir tous les fichiers vidéo dans le dossier et les sous-dossiers et les soumettre à find_loudest_moments et extract_segments.
    4. Exécution principale (if __name__ == "__main__"):

      • Demander à l'utilisateur de saisir certains paramètres : temps d'ignorance au début et à la fin, le nombre de moments à extraire, et la durée des segments.
      • Appel de process_video_files avec les paramètres spécifiés.
    5. Opérations de nettoyage :

      • Après le traitement, le script nettoie les fichiers audio temporaires qu'il a créés.

    Points à noter :

    • Le script utilise ffmpeg pour l'extraction de segments vidéo. Assurez-vous d'avoir ffmpeg installé sur votre système pour que le script fonctionne.
    • Pour l'audio, il utilise apparemment le codec non compressé pcm_s16le avec une fréquence d'échantillonnage de 44100 Hz.
    • Les fichiers vidéo temporaires sont supprimés à l'aide d'un finally bloc, ce qui garantit qu'ils sont supprimés même si une exception se produit pendant le traitement.
    • Il est important de fermer les VideoFileClip pour libérer les ressources.
    • Le script suppose qu'il est exécuté dans un répertoire contenant ou lié aux fichiers vidéo à traiter. Il recherche récursivement ces fichiers dans tous les sous-répertoires.
    • La variable temporary_audio_files est mise à jour avec chaque nouveau fichier audio temporaire généré, et ces fichiers sont supprimés une fois qu'ils ne sont plus nécessaires, contribuant à une bonne gestion des ressources.

    Avant d'exécuter le script, assurez-vous que tous les modules utilisés (en particulier moviepy et ffmpeg) sont installés et correctement configurés dans votre environnement Python.