Upload 4 files

LICENSE.md

@@ -0,0 +1,36 @@
+# Nick088's Non-Commercial License (NNC)
+
+## 1. Definitions
+
+- "Software" refers to the content present within this repository including code, text, graphics, sounds, images, and other files.
+- "You" refers to the individual or entity that wishes to use the Software.
+- "Nick088" refers to the original creator of the Software.
+- "Fork" refers to the action of creating a personal copy of another user's repository.
+
+## 2. Grant of Rights
+
+Subject to the terms of this license, Nick088 hereby grants You a worldwide, royalty-free, non-exclusive, perpetual license to use the Software for personal and non-commercial purposes. This includes the rights to use, copy, modify, merge, publish, and distribute the Software for non-commercial purposes.
+
+## 3. Redistribution
+
+You may not distribute or sell the Software, or any derivative works based on the Software, unless you have been specifically granted permission by Nick088. Any permitted redistribution must also be under the terms of this license. Unauthorized distribution is strictly prohibited and will result in the termination of this license.
+
+## 4. Commercial Use
+
+The use of the Software for commercial purposes, including any form of paid software support and , is strictly forbidden without the explicit written approval of Nick088. This applies to both profit-driven businesses and non-profit organizations that handle monetary transactions.
+
+Nick088 may agree to a predetermined or subsequently decided percentage of the profits. Nick088 maintains an upper hand in all such negotiations and reserves any rights, including the right to terminate the contract at any time.
+
+Any unauthorized commercial use is strictly prohibited and will result to an immediate termination of this license. In the event of a breach of these terms, Nick088 reserves the right to pursue legal remedies. This may result in litigation, and the offending party may be held liable for any damages incurred. Please be aware that non-compliance with these terms is a serious matter and could have significant legal consequences.
+
+## 5. Forking & Personal Use
+
+You are free to fork and modify the Software for your own personal use. You may not distribute, or create derivative works from your modifications unless granted permission by Nick088. All modifications must also be under the terms of this license.
+
+## 6. Liability
+
+Nick088 provides the Software "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall Nick088 be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the Software or the use or other dealings in the Software. You agree to use the Software at your own risk.
+
+## 7. Governing Law
+
+This license is governed by the laws of the jurisdiction in which Nick088 resides. Any disputes related to this license will be resolved in the courts of that jurisdiction.

app.py

@@ -0,0 +1,523 @@
+import os
+import subprocess
+import json
+from datetime import timedelta
+import tempfile
+import re
+import gradio as gr
+import groq
+from groq import Groq
+
+
+# setup groq 
+
+client = Groq(api_key=os.environ.get("Groq_Api_Key"))
+
+def handle_groq_error(e, model_name):
+    error_data = e.args[0]
+
+    if isinstance(error_data, str):
+        # Use regex to extract the JSON part of the string
+        json_match = re.search(r'(\{.*\})', error_data)
+        if json_match:
+            json_str = json_match.group(1)
+            # Ensure the JSON string is well-formed
+            json_str = json_str.replace("'", '"')  # Replace single quotes with double quotes
+            error_data = json.loads(json_str)
+
+    if isinstance(e, groq.RateLimitError):
+        if isinstance(error_data, dict) and 'error' in error_data and 'message' in error_data['error']:
+            error_message = error_data['error']['message']
+            raise gr.Error(error_message)
+    else:
+        raise gr.Error(f"Error during Groq API call: {e}")
+
+
+# language codes for subtitle maker
+
+LANGUAGE_CODES = {
+    "English": "en",
+    "Chinese": "zh",
+    "German": "de",
+    "Spanish": "es",
+    "Russian": "ru",
+    "Korean": "ko",
+    "French": "fr",
+    "Japanese": "ja",
+    "Portuguese": "pt",
+    "Turkish": "tr",
+    "Polish": "pl",
+    "Catalan": "ca",
+    "Dutch": "nl",
+    "Arabic": "ar",
+    "Swedish": "sv",
+    "Italian": "it",
+    "Indonesian": "id",
+    "Hindi": "hi",
+    "Finnish": "fi",
+    "Vietnamese": "vi",
+    "Hebrew": "he",
+    "Ukrainian": "uk",
+    "Greek": "el",
+    "Malay": "ms",
+    "Czech": "cs",
+    "Romanian": "ro",
+    "Danish": "da",
+    "Hungarian": "hu",
+    "Tamil": "ta",
+    "Norwegian": "no",
+    "Thai": "th",
+    "Urdu": "ur",
+    "Croatian": "hr",
+    "Bulgarian": "bg",
+    "Lithuanian": "lt",
+    "Latin": "la",
+    "Māori": "mi",
+    "Malayalam": "ml",
+    "Welsh": "cy",
+    "Slovak": "sk",
+    "Telugu": "te",
+    "Persian": "fa",
+    "Latvian": "lv",
+    "Bengali": "bn",
+    "Serbian": "sr",
+    "Azerbaijani": "az",
+    "Slovenian": "sl",
+    "Kannada": "kn",
+    "Estonian": "et",
+    "Macedonian": "mk",
+    "Breton": "br",
+    "Basque": "eu",
+    "Icelandic": "is",
+    "Armenian": "hy",
+    "Nepali": "ne",
+    "Mongolian": "mn",
+    "Bosnian": "bs",
+    "Kazakh": "kk",
+    "Albanian": "sq",
+    "Swahili": "sw",
+    "Galician": "gl",
+    "Marathi": "mr",
+    "Panjabi": "pa",
+    "Sinhala": "si",
+    "Khmer": "km",
+    "Shona": "sn",
+    "Yoruba": "yo",
+    "Somali": "so",
+    "Afrikaans": "af",
+    "Occitan": "oc",
+    "Georgian": "ka",
+    "Belarusian": "be",
+    "Tajik": "tg",
+    "Sindhi": "sd",
+    "Gujarati": "gu",
+    "Amharic": "am",
+    "Yiddish": "yi",
+    "Lao": "lo",
+    "Uzbek": "uz",
+    "Faroese": "fo",
+    "Haitian": "ht",
+    "Pashto": "ps",
+    "Turkmen": "tk",
+    "Norwegian Nynorsk": "nn",
+    "Maltese": "mt",
+    "Sanskrit": "sa",
+    "Luxembourgish": "lb",
+    "Burmese": "my",
+    "Tibetan": "bo",
+    "Tagalog": "tl",
+    "Malagasy": "mg",
+    "Assamese": "as",
+    "Tatar": "tt",
+    "Hawaiian": "haw",
+    "Lingala": "ln",
+    "Hausa": "ha",
+    "Bashkir": "ba",
+    "jw": "jw",
+    "Sundanese": "su",
+}
+
+
+# helper functions
+
+def split_audio(audio_file_path, chunk_size_mb):
+    chunk_size = chunk_size_mb * 1024 * 1024  # Convert MB to bytes
+    file_number = 1
+    chunks = []
+    with open(audio_file_path, 'rb') as f:
+        chunk = f.read(chunk_size)
+        while chunk:
+            chunk_name = f"{os.path.splitext(audio_file_path)[0]}_part{file_number:03}.mp3" # Pad file number for correct ordering
+            with open(chunk_name, 'wb') as chunk_file:
+                chunk_file.write(chunk)
+            chunks.append(chunk_name)
+            file_number += 1
+            chunk = f.read(chunk_size)
+    return chunks
+
+def merge_audio(chunks, output_file_path):
+    with open("temp_list.txt", "w") as f:
+        for file in chunks:
+            f.write(f"file '{file}'\n")
+    try:
+        subprocess.run(
+            [
+                "ffmpeg",
+                "-f",
+                "concat",
+                "-safe", "0",
+                "-i",
+                "temp_list.txt",
+                "-c",
+                "copy",
+                "-y",
+                output_file_path
+            ],
+            check=True
+        )
+        os.remove("temp_list.txt")
+        for chunk in chunks:
+            os.remove(chunk)
+    except subprocess.CalledProcessError as e:
+        raise gr.Error(f"Error during audio merging: {e}")
+
+
+# Checks file extension, size, and downsamples or splits if needed.
+
+ALLOWED_FILE_EXTENSIONS = ["mp3", "mp4", "mpeg", "mpga", "m4a", "wav", "webm"]
+MAX_FILE_SIZE_MB = 25
+CHUNK_SIZE_MB = 25
+
+def check_file(audio_file_path):
+    if not audio_file_path:
+        raise gr.Error("Please upload an audio/video file.")
+
+    file_size_mb = os.path.getsize(audio_file_path) / (1024 * 1024)
+    file_extension = audio_file_path.split(".")[-1].lower()
+
+    if file_extension not in ALLOWED_FILE_EXTENSIONS:
+        raise gr.Error(f"Invalid file type (.{file_extension}). Allowed types: {', '.join(ALLOWED_FILE_EXTENSIONS)}")
+
+    if file_size_mb > MAX_FILE_SIZE_MB:
+        gr.Warning(
+            f"File size too large ({file_size_mb:.2f} MB). Attempting to downsample to 16kHz MP3 128kbps. Maximum size allowed: {MAX_FILE_SIZE_MB} MB"
+        )
+
+        output_file_path = os.path.splitext(audio_file_path)[0] + "_downsampled.mp3"
+        try:
+            subprocess.run(
+                [
+                    "ffmpeg",
+                    "-i",
+                    audio_file_path,
+                    "-ar",
+                    "16000",
+                    "-ab",
+                    "128k",
+                    "-ac",
+                    "1",
+                    "-f",
+                    "mp3",
+                    "-y",
+                    output_file_path,
+                ],
+                check=True
+            )
+
+            # Check size after downsampling
+            downsampled_size_mb = os.path.getsize(output_file_path) / (1024 * 1024)
+            if downsampled_size_mb > MAX_FILE_SIZE_MB:
+                gr.Warning(f"File still too large after downsampling ({downsampled_size_mb:.2f} MB). Splitting into {CHUNK_SIZE_MB} MB chunks.")
+                return split_audio(output_file_path, CHUNK_SIZE_MB), "split"
+
+            return output_file_path, None
+        except subprocess.CalledProcessError as e:
+            raise gr.Error(f"Error during downsampling: {e}")
+    return audio_file_path, None
+
+
+# subtitle maker
+
+def format_time(seconds):
+    hours = int(seconds // 3600)
+    minutes = int((seconds % 3600) // 60)
+    seconds = int(seconds % 60)
+    milliseconds = int((seconds % 1) * 1000)
+
+    return f"{hours:02}:{minutes:02}:{seconds:02},{milliseconds:03}"
+
+def json_to_srt(transcription_json):
+    srt_lines = []
+
+    for segment in transcription_json:
+        start_time = format_time(segment['start'])
+        end_time = format_time(segment['end'])
+        text = segment['text']
+
+        srt_line = f"{segment['id']+1}\n{start_time} --> {end_time}\n{text}\n"
+        srt_lines.append(srt_line)
+
+    return '\n'.join(srt_lines)
+
+
+def generate_subtitles(audio_file_path, prompt, language, auto_detect_language, model, include_video, font_selection, font_file, font_color, font_size, outline_thickness, outline_color):
+    processed_path, split_status = check_file(audio_file_path)
+    full_srt_content = ""
+    total_duration = 0
+    segment_id_offset = 0
+
+    if split_status == "split":
+        srt_chunks = []
+        video_chunks = []
+        for i, chunk_path in enumerate(processed_path):
+            try:
+                with open(chunk_path, "rb") as file:
+                    transcription_json_response = client.audio.transcriptions.create(
+                        file=(os.path.basename(chunk_path), file.read()),
+                        model=model,
+                        prompt=prompt,
+                        response_format="verbose_json",
+                        language=None if auto_detect_language else language,
+                        temperature=0.0,
+                    )
+                transcription_json = transcription_json_response.segments
+
+                # Adjust timestamps and segment IDs
+                for segment in transcription_json:
+                    segment['start'] += total_duration
+                    segment['end'] += total_duration
+                    segment['id'] += segment_id_offset
+                segment_id_offset += len(transcription_json)
+                total_duration += transcription_json[-1]['end']  # Update total duration
+
+                srt_content = json_to_srt(transcription_json)
+                full_srt_content += srt_content
+                temp_srt_path = f"{os.path.splitext(chunk_path)[0]}.srt"
+                with open(temp_srt_path, "w", encoding="utf-8") as temp_srt_file:
+                    temp_srt_file.write(srt_content)
+                    temp_srt_file.write("\n") # add a new line at the end of the srt chunk file to fix format when merged
+                srt_chunks.append(temp_srt_path)
+
+                if include_video and audio_file_path.lower().endswith((".mp4", ".webm")):
+                    try:
+                        output_file_path = chunk_path.replace(os.path.splitext(chunk_path)[1], "_with_subs" + os.path.splitext(chunk_path)[1])
+                        # Handle font selection
+                        if font_selection == "Custom Font File" and font_file:
+                            font_name = os.path.splitext(os.path.basename(font_file.name))[0]  # Get font filename without extension
+                            font_dir = os.path.dirname(font_file.name)  # Get font directory path
+                        elif font_selection == "Custom Font File" and not font_file:
+                            font_name = None  # Let FFmpeg use its default Arial
+                            font_dir = None  # No font directory
+                            gr.Warning(f"You want to use a Custom Font File, but uploaded none. Using the default Arial font.")
+                        elif font_selection == "Arial":
+                            font_name = None  # Let FFmpeg use its default Arial
+                            font_dir = None  # No font directory
+                            
+                        # FFmpeg command
+                        subprocess.run(
+                            [
+                                "ffmpeg",
+                                "-y",
+                                "-i",
+                                chunk_path,
+                                "-vf",
+                                f"subtitles={temp_srt_path}:fontsdir={font_dir}:force_style='Fontname={font_name},Fontsize={int(font_size)},PrimaryColour=&H{font_color[1:]}&,OutlineColour=&H{outline_color[1:]}&,BorderStyle={int(outline_thickness)},Outline=1'",
+                                output_file_path,
+                            ],
+                            check=True,
+                        )
+                        video_chunks.append(output_file_path) 
+                    except subprocess.CalledProcessError as e:
+                        raise gr.Error(f"Error during subtitle addition: {e}")     
+                elif include_video and not audio_file_path.lower().endswith((".mp4", ".webm")):
+                    gr.Warning(f"You have checked on the 'Include Video with Subtitles', but the input file {audio_file_path} isn't a video (.mp4 or .webm). Returning only the SRT File.", duration=15)
+            except groq.RateLimitError as e:
+                handle_groq_error(e, model)
+                gr.Warning(f"API limit reached during chunk {i+1}. Returning processed chunks only.")
+                if srt_chunks and video_chunks:
+                    merge_audio(video_chunks, 'merged_output_video.mp4')
+                    with open('merged_output.srt', 'w', encoding="utf-8") as outfile:
+                        for chunk_srt in srt_chunks:
+                            with open(chunk_srt, 'r', encoding="utf-8") as infile:
+                                outfile.write(infile.read())
+                    return 'merged_output.srt', 'merged_output_video.mp4'
+                else:
+                    raise gr.Error("Subtitle generation failed due to API limits.")
+
+        # Merge SRT chunks
+        final_srt_path = os.path.splitext(audio_file_path)[0] + "_final.srt"
+        with open(final_srt_path, 'w', encoding="utf-8") as outfile:
+            for chunk_srt in srt_chunks:
+                with open(chunk_srt, 'r', encoding="utf-8") as infile:
+                    outfile.write(infile.read())
+
+        # Merge video chunks
+        if video_chunks:
+            merge_audio(video_chunks, 'merged_output_video.mp4')
+            return final_srt_path, 'merged_output_video.mp4'
+        else:
+            return final_srt_path, None
+
+    else:  # Single file processing (no splitting)
+        try:
+            with open(processed_path, "rb") as file:
+                transcription_json_response = client.audio.transcriptions.create(
+                    file=(os.path.basename(processed_path), file.read()),
+                    model=model,
+                    prompt=prompt,
+                    response_format="verbose_json",
+                    language=None if auto_detect_language else language,
+                    temperature=0.0,
+                )
+            transcription_json = transcription_json_response.segments
+
+            srt_content = json_to_srt(transcription_json)
+            temp_srt_path = os.path.splitext(audio_file_path)[0] + ".srt"
+            with open(temp_srt_path, "w", encoding="utf-8") as temp_srt_file:
+                temp_srt_file.write(srt_content)
+
+            if include_video and audio_file_path.lower().endswith((".mp4", ".webm")):
+                try:
+                    output_file_path = audio_file_path.replace(
+                        os.path.splitext(audio_file_path)[1], "_with_subs" + os.path.splitext(audio_file_path)[1]
+                    )
+                    # Handle font selection
+                    if font_selection == "Custom Font File" and font_file:
+                        font_name = os.path.splitext(os.path.basename(font_file.name))[0]  # Get font filename without extension
+                        font_dir = os.path.dirname(font_file.name)  # Get font directory path
+                    elif font_selection == "Custom Font File" and not font_file:
+                        font_name = None  # Let FFmpeg use its default Arial
+                        font_dir = None  # No font directory
+                        gr.Warning(f"You want to use a Custom Font File, but uploaded none. Using the default Arial font.")
+                    elif font_selection == "Arial":
+                        font_name = None  # Let FFmpeg use its default Arial
+                        font_dir = None  # No font directory
+
+                    # FFmpeg command
+                    subprocess.run(
+                        [
+                            "ffmpeg",
+                            "-y",
+                            "-i",
+                            audio_file_path,
+                            "-vf",
+                            f"subtitles={temp_srt_path}:fontsdir={font_dir}:force_style='FontName={font_name},Fontsize={int(font_size)},PrimaryColour=&H{font_color[1:]}&,OutlineColour=&H{outline_color[1:]}&,BorderStyle={int(outline_thickness)},Outline=1'",
+                            output_file_path,
+                        ],
+                        check=True,
+                    )
+                    return temp_srt_path, output_file_path
+                except subprocess.CalledProcessError as e:
+                    raise gr.Error(f"Error during subtitle addition: {e}")
+            elif include_video and not audio_file_path.lower().endswith((".mp4", ".webm")):
+                gr.Warning(f"You have checked on the 'Include Video with Subtitles', but the input file {audio_file_path} isn't a video (.mp4 or .webm). Returning only the SRT File.", duration=15)
+            
+            return temp_srt_path, None
+        except groq.RateLimitError as e:
+            handle_groq_error(e, model)
+        except ValueError as e:
+            raise gr.Error(f"Error creating SRT file: {e}")
+
+
+theme = gr.themes.Soft(
+    primary_hue="sky",
+    secondary_hue="blue",
+    neutral_hue="neutral"
+).set(
+    border_color_primary='*neutral_300',
+    block_border_width='1px',
+    block_border_width_dark='1px',
+    block_title_border_color='*secondary_100',
+    block_title_border_color_dark='*secondary_200',
+    input_background_fill_focus='*secondary_300',
+    input_border_color='*border_color_primary',
+    input_border_color_focus='*secondary_500',
+    input_border_width='1px',
+    input_border_width_dark='1px',
+    slider_color='*secondary_500',
+    slider_color_dark='*secondary_600'
+)
+
+css = """
+.gradio-container{max-width: 1400px !important}
+h1{text-align:center}
+.extra-option {
+    display: none;
+}
+.extra-option.visible {
+    display: block;
+}
+"""
+
+
+with gr.Blocks(theme=theme, css=css) as interface:
+    gr.Markdown(
+        """
+    # Fast Subtitle Maker
+    Inference by Groq API  
+    If you are having API Rate Limit issues, you can retry later based on the [rate limits](https://console.groq.com/docs/rate-limits) or <a href="https://huggingface.co/spaces/Nick088/Fast-Subtitle-Maker?duplicate=true" style="display: inline-block;margin-top: .5em;margin-right: .25em;" target="_blank"> <img style="margin-bottom: 0em;display: inline;margin-top: -.25em;" src="https://img.shields.io/badge/-Duplicate%20Space-blue?labelColor=white&style=flat&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAP5JREFUOE+lk7FqAkEURY+ltunEgFXS2sZGIbXfEPdLlnxJyDdYB62sbbUKpLbVNhyYFzbrrA74YJlh9r079973psed0cvUD4A+4HoCjsA85X0Dfn/RBLBgBDxnQPfAEJgBY+A9gALA4tcbamSzS4xq4FOQAJgCDwV2CPKV8tZAJcAjMMkUe1vX+U+SMhfAJEHasQIWmXNN3abzDwHUrgcRGmYcgKe0bxrblHEB4E/pndMazNpSZGcsZdBlYJcEL9Afo75molJyM2FxmPgmgPqlWNLGfwZGG6UiyEvLzHYDmoPkDDiNm9JR9uboiONcBXrpY1qmgs21x1QwyZcpvxt9NS09PlsPAAAAAElFTkSuQmCC&logoWidth=14" alt="Duplicate Space"></a> with <a href=https://console.groq.com/keys>your own API Key</a> </p>
+    Hugging Face Space by [Nick088](https://linktr.ee/Nick088)  
+    <br> <a href="https://discord.gg/osai"> <img src="https://img.shields.io/discord/1198701940511617164?color=%23738ADB&label=Discord&style=for-the-badge" alt="Discord"> </a>  
+    """
+    )
+    with gr.Row():
+        audio_input_subtitles = gr.File(label="Upload Audio/Video", file_types=[f".{ext}" for ext in ALLOWED_FILE_EXTENSIONS],)
+        model_choice_subtitles = gr.Dropdown(choices=["whisper-large-v3"], value="whisper-large-v3", label="Audio Speech Recogition (ASR) Model")
+    with gr.Row():
+        transcribe_prompt_subtitles = gr.Textbox(label="Prompt (Optional)", info="Specify any context or spelling corrections.")
+    with gr.Row():
+        language_subtitles = gr.Dropdown(choices=[(lang, code) for lang, code in LANGUAGE_CODES.items()], value="en", label="Language")
+        auto_detect_language_subtitles = gr.Checkbox(label="Auto Detect Language")
+    with gr.Row():
+        transcribe_button_subtitles = gr.Button("Generate Subtitles")
+    include_video_option = gr.Checkbox(label="Include Video with Subtitles")
+    gr.Markdown("The SubText Rip (SRT) File, contains the subtitles, you can upload this to any video editing app for adding the subs to your video and also modify/stilyze them")
+    srt_output = gr.File(label="SRT Output File")
+    show_subtitle_settings = gr.Checkbox(label="Show Subtitle Video Settings", visible=False)
+    with gr.Row(visible=False) as subtitle_video_settings:
+        with gr.Column():
+            font_selection = gr.Radio(["Arial", "Custom Font File"], value="Arial", label="Font Selection", info="Select what font to use")
+            font_file = gr.File(label="Upload Font File (TTF or OTF)", file_types=[".ttf", ".otf"], visible=False)
+        font_color = gr.ColorPicker(label="Font Color", value="#FFFFFF")
+        font_size = gr.Slider(label="Font Size (in pixels)", minimum=10, maximum=60, value=24, step=1)
+        outline_thickness = gr.Slider(label="Outline Thickness", minimum=0, maximum=5, value=1, step=1)
+        outline_color = gr.ColorPicker(label="Outline Color", value="#000000")
+
+    
+    video_output = gr.Video(label="Output Video with Subtitles", visible=False)
+
+
+    # Event bindings
+
+    # show video output
+    include_video_option.change(lambda include_video: gr.update(visible=include_video), inputs=[include_video_option], outputs=[video_output])
+    # show video output subs settings checkbox
+    include_video_option.change(lambda include_video: gr.update(visible=include_video), inputs=[include_video_option], outputs=[show_subtitle_settings])
+    # show video output subs settings
+    show_subtitle_settings.change(lambda show: gr.update(visible=show), inputs=[show_subtitle_settings], outputs=[subtitle_video_settings])
+    # uncheck show subtitle settings checkbox if include video is unchecked (to make the output subs settings not visible)
+    show_subtitle_settings.change(lambda show, include_video: gr.update(visible=show and include_video), inputs=[show_subtitle_settings, include_video_option], outputs=[show_subtitle_settings])
+    # show custom font file selection
+    font_selection.change(lambda font_selection: gr.update(visible=font_selection == "Custom Font File"), inputs=[font_selection], outputs=[font_file])
+    # generate subtitles event
+    transcribe_button_subtitles.click(
+        generate_subtitles,
+        inputs=[
+            audio_input_subtitles,
+            transcribe_prompt_subtitles,
+            language_subtitles,
+            auto_detect_language_subtitles,
+            model_choice_subtitles,
+            include_video_option,
+            font_selection,
+            font_file,
+            font_color,
+            font_size,
+            outline_thickness,
+            outline_color,
+        ],
+        outputs=[srt_output, video_output],
+    )
+
+
+interface.launch(share=True)

packages.txt

@@ -0,0 +1 @@
+ffmpeg

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+groq