Communitygithub.com

Audio- und Videoverarbeitung mit FFmpeg, WebRTC und Streaming

Audio- und Videoverarbeitung mit FFmpeg, WebRTC und Streaming. Umfasst Transcodierung, Formatkonvertierung, Echtzeitkommunikation und Medien-Pipelines. Nutzbar für Videoverarbeitung, Live-Streaming oder Audiobearbeitung.

Was ist Audio- und Videoverarbeitung mit FFmpeg, WebRTC und Streaming?

Diese Fähigkeit (Skill) bietet eine umfassende Anleitung zur Audio- und Videoverarbeitung mit Schwerpunkt auf FFmpeg, WebRTC und Streaming-Protokollen. Sie deckt grundlegende bis fortgeschrittene Aufgaben ab, darunter Transcodierung, Formatkonvertierung, Größenänderung, Zuschneiden, Thumbnail-Erstellung, Audiocxtraktion, Normalisierung und Live-Streaming. Die Fähigkeit ist sowohl über die Befehlszeile (CLI) als auch über Python-Integrationen (PyAV, MoviePy, Subprocess) nutzbar und ermöglicht so die Automatisierung komplexer Medien-Pipelines, z. B. asynchrone Verarbeitung mit Celery. Sie ist ideal für Entwickler, die Videoplattformen bauen, Inhalte für Streaming optimieren oder Audio-/Video-Workflows in größere Anwendungen integrieren möchten. Die Unterstützung für HLS und DASH sowie Codecs wie H.264, H.265/HEVC, VP9 und AV1 macht sie für eine breite Palette von Anwendungsfällen geeignet.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/David-Li0406/meta-skill-evloving/tree/HEAD/skill-flow/data/skills-refined-36k/skillsmp/audio-video

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Skill zur Audio- & Videoverarbeitung

Vollständiger Leitfaden für die Audio- und Videoverarbeitung.

Kurzreferenz

FFmpeg-Befehle

AufgabeBefehl
Konvertierenffmpeg -i input.mp4 output.webm
Audio extrahierenffmpeg -i video.mp4 -vn audio.mp3
Thumbnailffmpeg -i video.mp4 -ss 5 -frames:v 1 thumb.jpg
Größe ändernffmpeg -i input.mp4 -vf scale=1280:720 output.mp4
Komprimierenffmpeg -i input.mp4 -crf 28 output.mp4

Übliche Formate

Video: MP4, WebM, MKV, AVI, MOV
Audio: MP3, AAC, WAV, FLAC, OGG
Codecs: H.264, H.265/HEVC, VP9, AV1

1. FFmpeg-Grundlagen

Installation

# Ubuntu/Debian
sudo apt install ffmpeg

# macOS
brew install ffmpeg

# Windows (Chocolatey)
choco install ffmpeg

Grundlegende Konvertierung

# Videoformat konvertieren
ffmpeg -i input.avi output.mp4

# Audioformat konvertieren
ffmpeg -i input.wav output.mp3

# Mit Codec-Angabe
ffmpeg -i input.mp4 -c:v libx264 -c:a aac output.mp4

Videoqualität steuern

# CRF (Constant Rate Factor) - 0-51, niedriger = bessere Qualität
ffmpeg -i input.mp4 -c:v libx264 -crf 23 output.mp4

# Bitrate steuern
ffmpeg -i input.mp4 -c:v libx264 -b:v 2M output.mp4

# Zwei-Durchgang-Encoding für bessere Qualität
ffmpeg -i input.mp4 -c:v libx264 -b:v 2M -pass 1 -f null /dev/null
ffmpeg -i input.mp4 -c:v libx264 -b:v 2M -pass 2 output.mp4

2. Videoverarbeitung

Größe ändern und skalieren

# Auf bestimmte Auflösung skalieren
ffmpeg -i input.mp4 -vf "scale=1920:1080" output.mp4

# Skalieren unter Beibehaltung des Seitenverhältnisses
ffmpeg -i input.mp4 -vf "scale=1280:-1" output.mp4  # Automatische Höhe
ffmpeg -i input.mp4 -vf "scale=-1:720" output.mp4   # Automatische Breite

# Skalieren mit Polsterung (Letterbox)
ffmpeg -i input.mp4 -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2" output.mp4

Trimmen und Ausschneiden

# Von Zeitstempel zu Zeitstempel ausschneiden
ffmpeg -i input.mp4 -ss 00:01:00 -to 00:02:00 -c copy output.mp4

# Mit Dauer ausschneiden
ffmpeg -i input.mp4 -ss 00:01:00 -t 30 -c copy output.mp4

# Schnelles Suchen (-ss vor Eingabe setzen)
ffmpeg -ss 00:01:00 -i input.mp4 -t 30 -c copy output.mp4

Videos zusammenfügen

# Dateiliste erstellen
echo "file 'video1.mp4'" > list.txt
echo "file 'video2.mp4'" >> list.txt
echo "file 'video3.mp4'" >> list.txt

# Zusammenfügen
ffmpeg -f concat -safe 0 -i list.txt -c copy output.mp4

Wasserzeichen hinzufügen

# Bildwasserzeichen
ffmpeg -i input.mp4 -i logo.png -filter_complex "overlay=10:10" output.mp4

# Rechte untere Ecke
ffmpeg -i input.mp4 -i logo.png -filter_complex "overlay=W-w-10:H-h-10" output.mp4

# Textwasserzeichen
ffmpeg -i input.mp4 -vf "drawtext=text='Copyright':fontsize=24:fontcolor=white:x=10:y=10" output.mp4

Geschwindigkeit anpassen

# 2x beschleunigen
ffmpeg -i input.mp4 -filter:v "setpts=0.5*PTS" -filter:a "atempo=2.0" output.mp4

# 0,5x verlangsamen
ffmpeg -i input.mp4 -filter:v "setpts=2*PTS" -filter:a "atempo=0.5" output.mp4

3. Audioverarbeitung

Audio extrahieren

# Audiospur extrahieren
ffmpeg -i video.mp4 -vn -c:a copy audio.aac

# In MP3 konvertieren
ffmpeg -i video.mp4 -vn -c:a libmp3lame -q:a 2 audio.mp3

# Bestimmten Audiostream extrahieren
ffmpeg -i video.mp4 -map 0:a:0 -c copy audio.m4a

Audio konvertieren

# WAV in MP3
ffmpeg -i input.wav -c:a libmp3lame -b:a 320k output.mp3

# FLAC in MP3
ffmpeg -i input.flac -c:a libmp3lame -q:a 0 output.mp3

# MP3 in AAC
ffmpeg -i input.mp3 -c:a aac -b:a 256k output.m4a

Audionormalisierung

# Loudnorm-Filter (EBU R128)
ffmpeg -i input.mp3 -af loudnorm=I=-16:LRA=11:TP=-1.5 output.mp3

# Lautstärke anpassen
ffmpeg -i input.mp3 -af "volume=2.0" output.mp3  # 2x lauter
ffmpeg -i input.mp3 -af "volume=0.5" output.mp3  # Halbe Lautstärke

# Spitzennormalisierung
ffmpeg -i input.mp3 -af "acompressor" output.mp3

Audio/Video zusammenführen

# Audiospur ersetzen
ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -map 0:v -map 1:a output.mp4

# Audio zu Video hinzufügen (mischen)
ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -filter_complex "[0:a][1:a]amix=inputs=2:duration=first" output.mp4

4. Thumbnails und Screenshots

Einzelnes Thumbnail

# Zu bestimmter Zeit
ffmpeg -i video.mp4 -ss 00:00:05 -frames:v 1 thumbnail.jpg

# Beste Qualität
ffmpeg -i video.mp4 -ss 00:00:05 -frames:v 1 -q:v 2 thumbnail.jpg

# Bestimmte Größe
ffmpeg -i video.mp4 -ss 00:00:05 -frames:v 1 -vf "scale=320:180" thumbnail.jpg

Mehrere Thumbnails

# Alle N Sekunden
ffmpeg -i video.mp4 -vf "fps=1/10" thumbnails_%03d.jpg  # Alle 10 Sekunden

# Bestimmte Anzahl von Thumbnails
ffmpeg -i video.mp4 -vf "select='not(mod(n,300))'" -vsync vfr thumb_%03d.jpg

# Thumbnail-Sprite/Raster
ffmpeg -i video.mp4 -vf "fps=1/10,scale=160:90,tile=10x10" sprite.jpg

GIF-Erstellung

# Einfaches GIF
ffmpeg -i video.mp4 -ss 0 -t 5 -vf "fps=10,scale=320:-1" output.gif

# Hochwertiges GIF mit Palette
ffmpeg -i video.mp4 -ss 0 -t 5 -vf "fps=10,scale=320:-1:flags=lanczos,palettegen" palette.png
ffmpeg -i video.mp4 -i palette.png -ss 0 -t 5 -filter_complex "[0:v]fps=10,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" output.gif

5. Streaming-Formate

HLS (HTTP Live Streaming)

# HLS generieren
ffmpeg -i input.mp4 \
  -c:v libx264 -c:a aac \
  -hls_time 10 \
  -hls_list_size 0 \
  -hls_segment_filename "segment_%03d.ts" \
  output.m3u8

# Adaptive Bitrate HLS
ffmpeg -i input.mp4 \
  -filter_complex "[0:v]split=3[v1][v2][v3];[v1]scale=1920:1080[v1out];[v2]scale=1280:720[v2out];[v3]scale=854:480[v3out]" \
  -map "[v1out]" -c:v:0 libx264 -b:v:0 5M \
  -map "[v2out]" -c:v:1 libx264 -b:v:1 2M \
  -map "[v3out]" -c:v:2 libx264 -b:v:2 1M \
  -map 0:a -c:a aac -b:a 128k \
  -var_stream_map "v:0,a:0 v:1,a:0 v:2,a:0" \
  -master_pl_name master.m3u8 \
  -hls_time 6 \
  -hls_segment_filename "v%v/segment_%03d.ts" \
  v%v/index.m3u8

DASH (Dynamic Adaptive Streaming)

ffmpeg -i input.mp4 \
  -c:v libx264 -c:a aac \
  -f dash \
  -init_seg_name "init-\$RepresentationID$.m4s" \
  -media_seg_name "chunk-\$RepresentationID$-\$Number%05d$.m4s" \
  output.mpd

6. Python-Integration

PyAV (FFmpeg-Bindungen)

import av

def transcode_video(input_path, output_path, target_codec='libx264'):
    input_container = av.open(input_path)
    output_container = av.open(output_path, 'w')

    # Eingabeströme abrufen
    video_stream = input_container.streams.video[0]
    audio_stream = input_container.streams.audio[0] if input_container.streams.audio else None

    # Ausgabeströme erstellen
    output_video = output_container.add_stream(target_codec, rate=video_stream.average_rate)
    output_video.width = video_stream.width
    output_video.height = video_stream.height
    output_video.pix_fmt = 'yuv420p'

    if audio_stream:
        output_audio = output_container.add_stream('aac', rate=audio_stream.rate)

    for packet in input_container.demux():
        if packet.stream.type == 'video':
            for frame in packet.decode():
                for out_packet in output_video.encode(frame):
                    output_container.mux(out_packet)
        elif packet.stream.type == 'audio' and audio_stream:
            for frame in packet.decode():
                for out_packet in output_audio.encode(frame):
                    output_container.mux(out_packet)

    # Encoder leeren
    for packet in output_video.encode():
        output_container.mux(packet)

    output_container.close()
    input_container.close()

MoviePy

from moviepy.editor import VideoFileClip, concatenate_videoclips, TextClip, CompositeVideoClip

def process_video(input_path, output_path):
    # Video laden
    clip = VideoFileClip(input_path)

    # Trimmen
    trimmed = clip.subclip(10, 60)  # 10s bis 60s

    # Größe ändern
    resized = trimmed.resize(height=720)

    # Textüberlagerung hinzufügen
    txt_clip = TextClip("Hallo Welt", fontsize=50, color='white')
    txt_clip = txt_clip.set_position('center').set_duration(5)

    # Zusammensetzen
    final = CompositeVideoClip([resized, txt_clip])

    # Exportieren
    final.write_videofile(
        output_path,
        codec='libx264',
        audio_codec='aac'
    )

    clip.close()

def create_thumbnail(video_path, output_path, time=5):
    clip = VideoFileClip(video_path)
    frame = clip.get_frame(time)
    clip.save_frame(output_path, t=time)
    clip.close()

def concatenate_videos(video_paths, output_path):
    clips = [VideoFileClip(path) for path in video_paths]
    final = concatenate_videoclips(clips)
    final.write_videofile(output_path)
    for clip in clips:
        clip.close()

FFmpeg-Subprozess

import subprocess
import json

def get_video_info(video_path):
    """Videometadaten mit ffprobe abrufen"""
    cmd = [
        'ffprobe',
        '-v', 'quiet',
        '-print_format', 'json',
        '-show_format',
        '-show_streams',
        video_path
    ]

    result = subprocess.run(cmd, capture_output=True, text=True)
    return json.loads(result.stdout)

def transcode_video(input_path, output_path, options=None):
    """Video mit FFmpeg transcodieren"""
    cmd = ['ffmpeg', '-i', input_path]

    if options:
        if 'video_codec' in options:
            cmd.extend(['-c:v', options['video_codec']])
        if 'audio_codec' in options:
            cmd.extend(['-c:a', options['audio_codec']])
        if 'crf' in options:
            cmd.extend(['-crf', str(options['crf'])])
        if 'resolution' in options:
            cmd.extend(['-vf', f"scale={options['resolution']}"])

    cmd.extend(['-y', output_path])

    result = subprocess.run(cmd, capture_output=True, text=True)

    if result.returncode != 0:
        raise Exception(f"FFmpeg-Fehler: {result.stderr}")

    return True

def generate_hls(input_path, output_dir):
    """HLS-Stream generieren"""
    import os
    os.makedirs(output_dir, exist_ok=True)

    cmd = [
        'ffmpeg', '-i', input_path,
        '-c:v', 'libx264',
        '-c:a', 'aac',
        '-hls_time', '10',
        '-hls_list_size', '0',
        '-hls_segment_filename', f'{output_dir}/segment_%03d.ts',
        f'{output_dir}/index.m3u8'
    ]

    subprocess.run(cmd, check=True)

7. Live-Streaming

RTMP-Server (nginx-rtmp)

# nginx.conf
rtmp {
    server {
        listen 1935;

        application live {
            live on;
            record off;

            # HLS-Ausgabe
            hls on;
            hls_path /var/www/hls;
            hls_fragment 3;
            hls_playlist_length 60;
        }
    }
}

An RTMP streamen

# Datei an RTMP streamen
ffmpeg -re -i input.mp4 -c copy -f flv rtmp://server/live/stream

# Webcam streamen
ffmpeg -f v4l2 -i /dev/video0 -f alsa -i hw:0 \
  -c:v libx264 -preset veryfast -b:v 2M \
  -c:a aac -b:a 128k \
  -f flv rtmp://server/live/stream

# An YouTube streamen
ffmpeg -i input.mp4 \
  -c:v libx264 -preset medium -b:v 4M \
  -c:a aac -b:a 128k \
  -f flv rtmp://a.rtmp.youtube.com/live2/DEIN_STREAM_KEY

8. Videoverarbeitungs-Pipeline

Asynchrone Verarbeitung mit Celery

from celery import Celery
import os

celery = Celery('video_tasks')

@celery.task
def process_upload(video_id, input_path):
    """Komplette Videoverarbeitungs-Pipeline"""
    output_dir = f'/videos/{video_id}'
    os.makedirs(output_dir, exist_ok=True)

    # Thumbnail generieren
    generate_thumbnail.delay(video_id, input_path, f'{output_dir}/thumb.jpg')

    # In mehrere Auflösungen transcodieren
    resolutions = [
        ('1080p', '1920:1080', '5M'),
        ('720p', '1280:720', '2.5M'),
        ('480p', '854:480', '1M'),
    ]

    for name, scale, bitrate in resolutions:
        transcode_resolution.delay(
            video_id, input_path,
            f'{output_dir}/{name}.mp4',
            scale, bitrate
        )

    # HLS generieren
    generate_hls.delay(video_id, input_path, f'{output_dir}/hls')

@celery.task
def generate_thumbnail(video_id, input_path, output_path):
    cmd = [
        'ffmpeg', '-i', input_path,
        '-ss', '5', '-frames:v', '1',
        '-vf', 'scale=320:-1',
        output_path
    ]
    subprocess.run(cmd, check=True)

@celery.task
def transcode_resolution(video_id, input_path, output_path, scale, bitrate):
    cmd = [
        'ffmpeg', '-i', input_path,
        '-c:v', 'libx264', '-b:v', bitrate,
        '-vf', f'scale={scale}',
        '-c:a', 'aac', '-b:a', '128k',
        output_path
    ]
    subprocess.run(cmd, check=True)

9. Audioanalyse

Wellenformgenerierung

import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np

def generate_waveform(audio_path, output_path):
    """Wellenform-Bild generieren"""
    y, sr = librosa.load(audio_path)

    plt.figure(figsize=(14, 5))
    librosa.display.waveshow(y, sr=sr)
    plt.title('Wellenform')
    plt.savefig(output_path, dpi=150, bbox_inches='tight')
    plt.close()

def generate_spectrogram(audio_path, output_path):
    """Spektrogramm-Bild generieren"""
    y, sr = librosa.load(audio_path)
    D = librosa.stft(y)
    S_db = librosa.amplitude_to_db(np.abs(D), ref=np.max)

    plt.figure(figsize=(14, 5))
    librosa.display.specshow(S_db, sr=sr, x_axis='time', y_axis='hz')
    plt.colorbar(format='%+2.0f dB')
    plt.title('Spektrogramm')
    plt.savefig(output_path, dpi=150, bbox_inches='tight')
    plt.close()

10. Best Practices

Encoding-Voreinstellungen

# Für das Web optimiertes MP4
ffmpeg -i input.mp4 \
  -c:v libx264 -preset slow -crf 22 \
  -c:a aac -b:a 128k \
  -movflags +faststart \
  output.mp4

# Archivqualität
ffmpeg -i input.mp4 \
  -c:v libx264 -preset veryslow -crf 18 \
  -c:a flac \
  archive.mkv

# Für Mobilgeräte optimiert
ffmpeg -i input.mp4 \
  -c:v libx264 -preset fast -crf 28 \
  -vf "scale='min(720,iw)':-2" \
  -c:a aac -b:a 96k \
  mobile.mp4

Best Practices

  1. Hardwarebeschleunigung nutzen - NVENC, VAAPI, VideoToolbox
  2. Für das Web optimieren - faststart-Flag verwenden
  3. Auf Fehler prüfen - Stderr Ihres FFmpeg-Prozesses überwachen
  4. Aufgaben parallelisieren - Gleichzeitige Verarbeitung für Stapelkonvertierungen
  5. Container verwenden - FFmpeg mit Docker für Konsistenz

Fehlerbehebung

Häufige Probleme

ProblemLösung
Codec nicht gefundenÜberprüfen Sie die FFmpeg-Kompilierung (ffmpeg -codecs)
Stream-BerechtigungenVerwenden Sie -re für Echtzeit-Streaming
SpeicherproblemeReduzieren Sie die Thread-Anzahl (-threads 2)
A/V-DesynchronisationVerwenden Sie -async 1 oder -vsync 2

Debugging

# Detaillierte Ausgabe aktivieren
ffmpeg -loglevel debug -i input.mp4 output.mp4

# Stream-Statistiken anzeigen
ffmpeg -i input.mp4 -f null /dev/null

# Protocol-Informationen
ffmpeg -protocols

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

David-Li0406/meta-skill-evloving

Browser automation with persistent page state. Use when users ask to navigate websites, fill forms, take screenshots, extract web data, test web apps, or automate browser workflows. Trigger phrases include "go to [url]", "click on", "fill out the form", "take a screenshot", "scrape", "automate", "test the website", "log into", or any browser interaction request.

David-Li0406/meta-skill-evloving

Create technical diagrams using Mermaid syntax for architecture, sequences, ERDs, flowcharts, and state machines. Use for visualizing system design, data flows, and processes. Triggers: diagram, mermaid, architecture diagram, sequence diagram, flowchart, ERD, entity relationship, state diagram, C4 model, component diagram, visualize, draw.

David-Li0406/meta-skill-evloving

Comprehensive document creation, editing, and analysis with support for tracked changes, comments, formatting preservation, and text extraction. When Claude needs to work with professional documents (.docx files) for: (1) Creating new documents, (2) Modifying or editing content, (3) Working with tracked changes, (4) Adding comments, or any other document tasks

David-Li0406/meta-skill-evloving

Complete color manipulation and green screen effects system. PROACTIVELY activate for: (1) Green screen/chromakey removal, (2) Color grading with LUTs, (3) Color correction (levels, curves, white balance), (4) Colorkey/color removal effects, (5) Hue/saturation manipulation, (6) Color space conversions (BT.709, BT.2020, HDR), (7) Color isolation effects, (8) Teal and orange look, (9) Vintage/film looks, (10) Color keying for transparency. Provides: chromakey and colorkey filters, LUT application (lut3d), curves and levels adjustment, color balance, selective color manipulation, color space handling, HDR tone mapping, professional color grading chains.

David-Li0406/meta-skill-evloving

Convert files and office documents to Markdown. Supports PDF, DOCX, PPTX, XLSX, images (with OCR), audio (with transcription), HTML, CSV, JSON, XML, ZIP, YouTube URLs, EPubs and more.

David-Li0406/meta-skill-evloving

Guide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK).

David-Li0406/meta-skill-evloving

Build with OpenAI's stateless APIs - Chat Completions (GPT-5, GPT-4o), Embeddings, Images (DALL-E 3), Audio (Whisper + TTS), and Moderation. Includes Node.js SDK and fetch-based approaches for Cloudflare Workers. Use when: implementing chat completions with GPT-5/GPT-4o, streaming responses with SSE, using function calling/tools, creating structured outputs with JSON schemas, generating embeddings for RAG (text-embedding-3-small/large), generating images with DALL-E 3, editing images with GPT-Image-1, transcribing audio with Whisper, synthesizing speech with TTS (11 voices), moderating content (11 safety categories), or troubleshooting rate limits (429), invalid API keys (401), function calling failures, streaming parse errors, embeddings dimension mismatches, or token limit exceeded.

David-Li0406/meta-skill-evloving

Comprehensive PDF manipulation toolkit for extracting text and tables, creating new PDFs, merging/splitting documents, and handling forms. When Claude needs to fill in a PDF form or programmatically process, generate, or analyze PDF documents at scale.

David-Li0406/meta-skill-evloving

Presentation creation, editing, and analysis. When Claude needs to work with presentations (.pptx files) for: (1) Creating new presentations, (2) Modifying or editing content, (3) Working with layouts, (4) Adding comments or speaker notes, or any other presentation tasks

David-Li0406/meta-skill-evloving

Comprehensive spreadsheet creation, editing, and analysis with support for formulas, formatting, data analysis, and visualization. When Claude needs to work with spreadsheets (.xlsx, .xlsm, .csv, .tsv, etc) for: (1) Creating new spreadsheets with formulas and formatting, (2) Reading or analyzing data, (3) Modify existing spreadsheets while preserving formulas, (4) Data analysis and visualization in spreadsheets, or (5) Recalculating formulas

David-Li0406/meta-skill-evloving

Download YouTube videos with customizable quality and format options. Use this skill when the user asks to download, save, or grab YouTube videos. Supports various quality settings (best, 1080p, 720p, 480p, 360p), multiple formats (mp4, webm, mkv), and audio-only downloads as MP3.

David-Li0406/meta-skill-evloving

Best practices for Remotion - Video creation in React

David-Li0406/meta-skill-evloving

Provides bidirectional translation (Chinese/English), grammar checking, and sentence polishing. Supports specific tense constraints, context-aware tone adjustment, and natural expression optimization. Outputs direct text without formatting.

David-Li0406/meta-skill-evloving

指导如何通过自定义注解(如@Unicom)标识Dubbo接口,利用BeanDefinitionRegistryPostProcessor在启动时扫描并动态注册ReferenceBean,实现RPC调用的封装。

David-Li0406/meta-skill-evloving

生成Python脚本,利用FFmpeg将图片序列按3x3布局合并,或将合并图拆分。要求使用subprocess模块执行命令,并支持用户交互式输入路径。

David-Li0406/meta-skill-evloving

SOP for extracting and analyzing promotional activity details, handling time formatting, location mapping, payment logic, and step-by-step process validation.

David-Li0406/meta-skill-evloving

Specializes in creating TikTok short video scripts using an anthropomorphic 'Chef' perspective to explain wildlife food chains and survival environments, utilizing real field footage.

David-Li0406/meta-skill-evloving

针对TikTok平台,以拟人化视角(如动物作为厨师)创作系列短视频脚本。重点介绍野生动物、食物链及生态环境,要求使用野外实拍素材,风格幽默且具有教育意义。

David-Li0406/meta-skill-evloving

Generates KWL (Know, Want to know, Learned) charts for educational videos, specifically BrainPOP, using simple 7th-grade language and short, concise bullet points.

David-Li0406/meta-skill-evloving

Tracks complex, multi-session work using the Beads issue tracker and dependency graphs, and provides persistent memory that survives conversation compaction. Use when work spans multiple sessions, has complex dependencies, or needs persistent context across compaction cycles. Trigger with phrases like "create task for", "what's ready to work on", "show task", "track this work", "what's blocking", or "update status".

Verwandte Skills