Desenvolvimento de um pipeline local de dublagem automática de vídeos…

INEMA

fiz ajuste para criar um diretorio dublado abaixo e gerar o mesmo nome da entrada.

tambem fiz para o fit ajustar o tempo milimetricametne

→ fit. Exemplo acima do Cenário 3.

Não quero distorção de pitch, só “falar mais rápido/devagar”. Resposta: use fit (ou smart quando cair em fit). Ele usa atempo (preserva pitch).
Quero zero alterações de fala, só concatenar. Resposta: none. Útil para teste de TTS sem sincronizar; pode mudar a duração total.
Quando usar pad puro? Resposta: quando você quer garantir tempo exato sem alterar a fala; aceita silêncio/corte para casar cada segmento.

Aqui vai o explica-tudo dos 4 modos de sincronização do seu dublar.py, com o que acontece quando o TTS sai menor/maior que o segmento, prós/limites e exemplos de uso.

Visão geral rápida⌗

none • Não ajusta nada; só concatena os áudios como vieram do TTS. Útil para ouvir a dublagem “crua” sem se preocupar com tempo. • Consequência: o vídeo final pode ficar mais curto ou mais longo que o original (porque cada trecho mantém a própria duração).

fit • Ajusta a duração com ffmpeg atempo: acelera ou desacelera a fala preservando o pitch (é “falar mais rápido/devagar”, sem voz fina/grossa). • Só aplica se a diferença passar de tolerance; e respeita o limite de maxstretch. Usa cadeia atempo para fatores fora de 0.5–2.0.

pad • Se o TTS estiver maior que o alvo: corta exatamente no tempo do segmento (atrim). • Se o TTS estiver menor: preenche com silêncio até bater o tempo (apad + atrim). Garante duração exata por segmento.

smart • Decide por segmento: – Curto demais → aplica pad (preenche silêncio). – Longo demais → aplica fit (acelera/desacelera com atempo). – Dentro da faixa [target×(1−tolerance), target×(1+tolerance)] → deixa como está.

O que acontece em cada caso⌗

none • TTS menor: fica menor; não adiciona silêncio. • TTS maior: fica maior; não corta nem acelera. • Resultado global: somas podem desalinhar com o vídeo e alterar a duração total (para cima ou para baixo).

fit • TTS menor/maior: comprime/expande com atempo para aproximar do alvo, mas… – Se a diferença for menor que tolerance, não mexe. – Se precisar ajustar além de maxstretch, limita o quanto pode corrigir (não garante alvo milimétrico em casos extremos).

pad • TTS maior: corta no tempo exato (sem mexer na voz). • TTS menor: completa com silêncio até o tempo exato. • Resultado global: cada segmento bate no alvo; porém muitos “curtos” viram silêncio e podem dar sensação de pausas.

smart • Curto → pad; Longo → fit; Dentro da margem → mantém como veio. • Se tolerance for 0.0, nada “passa”: curto sempre preenche e longo sempre comprime. • É o equilíbrio automático entre naturalidade e tempo alvo.

Parâmetros que mandam no jogo⌗

tolerance • Margem de diferença aceitável. Se a razão target/cur estiver dentro de ±tolerance, o fit não roda; no smart, “dentro da faixa” não ajusta. Reduzir força mais ajustes; aumentar preserva mais naturalidade.

maxstretch • Limite do quanto pode acelerar/desacelerar (fit). Se for muito restrito, alguns trechos longos não cabem exatamente. Se for alto, cabe tudo, mas pode soar apressado/lento.

Exemplos práticos de uso⌗

Cenário 1 — quero máxima naturalidade (aceito variação pequena no tempo) Comando: python dublar.py --in video.mp4 --out dub.mp4 --src en --tgt pt --tts bark --sync smart --tolerance 0.15 --maxstretch 1.25 Efeito: • 15% de folga; smart só corrige quando necessário. Voz mais orgânica; tempo final tende a ficar próximo, mas não perfeito.

Cenário 2 — equilíbrio (tempo bem próximo e fala ainda natural) Comando: python dublar.py --in video.mp4 --out dub.mp4 --src en --tgt pt --tts bark --sync smart --tolerance 0.05 --maxstretch 1.5 Efeito: • 5% de folga; corrige na maioria dos casos; 1.5× dá margem sem soar “chipmunk”.

Cenário 3 — preciso cravar o tempo por segmento Comando: python dublar.py --in video.mp4 --out dub.mp4 --src en --tgt pt --tts bark --sync smart --tolerance 0.0 --maxstretch 3.0 --fade 0 Efeito: • Curto sempre vira pad (silêncio até o alvo) e longo sempre vira fit (atempo em cadeia). Remover micro-fades evita microvariações.

Dicas finas⌗

• Muitos trechos curtos no smart com tolerance alto geram preenchimentos de silêncio (pad) e podem percepcionalmente “alongar” a experiência. Reduza tolerance se quiser menos silêncio. • Se notar trechos ainda um pouco fora, dá para complementar o fit com um corte milimétrico no final (atrim após atempo); hoje o pad já usa atrim para cravar o alvo.

Perguntas rápidas (com exemplos)⌗

Quero que sempre bata no tempo. Qual modo? Resposta: smart com tolerance 0.0. Curto → pad; longo

Boa, vamos organizar os parâmetros principais do teu dublar.py para você ter uma visão clara do que cada um faz e quando usar.

Parâmetros principais⌗

--sync [none|fit|pad|smart] Define o modo de sincronização dos áudios com os tempos originais:

none → não faz nada, só junta os áudios.
fit → ajusta com atempo (fala mais rápido/lento, sem mudar o tom).
pad → corta se passar do tempo ou adiciona silêncio se for menor.
smart → decide: curto → pad, longo → fit, dentro da margem → mantém.

--tolerance (padrão: 0.15) Define a margem de diferença aceitável entre o áudio gerado e o tempo original.

Se a diferença for menor que esse valor, não ajusta.
Ex: 0.15 = 15% → um trecho de 10s pode variar entre 8.5s e 11.5s sem ajuste.

--maxstretch (padrão: 1.35) Define o limite máximo de compressão/expansão da fala.

Ex: 1.35 = até 35% mais lento ou mais rápido.
Se precisar mais que isso, ele não corrige (ou só até o limite).

--maxdur (padrão: 10.0) Máxima duração de cada segmento antes de dividir.

Se um segmento traduzido ficar muito longo, ele é quebrado em partes menores.
Colocar 0 desativa o split.

--tts [bark|coqui] Define o motor de síntese de voz (TTS):

bark → qualidade boa, mais pesado, aceita history_prompt para voz específica.
coqui → rápido, suporta alguns modelos prontos (pt-br disponível).

--voice Permite escolher a voz (no Bark via history_prompt, no Coqui via speaker).

--texttemp e --wavetemp (padrão: 0.6) Parâmetros de temperatura para o Bark:

texttemp → controla a variação na interpretação do texto.
wavetemp → controla a variação no áudio gerado.
Valores menores → mais estável e previsível.

--fade (padrão: 1) Ativa micro fades (fade-in/fade-out de 0.02s) nos áudios para evitar estalos nas junções.

1 = ligado (seguro e limpo).
0 = desligado (se quiser precisão absoluta de tempo).

--rate (padrão: 24000) Taxa de amostragem final do áudio.

--bitrate (padrão: 192k) Bitrate do áudio no MP4 final.

Perfeito: dá pra “forçar” esse comportamento.

O que você quer

Se o TTS ficar menor que o segmento: completar com silêncio.
Se o TTS ficar maior que o segmento: comprimir para caber no tempo.

Como fazer só com parâmetros

Use smart com tolerância 0, esticagem alta, sem micro-fade e sem split.
Comando sugerido:

python dublar.py --in video.mp4 --out video_dublado.mp4 \ --src en --tgt pt --tts bark \ --sync smart --tolerance 0.0 --maxstretch 3.0 \ --fade 0 --maxdur 0

Por quê:

smart decide: curto → pad, longo → fit, dentro da faixa → mantém. Com tolerance 0.0, nada “passa batido” e ele sempre ajusta.
pad preenche com silêncio ou corta no alvo, garantindo duração exata via apad/atrim.
fit comprime/expande com atempo; com maxstretch alto ele consegue caber mesmo quando o TTS passou muito.
fade 0 evita micro-fades que podem introduzir microvariações.
maxdur 0 desativa o split inteligente, mantendo os tempos originais de cada segmento.

Observação técnica importante

Hoje, pad já garante o alvo exato com apad+atrim.
fit não faz um corte final para “bater milissegundo” no alvo; ele só aplica atempo dentro dos limites de tolerance e maxstretch. Se quiser precisão milimétrica, posso te passar um patch rápido no sync_fit para aplicar um atrim final após o atempo.

Diagnóstico do seu caso

Se você usou pad ou smart com tolerance alto, muitos trechos curtos receberam silêncio até o tempo alvo, o que pode inflar a duração total ao concatenar. Usando tolerance 0.0 em smart, cada trecho sempre é ajustado no tempo, evitando “sobra”.

Exemplos rápidos

TTS 8.0 s para alvo 10.0 s → smart com tolerance 0.0 aplica pad e vira 10.0 s exatos.
TTS 12.0 s para alvo 10.0 s → smart aplica fit; com maxstretch 3.0, ele consegue comprimir para 10.0 s.

O script que você está usando ([dublar.py](https://dublar.py/)) tem quatro modos de sincronização definidos:

none → não faz ajuste nenhum.
fit → estica ou comprime o áudio com atempo para caber exatamente no tempo.
pad → corta se for maior, ou adiciona silêncio se for menor.
smart → decide entre pad e fit dependendo se o trecho ficou curto demais ou longo demais.

O que causou o aumento de tempo no seu caso:

Quando você usou pad ou smart, se os trechos sintetizados ficaram mais curtos do que o segmento original, o script adicionou silêncio até completar o tempo.
Se muitos trechos ficaram assim, o resultado acumulado pode inflar a duração total (por exemplo, de 16 min para 29 min).

Como evitar esse aumento⌗

Use --sync fit → o áudio vai ser comprimido/expandido para caber no tempo, sem adicionar silêncio extra.
Se quiser manter qualidade e evitar distorção exagerada, ajuste os parâmetros:

--tolerance 0.15 (padrão, permite 15% de diferença)
--maxstretch 1.35 (padrão, não estica mais que 35%) Você pode reduzir --tolerance e --maxstretch para evitar esticar demais. 3. Se preferir menos distorção, combine --sync smart mas reduza --tolerance (ex: 0.05). Assim ele só adiciona silêncio quando realmente precisa.

Exemplo de execução ajustada⌗

python dublar.py --in video.mp4 --out video_dublado.mp4 \ --src en --tgt pt --tts bark --sync fit \ --tolerance 0.10 --maxstretch 1.25

Isso deve manter o vídeo final com praticamente a mesma duração do original.

Aqui vai o checklist enxuto do passo a passo “único” para instalar do zero e rodar o dublar.py.

✔️ Passo 1 – Preparar ambiente conda⌗

conda create -n voz-bark python=3.10 -y conda activate voz-bark

✔️ Passo 2 – Instalar PyTorch (CPU ou GPU)⌗

CPU (seguro para qualquer máquina):

pip install --index-url https://download.pytorch.org/whl/cpu torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1

Se tiver GPU NVIDIA → usar index CUDA correspondente.

✔️ Passo 3 – Instalar libs de áudio⌗

pip install scipy soundfile ffmpeg-python librosa numpy==2.3.2

✔️ Passo 4 – Instalar Whisper rápido⌗

pip install faster-whisper==1.0.3

✔️ Passo 5 – Instalar tradução⌗

pip install transformers==4.41.2 sentencepiece sacremoses

✔️ Passo 6 – Instalar TTS⌗

Bark (principal):

pip install bark==0.1.5

Coqui (opcional):

pip install TTS

✔️ Passo 7 – Instalar e configurar FFmpeg⌗

Baixar em https://www.gyan.dev/ffmpeg/builds/
Extrair para C:\ffmpeg
Adicionar C:\ffmpeg\bin ao PATH do Windows

Teste:

ffmpeg -version ffprobe -version

✔️ Passo 8 – Organizar diretório do projeto⌗

C:\Users\neima\voz_teste\ dublar.py nei.mp4 dub_work\ (criada automaticamente)

✔️ Passo 9 – Rodar teste⌗

c```onda activate voz-bark cd C:\Users\neima\voz_teste python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit

---

### ✔️ Passo 10 – Saídas esperadas

* v`ideo_dublado.mp4 `→ vídeo final
* d`ub_work/ `com:

  * s`eg_0001.wav `etc.
  * d`ub_final.wav
`  * a`sr.srt `e a`sr_trad.srt
`  * l`ogs.json
`
---

**Passo a passo único** para preparar a máquina do zero e rodar o `dublar.py`. assim você não se perde entre pacotes, versões e ambientes.

---

## 1) preparar ambiente conda

```conda create -n voz-bark python=3.10 -y
conda activate voz-bark```

---

## 2) instalar dependências base

precisamos do pytorch + pacotes principais (ajustei para CPU, se quiser GPU troca o index-url pelo de CUDA).

```pip install --index-url https://download.pytorch.org/whl/cpu torch==2.5.1 torchvision==0.20.1 torchaudio==2.5.1```

---

## 3) instalar bibliotecas de áudio e utilitários

```pip install scipy soundfile ffmpeg-python```

⚠️ o ffmpeg precisa estar no **PATH** do windows. baixe em: [https://www.gyan.dev/ffmpeg/builds/](https://www.gyan.dev/ffmpeg/builds/) e adicione a pasta `bin` nas variáveis de ambiente.

---

## 4) instalar whisper rápido

```pip install faster-whisper==1.0.3```

---

## 5) instalar transformers e tradução

usamos `facebook/m2m100_418M` para tradução:

```pip install transformers==4.41.2 sentencepiece sacremoses```

---

## 6) instalar TTS

temos dois motores:

### bark (principal para dublagem):

```pip install bark==0.1.5```

### coqui TTS (opcional, fallback):

```pip install TTS```

---

## 7) pós-processo de áudio

já vem com ffmpeg, mas adicionamos extras para compatibilidade:

```pip install librosa numpy==2.3.2```

(numpy pode dar conflito, mas 2.3.2 funcionou no seu setup)

---

## 8) organizar o diretório

* crie uma pasta de trabalho, ex.: `C:\Users\neima\voz_teste\`
* coloque dentro:

  * `dublar.py` (script que recriamos)
  * um vídeo de entrada (ex.: `nei.mp4`)

---

## 9) rodar teste rápido

```conda activate voz-bark
cd C:\Users\neima\voz_teste
python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit```

---

## 10) saída

se tudo deu certo, você terá:

* `dub_work/` com os áudios segmentados (`seg_0001.wav`, etc.)
* `dub_work/dub_final.wav` → áudio dublado já processado
* `video_dublado.mp4` → vídeo final com áudio substituído
* `logs.json` com os parâmetros usados

---

## considerações finais

* **erro comum**: mistura de idiomas → sempre usar `v2/pt_speaker_X` ou um `.npz` treinado em português.
* **voz metálica**: reduza `--texttemp 0.55 --wavetemp 0.55` e mantenha pós-processo (normalização + denoise).
* **descompasso**: use `--sync fit` (mais rígido) ou `--sync loose` (mais natural).

---

Segue a estrutura mínima e os comandos para rodar o dublar.py no Windows, direto e sem rodeios.

Estrutura de pastas

```projeto/
  dublar.py
  nei.mp4                   # seu vídeo de entrada
  dub_work/                 # criado automaticamente (arquivos temporários e saídas)```

Pré-requisitos rápidos

1. FFmpeg no PATH
2. Ambiente Python (ex.: conda)
3. Pacotes

c```onda create -n voz-bark python=3.10 -y
conda activate voz-bark
pip install faster-whisper transformers==4.41.2 sentencepiece sacremoses bark==0.1.5 scipy

Checagem do FFmpeg

ff```mpeg -version ffprobe -version

```Comandos básicos para rodar Dentro da pasta projeto:

m```odo normal (sem ajuste de tempo)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync none

O```utros modos de sincronização

fi```t: comprime/estica a fala para caber no tempo original⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit

pad: mantém a fala e completa com silêncio no final⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync pad

smart: curto = silêncio; longo = comprime⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync smart

Pa```râmetros úteis

--out``` video_dublado.mp4 # nome do arquivo final --texttemp 0.6 --wavetemp 0.6 # Bark: temperaturas --tolerance 0.15 # tolerância do sync --maxstretch 1.35 # limite de compressão/alongamento (fit/smart) --maxdur 10 # divide trechos muito longos antes do TTS (0 desativa) --fade 0 # desliga micro-fade (se notar silêncio em trechos curtos)

Exe```mplos prontos

dubl```agem PT-BR com voz preset e ajuste inteligente⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync smart --tolerance 0.15 --maxstretch 1.35

usando seu history_prompt .npz⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice "C:\caminho\speaker.npz" --sync pad

Saíd```as esperadas

projeto```/ video_dublado.mp4 dub_work/ audio_src.wav asr.srt asr.json asr_trad.srt asr_trad.json seg_0001.wav ... # segmentos TTS seg_0001_xf.wav ... # com micro-fade (se --fade 1) seg_0001_fit.wav/_pad.wav # se usar fit/pad/smart dub_raw.wav dub_final.wav logs.json

Atalh```os de diagnóstico

rodar ```com ajuste, mas sem dividir frases⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit --maxdur 0

verificar volume de um segmento⌗

ffmpeg -v error -i dub_work/seg_0001.wav -af volumedetect -f null -```

normal (sem ajuste de tempo)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync none

fit (comprime/estica a fala para caber)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit

pad (mantém a fala e completa com silêncio)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync pad

smart (curto = silêncio; longo = comprime)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync smart

A parte mais “delicada” do dublar.py: alinhar uma fala em inglês (origem) com a mesma fala em português (destino), mesmo que a duração natural seja bem diferente.

O que acontece no pipeline⌗

Whisper transcreve o áudio original e fornece timestamps (start, end) de cada frase/segmento em inglês.

Exemplo:
- "Hello everyone" → start=10.0s, end=12.0s (duração 2s).

Tradução converte o texto para português.

"Olá a todos" (naturalmente mais curto que “Hello everyone”).

TTS (Bark/Coqui) gera áudio da frase traduzida.

Bark não sabe do tempo do vídeo → gera no ritmo natural (pode sair 1.3s ou 2.7s, depende da voz).

Sync (se ativado com --sync fit) entra nessa hora:

Mede a duração real do áudio gerado (ex.: 1.3s).
Compara com a duração-alvo (2.0s do original).
Se a diferença for maior que a tolerância (--tolerance, ex. 0.15), aplica time-stretch com ffmpeg atempo.
- alonga se for mais curto → 1.3s → 2.0s
- comprime se for mais longo → 2.7s → 2.0s
- Resultado: o português fica “espremido” ou “esticado” para caber no mesmo espaço do inglês.

Vantagens e limitações⌗

Vantagem: os blocos de áudio final sempre batem com os tempos do vídeo → sincronização labial básica e não invade falas seguintes.
Limitação: se o português é muito mais longo que o inglês, a compressão pode deixar a fala acelerada e pouco natural.
Se for muito mais curto, a fala soa “arrastada” porque o time-stretch alonga silêncios.

Controles que você tem⌗

--sync none → fala sai no ritmo natural (boa naturalidade, mas pode perder sincronia).
--sync fit + --tolerance → define o quanto aceita de diferença antes de forçar ajuste.
--maxstretch (se aplicamos) → limita o quanto pode acelerar/alongar.
--maxdur → evita trechos longos demais, dividindo em partes menores para reduzir distorções.

Em resumo⌗

O tempo de cada trecho vem do inglês (origem).
O áudio em português é esticado ou comprimido para caber nesses tempos.
Naturalidade × Sincronismo é sempre um trade-off: mais sync → menos natural, mais natural → menos sync.

No projeto de dublagem automática usamos as seguintes ferramentas e tecnologias:

Principais componentes⌗

FFmpeg → extrair e manipular áudio/vídeo.
Whisper (faster-whisper) → transcrição do áudio original com timestamps.
Transformers (M2M100) → tradução automática entre idiomas.
Bark TTS → geração de voz expressiva (com suporte a history prompts).
Coqui TTS → alternativa de voz estável, simples e leve.
Scipy / Numpy → salvar e manipular os arquivos de áudio.
Torch → base para os modelos de TTS e ASR.

Organização do pipeline⌗

Extração de áudio do vídeo.
Transcrição (Whisper).
Tradução (M2M100).
Geração de voz (Bark ou Coqui).
Ajuste de sincronização (none, fit, pad, smart).
Pós-processamento (normalização e equalização).
Mux final: juntar o vídeo com o novo áudio.

Saídas⌗

Vídeo dublado pronto.
Legendas originais (ASR) e traduzidas (SRT).
Áudios segmentados de cada fala.
Relatório/log JSON com parâmetros da execução.

Resumo claro e direto do que já temos e fazemos neste projeto:

O que temos⌗

Pipeline completo de dublagem local

Extração de áudio do vídeo (ffmpeg).
Transcrição automática com Whisper.
Tradução automática (modelo M2M100).
Síntese de voz com Bark ou Coqui TTS.
Pós-processamento e sincronização de áudio.
Multiplex final (vídeo + áudio dublado).

Quatro modos de sincronização

none → voz natural, sem ajustes de tempo.
fit → comprime/estica a fala para caber no tempo original.
pad → mantém a voz e completa silêncio no fim.
smart → curto = silêncio, longo = compressão.

Configurações flexíveis

Tolerância de tempo (--tolerance).
Limite de alongamento/compressão (--maxstretch).
Divisão de trechos longos (--maxdur).
Fade-in/out seguro para suavizar cortes.

O que fazemos⌗

Pegamos um vídeo em qualquer língua.
Transcrevemos e traduzimos as falas.
Geramos novo áudio em português (ou outro idioma).
Ajustamos para encaixar no tempo do vídeo (com os modos acima).
Entregamos o vídeo dublado pronto, mais legendas e arquivos de apoio.

Considerações⌗

Naturalidade vs. Sincronismo: o usuário pode escolher o equilíbrio.
Qualidade da voz depende do TTS (Bark mais expressivo, Coqui mais limpo).
Flexibilidade: dá para trocar voz, idioma de saída, tolerâncias e estilo de sync sem mexer no código.

Projeto de Dublagem Automática Local⌗

Desenvolvemos uma ferramenta completa de dublagem de vídeos que funciona localmente, sem depender de serviços externos. O sistema combina:

Whisper para transcrever o áudio original.
Modelos de tradução para converter o texto para o idioma desejado.
Bark ou Coqui TTS para gerar a nova voz.
FFmpeg para sincronizar, pós-processar e integrar o áudio dublado ao vídeo.

O usuário pode escolher entre quatro modos de sincronização:

None: mantém o ritmo natural.
Fit: ajusta a fala ao tempo original.
Pad: adiciona silêncio no final para preencher o tempo.
Smart: usa silêncio quando a fala é curta e compressão quando é longa.

O resultado é um vídeo dublado, acompanhado de legendas e arquivos de apoio. A ferramenta é flexível, suporta diferentes idiomas e vozes, e permite equilibrar naturalidade e sincronização de acordo com a necessidade do projeto.

Segue o script com os 4 modos de sincronização: normal (none), fit, pad, smart. uso rápido:

```# normal (sem ajuste de tempo) python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync none

fit (comprime/estica a fala para caber)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync fit

pad (mantém a fala e completa com silêncio)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync pad

smart (curto = silêncio; longo = comprime)⌗

python dublar.py --in nei.mp4 --src en --tgt pt --tts bark --voice v2/pt_speaker_6 --sync smart```

pré-requisitos no ambiente

p```ip install faster-whisper transformers==4.41.2 sentencepiece sacremoses bark==0.1.5 scipy

ffmpeg no PATH```⌗

Você pode usar sua própria voz no pipeline de duas formas diferentes, dependendo do motor escolhido.

1. Usando Bark com `history_prompt`⌗

O Bark aceita um arquivo .npz que guarda o “perfil” da sua voz.

Como criar seu history_prompt:⌗

Grave um áudio curto (10–30 segundos) só com sua voz, em boa qualidade.

Exemplo: minha_voz.wav.
Mono, 16kHz é suficiente.

Rode o script do Bark para extrair o embedding:

``` import numpy as np from bark.generation import generate_audio, preload_models from bark.api import semantic_to_waveform from bark.generation import codec_decode, generate_coarse, generate_fine from bark.generation import generate_text_semantic, SAMPLE_RATE from bark.generation import load_codec_model, generate_history_prompt

# cria o arquivo npz history = generate_history_prompt("minha_voz.wav") np.savez("minha_voz.npz", **history) ```

No comando de dublagem, use:

python dublar.py --in video.mp4 --src en --tgt pt --tts bark --voice minha_voz.npz --sync smart

Assim, cada trecho gerado usa sua voz como base.

2. Usando Coqui TTS com s`peaker_wav⌗

O Coqui aceita um áudio .wav `diretamente como referência de voz.

Como usar:⌗

Grave um trecho limpo da sua fala (10–20s).
Passe o arquivo na chamada:

``` from TTS.api import TTS tts = TTS("tts_models/multilingual/multi-dataset/your_tts", gpu=False) tts.tts_to_file( text="Este é um teste com minha voz.", speaker_wav="minha_voz.wav", language="pt-br", file_path="teste.wav" )

``3. No dublar.py,` a adaptação é:

`  --tts coqui --voice minha_voz.wav

`⌗

Diferença entre eles⌗

Bark: mais expressivo, mas pode distorcer se o áudio base for curto/demorado.
Coqui: mais limpo, porém a clonagem é menos realista (fica parecido, mas não idêntico)

================================

No contexto do Bark, “history” ou history_prompt é um perfil de voz:

É um arquivo .npz gerado a partir de uma gravação curta da voz original.
Guarda características sonoras (timbre, ritmo, entonação).
Serve como “memória” para que o Bark consiga imitar essa voz em novos textos.

Resumindo: o history é o molde que o Bark usa para falar com a sua voz.

👌 — além dos 4 modos de sincronização, também temos a escolha do motor de voz (TTS).

Opções de motor de voz⌗

Bark

Voz mais expressiva, com entonação natural.
Suporta history prompt (clonar estilo de fala com amostra).
Pode soar mais “metálica” em alguns trechos se os parâmetros não forem ajustados.
Recomendado quando a naturalidade e emoção são importantes.

Coqui TTS

Mais estável e simples.
Fácil de escolher voz/língua (speaker e language).
Menos expressivo que Bark, mas gera áudio limpo.
Recomendado para narrativas mais neutras (e também como fallback se o Bark falhar).

Combinações possíveis⌗

Na prática, você escolhe motor + modo de sincronização:

--tts bark --sync none → Bark natural, sem ajuste de tempo.
--tts bark --sync smart → Bark expressivo, com ajuste inteligente.
--tts coqui --sync pad → Coqui estável, completando silêncio.
--tts coqui --sync fit → Coqui com sincronia rígida.

Resumindo⌗

Opção 1: Bark → emoção, estilo, mas exige mais ajuste.
Opção 2: Coqui TTS → praticidade e estabilidade.

Ambos podem rodar em qualquer um dos 4 modos de sincronização.

O que temos⌗

Pipeline local de dublagem

Extrai áudio do vídeo com FFmpeg.
Transcreve com Whisper (faster-whisper).
Traduz com Transformers (modelo M2M100).
Gera voz com Bark (principal) ou Coqui TTS (opcional).
Sincroniza falas com diferentes modos.
Recria o vídeo final com o novo áudio + legendas.

Diretório automático (dub_work/) com:
Áudio original extraído.
Legendas originais e traduzidas (SRT/JSON).
Segmentos de voz em WAV.
Áudio final montado.
Log da execução.

Opções de sincronização⌗

none → Voz natural, sem ajustes. Uso: quando a naturalidade é mais importante que a sincronia.
fit → Ajusta o tempo da fala (acelera/alongar com atempo). Uso: quando precisa caber exatamente no tempo do vídeo, mesmo sacrificando um pouco da naturalidade.
pad → Mantém a fala original e adiciona silêncio no final para preencher o tempo. Uso: ótimo para palestras, entrevistas, vídeos informativos.
smart → Misto:

Se a fala for mais curta → adiciona silêncio.
Se for mais longa → aplica compressão para caber. Uso: equilíbrio entre naturalidade e sincronia.

Para que serve cada opção⌗

none → naturalidade total, mas pode ficar fora de tempo.
fit → sincronia rígida, usado em dublagem onde tempo é crítico.
pad → fala natural e suave, ideal para vídeos explicativos/documentários.
smart → flexível, automatiza a escolha entre silêncio e ajuste.

Dublar Local v1

chatgpt.com ↗ original

chatgpt.com ↗

Desenvolvimento de um pipeline local de dublagem automática de vídeos…

Visão geral rápida⌗

O que acontece em cada caso⌗

Parâmetros que mandam no jogo⌗

Exemplos práticos de uso⌗

Dicas finas⌗

Perguntas rápidas (com exemplos)⌗

Parâmetros principais⌗

Como evitar esse aumento⌗

Exemplo de execução ajustada⌗

✔️ Passo 1 – Preparar ambiente conda⌗

✔️ Passo 2 – Instalar PyTorch (CPU ou GPU)⌗

✔️ Passo 3 – Instalar libs de áudio⌗

✔️ Passo 4 – Instalar Whisper rápido⌗

✔️ Passo 5 – Instalar tradução⌗

✔️ Passo 6 – Instalar TTS⌗

✔️ Passo 7 – Instalar e configurar FFmpeg⌗

✔️ Passo 8 – Organizar diretório do projeto⌗

✔️ Passo 9 – Rodar teste⌗

m```odo normal (sem ajuste de tempo)⌗

fi```t: comprime/estica a fala para caber no tempo original⌗

pad: mantém a fala e completa com silêncio no final⌗

smart: curto = silêncio; longo = comprime⌗

dubl```agem PT-BR com voz preset e ajuste inteligente⌗

usando seu history_prompt .npz⌗

rodar ```com ajuste, mas sem dividir frases⌗

verificar volume de um segmento⌗

normal (sem ajuste de tempo)⌗

fit (comprime/estica a fala para caber)⌗

pad (mantém a fala e completa com silêncio)⌗

smart (curto = silêncio; longo = comprime)⌗

O que acontece no pipeline⌗

Vantagens e limitações⌗

Controles que você tem⌗

Em resumo⌗

Principais componentes⌗

Organização do pipeline⌗

Saídas⌗

O que temos⌗

O que fazemos⌗

Considerações⌗

Projeto de Dublagem Automática Local⌗

fit (comprime/estica a fala para caber)⌗

pad (mantém a fala e completa com silêncio)⌗

smart (curto = silêncio; longo = comprime)⌗

ffmpeg no PATH```⌗

1. Usando Bark com history_prompt⌗

Como criar seu history_prompt:⌗

2. Usando Coqui TTS com s`peaker_wav⌗

Como usar:⌗

`⌗

Diferença entre eles⌗

Opções de motor de voz⌗

Combinações possíveis⌗

Resumindo⌗

O que temos⌗

Opções de sincronização⌗

Para que serve cada opção⌗

Recursos

1. Usando Bark com `history_prompt`⌗