Skip to main content
skill CX Codex

ffmpeg-audio-processing skill for Claude Code: audio and loudnorm

ffmpeg-audio-processing — a skill that turns ffmpeg into a guided audio pipeline: codec choice, EBU R128 loudness, pulling tracks out of video. Handy for podcasts and broadcast masters.

MIT 195 installs ★ 66 updated 2026-06-18

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add JosiahSiegel/claude-plugin-marketplace --skill ffmpeg-audio-processing -a claude-code
Open on GitHub

What ffmpeg-audio-processing does

The skill covers audio work through ffmpeg. Pick a codec (AAC, MP3, Opus, FLAC), normalize loudness to EBU R128 with loudnorm, strip the audio out of a video, convert between formats. It also handles gain and dynamics, noise reduction with EQ, channel layout, sample rate and bit depth, fades, and podcast or broadcast chains.

What you get is reference material plus commands: codec comparison tables with bitrate guidance, a list of loudness targets (EBU R128 at -23 LUFS, ATSC A/85 at -24 LKFS, streaming around -14, Apple Music -16, podcasts from -16 to -19), a loudnorm-2pass.sh script, mastering chains, and a quick-reference block of one-line calls.

Two-pass normalization runs the file twice. The first pass only measures and prints JSON (print_format=json); the second feeds measured_I, measured_TP, measured_LRA, measured_thresh and offset back into the filter and writes 48000 Hz output. One-pass mode stays for live work and is less accurate. On Windows the skill wants backslashes in file paths whenever it writes something.

What it helps with

  • pull the audio track out of a video without re-encoding
  • hit a podcast loudness target with true-peak headroom
  • choose a bitrate for AAC, MP3 or Opus
  • batch-convert FLAC files to MP3
  • crossfade two segments together

Example prompts for the agent

  • Extract the audio from video.mp4 to audio.m4a and copy the stream instead of re-encoding.
  • Normalize episode.mp3 for podcast: -16 LUFS, true peak -1.5, two-pass loudnorm.
  • Convert every .flac in this folder to 320k MP3.

How to install ffmpeg-audio-processing

1Skills CLI (Vercel)

npx skills add JosiahSiegel/claude-plugin-marketplace --skill ffmpeg-audio-processing -a claude-code

2Manually: put the files in place

~/.claude/skills/ffmpeg-audio-processing/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/ffmpeg-audio-processing/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about ffmpeg-audio-processing

How do I install ffmpeg-audio-processing in Claude Code?

Run npx skills add JosiahSiegel/claude-plugin-marketplace --skill ffmpeg-audio-processing -a claude-code. The skill file lands at ~/.claude/skills/ffmpeg-audio-processing/SKILL.md.

What does ffmpeg-audio-processing do?

It supplies ffmpeg commands and references for encoding audio, hitting loudness targets, extracting tracks from video and processing podcasts. Codec tables, loudness standards and a two-pass normalization script come with it.

Why run loudnorm twice?

The first pass measures the input and prints the numbers as JSON. The second applies them with linear=true, which lands closer to the target than a single pass.

Source text

SKILL.md · MIT
---
name: ffmpeg-audio-processing
description: |
  Complete audio encoding and normalization system.
  PROACTIVELY activate for: (1) Audio codec selection (AAC, MP3, Opus, FLAC), (2) Loudness normalization (EBU R128, loudnorm), (3) Audio extraction from video, (4) Format conversion, (5) Volume adjustment and dynamics, (6) Noise reduction and EQ, (7) Channel operations (stereo/mono/surround), (8) Sample rate and bit depth conversion, (9) Audio fade in/out and crossfades, (10) Podcast and broadcast processing chains.
  Provides: Codec comparison tables, loudness standards reference, two-pass normalization scripts, professional mastering chains.
  Ensures: Broadcast-compliant audio with proper loudness and quality.
---

## CRITICAL GUIDELINES

### Windows File Path Requirements

**MANDATORY: Always Use Backslashes on Windows for File Paths**

When using Edit or Write tools on Windows, you MUST use backslashes (`\`) in file paths, NOT forward slashes (`/`).

---

## Quick Reference

| Task | Command |
|------|---------|
| Extract audio | `ffmpeg -i video.mp4 -vn -c:a copy audio.m4a` |
| Convert to MP3 | `ffmpeg -i input.flac -c:a libmp3lame -q:a 2 output.mp3` |
| Normalize (EBU R128) | `-af loudnorm=I=-23:LRA=7:TP=-2` |
| Podcast standard | `-af loudnorm=I=-16:TP=-1.5` |
| Adjust volume | `-af "volume=1.5"` or `-af "volume=6dB"` |
| Mono to stereo | `-ac 2` |

| Codec | Recommended Bitrate | Use Case |
|-------|---------------------|----------|
| AAC | 128-192k (music), 64k (speech) | Streaming, mobile |
| MP3 | 192-320k (music), 128k (speech) | Universal compatibility |
| Opus | 96-128k (music), 48k (speech) | WebM, VoIP, modern |

## When to Use This Skill

Use for **audio-focused operations**:
- Extracting audio from video files
- Loudness normalization for broadcast/streaming compliance
- Podcast and audiobook processing
- Audio format conversion
- Audio effects (EQ, compression, noise reduction)

---

# FFmpeg Audio Processing (2025)

Complete guide to audio encoding, normalization, and professional audio workflows with FFmpeg.

## Audio Codec Reference

### Codec Comparison

| Codec | Encoder | Bitrate Range | Quality | Compatibility | Use Case |
|-------|---------|---------------|---------|---------------|----------|
| AAC | aac, libfdk_aac | 64-320 kbps | Excellent | Universal | Streaming, mobile |
| MP3 | libmp3lame | 96-320 kbps | Good | Universal | Legacy, podcasts |
| Opus | libopus | 32-256 kbps | Best | Modern | VoIP, WebM |
| FLAC | flac | ~900 kbps | Lossless | Wide | Archival |
| ALAC | alac | ~900 kbps | Lossless | Apple | Apple ecosystem |
| Vorbis | libvorbis | 64-500 kbps | Very Good | Wide | WebM, games |
| AC3 | ac3 | 192-640 kbps | Good | Universal | DVD, Blu-ray |
| EAC3 | eac3 | 192-768 kbps | Very Good | Wide | Streaming |
| xHE-AAC | - (decode only) | 12-64 kbps | Excellent | Emerging | Ultra-low bitrate |

### Recommended Bitrates

| Use Case | AAC | MP3 | Opus |
|----------|-----|-----|------|
| Podcast/Speech | 64-96k | 96-128k | 48-64k |
| Music (Standard) | 128-192k | 192-256k | 96-128k |
| Music (High Quality) | 256-320k | 320k | 160-256k |
| Transparent Quality | 256k+ | 320k | 192k+ |

## Basic Audio Operations

### Extract Audio

```bash
# Extract to original format (no re-encode)
ffmpeg -i video.mp4 -vn -c:a copy audio.m4a

# Extract to MP3
ffmpeg -i video.mp4 -vn -c:a libmp3lame -b:a 320k audio.mp3

# Extract to AAC
ffmpeg -i video.mp4 -vn -c:a aac -b:a 256k audio.m4a

# Extract to FLAC (lossless)
ffmpeg -i video.mp4 -vn -c:a flac audio.flac

# Extract to WAV (uncompressed)
ffmpeg -i video.mp4 -vn -c:a pcm_s16le audio.wav
```

### Convert Audio Formats

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

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

# FLAC to MP3
ffmpeg -i input.flac -c:a libmp3lame -b:a 320k output.mp3

# Multiple files (batch)
for f in *.flac; do
  ffmpeg -i "$f" -c:a libmp3lame -b:a 320k "${f%.flac}.mp3"
done
```

### Quality Settings

```bash
# AAC VBR quality (1-5, higher = better)
ffmpeg -i input.wav -c:a aac -q:a 2 output.m4a

# MP3 VBR quality (0-9, lower = better)
ffmpeg -i input.wav -c:a libmp3lame -q:a 0 output.mp3

# Opus with target bitrate
ffmpeg -i input.wav -c:a libopus -b:a 128k output.opus
```

## Audio Normalization

### Loudness Standards

| Standard | Target | TP (True Peak) | Use Case |
|----------|--------|----------------|----------|
| EBU R128 | -23 LUFS | -1 dBTP | European broadcast |
| ATSC A/85 | -24 LKFS | -2 dBTP | US broadcast |
| Spotify | -14 LUFS | -1 dBTP | Streaming |
| YouTube | -14 LUFS | -1 dBTP | Video platform |
| Apple Music | -16 LUFS | -1 dBTP | Music streaming |
| Podcast | -16 to -19 LUFS | -1 dBTP | Podcast |

### EBU R128 Normalization (loudnorm)

#### Single-Pass (Live/Real-time)
```bash
# Quick normalization (less accurate)
ffmpeg -i input.mp3 \
  -af loudnorm=I=-16:TP=-1.5:LRA=11 \
  output.mp3
```

#### Two-Pass (Recommended)

```bash
# Pass 1: Analyze
ffmpeg -i input.mp3 \
  -af loudnorm=I=-16:TP=-1.5:LRA=11:print_format=json \
  -f null -

# Output will include:
# "input_i": "-25.23"
# "input_tp": "-0.50"
# "input_lra": "8.32"
# "input_thresh": "-35.87"
# "target_offset": "1.23"

# Pass 2: Normalize with measured values
ffmpeg -i input.mp3 \
  -af loudnorm=I=-16:TP=-1.5:LRA=11:measured_I=-25.23:measured_TP=-0.50:measured_LRA=8.32:measured_thresh=-35.87:offset=1.23:linear=true \
  -ar 48000 \
  output.mp3
```

#### Two-Pass Script

```bash
#!/bin/bash
# loudnorm-2pass.sh

INPUT="$1"
OUTPUT="$2"
TARGET_I="${3:--16}"
TARGET_TP="${4:--1.5}"
TARGET_LRA="${5:-11}"

# Pass 1: Analyze
stats=$(ffmpeg -i "$INPUT" \
  -af loudnorm=I=${TARGET_I}:TP=${TARGET_TP}:LRA=${TARGET_LRA}:print_format=json \
  -f null - 2>&1 | grep -A 12 "Parsed_loudnorm")

# Extract values
input_i=$(echo "$stats" | grep input_i | tr -d '", ' | cut -d':' -f2)
input_tp=$(echo "$stats" | grep input_tp | tr -d '", ' | cut -d':' -f2)
input_lra=$(echo "$stats" | grep input_lra | tr -d '", ' | cut -d':' -f2)
input_thresh=$(echo "$stats" | grep input_thresh | tr -d '", ' | cut -d':' -f2)
offset=$(echo "$stats" | grep target_offset | tr -d '", ' | cut -d':' -f2)

# Pass 2: Normalize
ffmpeg -i "$INPUT" \
  -af "loudnorm=I=${TARGET_I}:TP=${TARGET_TP}:LRA=${TARGET_LRA}:measured_I=${input_i}:measured_TP=${input_tp}:measured_LRA=${input_lra}:measured_thresh=${input_thresh}:offset=${offset}:linear=true" \
  -ar 48000 \
  "$OUTPUT"
```

### Peak Normalization

```bash
# Normalize to peak level
ffmpeg -i input.mp3 \
  -af "volume=0dB:eval=once:precision=fixed" \
  -af "loudnorm=I=-16:TP=-1:LRA=11" \
  output.mp3

# Simple peak normalization
ffmpeg -i input.mp3 \
  -filter:a "volume=replaygain=peak" \
  output.mp3
```

### RMS Normalization

```bash
# Normalize to specific RMS level
ffmpeg -i input.mp3 \
  -af "loudnorm=I=-23:LRA=7:TP=-2" \
  output.mp3
```

### ffmpeg-normalize Tool

The `ffmpeg-normalize` Python utility provides an easier interface:

```bash
# Install
pip install ffmpeg-normalize

# Basic usage
ffmpeg-normalize input.mp3 -o output.mp3

# Custom target
ffmpeg-normalize input.mp3 -o output.mp3 -t -14

# Batch normalize (album mode - preserves relative loudness)
ffmpeg-normalize *.mp3 --batch -o normalized/

# Use built-in presets (v1.36.0+)
ffmpeg-normalize input.mp3 --preset podcast -o output.mp3
ffmpeg-normalize *.mp3 --preset music --batch -o normalized/
```

## Audio Filters

### Volume Control

```bash
# Increase volume by 50%
ffmpeg -i input.mp3 -af "volume=1.5" output.mp3

# Increase by 6dB
ffmpeg -i input.mp3 -af "volume=6dB" output.mp3

# Decrease by 3dB
ffmpeg -i input.mp3 -af "volume=-3dB" output.mp3
```

### Fade In/Out

```bash
# Fade in 3 seconds, fade out last 3 seconds
ffmpeg -i input.mp3 \
  -af "afade=t=in:ss=0:d=3,afade=t=out:st=57:d=3" \
  output.mp3

# Calculate fade out start automatically
duration=$(ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 input.mp3)
fadeout_start=$(echo "$duration - 3" | bc)
ffmpeg -i input.mp3 \
  -af "afade=t=in:ss=0:d=3,afade=t=out:st=${fadeout_start}:d=3" \
  output.mp3
```

### Equalization

```bash
# Bass boost
ffmpeg -i input.mp3 \
  -af "equalizer=f=100:width_type=o:width=2:g=5" \
  output.mp3

# Treble reduction
ffmpeg -i input.mp3 \
  -af "equalizer=f=8000:width_type=o:width=2:g=-3" \
  output.mp3

# Multi-band EQ
ffmpeg -i input.mp3 \
  -af "equalizer=f=100:width_type=o:width=2:g=3,equalizer=f=1000:width_type=o:width=2:g=-2,equalizer=f=8000:width_type=o:width=2:g=2" \
  output.mp3
```

### High-Pass / Low-Pass Filters

```bash
# High-pass filter (remove below 80Hz)
ffmpeg -i input.mp3 -af "highpass=f=80" output.mp3

# Low-pass filter (remove above 8kHz)
ffmpeg -i input.mp3 -af "lowpass=f=8000" output.mp3

# Band-pass filter
ffmpeg -i input.mp3 -af "highpass=f=80,lowpass=f=12000" output.mp3
```

### Noise Reduction

```bash
# FFT-based noise reduction
ffmpeg -i input.mp3 \
  -af "afftdn=nf=-25" \
  output.mp3

# With noise floor adjustment
ffmpeg -i input.mp3 \
  -af "afftdn=nf=-20:tn=1" \
  output.mp3
```

### Compressor / Limiter

```bash
# Dynamic range compression
ffmpeg -i input.mp3 \
  -af "acompressor=threshold=-20dB:ratio=4:attack=5:release=50" \
  output.mp3

# Limiter
ffmpeg -i input.mp3 \
  -af "alimiter=limit=0.9:attack=5:release=50" \
  output.mp3

# De-esser
ffmpeg -i input.mp3 \
  -af "deesser=i=0.4:f=4000:w=0.5" \
  output.mp3
```

### Silence Detection/Removal

```bash
# Detect silence
ffmpeg -i input.mp3 \
  -af silencedetect=noise=-30dB:d=0.5 \
  -f null -

# Remove silence
ffmpeg -i input.mp3 \
  -af "silenceremove=start_periods=1:start_silence=0.5:start_threshold=-50dB:stop_periods=1:stop_silence=0.5:stop_threshold=-50dB" \
  output.mp3
```

## Channel Operations

### Stereo to Mono

```bash
# Average both channels
ffmpeg -i stereo.mp3 \
  -af "pan=mono|c0=0.5*c0+0.5*c1" \
  mono.mp3

# Use only left channel
ffmpeg -i stereo.mp3 -af "pan=mono|c0=c0" mono.mp3

# Downmix stereo to mono
ffmpeg -i stereo.mp3 -ac 1 mono.mp3
```

### Mono to Stereo

```bash
# Duplicate mono to both channels
ffmpeg -i mono.mp3 -af "pan=stereo|c0=c0|c1=c0" stereo.mp3

# Simple conversion
ffmpeg -i mono.mp3 -ac 2 stereo.mp3
```

### Extract Specific Channels

```bash
# Extract left channel
ffmpeg -i stereo.mp3 \
  -filter_complex "[0:a]channelsplit=channel_layout=stereo:channels=FL[left]" \
  -map "[left]" left.mp3

# Extract right channel
ffmpeg -i stereo.mp3 \
  -filter_complex "[0:a]channelsplit=channel_layout=stereo:channels=FR[right]" \
  -map "[right]" right.mp3
```

### 5.1 Surround Operations

```bash
# Downmix 5.1 to stereo
ffmpeg -i surround.ac3 \
  -af "pan=stereo|FL=0.5*FC+0.707*FL+0.707*BL+0.5*LFE|FR=0.5*FC+0.707*FR+0.707*BR+0.5*LFE" \
  stereo.mp3

# Extract center channel
ffmpeg -i surround.ac3 \
  -filter_complex "[0:a]channelsplit=channel_layout=5.1:channels=FC[center]" \
  -map "[center]" center.mp3
```

## Sample Rate & Bit Depth

### Sample Rate Conversion

```bash
# Convert to 44.1kHz
ffmpeg -i input.wav -ar 44100 output.wav

# Convert to 48kHz
ffmpeg -i input.wav -ar 48000 output.wav

# High-quality resampling
ffmpeg -i input.wav \
  -af "aresample=resampler=soxr:precision=33:cheby=1" \
  -ar 44100 output.wav
```

### Bit Depth Conversion

```bash
# Convert to 16-bit
ffmpeg -i input.wav -c:a pcm_s16le output.wav

# Convert to 24-bit
ffmpeg -i input.wav -c:a pcm_s24le output.wav

# Convert to 32-bit float
ffmpeg -i input.wav -c:a pcm_f32le output.wav
```

## Speed & Pitch

### Speed Change (Affects Pitch)

```bash
# 2x speed (chipmunk effect)
ffmpeg -i input.mp3 -af "atempo=2.0" output.mp3

# 0.5x speed (slow motion)
ffmpeg -i input.mp3 -af "atempo=0.5" output.mp3

# For >2x, chain filters
ffmpeg -i input.mp3 -af "atempo=2.0,atempo=2.0" output.mp3  # 4x
```

### Pitch Change (Preserves Speed)

```bash
# Pitch shift using rubberband
ffmpeg -i input.mp3 \
  -af "rubberband=pitch=1.5" \
  output.mp3

# Pitch shift semitones
ffmpeg -i input.mp3 \
  -af "asetrate=44100*2^(2/12),aresample=44100" \
  output.mp3  # +2 semitones
```

## Trimming & Concatenation

### Trim Audio

```bash
# Extract 30 seconds starting at 1 minute
ffmpeg -ss 00:01:00 -i input.mp3 -t 00:00:30 -c copy output.mp3

# Extract from 1:00 to 2:30
ffmpeg -ss 00:01:00 -to 00:02:30 -i input.mp3 -c copy output.mp3
```

### Concatenate Audio

```bash
# Create file list
echo "file 'part1.mp3'" > list.txt
echo "file 'part2.mp3'" >> list.txt

# Concatenate (same format)
ffmpeg -f concat -safe 0 -i list.txt -c copy output.mp3

# Concatenate with re-encode
ffmpeg -f concat -safe 0 -i list.txt -c:a aac -b:a 256k output.m4a
```

### Crossfade

```bash
# Crossfade two files (3 second overlap)
ffmpeg -i part1.mp3 -i part2.mp3 \
  -filter_complex "acrossfade=d=3:c1=tri:c2=tri" \
  output.mp3
```

## Professional Workflows & Troubleshooting

For complete processing chains (podcast, music mastering, broadcast EBU R128) and fixes for common post-processing issues (loudnorm resample artifact, A/V sync, re-encoding quality loss), see `references/workflows-and-troubleshooting.md`.

## Audio Analysis & Measurement

For detailed audio analysis and measurement filters, see `references/audio-analysis-measurement.md`. Covers:

- **astats** — RMS, peak, crest factor, DC offset, bit depth, dynamic range
- **ebur128** — EBU R128 / ITU-R BS.1770 integrated loudness, LRA, true-peak, with optional video meter output
- **speechnorm** — adaptive normalizer tuned for speech / podcasts
- **dialoguenhance** (FFmpeg 8.0+) — voice-band boost for poor recordings
- **sofalizer** — HRTF / binaural processing from SOFA files
- **volumedetect** — mean and peak volume detection
- **aweighting** — A-weighting curve for perceived loudness
- **chromaprint** — audio fingerprinting (raw and base64)
- **Complete analysis workflow** — `audio-analysis.sh` aggregating astats + ebur128 + volumedetect + silencedetect

<!-- LEGACY_REMOVED: detailed astats / ebur128 / speechnorm / dialoguenhance / sofalizer / volumedetect / aweighting / chromaprint / workflow content moved to references/audio-analysis-measurement.md -->

This guide covers FFmpeg audio processing. For video operations, see the fundamentals skill. For noise reduction details, see `ffmpeg-noise-reduction`.

© JosiahSiegel · MIT · JosiahSiegel/claude-plugin-marketplace

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set96

The whole set →
tailwindcss-debugging tailwindcss-debugging diagnoses missing styles, fixes dynamic class name issues, and guides builds through Tailwind CSS v4 upgrades. CX Codex +1 209installs tailwindcss-plugins tailwindcss-plugins — a Tailwind CSS plugin reference the agent loads on its own: official typography, forms and container queries, custom plugin() utilities, and the v3 to v4 move. CX Codex +1 204installs windows-path-troubleshooting windows-path-troubleshooting — a skill that tells the agent how to write Windows paths for Read, Write and Edit, and how to convert Git Bash paths that end in ENOENT. CX Codex +1 199installs viral-video-animated-captions viral-video-animated-captions turns a word-level transcript into ASS captions with pop, bounce and karaoke highlighting, then burns them into the video with FFmpeg. CX Codex +1 196installs powershell-security powershell-security implements modern PowerShell hardening: stores credentials with SecretManagement, creates JEA role endpoints, and configures WDAC policies. CX Codex +1 194installs query-optimization query-optimization — an agent skill for slow T-SQL on SQL Server and Azure SQL: check schema and plan evidence first, then rewrite, re-index or hint. CX Codex +1 194installs ffmpeg-kinetic-captions ffmpeg-kinetic-captions writes ASS subtitles with animated captions: a karaoke highlight that scales each word, pop-in bounces, shake on the beat. Made for vertical video. CX Codex +1 193installs docker-platform-guide docker-platform-guide — a skill that briefs your coding agent on Docker differences between Windows, Linux and macOS, from WSL2 backends to multi-arch builds. CX Codex +1 192installs

Project sponsors

Companies that keep this analytics open