Gerador de Legendas

# Script em linguagem Python gerador de legendas em português a partir de vídeos em inglês

import os
import subprocess
import vosk
import pysrt
import json

# Caminho do arquivo de vídeo
video_file = "movie.mp4"

# Caminho do arquivo de saída (legendas em pt-BR)
output_file = "traducaoptbr.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 audio.wav > /dev/null 2>&1"
subprocess.call(ffmpeg_command, shell=True)

# 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)

# Configurações do bloco de áudio
block_size = 10  # Duração em segundos de cada bloco de áudio

# Realizar o reconhecimento de fala por blocos de áudio
subtitles = pysrt.SubRipFile()
total_duration = os.path.getsize("audio.wav") / (sample_rate * 2)  # Tamanho do arquivo em bytes / taxa de amostragem / bytes por amostra (2 bytes)
start_time = 0

while start_time < total_duration:
    end_time = min(start_time + block_size, total_duration)

    # Carregar o bloco de áudio atual
    audio_file = "audio.wav"
    ffmpeg_command = f"ffmpeg -y -ss {start_time} -i {audio_file} -t {block_size} audio_block.wav > /dev/null 2>&1"
    subprocess.call(ffmpeg_command, shell=True)

    # Realizar o reconhecimento de fala no bloco atual
    with open("audio_block.wav", "rb") as f:
        audio_data = f.read()
        rec.AcceptWaveform(audio_data)
        result = rec.Result()

    # Extrair o texto reconhecido do resultado
    if result:
        result_json = json.loads(result)
        transcript = result_json["text"]

        if transcript.strip():  # Verificar se o texto não está vazio
            print(f"{start_time:}s - {transcript}")
            # Traduzir o texto para o português usando o translate-shell
            input_file = "transcript.txt"
            output_file = "translation.txt"
            with open(input_file, "w") as f:
                f.write(transcript.strip())
            command = f"trans -b -no-ansi -no-warn -no-auto -no-bidi -s en -t pt-br -i {input_file} > {output_file}"
            subprocess.call(command, shell=True)
            with open(output_file, "r") as f:
                translation = f.read().strip()
                print(f"{start_time:}s - {translation}")
            # Adicionar legenda traduzida ao arquivo de legendas
            start_timestamp = pysrt.SubRipTime(seconds=start_time)
            end_timestamp = pysrt.SubRipTime(seconds=end_time)
            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 = end_time

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

print("Processo concluído. Legenda em pt-BR gerada em", output_file)
   
   1. Dependências:
        ffmpeg: É uma ferramenta de linha de comando para manipulação de arquivos de áudio e vídeo.
        vosk: É uma biblioteca de reconhecimento de fala offline.
        translate-shell: É uma interface de linha de comando para os serviços de tradução online.
        pysrt: É uma biblioteca para criar, modificar e extrair informações de arquivos de legendas em formato SubRip.
        json: É um módulo nativo do Python para trabalhar com dados JSON.
        os: É um módulo que fornece várias funções relacionadas ao sistema operacional.
        subprocess: É um módulo usado para executar comandos do sistema operacional a partir do Python.
        
   2. Instalação das dependências:
        ffmpeg: Você pode instalar o ffmpeg seguindo as instruções disponíveis em https://ffmpeg.org/download.html.
        vosk: Para instalar a biblioteca vosk, você pode usar o gerenciador de pacotes pip com o seguinte comando: pip install vosk.
        pysrt: Para instalar a biblioteca pysrt, você pode usar o pip com o seguinte comando: pip install pysrt.
        Certifique-se de que todas as dependências estejam corretamente instaladas.
        Certifique-se que os caminhos dos arquivos de entrada e saída estejam definidos corretamente no script.
        A biblioteca Vosk pode ser encontrada no GitHub, no seguinte repositório: https://github.com/alphacep/vosk-api
        Para usar a biblioteca Vosk, siga estas etapas:
        Clone o repositório Vosk-API em seu ambiente:
             no bash digite: git clone https://github.com/alphacep/vosk-api.git
             Navegue até o diretório vosk-api/python: cd vosk-api/python
             Instale as dependências necessárias: pip install -r requirements.txt
             Instale a biblioteca Vosk: python setup.py install
             Baixe os modelos de idioma do Vosk que estão no repositório Vosk-API ou em https://alphacephei.com/vosk/models
        
   3. Arquivos de entrada e saída:
        Arquivo de vídeo: O caminho do arquivo de vídeo deve ser definido na variável video_file.
        Arquivo de áudio gerado: O script gera um arquivo chamado "audio.wav" que contém o áudio extraído do arquivo de vídeo. O caminho e o nome deste arquivo são definidos na variável audio_file.
        Arquivo de saída: O script gera também um arquivo cujo nome é definido na variável output_file. Este arquivo contém as legendas traduzidas do inglês para o português (pt-BR).

   4. Funcionamento do script:
        O script usa o ffmpeg para extrair o áudio do arquivo de vídeo movie.mp4 e convertê-lo para o formato WAV. O FFmpeg é executado com o seguinte comando: ffmpeg -y -i {video_file} -vn -acodec pcm_s16le -ar 16000 -ac 1 {audio_file} > /dev/null 2>&1.
        Em seguida, o script carrega o modelo de idioma do Vosk para realizar o reconhecimento de fala no áudio.
        O módulo os é usado para obter informações sobre o arquivo de áudio gerado audio.wav, como o tamanho do arquivo em bytes.
        O reconhecimento de fala é feito em blocos de áudio definidos pela variável block_size.
        Cada bloco de áudio é processado e o texto reconhecido é traduzido para o português usando o translate-shell.
        A tradução utiliza o serviço do Google Translate através do Translate-Shell.
        As legendas traduzidas são adicionadas a um arquivo de legendas em formato SubRip (.srt) usando a biblioteca pysrt.
        Por fim, o arquivo de legendas traducaoptbr.srt é salvo no caminho definido pela variável output_file.