app.py

import logging
import subprocess
from pprint import pprint
from tempfile import _TemporaryFileWrapper

from ffmpy import FFmpeg, FFRuntimeError

import gradio as gr
from functions import (
    Clear,
    CommandBuilder,
    audio_channels,
    audio_codecs,
    audio_quality,
    audio_sample_rates,
    change_clipbox,
    containers,
    set_custom_bitrate,
    media_change,
    presets,
    supported_codecs,
    supported_presets,
    video_codecs,
    VF,
)

logging.basicConfig(level=logging.INFO)


def convert(file: _TemporaryFileWrapper, container_format: str, new_state: str):
    if file is None:
        logging.error("No file provided for conversion.")
        return [None, None, None, "No file provided", new_state]

    output_file = ""
    ffmpeg = FFmpeg()
    try:
        logging.info("File name: %s", file.name)
        new_name, _ = file.name.split(".")
        logging.info("New filename:%s", new_name)
        output_file = f"{new_name}1.{container_format.lower()}"
        ffmpeg = FFmpeg(
            inputs={file.name: None},
            outputs={output_file: ffmpeg_commands.commands.split()},
            global_options=["-y", "-hide_banner"],
        )
        ffmpeg_wo = FFmpeg(
            inputs={"input_file": None},
            outputs={
                f"output_file.{container_format.lower()}": ffmpeg_commands.commands.split()
            },
            global_options=["-y", "-hide_banner"],
        )
        print(ffmpeg)
        print(ffmpeg.cmd)

        ffmpeg.run(stderr=subprocess.PIPE)
        # pprint(f"{stdout} {stderr}")
        output = f"{ffmpeg.cmd}"

    except FFRuntimeError as e:
        output = e.stderr.decode()
        print(str(e.stderr), flush=True)
        return [None, None, None, output, new_state]

    new_state = output_file

    return [output_file, output_file, output_file, ffmpeg_wo.cmd, new_state]


css = """
body {
  background: var(--body-background-fill);
}
"""

with gr.Blocks(
    css=css,
    theme=gr.themes.Soft(
        primary_hue=gr.themes.colors.green,
        secondary_hue=gr.themes.colors.amber,
        neutral_hue=gr.themes.colors.slate,
        font=["sans-serif"],
        # font=["ui-sans-serif", "system-ui", "sans-serif"],
    ),
) as demo:
    with gr.Tabs(selected="format", elem_classes="tabs"):
        with gr.Tab("Format", id="format"):
            # Input Buttons
            with gr.Row():
                with gr.Column() as inputs:
                    file_input = gr.File()
                    options = gr.Radio(
                        label="options", choices=containers, value=containers[0]
                    )
                    with gr.Row():
                        with gr.Row() as inputs_clip:
                            clip = gr.Dropdown(
                                choices=["None", "Enabled"], label="Clip:", value="None"
                            )
                            start_time = gr.Textbox(
                                label="Start Time:",
                                placeholder="00:00",
                                visible=False,
                                interactive=True,
                            )
                            stop_time = gr.Textbox(
                                label="Stop Time:",
                                placeholder="00:00",
                                visible=False,
                                interactive=True,
                            )
                    with gr.Row():
                        clearBtn = gr.Button("Clear")
                        convertBtn = gr.Button("Convert", variant="primary")

                # Output Buttons
                with gr.Column():
                    # media_output = gr.Audio(label="Output")
                    with gr.Row():
                        video_button = gr.Button("Video")
                        audio_button = gr.Button("Audio")
                        file_button = gr.Button("File")
                    media_output_audio = gr.Audio(
                        type="filepath",
                        label="Audio",
                        visible=False,
                        interactive=False,
                    )
                    media_output_video = gr.Video(
                        label="Video", visible=True, height=300
                    )
                    media_output_file = gr.File(label="File", visible=False)
                    with gr.Row() as command_output:
                        output_textbox = gr.Code(
                            value="$ echo 'Hello, World!'",
                            label="command",
                            language="shell",
                            elem_id="outputtext",
                        )

                resetFormat = Clear(inputs, inputs_clip)
                # print(inputs_clip.children)
                # print(resetFormat)
                state = gr.State()
                clearBtn.click(resetFormat.clear, resetFormat(), resetFormat())
                convertBtn.click(
                    convert,
                    inputs=[file_input, options, state],
                    outputs=[
                        media_output_audio,
                        media_output_file,
                        media_output_video,
                        output_textbox,
                        state,
                    ],
                )

        with gr.Tab("Video", id="video"):
            with gr.Row() as video_inputs:
                video_options = gr.Dropdown(
                    label="video", choices=video_codecs, value=video_codecs[-1]
                )
                preset_options = gr.Dropdown(
                    choices=presets, label="presets", value=presets[-1]
                )

            with gr.Row(elem_id="button"):
                with gr.Column():
                    clearBtn = gr.Button("Clear")
                videoReset = Clear(video_inputs)
                clearBtn.click(videoReset.clear, videoReset(), videoReset())

        with gr.Tab("Audio", id="audio"):
            with gr.Row() as audio_inputs:
                # print(names[0])
                audio_options = gr.Dropdown(
                    label="audio", choices=audio_codecs, value=audio_codecs[-1]
                )
                audio_bitrate = gr.Dropdown(
                    choices=audio_quality,
                    label="Audio Qualities",
                    value=audio_quality[0],
                )
                custom_bitrate = gr.Number(label="Audio Qualities", visible=False)
                gr.Dropdown(
                    choices=audio_channels,
                    label="Audio Channels",
                    value=audio_channels[0],
                )
                gr.Dropdown(
                    choices=audio_sample_rates,
                    label="Sample Rates",
                    value=audio_sample_rates[0],
                )

            with gr.Column(elem_id="button"):
                clearBtn = gr.Button("Clear")
            audioReset = Clear(audio_inputs)
            clearBtn.click(audioReset.clear, audioReset(), audioReset())

        with gr.Tab("Filters", id="filters") as filter_inputs:
            gr.Markdown("## Video")
            # equal_height=True
            with gr.Row(equal_height=True) as filter_inputs:
                for i in VF:
                    # print(i.values())
                    # values = list(i.values())
                    values = list(i.values())[0]
                    choices = [j for lst in values for j in [lst.get("name")]]
                    a = gr.Dropdown(
                        label=str(list(i.keys())[0]), choices=choices, value=choices[0]
                    )
            gr.Markdown("## Audio")
            with gr.Row(elem_id="acontrast") as filter_inputs_1:
                acontrastSlider = gr.Slider(label="Acontrast", elem_id="acontrast")

            with gr.Column(elem_id="button"):
                clearBtn = gr.Button("Clear")

            filterReset = Clear(filter_inputs, filter_inputs_1)
            clearBtn.click(filterReset.clear, filterReset(), filterReset())

    # demo.load(fn=ffmpeg_commands.reset, inputs=[], outputs=[])
    clip.change(fn=change_clipbox, inputs=clip, outputs=[start_time, stop_time])
    # file_input.change(fn=updateOutput,inputs=file_input,outputs=output_textbox)

    options.change(supported_codecs, [options], [video_options, audio_options])
    # options.change(mediaChange,[options],[media_output_audio,media_output_video])
    # video_button.click(fn=videoChange,inputs=media_output_file,outputs=media_output_video)
    audio_button.click(
        media_change,
        [audio_button, state],
        [media_output_audio, media_output_video, media_output_file],
    )
    video_button.click(
        media_change,
        [video_button, state],
        [media_output_audio, media_output_video, media_output_file],
    )
    # media_output_audio.change(lambda x:gr.update(value=x),[media_output_audio],[media_output_video])
    file_button.click(
        media_change,
        [file_button, state],
        [media_output_audio, media_output_video, media_output_file],
    )
    """Video Tab change functions"""
    video_options.change(supported_presets, [video_options], [preset_options])
    """Audio Tab change functions"""
    audio_bitrate.change(set_custom_bitrate, [audio_bitrate], [custom_bitrate])

    """ Format Tab change functions"""
    ffmpeg_commands = CommandBuilder(
        inputs_clip, video_inputs, audio_inputs, filter_inputs, filter_inputs_1
    )
    ffmpeg_commands.setup_listener()
    # pprint(ffmpeg_commands.commands)
    ffmpeg_commands.update(output_textbox)

if __name__ == "__main__":
    demo.launch(show_error=True, max_threads=300)