Gerador de Legendas - 6.0

- A ideia desta versão é gerar o arquivo de legenda no formato .srt a partir de uma interface Web.

- Instale o Flask com o comando:

pip install flask

- Segue o código para criar um aplicativo da web usando Flask:

import os
import subprocess
import vosk
import pysrt
import json
from flask import Flask, render_template, request
from werkzeug.utils import secure_filename
from moviepy.editor import VideoFileClip

app = Flask(__name__)

UPLOAD_FOLDER = 'uploads'
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER

def recognize_speech(file_path, language, text_widget=None, subtitles=None):
    # Configurar o caminho do modelo de idioma Vosk de acordo com a escolha do usuário
    if language == "en":
        model_path = "vosk-model-small-en-us-0.15"
    elif language == "pt":
        model_path = "vosk-model-pt-fb-v0.1.1-20220516_2113"
    elif language == "es":
        model_path = "vosk-model-small-es-0.42"
    else:
        raise ValueError("Idioma não suportado.")

    # Verificar se o arquivo de entrada existe
    if not os.path.isfile(file_path):
        raise FileNotFoundError("O arquivo de vídeo não existe.")

    # Configurar a taxa de amostragem para o modelo Vosk
    sample_rate = 16000

    # Carregar o modelo de idioma Vosk
    model = vosk.Model(model_path)

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

    # Obter a duração do áudio para atualização da barra de progresso
    audio_duration = VideoFileClip(file_path).duration

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

    # Realizar o reconhecimento de fala por blocos de áudio
    start_time = 0
    block_duration = 9  # Definir a duração do bloco em segundos

    while start_time < audio_duration:
        # Ler o próximo bloco de áudio do processo ffmpeg
        audio_data = ffmpeg_process.stdout.read(sample_rate * block_duration)

        # 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
                end_time = min(start_time + block_duration, audio_duration)
                subtitles.append(pysrt.SubRipItem(index=len(subtitles) + 1, start=pysrt.SubRipTime(seconds=start_time), end=pysrt.SubRipTime(seconds=end_time), text=transcript))

                # Atualizar o texto no widget Text (interface do usuário)
                if text_widget is not None:
                    text_widget.insert(tk.END, f"--> {transcript}\n")
                    text_widget.see(tk.END)  # Rolar o texto para mantê-lo visível
                    text_widget.update()  # Atualizar a interface do usuário

        # Atualizar o tempo de início para o próximo bloco
        start_time += block_duration

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

    return subtitles

@app.route("/", methods=["GET", "POST"])
def index():
    if request.method == "POST":
        file = request.files["video_file"]
        language = request.form["language_choice"]

        # Verificar se o arquivo foi enviado corretamente
        if file and file.filename.endswith(".mp4"):
            # Crie o diretório de uploads se ainda não existir
            if not os.path.exists(app.config['UPLOAD_FOLDER']):
                os.makedirs(app.config['UPLOAD_FOLDER'])

            # Salvar o arquivo de vídeo com um nome exclusivo no diretório "uploads"
            file_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(file.filename))
            file.save(file_path)

            try:
                subtitles = pysrt.SubRipFile()
                recognize_speech(file_path, language, text_widget=None, subtitles=subtitles)
                output_file = os.path.splitext(file_path)[0]

                if language == "en":
                    output_file += "_ing.srt"
                elif language == "pt":
                    output_file += "_por.srt"
                elif language == "es":
                    output_file += "_esp.srt"

                with open(output_file, "w", encoding="utf-8") as f:
                    for subtitle in subtitles:
                        f.write(str(subtitle))
                        f.write("\n")

                message = f"Processo concluído. Legenda gerada em {output_file}"
            except Exception as e:
                message = f"Erro durante o reconhecimento: {str(e)}"
        else:
            message = "Selecione um arquivo de vídeo no formato .mp4."

        return render_template("index.html", message=message)

    return render_template("index.html")

if __name__ == "__main__":
    app.run(debug=True)

- Crie um diretório chamado "templates" no mesmo diretório onde se encontra o aplicativo web com o código acima (arquivo Python com extensão .py)  e crie um arquivo chamado "index.html" dentro desse diretório. O conteúdo do arquivo "index.html" será a interface do aplicativo da web. Você pode escrever o HTML, CSS e JavaScript necessários para criar a interface do usuário de acordo com suas preferências e requisitos.

Exemplo básico do arquivo "index.html":

html

<!DOCTYPE html>
<html>
<head>
    <title>Gerador de Legendas</title>
</head>
<body>
    <h1>Gerador de Legendas</h1>
    <form action="/" method="post" enctype="multipart/form-data">
        <label for="video_file">Escolha o arquivo de vídeo:</label>
        <input type="file" name="video_file" id="video_file" accept=".mp4"><br>
        
        <label>Selecione o idioma para reconhecimento:</label><br>
        <input type="radio" name="language_choice" value="en" checked> Inglês<br>
        <input type="radio" name="language_choice" value="pt"> Português<br>
        <input type="radio" name="language_choice" value="es"> Espanhol<br>

        <input type="submit" value="Iniciar Reconhecimento">
    </form>

    {% if message %}
        <p>{{ message }}</p>
    {% endif %}
</body>
</html>

- Este é um exemplo simples que mostra a página com um formulário para enviar o arquivo de vídeo e selecionar o idioma para o reconhecimento. O resultado do reconhecimento será exibido como uma mensagem na mesma página após o processamento. Note que este é apenas um exemplo básico, e você pode estilizar e aprimorar a interface do usuário conforme necessário.

- Depois de criar o arquivo "index.html" e o diretório "templates", execute o script Python para iniciar o servidor da web:

python3 seu_script.py

- Acesse o aplicativo em um navegador web acessando http://127.0.0.1:5000/ e utilize-o para reconhecer o áudio do arquivo de vídeo selecionado e gerar as legendas.

- O arquivo de vídeo carregado e o arquivo de legenda no formato .srt gerado são salvos no diretório "uploads". O código do aplicativo web garante que o arquivo seja salvo com um nome exclusivo para evitar conflitos se várias pessoas usarem o aplicativo simultaneamente.