Upload 6 files

README.md

@@ -1,12 +1,40 @@
----
-title: Transcribe
-emoji: 🐢
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 4.38.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/EliasVincent/whisper-subtitles-webui/blob/master/colab/whisper_subtitles_webui_colab.ipynb)
+
+# What
+
+A gradio frontend for generating transcribed or translated subtitles for videos using OpenAI Whisper locally.
+
+# Why
+
+I just wanted a nice frontend where you can just drop a video or url and it will spit out subs. Whisper is amazing but I haven't found that many implementations, especially ones that can be run locally.
+
+![](img/1.png)
+
+# Install
+
+```
+python -m venv .
+.\Scripts\activate
+
+# if this doesn't work, pip install the following manually: openai-whisper ffmpeg torch gradio
+
+pip install -r requirements.txt
+
+python server.py
+```
+
+To share, add `--remote=True`.
+
+# Features
+
+- Input a video or any other media file
+- Input a YouTube URL
+- Transcribe
+- Translate to English
+- Select different models for your hardware
+- CUDA support
+- Output .srt or video file with embedded subtitles
+
+# Troubleshooting
+
+If the output says `gpu available: False` [you might need to pip install a different version of Torch for your specific hardware](https://pytorch.org/get-started/locally/#start-locally)

colab/whisper_subtitles_webui_colab.ipynb

@@ -0,0 +1,64 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "gpuClass": "standard"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Clone and install dependencies"
+      ],
+      "metadata": {
+        "id": "ZiuEHGjLiLq-"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "! git clone https://github.com/EliasVincent/whisper-subtitles-webui\n",
+        "! pip install -U pip\n",
+        "! pip install -r whisper-subtitles-webui/requirements.txt\n",
+        "! add-apt-repository -y ppa:savoury1/ffmpeg4\n",
+        "! apt-get -qq install -y ffmpeg\n"
+      ],
+      "metadata": {
+        "id": "cdhoSxCJiMFA"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Start server"
+      ],
+      "metadata": {
+        "id": "zj_Xi9baiqQk"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "! python whisper-subtitles-webui/server.py --remote=True"
+      ],
+      "metadata": {
+        "id": "fOC6bU2nui_r"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

server.py

@@ -0,0 +1,105 @@
+import gradio as gr
+import ffmpeg
+import argparse
+import tempfile
+import torch
+import whisper
+from whisper.utils import get_writer
+
+import ytdlp_functions
+
+
+def download_video(url, quick, language, model, task, addSrtToVideo):
+    if quick:
+        returned_yt_file = ytdlp_functions.download_quick_mp4(url=url, folder=str(tempfile.gettempdir()))
+
+        return transcribe(
+            inputFile=returned_yt_file,
+            language=language,
+            model=model,
+            task=task,
+            addSrtToVideo=addSrtToVideo)
+
+
+def transcribe(inputFile, language, model, task, addSrtToVideo):
+    print("gpu available: " + str(torch.cuda.is_available()))
+    gpu = torch.cuda.is_available()
+    model = whisper.load_model(model)
+    # ytdlp_functions will give us a string, gradio filepicker an actual file
+    inputFileCleared = inputFile if isinstance(inputFile, str) else inputFile.name
+
+    whisperOutput = model.transcribe(
+        inputFileCleared,
+        task=task,
+        language=language,
+        verbose=True,
+        fp16=gpu
+    )
+
+    writer = get_writer("srt", str(tempfile.gettempdir()))
+    writer(whisperOutput, inputFileCleared)
+    # broken srt filepaths. Use those if tempdir acts weird.
+    # srtFile = f"{inputFileCleared}" + ".srt"
+    # anotherSrtFile = inputFileCleared.rsplit(".", 2)[0] + ".srt"
+    srtFile = inputFileCleared.rsplit(".", 1)[0] + ".srt"
+    if addSrtToVideo:
+        video_out = inputFileCleared + "_output.mkv"
+
+        input_ffmpeg = ffmpeg.input(inputFileCleared)
+        input_ffmpeg_sub = ffmpeg.input(srtFile)
+
+        input_video = input_ffmpeg['v']
+        input_audio = input_ffmpeg['a']
+        input_subtitles = input_ffmpeg_sub['s']
+        stream = ffmpeg.output(
+            input_video, input_audio, input_subtitles, video_out,
+            vcodec='copy', acodec='copy', scodec='srt'
+        )
+        stream = ffmpeg.overwrite_output(stream)
+        ffmpeg.run(stream)
+        return video_out
+
+    return srtFile
+
+
+with gr.Blocks() as app:
+    gr.Markdown("# whisper-subtitles-webui")
+    with gr.Tab("Subtitle Video"):
+        st_file = gr.File()
+        st_lang = gr.Textbox(label="Language", placeholder="source language (en, de, ja, ..)")
+        st_model = gr.Dropdown(["tiny", "small", "medium", "large", ], label="Model", value="tiny")
+        st_task = gr.Radio(["transcribe", "translate"], label="Task", value="translate")
+        st_embed = gr.Checkbox(label="embed subtitles into video file")
+        st_file_out = gr.File()
+        st_start_button = gr.Button("Run", variant="primary")
+    with gr.Tab("YouTube to Subtitle"):
+        gr.Markdown(">try to update yt-dlp if downloads don't work")
+        yt_url = gr.Textbox(label="YouTube URL", placeholder="YouTube URL")
+        yt_quick = gr.Checkbox(label="Quick settings", value=True, interactive=False)
+        yt_lang = gr.Textbox(label="Language", placeholder="source language (en, de, ja, ..)")
+        yt_model = gr.Dropdown(["tiny", "small", "medium", "large"], label="Model", value="tiny")
+        yt_task = gr.Radio(["transcribe", "translate"], label="Task", value="translate")
+        yt_embed = gr.Checkbox(label="embed subtitles into video file")
+        yt_file_out = gr.File()
+        yt_start_button = gr.Button("Download and Run", variant="primary")
+
+    st_start_button.click(fn=transcribe, inputs=
+    [st_file,
+     st_lang,
+     st_model,
+     st_task,
+     st_embed
+     ], outputs=st_file_out, api_name="video_to_subs")
+    yt_start_button.click(fn=download_video, inputs=
+    [
+        yt_url,
+        yt_quick,
+        yt_lang,
+        yt_model,
+        yt_task,
+        yt_embed,
+    ], outputs=yt_file_out, api_name="yt_to_subs")
+parser = argparse.ArgumentParser(description='Share option')
+parser.add_argument('--remote', type=bool, help='share', default=False)
+args = parser.parse_args()
+app.launch(share=args.remote)

ytdlp_functions.py

@@ -0,0 +1,13 @@
+from yt_dlp import YoutubeDL
+import os
+
+def download_quick_mp4(url, folder):
+    ytdl_format_options = {
+        'outtmpl': os.path.join(folder, '%(title)s-%(id)s.%(ext)s')
+    }
+
+    with YoutubeDL(ytdl_format_options) as ydl:
+        info = ydl.extract_info(url, download=False)
+        file = ydl.download(url)
+
+        return os.path.join(folder, f"{info['title']}-{info['id']}.{info['ext']}")