video_dubbing_assistant.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UC5387q74wfV"
      },
      "outputs": [],
      "source": [
        "# -*- coding: utf-8 -*-\n",
        "\"\"\"Assistente de Dublagem de Vídeo\"\"\"\n",
        "\n",
        "# Célula 1: Instalação de dependências e configuração inicial\n",
        "#@title 🎬 Dublagem de Vídeo: Instalação e Introdução { display-mode: \"form\" }\n",
        "#@markdown ## Bem-vindo ao Assistente de Dublagem de Vídeos!\n",
        "#@markdown Este script automatiza a dublagem de vídeos do inglês para o português brasileiro usando tecnologias de ponta em IA.\n",
        "#@markdown ### 🛠️ Tecnologias Utilizadas:\n",
        "#@markdown - **FFmpeg**: Para manipulação de áudio e vídeo\n",
        "#@markdown - **Whisper**: Transcrição de áudio da OpenAI\n",
        "#@markdown - **Google Cloud Text-to-Speech**: Síntese de voz de alta qualidade\n",
        "#@markdown - **Google Cloud Translate**: Tradução precisa de texto\n",
        "#@markdown - **MoviePy & Pydub**: Processamento de áudio e vídeo em Python\n",
        "#@markdown ### 📚 Repositório GitHub: (Exemplo - substitua pelo seu repositório se houver)\n",
        "#@markdown [github.com/seu-usuario/seu-repositorio](https://github.com/seu-usuario/seu-repositorio)\n",
        "#@markdown ### 🚀 Instalação de Dependências:\n",
        "#@markdown Executar esta célula instalará todas as dependências necessárias.\n",
        "\n",
        "!apt-get update && apt-get install -y ffmpeg\n",
        "!pip install --quiet pydub moviepy google-cloud-texttospeech google-cloud-translate openai-whisper spacy spacy_syllables tqdm\n",
        "\n",
        "!python -m spacy download en_core_web_sm\n",
        "!python -m spacy download pt_core_news_sm\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive', force_remount=True)\n",
        "\n",
        "print(\"Configuração inicial concluída. Você está pronto para começar a dublar seus vídeos!\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Célula 2: Instruções e preparação\n",
        "#@title 🎬 Preparação para Dublagem { display-mode: \"form\" }\n",
        "#@markdown ## Bem-vindo ao Assistente de Dublagem de Vídeos!\n",
        "#@markdown Este script irá dublar seu vídeo do inglês para o português brasileiro.\n",
        "#@markdown ### Passo 1: Configurar as Credenciais do Google Cloud\n",
        "#@markdown 1. Acesse o [Console do Google Cloud](https://console.cloud.google.com/)\n",
        "#@markdown 2. Crie um novo projeto ou selecione um existente\n",
        "#@markdown 3. Ative as APIs: Cloud Text-to-Speech e Cloud Translation\n",
        "#@markdown 4. Crie uma chave de conta de serviço e baixe o arquivo JSON\n",
        "#@markdown 5. Renomeie o arquivo para `google_cloud_credentials.json`\n",
        "#@markdown 6. Faça upload do arquivo para a pasta `Dubbing` no seu Google Drive\n",
        "#@markdown ### Passo 2: Preparar o Vídeo\n",
        "#@markdown 1. Faça upload do vídeo que deseja dublar para a pasta `Dubbing` no seu Google Drive\n",
        "#@markdown 2. O script só dubla um arquivo por vez\n",
        "#@markdown ### Passo 3: Escolher a Voz (Configurações abaixo)\n",
        "\n",
        "print(\"Preparação concluída. Vamos começar!\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SszZbJbW429Q",
        "outputId": "744bf9dc-da24-4565-f79d-367472370f9a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Preparação concluída. Vamos começar!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Célula 3: Importações e funções auxiliares\n",
        "#@title 🔧 Configurações e Funções Auxiliares { display-mode: \"form\" }\n",
        "\n",
        "import os\n",
        "import uuid\n",
        "import subprocess\n",
        "from pydub import AudioSegment\n",
        "from moviepy.editor import VideoFileClip, AudioFileClip\n",
        "from google.cloud import texttospeech\n",
        "from google.cloud import translate_v2 as translate\n",
        "import whisper\n",
        "import spacy\n",
        "from spacy_syllables import SpacySyllables\n",
        "from tqdm import tqdm\n",
        "import tempfile\n",
        "import re\n",
        "from google.oauth2 import service_account\n",
        "import json\n",
        "import time\n",
        "\n",
        "# Configurações da interface do Colab\n",
        "voz_selecionada = \"pt-BR-Neural2-B\" #@param [\"pt-BR-Neural2-A\", \"pt-BR-Neural2-B\", \"pt-BR-Neural2-C\", \"pt-BR-Standard-A\", \"pt-BR-Standard-B\", \"pt-BR-Standard-C\", \"pt-BR-Wavenet-A\", \"pt-BR-Wavenet-B\", \"pt-BR-Wavenet-C\"]\n",
        "#@markdown [Ouça amostras das vozes aqui](https://cloud.google.com/text-to-speech/docs/voices)\n",
        "modelo_whisper = \"tiny\" #@param [\"tiny\", \"base\", \"small\", \"medium\", \"large-v3\"]\n",
        "\n",
        "\n",
        "def listar_videos():\n",
        "    video_path = '/content/drive/My Drive/Dubbing/'\n",
        "    videos = [f for f in os.listdir(video_path) if f.endswith('.mp4')]\n",
        "    for i, video in enumerate(videos):\n",
        "        print(f\"{i+1}. {video}\")\n",
        "    return videos\n",
        "\n",
        "def carregar_video():\n",
        "    videos = listar_videos()\n",
        "    escolha = int(input(\"Escolha o número do vídeo: \"))\n",
        "    video_path = '/content/drive/My Drive/Dubbing/'\n",
        "    return os.path.join(video_path, videos[escolha-1])\n",
        "\n",
        "print(\"Funções auxiliares definidas.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "elLR6hLY5AcP",
        "outputId": "b15d89e4-e1f8-4b7a-8364-ade294d14ea9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Funções auxiliares definidas.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Célula 4: Funções principais\n",
        "#@title 🎭 Funções de Dublagem { display-mode: \"form\" }\n",
        "def extract_audio_from_video(video_file):\n",
        "    try:\n",
        "        print(\"Extraindo faixa de áudio\")\n",
        "        audio_file = tempfile.NamedTemporaryFile(delete=False, suffix=\".mp3\").name\n",
        "        command = [\n",
        "            'ffmpeg',\n",
        "            '-i', video_file,\n",
        "            '-vn',\n",
        "            '-acodec', 'libmp3lame',\n",
        "            '-b:a', '64k',\n",
        "            '-y',\n",
        "            audio_file\n",
        "        ]\n",
        "        subprocess.run(command, check=True, capture_output=True, text=True)\n",
        "        print(\"Áudio extraído com sucesso.\")\n",
        "        return audio_file\n",
        "    except subprocess.CalledProcessError as e:\n",
        "        print(f\"Erro ao extrair áudio do vídeo (código de retorno {e.returncode}): {e.stderr}\")\n",
        "        return None\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao extrair áudio do vídeo: {e}\")\n",
        "        return None\n",
        "\n",
        "def transcribe_audio(audio_file, source_language):\n",
        "    try:\n",
        "        print(\"Transcrevendo faixa de áudio\")\n",
        "        model = whisper.load_model(modelo_whisper, device=\"cpu\")\n",
        "        trans = model.transcribe(audio_file, language=source_language, fp16=False)\n",
        "        return trans\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao transcrever áudio: {e}\")\n",
        "        return None\n",
        "\n",
        "def translate_text(texts, target_language, credentials):\n",
        "    try:\n",
        "        translate_client = translate.Client(credentials=credentials)\n",
        "        results = []\n",
        "        for i in tqdm(range(0, len(texts), 100), desc=\"Traduzindo textos\"):\n",
        "            batch = texts[i:i+100]\n",
        "            batch_results = translate_client.translate(batch, target_language=target_language)\n",
        "            results.extend(batch_results)\n",
        "        return [result['translatedText'] for result in results]\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao traduzir textos: {e}\")\n",
        "        return None\n",
        "\n",
        "def create_audio_from_text(text, target_language, target_voice, credentials):\n",
        "    audio_file = \"translated_\" + str(uuid.uuid4()) + \".mp3\"\n",
        "    try:\n",
        "        client = texttospeech.TextToSpeechClient(credentials=credentials)\n",
        "        input_text = texttospeech.SynthesisInput(text=text)\n",
        "        voice = texttospeech.VoiceSelectionParams(\n",
        "            language_code=target_language,\n",
        "            name=target_voice\n",
        "        )\n",
        "        audio_config = texttospeech.AudioConfig(\n",
        "            audio_encoding=texttospeech.AudioEncoding.MP3,\n",
        "            speaking_rate=1.1,\n",
        "            sample_rate_hertz=22050\n",
        "        )\n",
        "        response = client.synthesize_speech(\n",
        "            input=input_text, voice=voice, audio_config=audio_config\n",
        "        )\n",
        "        with open(audio_file, \"wb\") as out:\n",
        "            out.write(response.audio_content)\n",
        "        return audio_file\n",
        "    except Exception as e:\n",
        "        if os.path.isfile(audio_file):\n",
        "            os.remove(audio_file)\n",
        "        print(f\"Erro ao criar áudio a partir do texto: {e}\")\n",
        "        return None\n",
        "\n",
        "def merge_audio_files(transcription, source_language, target_language, target_voice, credentials):\n",
        "    temp_files = []\n",
        "    try:\n",
        "        nlp = spacy.load(\"en_core_web_sm\")\n",
        "        nlp.add_pipe(\"syllables\", after=\"tagger\")\n",
        "        merged_audio = AudioSegment.silent(duration=0)\n",
        "        sentences = [segment[\"text\"] for segment in transcription[\"segments\"]]\n",
        "\n",
        "        print(\"Traduzindo frases\")\n",
        "        translated_texts = translate_text(sentences, target_language, credentials)\n",
        "        if translated_texts is None:\n",
        "            raise Exception(\"Falha na tradução\")\n",
        "\n",
        "        print(\"Criando faixa de áudio traduzida\")\n",
        "        for translated_text in tqdm(translated_texts, desc=\"Gerando áudio\"):\n",
        "            translated_text = re.sub(r'^OK\\s*', '', translated_text, flags=re.IGNORECASE)\n",
        "            translated_audio_file = create_audio_from_text(translated_text, target_language, target_voice, credentials)\n",
        "            if translated_audio_file is None:\n",
        "                raise Exception(\"Falha na criação do áudio\")\n",
        "            temp_files.append(translated_audio_file)\n",
        "            translated_audio = AudioSegment.from_mp3(translated_audio_file)\n",
        "            merged_audio += translated_audio\n",
        "\n",
        "        return merged_audio\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao mesclar arquivos de áudio: {e}\")\n",
        "        return None\n",
        "    finally:\n",
        "        for file in temp_files:\n",
        "            try:\n",
        "                os.remove(file)\n",
        "            except Exception as e:\n",
        "                print(f\"Erro ao remover arquivo temporário {file}: {e}\")\n",
        "\n",
        "def replace_audio_in_video(video_file, new_audio, output_filename):\n",
        "    try:\n",
        "        print(\"Substituindo áudio no vídeo\")\n",
        "        temp_audio_file = tempfile.NamedTemporaryFile(delete=False, suffix=\".mp3\")\n",
        "        new_audio.export(temp_audio_file.name, format=\"mp3\", bitrate=\"64k\")\n",
        "\n",
        "        command = [\n",
        "            'ffmpeg',\n",
        "            '-i', video_file,\n",
        "            '-i', temp_audio_file.name,\n",
        "            '-c:v', 'copy',\n",
        "            '-c:a', 'aac',\n",
        "            '-b:a', '64k',\n",
        "            '-map', '0:v:0',\n",
        "            '-map', '1:a:0',\n",
        "            '-y',\n",
        "            output_filename\n",
        "        ]\n",
        "        subprocess.run(command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)\n",
        "        print(f\"Vídeo dublado salvo como {output_filename}\")\n",
        "    except subprocess.CalledProcessError as e:\n",
        "        print(f\"Erro ao substituir áudio no vídeo (código de retorno {e.returncode}): {e.stderr}\")\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao substituir áudio no vídeo: {e}\")\n",
        "    finally:\n",
        "        if os.path.isfile(temp_audio_file.name):\n",
        "            os.remove(temp_audio_file.name)\n",
        "\n",
        "print(\"Funções principais definidas.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GWv4WrDF5I-A",
        "outputId": "0455949b-cd44-4f83-896b-1a3abdca14b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Funções principais definidas.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Célula 5: Função principal e execução\n",
        "#@title 🚀 Iniciar Dublagem { display-mode: \"form\" }\n",
        "def dub_video(video_file, target_voice, credentials):\n",
        "    start_time = time.time()\n",
        "    audio_file = extract_audio_from_video(video_file)\n",
        "\n",
        "    if audio_file:\n",
        "        try:\n",
        "            transcription = transcribe_audio(audio_file, \"en\")\n",
        "            if transcription:\n",
        "                merged_audio = merge_audio_files(transcription, \"en\", \"pt-BR\", target_voice, credentials)\n",
        "                if merged_audio:\n",
        "                    base_name, ext = os.path.splitext(os.path.basename(video_file))\n",
        "                    safe_base_name = re.sub(r'[\\\\/*?:\"<>|]', \"\", base_name) # Remove caracteres inválidos\n",
        "                    output_filename = os.path.join('/content/drive/My Drive/Dubbing/Results', f\"{safe_base_name}__pt{ext}\")\n",
        "                    replace_audio_in_video(video_file, merged_audio, output_filename)\n",
        "                    end_time = time.time()\n",
        "                    print(f\"Processamento do vídeo {video_file} concluído em {end_time - start_time:.2f} segundos!\")\n",
        "                else:\n",
        "                    print(f\"Falha ao dublar o vídeo {video_file}. merged_audio é None.\")\n",
        "        except Exception as e:\n",
        "            print(f\"Erro durante o processamento do vídeo {video_file}: {e}\")\n",
        "        finally:\n",
        "            if os.path.exists(audio_file):\n",
        "                os.remove(audio_file)\n",
        "\n",
        "def main():\n",
        "    print(\"Iniciando o processo de dublagem...\")\n",
        "\n",
        "    dubbing_folder = '/content/drive/My Drive/Dubbing/'\n",
        "    credentials_path = os.path.join(dubbing_folder, 'google_cloud_credentials.json')\n",
        "    if not os.path.exists(credentials_path):\n",
        "        print(\"Erro: Arquivo de credenciais não encontrado.\")\n",
        "        print(\"Por favor, faça upload do arquivo 'google_cloud_credentials.json' para a pasta 'Dubbing' no seu Google Drive.\")\n",
        "        return\n",
        "\n",
        "    try:\n",
        "        credentials = service_account.Credentials.from_service_account_file(\n",
        "            credentials_path,\n",
        "            scopes=['https://www.googleapis.com/auth/cloud-platform']\n",
        "        )\n",
        "    except Exception as e:\n",
        "        print(f\"Erro ao carregar credenciais: {e}\")\n",
        "        return\n",
        "\n",
        "    video_path = '/content/drive/My Drive/Dubbing/'\n",
        "    os.makedirs(os.path.join(video_path, 'Results'), exist_ok=True)\n",
        "\n",
        "    start_time = time.time()\n",
        "\n",
        "    for filename in os.listdir(video_path):\n",
        "        if filename.endswith(\".mp4\"):\n",
        "            video_file = os.path.join(video_path, filename)\n",
        "            try:\n",
        "                dub_video(video_file, voz_selecionada, credentials)\n",
        "            except Exception as e:\n",
        "                print(f\"Erro ao processar o vídeo {filename}: {e}\")\n",
        "\n",
        "    end_time = time.time()\n",
        "    print(f\"Processamento total concluído em {end_time - start_time:.2f} segundos!\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ],
      "metadata": {
        "id": "0ij4-f015Q8I"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}