case técnico

Automação • Vídeos curtos / Pipeline

Factory Shorts

Pipeline em Python que transforma roteiros em vídeos curtos verticais, com legenda gravada, fundo sorteado e geração em lote. São duas versões: uma com APIs de IA e outra só com o ffmpeg.

Automação e scripts em Python Protótipo Duas versões: março de 2025 e janeiro de 2026
Python ffmpeg MoviePy OpenAI API Pexels API gTTS
resumo executivo

Problema

Produzir vídeos curtos com frequência toma tempo: escrever, achar um fundo, narrar ou legendar e editar cada vídeo à mão.

Solução

Um script que junta essas etapas num fluxo único. A versão 1 gerava o texto com IA, buscava a imagem e narrava; a versão 2 lê roteiros prontos e renderiza todos de uma vez, com legenda.

Resultado

Da versão 1 para a 2, o pipeline deixou de depender de APIs pagas e de internet e passou a gerar vídeos em lote, um para cada roteiro.

Estado atual

Protótipo funcional. Próximos passos: legenda com tamanho e margem certos para tela vertical, música de fundo e formato 1080 × 1920 fixo.

contexto

Do vídeo motivacional ao lote de shorts

A primeira versão, de março de 2025, era um experimento de ponta a ponta: pedia uma frase motivacional ao GPT-4, buscava uma imagem de natureza no Pexels, gerava a narração com gTTS e montava um vídeo de 10 segundos com o MoviePy. A segunda, de janeiro de 2026, mudou a abordagem: os roteiros são escritos antes, em arquivos de texto, e o script cuida só da parte repetitiva, legendando e renderizando cada um com o ffmpeg.

objetivos e restrições

Objetivos

  • Transformar texto em vídeo sem edição manual
  • Gerar vários vídeos de uma vez a partir de uma pasta de roteiros
  • Variar o fundo automaticamente
  • Manter o fluxo simples: um comando e os vídeos aparecem na pasta out

Restrições

  • A versão 1 dependia de três serviços externos e de chaves de API
  • Formato e resolução seguem o vídeo de fundo sorteado
  • Legenda com tamanho fixo pode ficar grande demais em tela vertical
  • A música ainda não é aplicada na versão 2
arquitetura da solução

Front-end

Sem interface: o resultado é o próprio vídeo. Na versão 2, as legendas são gravadas na imagem, centralizadas, em Arial 42.

Back-end

Versão 1: Python chamando OpenAI, Pexels, gTTS e MoviePy em sequência. Versão 2: Python gera um .srt para cada roteiro e chama o ffmpeg para repetir o fundo, aplicar as legendas e cortar o vídeo em 30 segundos.

Banco de dados

Sem banco de dados: roteiros em scripts/, fundos e música em assets/ e vídeos prontos em out/.

segurança e prevenções

Chaves fora do código

Na versão 1, as chaves das APIs ficavam no próprio script. A versão 2 não precisa de chave nenhuma; se uma próxima versão voltar a usar APIs, elas ficam em variáveis de ambiente.

Execução local

A versão 2 roda inteira na máquina, sem enviar os roteiros para serviços externos.

Sem dados pessoais

O pipeline só lida com textos de roteiro e mídias de fundo; nenhum dado de usuário é coletado.

processo
01

Primeiro experimento

Março de 2025: frase com GPT-4, imagem do Pexels, voz com gTTS e vídeo com MoviePy.

02

Limites da versão 1

Dependência de APIs pagas, imagem parada e um único vídeo por execução.

03

Pipeline em lote

Janeiro de 2026: roteiros em .txt, legendas .srt e render com ffmpeg para a pasta inteira.

04

Próximos passos

Formato vertical fixo, legenda ajustada à tela e trilha de fundo.

bastidores técnicos
auto_shorts/run.py Python linhas 13–21
def text_to_srt(text, path):
    lines = text.strip().split("\n")
    with open(path, "w", encoding="utf-8") as f:
        t = 0
        for i, line in enumerate(lines, 1):
            start = f"00:00:{t:02},000"
            end = f"00:00:{t+3:02},000"
            f.write(f"{i}\n{start} --> {end}\n{line}\n\n")
            t += 3
Cada linha do roteiro vira uma legenda de 3 segundos no formato .srt.
auto_shorts/run.py Python linhas 23–44
def generate_video(script_path):
    name = script_path.stem
    with open(script_path, encoding="utf-8") as f:
        text = f.read()

    bg = random.choice(list(BACKGROUNDS.glob("*.mp4")))
    temp_srt = OUT / f"{name}.srt"
    output = OUT / f"{name}.mp4"

    text_to_srt(text, temp_srt)

    cmd = [
        "ffmpeg", "-y",
        "-stream_loop", "-1",
        "-i", str(bg),
        "-vf", f"subtitles={temp_srt}:force_style='FontName=Arial,FontSize=42,Alignment=10'",
        "-t", "30",
        "-pix_fmt", "yuv420p",
        str(output)
    ]

    subprocess.run(cmd, shell=True)
Sorteia um fundo, repete o vídeo em loop, grava as legendas e corta em 30 segundos numa única chamada ao ffmpeg.
videos automaticos/sla.py Python linhas 41–57
# 3. Gerar áudio do texto
speech = gTTS(text=texto_motivacional, lang="pt")
audio_path = "audio.mp3"
speech.save(audio_path)

# Converter para WAV para evitar erros no MoviePy
os.system("ffmpeg -i audio.mp3 audio_converted.wav")
narration = mp.AudioFileClip("audio_converted.wav")

# 4. Criar vídeo
background = mp.ImageClip(image_path).set_duration(10)  # Duração de 10 segundos
music = mp.AudioFileClip(MUSIC_PATH).set_duration(10).volumex(0.3)  # Música mais baixa
final_audio = mp.CompositeAudioClip([narration.set_duration(10), music.set_duration(10)])

video = background.set_audio(final_audio)
video_path = "video_motivacional.mp4"
video.write_videofile(video_path, fps=24)
Versão 1: narração com gTTS e montagem no MoviePy, com a música em 30% do volume por baixo da voz.
impacto

Resultados

A versão 2 transforma uma pasta de roteiros em vídeos prontos com um comando, sem custo de API.

Aprendizados

Separar o que é criativo (o roteiro) do que é repetitivo (legendar e renderizar) deixou o pipeline mais simples, barato e previsível do que gerar tudo com IA.