Automação de Tarefas de Vídeo com CMD e PowerShell na Prática

Por que a linha de comando voltou ao centro do fluxo criativo

Quem produz vídeo com apoio de inteligência artificial descobre rapidamente um limite prático: a interface gráfica é excelente para explorar ideias, mas sofrível para repetir a mesma operação trezentas vezes. Gerar dez variações de uma cena, renomear arquivos, conferir duração, extrair áudio, padronizar resolução e registrar resultados em uma planilha são tarefas simples — e exatamente por isso consomem horas quando feitas manualmente.

O prompt de comando e o PowerShell resolvem esse problema porque transformam ações repetitivas em instruções verificáveis. Um script não se distrai, não esquece um parâmetro e deixa registro do que fez. Quando o volume de projetos cresce, a diferença entre uma equipe que entrega no prazo e outra que vive apagando incêndio raramente está no modelo de geração escolhido: está na organização do pipeline.

Neste guia, você vai aprender a usar CMD e PowerShell para organizar ativos, monitorar recursos da máquina, disparar jobs de geração por API, tratar falhas com elegância e manter um histórico auditável de tudo o que foi produzido. Não é necessário ser programador profissional — é necessário entender algumas ideias centrais e aplicá-las com disciplina.

Fundamentos: CMD, PowerShell e quando usar cada um

Escolhendo a ferramenta certa

O CMD é o interpretador clássico do Windows. Ele é leve, está em qualquer máquina e executa bem comandos únicos, chamadas a executáveis e tarefas de cópia ou movimentação de arquivos. Já o PowerShell é orientado a objetos: cada comando devolve estruturas com propriedades, o que permite filtrar, ordenar, comparar e exportar dados sem precisar interpretar texto solto.

Na prática, a regra é simples:

• Use CMD para chamadas diretas a ferramentas de linha de comando, como ffmpeg, ffprobe, magick ou 7z, sobretudo quando o comando é pontual.
• Use PowerShell para qualquer coisa que envolva lógica condicional, listas de arquivos, requisições HTTP, manipulação de JSON ou integração com banco de dados.
• Prefira PowerShell 7 se parte da equipe trabalha em macOS ou Linux, porque a sintaxe e os cmdlets são consistentes entre sistemas.

Vale lembrar que o PowerShell permite encadear comandos com pipes, e esse é o seu maior trunfo. Em vez de escrever um programa longo, você compõe pequenas operações: listar arquivos, filtrar por extensão, medir duração, ordenar por tamanho, exportar um relatório.

Preparando o ambiente

Antes de escrever qualquer script, garanta que as ferramentas essenciais estejam instaladas e acessíveis no PATH:

winget install --id Microsoft.PowerShell
winget install Gyan.FFmpeg
$PSVersionTable.PSVersion
Get-Command ffmpeg | Select-Object Source

Se o comando Get-Command ffmpeg retornar erro, o executável não está no PATH e nenhum script vai funcionar. Resolva isso primeiro.

Em seguida, ajuste a política de execução de scripts para o seu usuário. Sem isso, o Windows bloqueia arquivos .ps1 baixados ou criados fora do ambiente local:

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned

Por fim, defina uma estrutura de pastas fixa. Um pipeline previsível sempre tem diretórios como entrada, processando, saida, logs e lixo. Essa convenção parece burocrática até o dia em que você precisa reprocessar apenas os arquivos que falharam.

Organização de ativos de vídeo em escala

Nomenclatura padronizada

O maior inimigo da automação é o nome de arquivo criativo. final_v3_ok_agora_vai.mp4 não é ordenável, não é filtrável e não sobrevive a um backup. Adote um padrão com campos separados por underline ou hífen, na ordem do mais geral para o mais específico:

projeto_cena_take_versao_resolucao.extensao
exemplo: campanha-verao_cena04_take02_v03_1080p.mp4

Com esse padrão, você consegue selecionar todos os takes de uma cena usando um padrão de busca, ordenar por versão e gerar listas de entrega automaticamente.

Renomeação e triagem em lote

Um script de renomeação em massa evita erros de digitação e economiza dezenas de minutos por lote:

$origem = "D:\projetos\campanha-verao\brutos"
$destino = "D:\projetos\campanha-verao\entrada"
$contador = 1

Get-ChildItem -Path $origem -Filter *.mp4 | Sort-Object Name | ForEach-Object {
    $novoNome = "campanha-verao_cena01_take{0:D2}_v01_1080p.mp4" -f $contador
    $alvo = Join-Path $destino $novoNome
    Move-Item -Path $_.FullName -Destination $alvo
    $contador++
}

Observe três detalhes que separam um script frágil de um script confiável: uso de -Filter em vez de filtrar depois, ordenação explícita para que a numeração seja determinística e construção de caminhos com Join-Path em vez de concatenar strings.

Metadados e integridade com ffprobe

Antes de enviar qualquer material para geração ou montagem, valide-o. O ffprobe devolve metadados em JSON, que o PowerShell converte em objeto nativamente:

$arquivos = Get-ChildItem "D:\projetos\campanha-verao\entrada" -Filter *.mp4

$relatorio = foreach ($arquivo in $arquivos) {
    $json = ffprobe -v quiet -print_format json -show_format -show_streams $arquivo.FullName | ConvertFrom-Json
    $video = $json.streams | Where-Object { $_.codec_type -eq 'video' } | Select-Object -First 1
    [pscustomobject]@{
        Arquivo    = $arquivo.Name
        Duracao    = [math]::Round([double]$json.format.duration, 2)
        Largura    = $video.width
        Altura     = $video.height
        Fps        = $video.r_frame_rate
        TamanhoMB  = [math]::Round($arquivo.Length / 1MB, 2)
        TemAudio   = [bool]($json.streams | Where-Object { $_.codec_type -eq 'audio' })
    }
}

$relatorio | Format-Table -AutoSize
$relatorio | Export-Csv "D:\projetos\logs\inventario.csv" -NoTypeInformation -Encoding UTF8

Esse inventário é o alicerce de tudo o que vem depois. Com ele, você detecta arquivos sem faixa de áudio, duração fora do esperado, resoluções inconsistentes e taxas de quadros estranhas antes que o problema chegue à etapa de edição.

Preparando a máquina: GPU, VRAM e filas de renderização

Geração de vídeo é uma tarefa intensiva em memória de vídeo. Disparar mais jobs do que a placa suporta não acelera nada: gera erro, travamento ou queda brusca de desempenho. Antes de lançar um lote, verifique o estado dos recursos:

nvidia-smi --query-gpu=name,memory.total,memory.used,utilization.gpu,temperature.gpu --format=csv

Se você não usa GPU dedicada, monitore CPU, memória e disco, que costumam ser o gargalo real na codificação:

Get-Counter '\Processor(_Total)\% Processor Time', '\Memory\Available MBytes'

Uma política prática de fila é limitar a concorrência com base na memória disponível. Em vez de rodar tudo em paralelo, processe em ondas: dois ou três jobs simultâneos, aguarde a conclusão, libere recursos, comece a próxima onda. Em PowerShell, isso costuma ser feito com ForEach-Object -Parallel e um parâmetro de limite:

$jobs = Get-ChildItem "D:\projetos\fila" -Filter *.json
$jobs | ForEach-Object -ThrottleLimit 2 -Parallel {
    # chamada de geração aqui
}

Esse controle simples reduz falhas de memória e torna o tempo total de processamento previsível — dois fatores que impactam diretamente o cronograma de entrega.

Automatizando chamadas de API para geração de vídeo

Primeira chamada bem-sucedida

A maioria dos serviços de geração expõe uma API HTTP com autenticação por token. No PowerShell, Invoke-RestMethod faz o trabalho:

$token = $env:VIDEO_API_TOKEN
$headers = @{ Authorization = "Bearer $token"; 'Content-Type' = 'application/json' }

$corpo = @{
    prompt  = "plano aéreo de floresta ao amanhecer, neblina baixa, movimento lento de câmera"
    duracao = 5
    formato = "16:9"
} | ConvertTo-Json

$resposta = Invoke-RestMethod -Uri "https://api.exemplo.com/v1/videos" -Method Post -Headers $headers -Body $corpo
$resposta.id

Três cuidados evitam muita dor de cabeça: guarde o token em variável de ambiente, e não no script; monte o corpo com ConvertTo-Json em vez de strings concatenadas; e registre o identificador do job retornado para poder consultar o resultado mais tarde.

Fila com paralelismo controlado

Para produção real, você precisa de uma fila com estado. A ideia é simples: cada job tem um arquivo de descrição, um status e um identificador remoto. O script percorre a pasta, envia o que estiver pendente e atualiza o status:

$fila = Get-ChildItem "D:\projetos\fila" -Filter *.json
foreach ($item in $fila) {
    $dados = Get-Content $item.FullName -Raw | ConvertFrom-Json
    if ($dados.status -ne 'pendente') { continue }

    try {
        $resposta = Invoke-RestMethod -Uri $endpoint -Method Post -Headers $headers -Body ($dados.payload | ConvertTo-Json)
        $dados.status = 'enviado'
        $dados.remoteId = $resposta.id
    } catch {
        $dados.status = 'erro'
        $dados.erro = $_.Exception.Message
    }

    $dados | ConvertTo-Json -Depth 6 | Set-Content $item.FullName -Encoding UTF8
}

Esse padrão de arquivo como fonte da verdade sobrevive a quedas de energia, reinícios e interrupções. Se algo falhar, basta rodar o script novamente: ele ignora o que já foi enviado.

Orquestração de diferentes modelos

Times maduros não dependem de um único modelo. Diferentes motores têm pontos fortes distintos: alguns brilham em movimento de câmera realista, outros em estilo estilizado, outros em consistência de personagem entre planos. A automação permite decidir qual motor usar por cena, com base em metadados:

$perfil = @{
    'plano-aberto'  = 'modelo-a'
    'close-retrato' = 'modelo-b'
    'transicao'     = 'modelo-c'
}
$motor = $perfil[$dados.tipoDePlano]

Manter esse mapa em um arquivo de configuração separado, e não dentro do script, permite ajustar estratégia sem mexer no código. É a diferença entre operar um pipeline e reescrevê-lo toda semana.

Resiliência: retries, backoff e fallback

APIs falham. É normal. O que não pode ser normal é um lote inteiro parar porque uma requisição recebeu um erro temporário. Implemente tentativas com espera crescente:

function Invoke-ComRetry {
    param([scriptblock]$Acao, [int]$Tentativas = 4)
    for ($i = 1; $i -le $Tentativas; $i++) {
        try { return & $Acao }
        catch {
            if ($i -eq $Tentativas) { throw }
            Start-Sleep -Seconds ([math]::Pow(2, $i))
        }
    }
}

Além do retry, planeje o fallback. Se um modelo recusar o pedido por política de conteúdo, por limite de duração ou por indisponibilidade, o script deve registrar o motivo e tentar um motor alternativo com parâmetros ajustados. Três decisões merecem ser tomadas antes, não durante a crise:

• Quais erros justificam nova tentativa? Erros de rede e limites temporários sim; erros de conteúdo, não.
• Qual é o motor substituto padrão? Defina um e documente suas limitações.
• Quando desistir e alertar uma pessoa? Após N tentativas, grave o job como pendente de revisão manual.

Sem essas regras, você acaba com um pipeline que roda durante horas e produz arquivos incompletos sem que ninguém perceba.

Logs, auditoria e rastreabilidade

Log não é burocracia: é a única forma de responder perguntas como "o que foi gerado ontem?", "qual parâmetro produziu essa cena?" e "quanto tempo cada job levou?". O formato mais prático para automação é JSON por linha, porque cada linha é um evento independente e fácil de filtrar depois:

function Write-Log {
    param([string]$Evento, [hashtable]$Dados)
    $linha = [pscustomobject]@{
        timestamp = (Get-Date).ToString('o')
        evento    = $Evento
        host      = $env:COMPUTERNAME
        dados     = $Dados
    } | ConvertTo-Json -Compress -Depth 5
    Add-Content -Path "D:\projetos\logs\producao.jsonl" -Value $linha -Encoding UTF8
}

Registre pelo menos: identificador do job, prompt enviado, modelo usado, duração da requisição, resultado, caminho do arquivo final e tempo total. Com esses campos, você consegue medir taxa de sucesso por modelo, tempo médio por cena e gargalos por etapa.

Uma dica pouco óbvia: registre também o hash do arquivo de entrada. Se dois jobs gerarem resultados diferentes com o mesmo prompt, o hash mostra se o material de base era realmente o mesmo.

Integração com banco de dados e planilhas

PostgreSQL via psql

Quando o volume cresce, planilhas deixam de ser suficientes. Um banco relacional permite consultas rápidas sobre milhares de jobs. Se você usa PostgreSQL, o utilitário psql pode ser chamado diretamente do PowerShell:

$env:PGPASSWORD = $env:DB_PASSWORD
$sql = "INSERT INTO jobs (id, cena, modelo, status) VALUES ('$id', '$cena', '$modelo', 'enviado') ON CONFLICT (id) DO NOTHING;"
psql -h $env:DB_HOST -U $env:DB_USER -d producao -c $sql

Para relatórios, prefira exportar do banco para CSV e processar no PowerShell, em vez de tentar fazer toda a lógica dentro do SQL:

psql -h $env:DB_HOST -U $env:DB_USER -d producao -c "\copy (SELECT modelo, COUNT(*), AVG(duracao_ms) FROM jobs GROUP BY modelo) TO 'D:\projetos\logs\por_modelo.csv' CSV HEADER"

Exportando relatórios em CSV

Sempre que precisar compartilhar resultados com pessoas fora do pipeline, gere CSV com Export-Csv -Encoding UTF8. É um formato que abre em qualquer ferramenta de planilha, aceita acentuação corretamente quando codificado em UTF-8 e não exige que ninguém instale nada.

Vale combinar as duas pontas: o banco guarda o estado operacional, o CSV guarda a visão gerencial. Misturar os dois papéis gera consultas lentas e relatórios frágeis.

Agendamento, segurança e controle de gastos

Agendando pipelines

No Windows, o Agendador de Tarefas executa scripts sem supervisão. Registre a tarefa apontando para o executável do PowerShell, com o arquivo .ps1 como argumento, e defina a política de execução no próprio comando:

$acao = New-ScheduledTaskAction -Execute 'pwsh.exe' -Argument '-NoProfile -ExecutionPolicy Bypass -File D:\scripts\pipeline.ps1'
$gatilho = New-ScheduledTaskTrigger -Daily -At 03:00
Register-ScheduledTask -TaskName 'PipelineVideoDiario' -Action $acao -Trigger $gatilho -RunLevel Highest

Em ambientes mistos, um agendador do sistema operacional equivalente cumpre o mesmo papel. O ponto crítico é que o script agendado roda sem interface: caminhos relativos quebram, variáveis de sessão não existem e o diretório de trabalho é diferente. Use sempre caminhos absolutos e defina o diretório explicitamente no início do script.

Guardando segredos

Nunca coloque tokens em arquivos de script versionados. As opções razoáveis são variáveis de ambiente definidas no escopo do usuário, um gerenciador de segredos ou o cofre de credenciais do próprio sistema. Para tarefas agendadas, verifique qual conta executa a tarefa: um token salvo na sua sessão provavelmente não estará disponível para ela.

Controlando gastos operacionais

Automação sem limite é automação cara. Estabeleça tetos antes de rodar qualquer lote grande:

• Limite o número de jobs por execução e por dia no próprio script.
• Registre o consumo estimado de cada lote em uma tabela e compare com o orçamento definido.
• Faça um teste com poucos segundos de duração antes de disparar um lote de planos longos.
• Prefira gerar rascunhos curtos para validar composição e movimento antes de investir em resoluções maiores.

Esses limites transformam a automação de um risco financeiro em uma ferramenta previsível.

Erros comuns e perguntas frequentes

Por que meu script funciona quando eu rodo, mas falha no agendador?

Quase sempre é ambiente. O agendador não herda variáveis de sessão nem o diretório atual do terminal. Defina caminhos absolutos, carregue variáveis de ambiente no começo do script e registre um log detalhado para descobrir exatamente onde ele para.

Como evitar que dois jobs escrevam no mesmo arquivo?

Inclua o identificador do job no nome do arquivo de saída e grave primeiro em uma pasta temporária, movendo para a pasta final apenas na conclusão. Use um nome com carimbo de tempo para garantir unicidade.

Vale a pena usar Python em vez de PowerShell?

Se a equipe já domina Python e o pipeline roda em servidores Linux, sim. Se o ambiente é Windows e você quer automação leve, integrada ao sistema de arquivos e sem instalar nada extra, o PowerShell costuma ser mais direto. O critério é a manutenção: escolha a linguagem que a próxima pessoa da equipe vai conseguir editar com segurança.

Como medir se a automação realmente economiza tempo?

Cronometre três execuções manuais e três automatizadas do mesmo lote. Compare tempo total, número de erros e tempo gasto corrigindo falhas. A automação vence com folga quando o lote passa de umas poucas dezenas de arquivos.

Preciso automatizar tudo de uma vez?

Não. Comece pela tarefa mais chata e mais frequente: provavelmente organização e renomeação de arquivos. Depois adicione validação com ffprobe, em seguida logs e só então as chamadas de API. Pipelines crescem por camadas, e cada camada precisa estar estável antes da próxima.

Devo versionar meus scripts?

Sim, e isso inclui o mapa de configuração e os modelos de prompt. Um repositório Git com histórico torna possível responder o que mudou quando a qualidade caiu — algo quase impossível se os scripts vivem apenas na máquina de uma pessoa.

O ganho real da automação em vídeo não está em fazer mais rápido o que já era feito. Está em tornar o processo repetível, mensurável e transferível. Quando o pipeline é claro o suficiente para ser executado por um script, ele também é claro o suficiente para ser melhorado por qualquer pessoa da equipe — e é aí que a produção deixa de depender de heroísmo individual.