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.

 

Ferramenta Para Comprimir Mola de Espingarda de Pressão

- Ideia para comprimir com segurança a mola de espingardas de pressão.

- É possível (e até melhor) usar sem o cano raiado.

- Sem esta ferramenta é praticamente impossível recolocar o gatilho na posição, pois neste modelo de espingarda o pino que fixa o batente da mola de pressão serve de eixo para o gatilho.

Gerador de Legendas - 5.0

- Nesta versão foi acrescentada uma interface gráfica ao script;

- A parte de tradução das foi retirada;

- O reconhecimento da fala suporta 3 idiomas: Inglês, Português e Espanhol.

import os
import subprocess
import vosk
import pysrt
import json
import sys
import tkinter as tk
from tkinter import filedialog
import threading
from moviepy.editor import VideoFileClip

def recognize_speech(file_path, language, text_widget, subtitles):
    # 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
    prev_end_time = 0

    while True:
        # Ler o próximo bloco de áudio do processo ffmpeg
        audio_data = ffmpeg_process.stdout.read(sample_rate * 9)
        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
                block_duration = result["result"][-1]["end"] - prev_end_time
                progress_percentage = (start_time + block_duration) / audio_duration * 100
                subtitles.append(pysrt.SubRipItem(index=len(subtitles) + 1, start=pysrt.SubRipTime(seconds=start_time), end=pysrt.SubRipTime(seconds=start_time + block_duration), text=transcript))
                
                # Atualizar o texto no widget Text
                text_widget.insert(tk.END, f"--> {transcript}\n")
                text_widget.see(tk.END)  # Rolar o texto para mantê-lo visível

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

    return subtitles

class SpeechRecognitionApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Gerador de Legendas")
        self.geometry("500x500")

        self.file_path = tk.StringVar()
        self.language_choice = tk.StringVar(value="en")

        tk.Label(self, text="Escolha o arquivo de vídeo:").pack(pady=10)
        tk.Button(self, text="Procurar", command=self.browse_file).pack(pady=5)

        tk.Label(self, text="Selecione o idioma para reconhecimento:").pack(pady=10)
        tk.Radiobutton(self, text="Inglês", variable=self.language_choice, value="en").pack(anchor=tk.W)
        tk.Radiobutton(self, text="Português", variable=self.language_choice, value="pt").pack(anchor=tk.W)
        tk.Radiobutton(self, text="Espanhol", variable=self.language_choice, value="es").pack(anchor=tk.W)

        self.display_text = tk.Text(self, wrap="word", width=60, height=10)
        self.display_text.pack(pady=10)

        self.start_recognition_button = tk.Button(self, text="Iniciar Reconhecimento", command=self.start_recognition_process)
        self.start_recognition_button.pack(pady=10)

    def browse_file(self):
        self.file_path.set(filedialog.askopenfilename(filetypes=[("Arquivos de Vídeo", "*.mp4")]))
        file_path = self.file_path.get()
        self.display_text.delete(1.0, tk.END)
        self.display_text.insert(tk.END, f"Arquivo de vídeo: {file_path}")

    def start_recognition_process(self):
        file_path = self.file_path.get()
        language = self.language_choice.get()
        if not file_path:
            self.display_text.delete(1.0, tk.END)
            self.display_text.insert(tk.END, "Selecione um arquivo de vídeo.")
            return

        if not os.path.isfile(file_path):
            self.display_text.delete(1.0, tk.END)
            self.display_text.insert(tk.END, "O arquivo de vídeo não existe.")
            return

        # Limpar o texto reconhecido anterior
        self.display_text.delete(1.0, tk.END)

        # Desabilitar o botão de início para evitar múltiplas execuções
        self.start_recognition_button.config(state=tk.DISABLED)

        # Iniciar o processo de reconhecimento em uma thread separada
        threading.Thread(target=self.perform_recognition, args=(file_path, language)).start()

    def save_subtitles(self, output_file, subtitles):
        # Cria um arquivo .srt com as legendas geradas
        with open(output_file, "w", encoding="utf-8") as f:
            for subtitle in subtitles:
                f.write(str(subtitle))
                f.write('\n')

        self.display_text.delete(1.0, tk.END)
        self.display_text.insert(tk.END, f"Processo concluído. Legenda gerada em {output_file}")

    def perform_recognition(self, file_path, language):
        try:
            subtitles = pysrt.SubRipFile()
            self.display_text.insert(tk.END, "Iniciando o reconhecimento...\n")
            self.update_idletasks()

            blocks = recognize_speech(file_path, language, self.display_text, subtitles)

            # Obter o caminho do arquivo de saída .srt
            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"

            # Salvar as legendas em formato .srt
            self.save_subtitles(output_file, subtitles)

        except Exception as e:
            self.display_text.insert(tk.END, f"Erro durante o reconhecimento: {str(e)}\n")
            self.update_idletasks()

        finally:
            # Habilitar o botão de início após o término do reconhecimento
            self.start_recognition_button.config(state=tk.NORMAL)

if __name__ == "__main__":
    app = SpeechRecognitionApp()
    app.mainloop()
 

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)

Gerador de Legendas - 3.0

- Nesta versão o tamanho do bloco a ser lido não é mais fixo, depende das pausas existente no áudio. Parece ter gerado melhores legendas.

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 = "traducaoptbrblocovariavel.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)

 

Gerador de Legendas - 2.0

- Pequena alteração no código para otimização do tempo de resposta. O comando FFmpeg é executado como um subprocesso PIPE, isto evita o carregamento do código do programa para a memória a cada execução em um bloco de áudio. 

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 = "legendatraduzidaveloz.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)

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

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

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

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

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

        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
            start_timestamp = pysrt.SubRipTime(seconds=start_time)
            end_timestamp = pysrt.SubRipTime(seconds=start_time + block_size)
            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_size

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

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.

Pedestal Para Celular

 - Suporte para manter o celular fixo durante uma filmagem.

Cabos de Faca

- Um cabo feito com plástico derretido numa sanduicheira e "acabamento" com o soprador térmico;

- o outro feito com um cabo de resistência elétrica.

 

-