@autoaiai/aicut 0.1.11 → 0.1.13

package/skills/shorts/SKILL.md

@@ -1,372 +0,0 @@
----
-name: shorts
-description: "shorts — Interactive Shortform Video Creator: the method the original skill taught, run as an AICUT film — pages that draw any moment t, cut on tracks. Runs in AICUT: the film is film.html, a page per shot, drawn by `aicut look` and `aicut render`."
-license: MIT
-source: "AgriciDaniel/claude-shorts"
----
-
-# shorts — Interactive Shortform Video Creator
-
-## Running it in AICUT
-
-AICUT's film is `film.html`: it cuts pages, footage, pictures and sound together on tracks. A page is a web page that
-sets `window.film = { frame(t) }` and draws that moment — no framework, no build step, no composition object, no
-`registerRoot`. Five shots are five pages cut together, not one page that changes scene, so each shot stays trimmable
-and replaceable in Studio.
-
-```sh
-npx -y @autoaiai/aicut@latest          # the manual: the format and the commands, always current
-npx -y @autoaiai/aicut@latest open .   # make this folder a film and print Studio's address
-npx -y @autoaiai/aicut@latest look     # a contact sheet of the whole film, its sound, and a determinism check
-npx -y @autoaiai/aicut@latest look 4.5 # one frame, full size — look at the PNG, not at the code
-npx -y @autoaiai/aicut@latest render   # the MP4, beside film.html
-```
-
-Run the manual before the first film: it is authoritative for the format, and this skill is about the method above it.
-
-Where the words below name another program's part, it becomes this:
-
-| elsewhere | in AICUT |
-|---|---|
-| composition, timeline, project file | `film.html`; tracks and clips inside it |
-| a scene, a sequence, a slide | a page (`pages/<name>.html`) cut onto a track |
-| `useCurrentFrame()`, `interpolate()` | `frame(t)` — the picture depends only on `t`, never on state or `Date.now()` |
-| a still, a screengrab | `aicut look <t>` |
-| `render` / `build` / `export` | `aicut render` (the person can also export from Studio) |
-| a dev server, a preview window | `aicut open` and the Studio address it prints |
-
-Hard rules that hold whatever the method says: the picture depends only on `t`; every value in the person's prompt is
-binding; look at the frames `look` writes before saying a film is done.
-
-
-You are an interactive shortform video producer. You guide the user through a 10-step
-pipeline where YOU (Claude) analyze the transcript, identify the best segments, present
-them for approval, snap boundaries to natural audio cut points, and render premium
-vertical videos with animated captions.
-
-## Pre-Flight
-
-Before starting, locate the project root:
-
-# Try common locations in priority order
-SHORTS_ROOT=""
-for dir in "$HOME/.claude/skills/shorts" "$HOME/.claude/skills/claude-shorts" "$HOME/claude-shorts" "$(pwd)"; do
-    if [ -f "$dir/SKILL.md" ]; then
-        SHORTS_ROOT="$dir"
-        break
-    fi
-done
-if [ -z "$SHORTS_ROOT" ]; then
-    echo "ERROR: shorts skill project root not found. Please run from the project directory or install with install.sh"
-fi
-```
-Set up the temp directory (configurable via `SHORTS_TMP` environment variable):
-```
-```bash
-SHORTS_TMP="${SHORTS_TMP:-/tmp/claude-shorts}"
-mkdir -p "$SHORTS_TMP/clips"
-```
-
-## 10-Step Interactive Pipeline
-
-### Step 1: PREFLIGHT
-
-Run safety checks on the input video:
-
-```bash
-bash "$SHORTS_ROOT/scripts/preflight.sh" INPUT_FILE [OUTPUT_DIR]
-```
-```
-If preflight fails, report errors and stop. If warnings exist, report them and ask
-the user whether to proceed.
-
-Also detect GPU capabilities:
-```
-```bash
-bash "$SHORTS_ROOT/scripts/detect_gpu.sh"
-```
-```
-Report to user: input duration, resolution, GPU status, estimated processing time.
-```
-
-### Step 2: TRANSCRIBE
-
-Transcribe with faster-whisper (GPU-accelerated, word-level timestamps).
-Audio extraction is handled internally by transcribe.py:
-```bash
-VENV="$HOME/.video-skill"
-[ -d "$VENV" ] || VENV="$HOME/.shorts-skill"
-source "$VENV/bin/activate"
-
-python3 "$SHORTS_ROOT/scripts/transcribe.py" INPUT_FILE \
-    --output $SHORTS_TMP/transcript.json
-```
-```
-Output is dual-format JSON:
-- `segments[]` — WhisperX-style with word timestamps (for Claude to read)
-- `captions[]` — Remotion-native `{text, startMs, endMs}` array (for rendering)
-
-Report to user: transcription time, word count, language detected.
-```
-
-### Step 3: DETECT CONTENT TYPE
-
-Auto-detect whether the video is talking-head, screen recording, or podcast:
-```bash
-python3 "$SHORTS_ROOT/scripts/detect_content.py" INPUT_FILE \
-    --output $SHORTS_TMP/content_type.json
-```
-```
-Report detected type to user. Ask if they want to override.
-- **talking-head**: Face-tracked center crop to 9:16
-- **screen**: Letterboxed framed layout (content centered, dark padding)
-- **podcast**: Side-by-side speaker tracking or center crop
-```
-
-### Step 4: ANALYZE — Claude Reads Transcript
-
-Read the full transcript directly:
-```
-Read $SHORTS_TMP/transcript.json
-```
-```
-Also load the scoring rubric:
-```
-```
-Read $SHORTS_ROOT/references/scoring-rubric.md
-```
-```
-Score 8-12 candidate segments (15-55 seconds each) on 5 dimensions:
-
-| Dimension | Weight | What to look for |
-|-----------|--------|------------------|
-| Hook strength | 0.30 | Bold claims, curiosity gaps, value promises, pattern interrupts |
-| Standalone coherence | 0.25 | Makes complete sense without any context from the rest of the video |
-| Emotional intensity | 0.20 | Strong opinions, surprise reveals, humor, passion |
-| Value density | 0.15 | Actionable insights, data points, frameworks per second |
-| Payoff quality | 0.10 | Satisfying conclusion — punchline, reveal, call-to-action |
-
-**Weighted score** = sum of (dimension_score * weight), scale 0-100.
-
-For each candidate, identify:
-- Start/end timestamps (to the nearest second)
-- A suggested hook line (first 3 seconds of text overlay)
-- Brief rationale (1 sentence explaining why this segment works)
-
-**Transcript cleanup:** While analyzing, also produce cleaned captions for rendering.
-Read the `captions[]` array from transcript.json, then:
-1. Remove filler words (um, uh, you know, like, sort of, I mean, right, basically, actually)
-2. Fix obvious transcription errors based on surrounding context
-3. Consolidate incomplete sentence fragments where appropriate
-4. **Keep all timestamps unchanged** — only modify the `text` field
-
-Write the cleaned transcript to `$SHORTS_TMP/transcript_cleaned.json` using the same
-JSON structure as transcript.json (both `segments` and `captions` arrays). The `captions`
-array should contain the cleaned text; copy `segments` as-is.
-```
-
-### Step 5: PRESENT — Show Candidates Interactively
-
-Present candidates in a formatted table:
-
-```
-| # | Time          | Dur  | Score | Hook                              | Why                                    |
-|---|---------------|------|-------|-----------------------------------|----------------------------------------|
-| 1 | 04:22 → 05:01 | 39s  | 87    | "Nobody talks about this..."     | Contrarian take with data backing      |
-| 2 | 12:45 → 13:28 | 43s  | 82    | "Here's the exact framework..."  | Complete actionable method, clean arc   |
-| 3 | 08:11 → 08:52 | 41s  | 79    | "I tested this for 6 months..."  | Personal story + surprising result     |
-```
-```
-Then ask the user using AskUserQuestion:
-1. **Which segments?** — "all", specific numbers, or "none, re-analyze"
-2. **Caption style?** — bold (ALL CAPS pop-in), bounce (bouncy colorful), clean (minimal fade)
-3. **Platform?** — youtube, tiktok, instagram, or all
-```
-
-### Step 6: APPROVE — Interactive Adjustment Loop
-
-After user selects segments:
-- Show selected segments with exact timestamps
-- Allow timecode adjustments ("move segment 2 start back 3 seconds")
-- Confirm final selections
-- Estimate render time (~15-30s per segment with Remotion)
-
-Write approved segments to:
-```bash
-cat > $SHORTS_TMP/approved_segments.json << 'EOF'
-{
-  "segments": [
-    {
-      "id": 1,
-      "start": 262.0,
-      "end": 301.0,
-      "hook_line1": "Nobody talks about this...",
-      "hook_line2": "The hidden cost of scaling",
-      "score": 87
-    }
-  ],
-  "style": "bold",
-  "platform": "all",
-  "content_type": "talking-head"
-}
-EOF
-```
-
-### Step 7: SNAP BOUNDARIES — Audio-Aware Cut Points
-
-Snap segment boundaries to natural audio cut points so clips never cut mid-word
-or mid-sentence:
-
-```bash
-python3 "$SHORTS_ROOT/scripts/snap_boundaries.py" \
-    --segments $SHORTS_TMP/approved_segments.json \
-    --transcript $SHORTS_TMP/transcript.json \
-    --input-video INPUT_FILE \
-    --output $SHORTS_TMP/snapped_segments.json
-```
-```
-The script:
-1. Loads word-level timestamps from the transcript
-2. Snaps start times to the nearest word boundary (prefers sentence starts)
-3. Extends end times to the next sentence boundary (. ? !) if within 3 seconds
-4. Adds 300ms padding after the last word
-5. Uses FFmpeg silencedetect to find natural pauses near cut points
-6. Enforces min 5s / max 60s duration, clamps to video bounds
-
-Use `--no-silence` to skip silence detection (faster, word-boundary snapping only).
-
-Report to user: adjustment deltas per segment (e.g., "start +150ms, end +362ms").
-
-From this point forward, use `snapped_segments.json` instead of `approved_segments.json`.
-```
-
-### Step 8: PREPARE — Extract Clips + Compute Reframe
-
-Extract each snapped segment via FFmpeg stream copy (near-instant, lossless).
-Use the snapped start/end times from `$SHORTS_TMP/snapped_segments.json`:
-```bash
-$SHORTS_TMP/clips/clip_01.mp4
-```
-```
-Compute reframe coordinates for each clip:
-```
-```bash
-python3 "$SHORTS_ROOT/scripts/compute_reframe.py" \
-    --clips-dir $SHORTS_TMP/clips/ \
-    --content-type CONTENT_TYPE \
-    --output $SHORTS_TMP/reframe.json
-```
-```
-Report to user: clips extracted, content type per clip, reframe strategy.
-```
-
-### Step 9: RENDER via Remotion
-
-Render all snapped segments with the selected caption style:
-```bash
-node "$SHORTS_ROOT/remotion/render.mjs" \
-    --segments $SHORTS_TMP/snapped_segments.json \
-    --reframe $SHORTS_TMP/reframe.json \
-    --captions $SHORTS_TMP/transcript_cleaned.json \
-    --style STYLE \
-    --clips-dir $SHORTS_TMP/clips/ \
-    --output-dir $SHORTS_TMP/render/
-```
-```
-The render script:
-1. Bundles the Remotion project once (~5-10s)
-2. Opens a shared Chrome instance
-3. Renders each segment sequentially (~15-30s each)
-4. Outputs 1080x1920 MP4 files
-
-Report progress to user as each segment renders.
-```
-
-### Step 10: EXPORT — Platform-Optimized Encoding
-
-Export rendered shorts with platform-specific encoding:
-```bash
-bash "$SHORTS_ROOT/scripts/export.sh" \
-    --input-dir $SHORTS_TMP/render/ \
-    --platform PLATFORM \
-    --output-dir ./shorts/
-```
-```
-Platform encoding specs:
-- **YouTube Shorts**: H.264 High 4.2, 12 Mbps, AAC 192k
-- **TikTok**: H.264, CRF 18, -preset slow, AAC 128k
-- **Instagram Reels**: H.264 High 4.2, 4.5 Mbps maxrate 5000k, AAC 128k
-- **All**: Exports all three variants per clip
-
-With NVENC GPU: `h264_nvenc -preset p5 -tune hq` for 5-10x faster encoding.
-
-Present final summary table:
-```
-```
-| # | File                      | Platform  | Duration | Size   |
-|---|---------------------------|-----------|----------|--------|
-| 1 | shorts/short_01_yt.mp4    | YouTube   | 39s      | 12.3MB |
-| 1 | shorts/short_01_tt.mp4    | TikTok    | 39s      | 8.7MB  |
-| 1 | shorts/short_01_ig.mp4    | Instagram | 39s      | 7.1MB  |
-```
-```
-**Post-export validation:** Run validation on all exported files:
-```
-```bash
-bash "$SHORTS_ROOT/scripts/validate.sh" --output-dir ./shorts/
-```
-```
-Checks: file is playable, resolution is 1080x1920, audio track exists and isn't silent,
-file size is within platform limits, video codec is H.264, duration is 3-90 seconds.
-If any file fails, report the issues to the user. Failed files should be re-rendered
-or re-exported before delivery.
-```
-
-## Important Rules
-
-1. **Always run preflight** before any processing
-2. **Always present segments for approval** — never auto-render without user confirmation
-3. **Always report costs** — Remotion rendering is free (local), only potential cost is GPU power
-4. **Handle errors gracefully** — if any step fails, report the error and suggest fixes
-5. **Clean up on success** — offer to delete $SHORTS_TMP/ after export
-6. **Respect the user's choices** — if they say "re-analyze", go back to Step 4
-7. **Stream copy for extraction** — never re-encode when cutting segments (use -c copy)
-8. **One segment at a time** for progress reporting during render
-9. **Load references** when needed — scoring-rubric.md for Step 4, caption-styles.md for style questions
-
-## Caption Style Reference
-
-| Style | Font | Look | Best for |
-|-------|------|------|----------|
-| **bold** | Montserrat Bold | ALL CAPS, pop-in, yellow active word | Business, education, motivation |
-| **bounce** | Bangers | Bouncy scale, rotating bright colors | Entertainment, reactions, energy |
-| **clean** | Inter Bold | Minimal fade-in, white + shadow | Professional, calm, interviews |
-
-Load `references/caption-styles.md` for detailed visual specs and spring configs.
-
-## Configurable Parameters
-
-These defaults work well for most content. Offer alternatives when the user has specific needs.
-
-| Parameter | Default | Flag/Var | When to change |
-|-----------|---------|----------|----------------|
-| Whisper model | `large-v3` | `--model small` | Low VRAM (< 6 GB) |
-| Screen zoom | `0.55` | `--zoom 0.4` | More context visible in screen recordings |
-| Cursor tracking | enabled | `--no-cursor-track` | Static screen content (slides, documents) |
-| Silence detection | enabled | `--no-silence` | Faster processing, word-boundary-only snapping |
-| Score threshold | 60 | (SKILL.md instruction) | Lower for longer videos with fewer highlights |
-| Segment duration | 15-55s | (SKILL.md instruction) | Adjust per platform (TikTok prefers 21-34s) |
-| Temp directory | `/tmp/claude-shorts/` | `SHORTS_TMP` env var | Systems with limited /tmp space |
-| Export platform | `all` | `--platform youtube` | Single-platform targeting |
-
-## Error Recovery
-
-- **Transcription fails**: Check venv activation, try `--model small` for less VRAM
-- **Remotion render fails**: Check `cd remotion && npm install`, verify node_modules exists
-- **Export fails**: Check FFmpeg version (`ffmpeg -version`), try CPU encoding if NVENC fails
-- **Out of disk space**: Clean $SHORTS_TMP/, check with `df -h /tmp`
-
-## Source
-
-Rewritten for AICUT from [`AgriciDaniel/claude-shorts`](https://github.com/AgriciDaniel/claude-shorts)
-(MIT), SKILL.md. The method is that skill's own; the way it runs is AICUT's.

package/skills/shorts/references/caption-styles.md

@@ -1,105 +0,0 @@
-# Caption Styles — Visual Specifications
-
-Three premium caption presets for different content tones. Each uses `@remotion/captions` createTikTokStyleCaptions() for word-level timing.
-
-## Bold Style
-
-Best for: Business, education, motivation, "guru" content.
-
-| Property | Value |
-|----------|-------|
-| Font | Montserrat Bold (800 weight) |
-| Font Size | 72px |
-| Text Transform | UPPERCASE |
-| Words Per Page | 2-3 |
-| Combine Window | 800ms |
-| Text Color | White (#FFFFFF) |
-| Active Word | Yellow (#FFD700) |
-| Text Shadow | 3px solid black outline (all 4 directions) |
-| Position | Bottom: 350px from bottom edge |
-| Animation | Pop-in spring: {mass:1, damping:12, stiffness:200} |
-| Timing | Page appears at first word, disappears after last word |
-
-**Visual reference**: All caps, word-by-word yellow highlight, bold pop-in entrance.
-
-**Spring config explained**:
-- `damping: 12` — moderate bounce, settles in ~0.4s
-- `stiffness: 200` — snappy entrance
-- Scale goes from 0 → slight overshoot (~1.05) → 1.0
-
-## Bounce Style
-
-Best for: Entertainment, reactions, challenges, high-energy content.
-
-| Property | Value |
-|----------|-------|
-| Font | Bangers (Google Fonts, OFL) |
-| Font Size | 84px |
-| Text Transform | UPPERCASE |
-| Words Per Page | 1-2 |
-| Combine Window | 600ms |
-| Text Color | Rotating (see below) |
-| Text Shadow | 4px solid black outline (all 4 directions) |
-| Position | Bottom: 350px from bottom edge |
-| Animation | Bouncy scale: 70% → ~120% → 100% |
-| Spring Config | {mass:1, damping:8, stiffness:180} |
-
-**Color rotation** (per page, cycling):
-1. Cyan (#00FFFF)
-2. Magenta (#FF00FF)
-3. Lime (#00FF00)
-4. Yellow (#FFFF00)
-5. Orange (#FF6600)
-6. Hot Pink (#FF0066)
-
-**Spring config explained**:
-- `damping: 8` — very bouncy, overshoots significantly
-- Scale: starts at 0.7, springs up to ~1.2, settles at 1.0
-- Creates the "explosive word pop" effect
-
-## Clean Style
-
-Best for: Professional, interviews, calm content, podcasts.
-
-| Property | Value |
-|----------|-------|
-| Font | Inter Bold (700 weight) |
-| Font Size | 56px |
-| Text Transform | None (preserves original case) |
-| Words Per Page | 3-5 |
-| Combine Window | 1500ms |
-| Text Color | White (#FFFFFF) |
-| Active Word | Light gray (#E0E0E0) |
-| Text Shadow | 2px 2px 8px rgba(0,0,0,0.6) — soft shadow |
-| Position | Bottom: 350px from bottom edge |
-| Animation | Fade-in opacity 0→1 over 6 frames (200ms at 30fps) |
-
-**Visual reference**: Minimal, readable, doesn't distract from the speaker. Subtle active-word highlighting through slight color change rather than bold contrast.
-
-## Font Files
-
-All fonts must be placed in `remotion/public/fonts/`:
-- `Montserrat-Bold.ttf` — from Google Fonts (OFL license)
-- `Bangers-Regular.ttf` — from Google Fonts (OFL license)
-- `Inter-Bold.ttf` — from Google Fonts (OFL license)
-
-Download from: https://fonts.google.com/
-
-## Caption Positioning
-
-All styles share the same vertical positioning:
-- **Bottom offset**: 350px from bottom edge of 1920px frame
-- This places captions above the platform's built-in UI elements (like/comment/share buttons)
-- Safe zone for TikTok: 150px from bottom, 64px from sides
-- Safe zone for YouTube Shorts: 120px from bottom
-- Our 350px offset clears all platform UI with margin
-
-## Integration with Hook Overlay
-
-The hook overlay occupies the top 200px zone (first 3.5s only). Captions appear in the bottom zone. No overlap.
-
-When both are visible (0.3s - 3.5s), the visual hierarchy is:
-1. Hook text (top, large, attention-grabbing)
-2. Video content (center)
-3. Captions (bottom, word-level)
-4. Progress bar (very bottom, subtle)

package/skills/shorts/references/platform-specs.md

@@ -1,149 +0,0 @@
-# Platform Export Specifications
-
-Encoding specs for each target platform, optimized for quality and upload compatibility.
-
-## YouTube Shorts
-
-| Property | Value |
-|----------|-------|
-| Resolution | 1080x1920 |
-| Aspect Ratio | 9:16 |
-| Max Duration | 60 seconds |
-| Video Codec | H.264 (AVC) |
-| Profile | High |
-| Level | 4.2 |
-| Bitrate | 12 Mbps (target) |
-| Max Bitrate | 14 Mbps |
-| Buffer Size | 24 Mbps |
-| Audio Codec | AAC |
-| Audio Bitrate | 192 kbps |
-| Sample Rate | 48 kHz |
-| Container | MP4 |
-| Pixel Format | yuv420p |
-| Max File Size | 256 MB |
-
-**FFmpeg (CPU)**:
-```bash
-ffmpeg -y -i input.mp4 \
-    -c:v libx264 -preset slow \
-    -b:v 12M -maxrate 14M -bufsize 24M \
-    -profile:v high -level 4.2 \
-    -af loudnorm=I=-14:TP=-1:LRA=11 \
-    -c:a aac -b:a 192k -ar 48000 \
-    -pix_fmt yuv420p -movflags +faststart \
-    output_yt.mp4
-```
-
-**FFmpeg (NVENC)**:
-```bash
-ffmpeg -y -i input.mp4 \
-    -c:v h264_nvenc -preset p5 -tune hq \
-    -b:v 12M -maxrate 14M -bufsize 24M \
-    -profile:v high -level 4.2 \
-    -af loudnorm=I=-14:TP=-1:LRA=11 \
-    -c:a aac -b:a 192k -ar 48000 \
-    -pix_fmt yuv420p -movflags +faststart \
-    output_yt.mp4
-```
-
-## TikTok
-
-| Property | Value |
-|----------|-------|
-| Resolution | 1080x1920 |
-| Aspect Ratio | 9:16 |
-| Max Duration | 60 seconds (3 min with account) |
-| Video Codec | H.264 (AVC) |
-| Bitrate Mode | CRF 18 (quality-based) |
-| Max Bitrate | 10 Mbps |
-| Buffer Size | 20 Mbps |
-| Audio Codec | AAC |
-| Audio Bitrate | 128 kbps |
-| Sample Rate | 44.1 kHz |
-| Container | MP4 |
-| Pixel Format | yuv420p |
-| Max File Size | 287 MB |
-
-**FFmpeg (CPU)**:
-```bash
-ffmpeg -y -i input.mp4 \
-    -c:v libx264 -preset slow -crf 18 \
-    -maxrate 10M -bufsize 20M \
-    -af loudnorm=I=-14:TP=-1:LRA=11 \
-    -c:a aac -b:a 128k -ar 44100 \
-    -pix_fmt yuv420p -movflags +faststart \
-    output_tt.mp4
-```
-
-**FFmpeg (NVENC)**:
-```bash
-ffmpeg -y -i input.mp4 \
-    -c:v h264_nvenc -preset p5 -tune hq \
-    -cq 18 -maxrate 10M -bufsize 20M \
-    -af loudnorm=I=-14:TP=-1:LRA=11 \
-    -c:a aac -b:a 128k -ar 44100 \
-    -pix_fmt yuv420p -movflags +faststart \
-    output_tt.mp4
-```
-
-## Instagram Reels
-
-| Property | Value |
-|----------|-------|
-| Resolution | 1080x1920 |
-| Aspect Ratio | 9:16 |
-| Max Duration | 90 seconds |
-| Video Codec | H.264 (AVC) |
-| Profile | High |
-| Level | 4.2 |
-| Bitrate | 4.5 Mbps (target) |
-| Max Bitrate | 5 Mbps |
-| Buffer Size | 10 Mbps |
-| Audio Codec | AAC |
-| Audio Bitrate | 128 kbps |
-| Sample Rate | 44.1 kHz |
-| Container | MP4 |
-| Pixel Format | yuv420p |
-| Max File Size | 250 MB |
-
-**FFmpeg (CPU)**:
-```bash
-ffmpeg -y -i input.mp4 \
-    -c:v libx264 -preset slow \
-    -b:v 4500k -maxrate 5000k -bufsize 10M \
-    -profile:v high -level 4.2 \
-    -af loudnorm=I=-14:TP=-1:LRA=11 \
-    -c:a aac -b:a 128k -ar 44100 \
-    -pix_fmt yuv420p -movflags +faststart \
-    output_ig.mp4
-```
-
-## Safe Zones
-
-All platforms have UI overlays that consume screen space. Values below are the median of 10+ community-measured sources at 1080x1920 (no platform publishes official pixel specs). Bottom margins vary with caption/description length — values reflect typical organic content.
-
-| Zone | TikTok | YouTube Shorts | Instagram Reels | Universal |
-|------|--------|----------------|-----------------|-----------|
-| Top | 150px | 150px | 210px | 210px |
-| Bottom | 320px | 350px | 340px | 450px |
-| Left | 60px | 60px | 40px | 60px |
-| Right | 120px | 150px | 100px | 150px |
-| Safe Area | 900x1450px | 870x1420px | 940x1370px | 870x1260px |
-
-Caption position at 350px from bottom clears TikTok (320px) and Instagram (340px). For YouTube Shorts safety, 400px+ is recommended. For universal cross-platform safety, 450px+ is ideal.
-
-## Audio Normalization
-
-All exports normalize audio to -14 LUFS (EBU R128) using FFmpeg's `loudnorm` filter:
-- `I=-14` — integrated loudness target (-14 LUFS, YouTube/streaming standard)
-- `TP=-1` — true peak max (-1 dBFS headroom, prevents clipping)
-- `LRA=11` — loudness range (dynamic variation allowed)
-
-## NVENC Encoding Notes
-
-For NVIDIA GPUs with NVENC support (GTX 1650+, RTX series):
-- `h264_nvenc -preset p5 -tune hq` provides best quality
-- 5-10x faster than CPU `-preset slow`
-- Quality is comparable to CPU at same bitrate
-- `-preset p7` for maximum quality (slower but still faster than CPU)
-- Always verify NVENC availability: `ffmpeg -encoders | grep nvenc`