Nesta página

Workflow after + FFmpeg

O after renderiza para ProRes ou EXR. O FFmpeg converte para o formato final. Essa divisão de trabalho é a mais eficiente: cada ferramenta faz o que faz melhor.

Por que não renderizar H.264 direto do after

O encoder H.264 interno do after:

É lento
Gera arquivos maiores que o FFmpeg para a mesma qualidade
Não suporta todas as opções do codec
Trava o after durante o processo

after renderiza ProRes (rápido, sem perda), after fica livre depois
FFmpeg converte ProRes para H.264 (mais rápido e melhor que o Media Encoder)

Preparando footage para o after

# ProRes 422 HQ, sem alpha, alta qualidade
ffmpeg -i input.mp4 -c:v prores_ks -profile:v 3 -c:a pcm_s16le output.mov

# ProRes 4444, com alpha
ffmpeg -i input.mov -c:v prores_ks -profile:v 4 -c:a pcm_s16le output_alpha.mov

# PNG sequence para ProRes
ffmpeg -framerate 24 -i frame_%04d.png -c:v prores_ks -profile:v 3 sequence.mov

# EXR sequence, preview MP4 para checagem rápida
ffmpeg -framerate 24 -i frame.%04d.exr -c:v libx264 -crf 18 -pix_fmt yuv420p preview.mp4

Ajustando frame rate antes de importar

# Converte 30fps para 24fps
ffmpeg -i input_30fps.mp4 -vf fps=24 output_24fps.mp4

# Com motion interpolation (mais suave)
ffmpeg -i input.mp4 -vf "minterpolate=fps=24:mi_mode=mci" output_24fps.mp4

Normalizando resolução

# Para 1920x1080 com letterbox preto
ffmpeg -i input.mp4 \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:-1:-1:color=black" \
  output_1080p.mp4

# Crop para 9:16 a partir de 16:9
ffmpeg -i input_169.mp4 -vf "crop=1080:1920:420:0" output_916.mp4

Script de conversão automática

Crie um converter.sh na pasta de renders:

#!/bin/bash
# Converte todos os ProRes novos para H.264

for f in *.mov; do
    output="${f%.mov}_web.mp4"
    if [ ! -f "$output" ]; then
        echo "Convertendo: $f"
        ffmpeg -i "$f" \
            -c:v libx264 \
            -crf 18 \
            -preset slow \
            -pix_fmt yuv420p \
            -movflags +faststart \
            -c:a aac -b:a 192k \
            "$output"
        echo "Concluído: $output"
    fi
done

Torne executável: chmod +x converter.sh Rode: ./converter.sh

Monitorando pasta de renders

Script Python que fica monitorando a pasta e converte automaticamente quando novos arquivos aparecem:

import time
import os
import subprocess
import glob

pasta = '/renders'
convertidos = set()

print(f'Monitorando {pasta}...')

while True:
    movs = set(glob.glob(os.path.join(pasta, '*.mov')))
    novos = movs - convertidos

    for arquivo in novos:
        saida = arquivo.replace('.mov', '_web.mp4')
        print(f'Convertendo: {os.path.basename(arquivo)}')
        subprocess.run([
            'ffmpeg', '-i', arquivo,
            '-c:v', 'libx264', '-crf', '18',
            '-pix_fmt', 'yuv420p',
            '-movflags', '+faststart',
            saida
        ])
        convertidos.add(arquivo)
        print(f'OK: {os.path.basename(saida)}')

    time.sleep(10)  # verifica a cada 10 segundos

EXR sequence para ProRes (HDR)

Quando o after renderiza EXR sequence para preservar HDR:

# EXR sequence para ProRes 4444 (com alpha se presente):
ffmpeg -framerate 24 -i frame.%04d.exr \
    -c:v prores_ks -profile:v 4 \
    -pix_fmt yuva444p10le \
    output.mov

# EXR para ProRes 422 HQ (sem alpha):
ffmpeg -framerate 24 -i frame.%04d.exr \
    -c:v prores_ks -profile:v 3 \
    output.mov

Tip

Script Python para preparar uma pasta inteira para o after, normalizando resolução e fps de uma vez:

import subprocess, glob, os
from pathlib import Path

def prepare_for_ae(input_dir, output_dir):
    Path(output_dir).mkdir(exist_ok=True)

    for f in glob.glob(os.path.join(input_dir, '*.mp4')):
        name = Path(f).stem
        output = os.path.join(output_dir, f"{name}.mov")

        subprocess.run([
            'ffmpeg', '-i', f,
            '-c:v', 'prores_ks', '-profile:v', '3',
            '-vf', 'fps=24,scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:-1:-1:color=black',
            '-c:a', 'pcm_s16le', '-ar', '48000',
            output
        ], check=True)
        print(f"OK: {name}.mov")

prepare_for_ae('/footage/raw', '/footage/ae_ready')