Gerador de Legendas - 4.0

- Nesta versão o arquivo de entrada é recebido como parâmetro do script .py e o arquivo de saída será a legenda traduzida e terá o mesmo nome do arquivo de entrada com a extensão .srt .

import os
import subprocess
import vosk
import pysrt
import json
import sys

if len(sys.argv) != 2:
    print("Uso: python3 nome_do_script.py arquivo_de_entrada.mp4")
    sys.exit(1)

# Caminho do arquivo de vídeo (arquivo de entrada)
video_file = sys.argv[1]

# Verificar se o arquivo de entrada existe
if not os.path.isfile(video_file):
    print("O arquivo de entrada não existe.")
    sys.exit(1)

# Caminho do arquivo de saída (legendas em pt-BR)
output_file = os.path.splitext(video_file)[0] + ".srt"

# Comando FFmpeg para extrair o áudio e converter para WAV
ffmpeg_command = f"ffmpeg -y -i {video_file} -vn -acodec pcm_s16le -ar 16000 -ac 1 -f wav -"
ffmpeg_process = subprocess.Popen(ffmpeg_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)

# Carregar o modelo de idioma Vosk
model_path = "vosk-model-small-en-us-0.15"
model = vosk.Model(model_path)
sample_rate = 16000

# Inicializar o reconhecedor de fala Vosk
rec = vosk.KaldiRecognizer(model, sample_rate)
rec.SetWords(True)

# Realizar o reconhecimento de fala por blocos de áudio
subtitles = pysrt.SubRipFile()
start_time = 0
prev_end_time = 0

while True:
    # Ler o próximo bloco de áudio do processo ffmpeg
    audio_data = ffmpeg_process.stdout.read(sample_rate * 2 * 10)
    if len(audio_data) == 0:
        break

    # Realizar o reconhecimento de fala no bloco atual
    rec.AcceptWaveform(audio_data)

    # Extrair o texto reconhecido do resultado
    result = json.loads(rec.Result())

    if "result" in result:
        transcript = " ".join([word["word"] for word in result["result"]])

        if transcript.strip():  # Verificar se o texto não está vazio
            #print(f"{start_time:.2f}s - {transcript}")

            # Traduzir o texto para o português usando o translate-shell
            translation_command = ["trans", "-b", "-no-ansi", "-no-warn", "-no-auto", "-no-bidi", "-s", "en", "-t", "pt-br"]
            translation_process = subprocess.Popen(translation_command, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
            translation, _ = translation_process.communicate(input=transcript.strip().encode())
            translation = translation.decode().strip()
            print(f"{start_time:.2f}s - {translation}")

            # Adicionar legenda traduzida ao arquivo de legendas
            block_duration = result["result"][-1]["end"] - prev_end_time
            start_timestamp = pysrt.SubRipTime(seconds=start_time)
            end_timestamp = pysrt.SubRipTime(seconds=start_time + block_duration)
            subtitles.append(pysrt.SubRipItem(index=len(subtitles) + 1, start=start_timestamp, end=end_timestamp, text=translation))

            # Atualizar o tempo de início para o próximo bloco
            start_time += block_duration
            prev_end_time = result["result"][-1]["end"]

# Fechar o processo ffmpeg
ffmpeg_process.stdout.close()
ffmpeg_process.wait()

# Salvar legendas em pt-BR
subtitles.save(output_file, encoding="utf-8")

print("Processo concluído. Legenda em pt-BR gerada em", output_file)