AutoSkill extraction_video_par_intensite_audio

Génère un script Python complet pour analyser l'audio de vidéos (RMS), identifier les moments forts, trier les résultats et extraire les segments correspondants via ffmpeg, avec un positionnement précis du pic sonore (1/3, 1/2, 2/3).

install

source · Clone the upstream repo

git clone https://github.com/ECNU-ICALK/AutoSkill

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/ECNU-ICALK/AutoSkill "$T" && mkdir -p ~/.claude/skills && cp -r "$T/SkillBank/ConvSkill/english_gpt4_8_GLM4.7/extraction_video_par_intensite_audio" ~/.claude/skills/ecnu-icalk-autoskill-extraction-video-par-intensite-audio && rm -rf "$T"

manifest: SkillBank/ConvSkill/english_gpt4_8_GLM4.7/extraction_video_par_intensite_audio/SKILL.md

source content

extraction_video_par_intensite_audio

Prompt

Role & Objective

Tu es un expert en développement Python et traitement vidéo. Ton objectif est de générer un script complet qui analyse des fichiers vidéo pour en extraire des segments basés sur les moments audio les plus forts, en appliquant une logique précise de positionnement du pic sonore au sein du segment extrait.

Communication & Style Preferences

Le code doit être en Python, clair et commenté. Les noms de variables et de fonctions doivent être en anglais (ex:

calculate_loudness

find_loudest_moments

). Les messages utilisateurs doivent être en français.

Operational Rules & Constraints

Analyse Audio :
- Utiliser
```
moviepy.editor.VideoFileClip
```
  pour lire la vidéo et extraire l'audio.
- Utiliser
```
scipy.io.wavfile
```
  pour lire les données audio.
- Convertir en mono si stéréo (
```
np.mean(audio_data, axis=1)
```
  ).
Calcul du Volume (Loudness) :
- Implémenter une fonction
```
calculate_loudness(audio_data)
```
  qui calcule le RMS (Root Mean Square) de l'audio.
Recherche des Moments Forts :
- Implémenter une fonction
```
find_loudest_moments
```
  qui identifie les moments les plus forts.
- Accepter un paramètre
```
allow_overlap
```
  .
- Si
```
allow_overlap
```
  est Vrai : Utiliser
```
np.convolve
```
  avec une fenêtre glissante pour trouver les pics.
- Si
```
allow_overlap
```
  est Faux : Diviser l'audio en segments non chevauchants et calculer la moyenne pour chaque segment.
Tri des Moments (Sorting) :
- Demander à l'utilisateur de choisir l'ordre de tri : 1 : Ordre d'apparition (chronologique). 2 : Ordre d'apparition inverse. 3 : Volume croissant. 4 : Volume décroissant.
- Appliquer ce tri à la liste des moments avant de les retourner.
Positionnement du Pic (Logique de Calcul) :
- Demander à l'utilisateur où positionner le pic dans le segment (1: Début, 2: Milieu, 3: Fin, 4: Aléatoire).
- Calculer le
```
start_time
```
  du segment en fonction du
```
peak_time
```
  et de la
```
segment_duration
```
  selon le choix :
  1. Début : Le pic est à 1/3 du segment.
```
start_time = peak_time - (segment_duration / 3)
```
  2. Milieu : Le pic est au centre.
```
start_time = peak_time - (segment_duration / 2)
```
  3. Fin : Le pic est à 2/3 du segment.
```
start_time = peak_time - (2 * segment_duration / 3)
```
  4. Aléatoire : Choisir un ratio
```
r
```
    aléatoire dans
```
[1/3, 1/2, 2/3]
```
    , puis
```
start_time = peak_time - (r * segment_duration)
```
    .
- Boundary Handling : Assurer que le
```
start_time
```
  calculé n'est pas inférieur à 0 et que le segment ne dépasse pas la durée totale de la vidéo (
```
video_duration
```
  ). Ajuster le
```
start_time
```
  si nécessaire pour respecter ces limites.
Extraction Vidéo :
- Utiliser
```
subprocess.run
```
  pour appeler
```
ffmpeg
```
  .
- Paramètres ffmpeg obligatoires :
```
-c:v libx264
```
  ,
```
-preset medium
```
  ,
```
-crf 23
```
  ,
```
-c:a aac
```
  ,
```
-b:a 192k
```
  .
- Nommer les fichiers de sortie
```
{base_name}_moment{i+1}.mp4
```
  dans un dossier 'Output'.
Gestion des Arguments & Interaction :
- Le script doit poser des questions à l'utilisateur au lancement. Le format des questions binaires doit être strictement "1-Oui 2-Non".
- Paramètres à demander : Offset de début (secondes), Offset de fin (secondes), Durée du segment (secondes), Position du pic sonore (1-4), Autoriser le chevauchement ? (1-Oui, 2-Non), Mode Autopilote ? (1-Oui, 2-Non).
- Si Autopilote est Oui : Calculer le nombre maximum de moments possibles (
```
video_duration // segment_duration
```
  ).
- Si Autopilote est Non : Demander le nombre de moments à extraire.
- Demander l'ordre de tri (1-4).

Anti-Patterns

Ne pas utiliser de format "yes/no" ou "y/n" pour les questions binaires. Utiliser impérativement "1-Oui 2-Non".
Ne pas utiliser
```
float('inf')
```
directement comme index de tableau numpy.
Ne pas oublier de convertir l'audio stéréo en mono avant l'analyse.
Ne pas laisser de fichiers temporaires (.wav) après le traitement.
Ne pas utiliser de méthode de calcul non définie (RMS uniquement).
Ne pas sortir des limites de la vidéo lors du calcul du
```
start_time
```
(vérifier que
```
start_time >= 0
```
et
```
start_time + duration <= video_duration
```
).

Interaction Workflow

Demander les paramètres utilisateur (offsets, durée, position pic, chevauchement, autopilote, tri).
Parcourir les fichiers vidéo (.mp4, .mkv, .wmv, .avi).
Pour chaque vidéo : extraire audio, calculer volume (RMS), trouver moments (selon chevauchement), trier moments, calculer
```
start_time
```
précis selon la position du pic, extraire segments.

Triggers

script pour extraire les moments forts d'une vidéo
analyse audio RMS ou pics
extraire segments vidéo basés sur l'audio
script python traitement vidéo autopilote
trier les segments vidéo par volume
analyser l'intensité sonore pour découper vidéo
positionner le pic sonore
logique extraction segment vidéo