Duplicate from Micrrosoft/Media-Converter

Co-authored-by: Microsoft <[email protected]>

.github/workflows/main.yml

@@ -0,0 +1,27 @@
+name: Sync to Hugging Face hub
+on:
+  push:
+    branches: [main]
+
+  # to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      - name: Add remote 
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: Accel
+          HF_SPACE: huggingface.co/spaces/Accel/media-converter
+        run: git remote add space https://$HF_USERNAME:$HF_TOKEN@$HF_SPACE 
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+          HF_USERNAME: Accel
+          HF_SPACE: huggingface.co/spaces/Accel/media-converter
+        run: git push --force https://$HF_USERNAME:$HF_TOKEN@$HF_SPACE main

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.pyc
+flagged/
+.venv
+docs/

README.md

@@ -0,0 +1,47 @@
+---
+title: FFmpeg Media Converter
+emoji: 💻
+colorFrom: blue
+colorTo: blue
+sdk: gradio
+sdk_version: 3.3.1
+app_file: app.py
+tags:
+- ffmpeg
+- converter
+- media
+- processing
+pinned: false
+license: mit
+duplicated_from: Micrrosoft/Media-Converter
+---
+
+
+Visit for more powerful tools www.aibeast.net
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Overview 
+Simple gradio interface for ffmpeg filters and codecs
+
+![Content](./images/gradio-app.png)
+## Dev
+Built with Gradio and ffmpy
+
+inspiration by [ffmpeg-commander](https://www.github.com/alfg/ffmpeg-commander)
+# Install
+ Clone the repo and 
+`pip install -r requirements.txt`
+- To run locally
+
+    `gradio app.py`

app.py

@@ -0,0 +1,174 @@
+import logging
+import subprocess
+from pprint import pprint
+from tempfile import _TemporaryFileWrapper
+
+from ffmpy import FFmpeg
+
+import gradio as gr
+from functions import (Clear, CommandBuilder, audio_channels, audio_codecs,
+                       audio_quality, audio_sample_rates,
+                       change_clipbox, containers, customBitrate, mediaChange, presets, supported_codecs, supported_presets, video_codecs, video_containers,
+                       vf)
+
+logging.basicConfig(level=logging.INFO)
+
+logging.info(msg=f"{video_containers}")
+
+
+def convert(file: _TemporaryFileWrapper, options: str,state):
+    stderr=""
+    stdout=""
+    output_file=""
+    video=""
+    ffmpeg=FFmpeg()
+    try:
+        logging.info(f"File name: {file.name}")
+        new_name, _ = file.name.split(".")
+        logging.info(f"New filename:{new_name}")
+        output_file = f"{new_name}1.{options.lower()}"
+        ffmpeg = FFmpeg(inputs={file.name: None}, outputs={
+                        output_file: 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}"
+        # video=gr.update(label=output_file,value=output_file)
+
+    except Exception as e:
+        stderr=e
+        output=f"{stderr}"
+        return [None,None,None,output]
+
+    state=output_file    
+
+    return [output_file,output_file,output_file,output,state]
+
+title="##"
+
+description="""
+<p style="text-align:center;">
+<br />You can visit for more powerful tools <a href="https://aibeast.net" target="_blank">AI Beast</a> and follow for updates <a href="https://www.facebook.com/abbas143office" target="_blank">Follow</a>
+</p>
+"""
+
+with gr.Blocks(css="./styles.css") as dm:
+    with gr.Tabs():
+        with gr.TabItem("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)
+                    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="Output",visible=True,interactive=False,source="filepath")
+                    media_output_video = gr.Video(label="Output",visible=False)
+                    media_output_file = gr.File(label="Output",visible=False)
+                    with gr.Row() as command_output:
+                        output_textbox = gr.Textbox(label="command",elem_id="outputtext")
+                
+                resetFormat=Clear(inputs,inputs_clip)
+                print(inputs_clip.children)
+                print(resetFormat)
+                state=gr.Variable()
+                clearBtn.click(resetFormat.clear, inputs=resetFormat(), outputs=resetFormat())
+                convertBtn.click(convert, inputs=[file_input, options,state], outputs=[
+                    media_output_audio,media_output_file,media_output_video, output_textbox,state])
+
+        with gr.TabItem("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.TabItem("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.TabItem("Filters") as filter_inputs:
+            gr.Markdown("## Video")
+            with gr.Row().style(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=list(i.keys()),
+                                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())
+    
+    """ Format Tab change functions"""
+    ffmpeg_commands=CommandBuilder(inputs_clip,video_inputs,audio_inputs,filter_inputs,filter_inputs_1)
+    # ffmpeg_commands.do()
+    dm.load(fn=ffmpeg_commands.reset,inputs=[],outputs=[])
+    pprint(ffmpeg_commands.commands)
+    ffmpeg_commands.update(output_textbox)
+    # file_input.change(fn=updateOutput,inputs=file_input,outputs=output_textbox)
+    clip.change(fn=change_clipbox, inputs=clip,
+                outputs=[start_time, stop_time])
+    
+    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(mediaChange,[audio_button,state],[media_output_audio,media_output_video,media_output_file])
+    video_button.click(mediaChange,[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(mediaChange,[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(customBitrate,[audio_bitrate],[custom_bitrate])
+
+if __name__=='__main__':
+    dm.launch()

codecs.json

@@ -0,0 +1,25 @@
+{
+    "video": {
+        "x264": "libx264",
+        "x265": "libx265",
+        "h264_nvenc": "h264_nvenc",
+        "hevc_nvenc": "hevc_nvenc",
+        "vp8": "libvpx",
+        "vp9": "libvpx-vp9",
+        "av1": "libaom-av1",
+        "mpeg2": "mpeg2video",
+        "mpeg4": "mpeg4 -vtag xvid",
+        "theora": "libtheora"
+    },
+    "audio": {
+        "aac": "aac",
+        "alac": "alac",
+        "dts": "dca",
+        "ac3": "ac3",
+        "vorbis": "libvorbis",
+        "opus": "libopus",
+        "lame":"libmp3lame",
+        "pcm":"pcm_s16le"
+    },
+    "copy": "copy"
+}

data.json

@@ -0,0 +1,1189 @@
+{
+    "protocols": [
+      {
+        "name": "File",
+        "value": "movie.mp4"
+      },
+      {
+        "name": "FTP",
+        "value": "ftp://[user[:password]@]server[:port]/path/to/remote/movie.mp4"
+      },
+      {
+        "name": "HTTP",
+        "value": "http://server:port/movie.mp4"
+      },
+      {
+        "name": "HTTPS",
+        "value": "https://server:port/movie.mp4"
+      },
+      {
+        "name": "RTMP",
+        "value": "rtmp://[username:password@]server[:port][/app][/instance][/playpath]"
+      },
+      {
+        "name": "SRT",
+        "value": "srt://hostname:port[?options]"
+      },
+      {
+        "name": "TCP",
+        "value": "tcp://hostname:port[?options]"
+      },
+      {
+        "name": "UDP",
+        "value": "udp://hostname:port[?options]"
+      }
+    ],
+    "containers": {
+      "video": [
+        {
+          "name": "MP4",
+          "value": "mp4"
+        },
+        {
+          "name": "MKV",
+          "value": "mkv"
+        },
+        {
+          "name": "WebM",
+          "value": "webm"
+        },
+        {
+          "name": "MPG",
+          "value": "mpg"
+        },
+        {
+          "name": "AVI",
+          "value": "avi"
+        },
+        {
+          "name": "OGV",
+          "value": "ogv"
+        },
+        {
+          "name": "FLV",
+          "value": "flv"
+        }
+      ],
+      "audio": [
+        {
+          "name": "MP3",
+          "value": "mp3"
+        },
+        {
+          "name": "M4A",
+          "value": "m4a"
+        },
+        {
+          "name": "OGG",
+          "value": "ogg"
+        },
+        {
+          "name": "FLAC",
+          "value": "flac"
+        },
+        {
+          "name": "WAV",
+          "value": "wav"
+        }
+      ]
+    },
+    "clip": [
+      {
+        "name": "None",
+        "value": false
+      },
+      {
+        "name": "Enabled",
+        "value": true
+      }
+    ],
+    "codecs": {
+      "video": [
+        {
+          "name": "x264",
+          "value": "x264",
+          "supported": [
+            "mp4",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "x265",
+          "value": "x265",
+          "supported": [
+            "mp4",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "h264_nvenc (Nvidia NVENC)",
+          "value": "h264_nvenc",
+          "supported": [
+            "mp4"
+          ]
+        },
+        {
+          "name": "hevc_nvenc (Nvidia NVENC)",
+          "value": "hevc_nvenc",
+          "supported": [
+            "mp4"
+          ]
+        },
+        {
+          "name": "AV1",
+          "value": "av1",
+          "supported": [
+            "mp4",
+            "mkv"
+          ]
+        },
+        {
+          "name": "VP8",
+          "value": "vp8",
+          "supported": [
+            "mp4",
+            "webm",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "VP9",
+          "value": "vp9",
+          "supported": [
+            "mp4",
+            "webm",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "copy",
+          "value": "copy",
+          "supported": null
+        }
+      ],
+      "audio": [
+        {
+          "name": "AAC",
+          "value": "aac",
+          "supported": [
+            "mp4",
+            "mp3",
+            "m4a",
+            "mkv",
+            "avi",
+            "flv"
+          ]
+        },
+        {
+          "name": "AC3",
+          "value": "ac3",
+          "supported": [
+            "mp4",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "DTS",
+          "value": "dts",
+          "supported": [
+            "mp4",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "Vorbis",
+          "value": "vorbis",
+          "supported": [
+            "mp4",
+            "mkv",
+            "ogg",
+            "webm"
+          ]
+        },
+        {
+          "name": "Opus",
+          "value": "opus",
+          "supported": [
+            "mp4",
+            "mkv",
+            "ogg",
+            "webm"
+          ]
+        },
+        {
+          "name": "LAME",
+          "value": "lame",
+          "supported": [
+            "mp3",
+            "mkv"
+          ]
+        },
+        {
+          "name": "ALAC",
+          "value": "alac",
+          "supported": [
+            "mp4",
+            "mkv",
+            "m4a",
+            "avi"
+          ]
+        },
+        {
+          "name": "FLAC",
+          "value": "flac",
+          "supported": [
+            "flac",
+            "mkv",
+            "avi"
+          ]
+        },
+        {
+          "name": "PCM",
+          "value": "pcm",
+          "supported": [
+            "mkv"
+          ]
+        },
+        {
+          "name": "Copy",
+          "value": "copy",
+          "supported": null
+        },
+        {
+          "name": "None",
+          "value": "none",
+          "supported": null
+        }
+      ]
+    },
+    "presets": [
+      {
+        "name": "Placebo",
+        "value": "placebo",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Very Slow",
+        "value": "veryslow",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Slower",
+        "value": "slower",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Slow",
+        "value": "slow",
+        "supported": [
+          "x264",
+          "x265",
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "Medium",
+        "value": "medium",
+        "supported": [
+          "x264",
+          "x265",
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "Fast",
+        "value": "fast",
+        "supported": [
+          "x264",
+          "x265",
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "Faster",
+        "value": "faster",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Very Fast",
+        "value": "veryfast",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Super Fast",
+        "value": "superfast",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "Ultra Fast",
+        "value": "ultrafast",
+        "supported": [
+          "x264",
+          "x265"
+        ]
+      },
+      {
+        "name": "hp",
+        "value": "hp",
+        "supported": [
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "hq",
+        "value": "hq",
+        "supported": [
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "bd",
+        "value": "bd",
+        "supported": [
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "lossless",
+        "value": "lossless",
+        "supported": [
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "losslesshp",
+        "value": "losslesshp",
+        "supported": [
+          "h264_nvenc",
+          "hevc_nvenc"
+        ]
+      },
+      {
+        "name": "None",
+        "value": "none"
+      }
+    ],
+    "passOptions": [
+      {
+        "name": "CRF",
+        "value": "crf"
+      },
+      {
+        "name": "1 Pass",
+        "value": "1"
+      },
+      {
+        "name": "2 Pass",
+        "value": "2"
+      }
+    ],
+    "pixelFormats": [
+      {
+        "name": "auto",
+        "value": "auto"
+      },
+      {
+        "name": "gray",
+        "value": "gray"
+      },
+      {
+        "name": "gray10le",
+        "value": "gray10le"
+      },
+      {
+        "name": "nv12",
+        "value": "nv12"
+      },
+      {
+        "name": "nv16",
+        "value": "nv16"
+      },
+      {
+        "name": "nv20le",
+        "value": "nv20le"
+      },
+      {
+        "name": "nv21",
+        "value": "nv21"
+      },
+      {
+        "name": "yuv420p",
+        "value": "yuv420p"
+      },
+      {
+        "name": "yuv420p10le",
+        "value": "yuv420p10le"
+      },
+      {
+        "name": "yuv422p",
+        "value": "yuv422p"
+      },
+      {
+        "name": "yuv422p10le",
+        "value": "yuv422p10le"
+      },
+      {
+        "name": "yuv444p",
+        "value": "yuv444p"
+      },
+      {
+        "name": "yuv444p10le",
+        "value": "yuv444p10le"
+      },
+      {
+        "name": "yuvj420p",
+        "value": "yuvj420p"
+      },
+      {
+        "name": "yuvj422p",
+        "value": "yuvj422p"
+      },
+      {
+        "name": "yuvj444p",
+        "value": "yuvj444p"
+      }
+    ],
+    "frameRates": [
+      {
+        "name": "auto",
+        "value": "auto"
+      },
+      {
+        "name": "ntsc",
+        "value": "ntsc"
+      },
+      {
+        "name": "pal",
+        "value": "pal"
+      },
+      {
+        "name": "film",
+        "value": "film"
+      },
+      {
+        "name": "23.976",
+        "value": "24000/1001"
+      },
+      {
+        "name": "24",
+        "value": "24"
+      },
+      {
+        "name": "25",
+        "value": "25"
+      },
+      {
+        "name": "29.97",
+        "value": "30000/1001"
+      },
+      {
+        "name": "30",
+        "value": "30"
+      },
+      {
+        "name": "48",
+        "value": "48"
+      },
+      {
+        "name": "50",
+        "value": "50"
+      },
+      {
+        "name": "59.94",
+        "value": "60000/1001"
+      },
+      {
+        "name": "60",
+        "value": "60"
+      }
+    ],
+    "speeds": [
+      {
+        "name": "auto",
+        "value": "auto"
+      },
+      {
+        "name": "10%",
+        "value": "10*PTS"
+      },
+      {
+        "name": "25%",
+        "value": "4*PTS"
+      },
+      {
+        "name": "50%",
+        "value": "2*PTS"
+      },
+      {
+        "name": "75%",
+        "value": "1.33333*PTS"
+      },
+      {
+        "name": "150%",
+        "value": ".66667*PTS"
+      },
+      {
+        "name": "200%",
+        "value": ".5*PTS"
+      },
+      {
+        "name": "250%",
+        "value": ".4*PTS"
+      },
+      {
+        "name": "300%",
+        "value": ".33333*PTS"
+      },
+      {
+        "name": "500%",
+        "value": ".2*PTS"
+      }
+    ],
+    "tunes": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "Film",
+        "value": "film"
+      },
+      {
+        "name": "Animation",
+        "value": "animation"
+      },
+      {
+        "name": "Grain",
+        "value": "grain"
+      },
+      {
+        "name": "Still Image",
+        "value": "stillimage"
+      },
+      {
+        "name": "Fast Decode",
+        "value": "fastdecode"
+      },
+      {
+        "name": "Zero Latency",
+        "value": "zerolatency"
+      }
+    ],
+    "profiles": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "Baseline",
+        "value": "baseline"
+      },
+      {
+        "name": "Main",
+        "value": "main"
+      },
+      {
+        "name": "High",
+        "value": "high"
+      }
+    ],
+    "levels": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "1.0",
+        "value": "1.0"
+      },
+      {
+        "name": "1.1",
+        "value": "1.1"
+      },
+      {
+        "name": "1.2",
+        "value": "1.2"
+      },
+      {
+        "name": "1.3",
+        "value": "1.3"
+      },
+      {
+        "name": "2.0",
+        "value": "2.0"
+      },
+      {
+        "name": "2.1",
+        "value": "2.1"
+      },
+      {
+        "name": "2.2",
+        "value": "2.2"
+      },
+      {
+        "name": "3.0",
+        "value": "3.0"
+      },
+      {
+        "name": "3.1",
+        "value": "3.1"
+      },
+      {
+        "name": "3.2",
+        "value": "3.2"
+      },
+      {
+        "name": "4.0",
+        "value": "4.0"
+      },
+      {
+        "name": "4.1",
+        "value": "4.1"
+      },
+      {
+        "name": "4.2",
+        "value": "4.2"
+      },
+      {
+        "name": "5.0",
+        "value": "5.0"
+      },
+      {
+        "name": "5.1",
+        "value": "5.1"
+      },
+      {
+        "name": "5.2",
+        "value": "5.2"
+      }
+    ],
+    "fastStart": [
+      {
+        "name": "Enabled (faststart)",
+        "value": true
+      },
+      {
+        "name": "None",
+        "value": false
+      }
+    ],
+    "sizes": [
+      {
+        "name": "Source",
+        "value": "source"
+      },
+      {
+        "name": "8K",
+        "value": "8192"
+      },
+      {
+        "name": "8K UHD",
+        "value": "7680"
+      },
+      {
+        "name": "4K",
+        "value": "4096"
+      },
+      {
+        "name": "4K UHD",
+        "value": "3840"
+      },
+      {
+        "name": "2K",
+        "value": "2048"
+      },
+      {
+        "name": "1600p",
+        "value": "2560"
+      },
+      {
+        "name": "1440p",
+        "value": "2560"
+      },
+      {
+        "name": "1200p",
+        "value": "1920"
+      },
+      {
+        "name": "1080p",
+        "value": "1920"
+      },
+      {
+        "name": "900p",
+        "value": "1600"
+      },
+      {
+        "name": "720p",
+        "value": "1280"
+      },
+      {
+        "name": "576p",
+        "value": "1024"
+      },
+      {
+        "name": "480p",
+        "value": "720"
+      },
+      {
+        "name": "320p",
+        "value": "480"
+      },
+      {
+        "name": "240p",
+        "value": "320"
+      },
+      {
+        "name": "Custom",
+        "value": "custom"
+      }
+    ],
+    "formats": [
+      {
+        "name": "Widescreen",
+        "value": "widescreen"
+      },
+      {
+        "name": "Full Screen",
+        "value": "fullscreen"
+      }
+    ],
+    "aspects": [
+      {
+        "name": "Auto",
+        "value": "auto"
+      },
+      {
+        "name": "1:1",
+        "value": "1:1"
+      },
+      {
+        "name": "2.4:1",
+        "value": "2.4:1"
+      },
+      {
+        "name": "3:2",
+        "value": "3:2"
+      },
+      {
+        "name": "4:3",
+        "value": "4:3"
+      },
+      {
+        "name": "5:4",
+        "value": "5:4"
+      },
+      {
+        "name": "8:7",
+        "value": "8:7"
+      },
+      {
+        "name": "14:10",
+        "value": "14:10"
+      },
+      {
+        "name": "16:9",
+        "value": "16:9"
+      },
+      {
+        "name": "16:10",
+        "value": "16:10"
+      },
+      {
+        "name": "19:10",
+        "value": "19:10"
+      },
+      {
+        "name": "21:9",
+        "value": "21:9"
+      },
+      {
+        "name": "32:9",
+        "value": "32:9"
+      }
+    ],
+    "scalings": [
+      {
+        "name": "Auto",
+        "value": "auto"
+      },
+      {
+        "name": "Neighbor",
+        "value": "neighbor"
+      },
+      {
+        "name": "Area",
+        "value": "area"
+      },
+      {
+        "name": "Fast Bilinear",
+        "value": "fast_bilinear"
+      },
+      {
+        "name": "Bilinear",
+        "value": "bilinear"
+      },
+      {
+        "name": "Bicubic",
+        "value": "bicubic"
+      },
+      {
+        "name": "Experimental",
+        "value": "experimental"
+      },
+      {
+        "name": "Bicublin",
+        "value": "bicublin"
+      },
+      {
+        "name": "Gauss",
+        "value": "gauss"
+      },
+      {
+        "name": "Sinc",
+        "value": "sinc"
+      },
+      {
+        "name": "Lanczos",
+        "value": "lanczos"
+      },
+      {
+        "name": "Spline",
+        "value": "spline"
+      }
+    ],
+    "audioStreams": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "All",
+        "value": "all"
+      },
+      {
+        "name": "1",
+        "value": "1"
+      },
+      {
+        "name": "2",
+        "value": "2"
+      },
+      {
+        "name": "3",
+        "value": "3"
+      },
+      {
+        "name": "4",
+        "value": "4"
+      },
+      {
+        "name": "5",
+        "value": "5"
+      },
+      {
+        "name": "6",
+        "value": "6"
+      },
+      {
+        "name": "7",
+        "value": "7"
+      },
+      {
+        "name": "8",
+        "value": "8"
+      }
+    ],
+    "audioChannels": [
+      {
+        "name": "Source",
+        "value": "source"
+      },
+      {
+        "name": "Mono",
+        "value": "1"
+      },
+      {
+        "name": "Stereo",
+        "value": "2"
+      },
+      {
+        "name": "5.1",
+        "value": "6"
+      }
+    ],
+    "audioQualities": [
+      {
+        "name": "Auto",
+        "value": "auto"
+      },
+      {
+        "name": "400",
+        "value": "400k"
+      },
+      {
+        "name": "320",
+        "value": "320k"
+      },
+      {
+        "name": "256",
+        "value": "256k"
+      },
+      {
+        "name": "224",
+        "value": "224k"
+      },
+      {
+        "name": "192",
+        "value": "192k"
+      },
+      {
+        "name": "160",
+        "value": "160k"
+      },
+      {
+        "name": "128",
+        "value": "128k"
+      },
+      {
+        "name": "96",
+        "value": "96k"
+      },
+      {
+        "name": "Custom",
+        "value": "custom"
+      },
+      {
+        "name": "Mute",
+        "value": "mute"
+      }
+    ],
+    "sampleRates": [
+      {
+        "name": "Auto",
+        "value": "auto"
+      },
+      {
+        "name": "7.35k",
+        "value": "7350"
+      },
+      {
+        "name": "8k",
+        "value": "8000"
+      },
+      {
+        "name": "11.025k",
+        "value": "11025"
+      },
+      {
+        "name": "12k",
+        "value": "12000"
+      },
+      {
+        "name": "16k",
+        "value": "16000"
+      },
+      {
+        "name": "22.05k",
+        "value": "22050"
+      },
+      {
+        "name": "24k",
+        "value": "24000"
+      },
+      {
+        "name": "32k",
+        "value": "32000"
+      },
+      {
+        "name": "44.1k",
+        "value": "44100"
+      },
+      {
+        "name": "48k",
+        "value": "48000"
+      }
+    ],
+    "deband": [
+      {
+        "name": "None",
+        "value": false
+      },
+      {
+        "name": "Enabled",
+        "value": true
+      }
+    ],
+    "deshake": [
+      {
+        "name": "None",
+        "value": false
+      },
+      {
+        "name": "Enabled",
+        "value": true
+      }
+    ],
+    "deflicker": [
+      {
+        "name": "None",
+        "value": false
+      },
+      {
+        "name": "Enabled",
+        "value": true
+      }
+    ],
+    "dejudder": [
+      {
+        "name": "None",
+        "value": false
+      },
+      {
+        "name": "Enabled",
+        "value": true
+      }
+    ],
+    "denoise": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "Default",
+        "value": "default"
+      },
+      {
+        "name": "Light",
+        "value": "light"
+      },
+      {
+        "name": "Medium",
+        "value": "medium"
+      },
+      {
+        "name": "Heavy",
+        "value": "heavy"
+      }
+    ],
+    "deinterlace": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "Frame",
+        "value": "frame"
+      },
+      {
+        "name": "Field",
+        "value": "field"
+      },
+      {
+        "name": "Frame Nospatial",
+        "value": "frame_nospatial"
+      },
+      {
+        "name": "Field Nospatial",
+        "value": "field_nospatial"
+      }
+    ],
+    "extraOptions": [
+      {
+        "text": "Force output file format.",
+        "value": "f"
+      },
+      {
+        "text": "Overwrite output files without asking.",
+        "value": "y"
+      },
+      {
+        "text": "Do not overwrite output files, and exit immediately if a specified output file already exists.",
+        "value": "n"
+      },
+      {
+        "text": "Send program-friendly progress information to stdout.",
+        "value": "progress"
+      },
+      {
+        "text": "Suppress printing banner.",
+        "value": "hide_banner"
+      },
+      {
+        "text": "Dump full command line and log output to a file named program-YYYYMMDD-HHMMSS.log in the current directory.",
+        "value": "report"
+      }
+    ],
+    "logLevels": [
+      {
+        "name": "None",
+        "value": "none"
+      },
+      {
+        "name": "Quiet",
+        "value": "quiet"
+      },
+      {
+        "name": "Panic",
+        "value": "panic"
+      },
+      {
+        "name": "Fatal",
+        "value": "fatal"
+      },
+      {
+        "name": "Error",
+        "value": "error"
+      },
+      {
+        "name": "Warning",
+        "value": "warning"
+      },
+      {
+        "name": "Info",
+        "value": "info"
+      },
+      {
+        "name": "Verbose",
+        "value": "verbose"
+      },
+      {
+        "name": "Debug",
+        "value": "debug"
+      },
+      {
+        "name": "Trace",
+        "value": "trace"
+      }
+    ]
+  }

functions.py

@@ -0,0 +1,515 @@
+"""
+util functions and classes
+"""
+import json
+from pprint import pprint
+from tempfile import _TemporaryFileWrapper
+from typing import List
+
+import gradio as gr
+from gradio.components import Component
+
+def parse(param: json) -> dict:
+    with open(param) as file:
+        return json.load(file)
+
+
+data = parse("./data.json")
+codecs = parse("./codecs.json")
+
+"""Video"""
+containers = [j.get("name") for i in data["containers"]
+              for j in data["containers"][i]]
+video_containers = [i.get("name") for i in data["containers"]["video"]]
+video_codecs = [i.get("value") for i in data["codecs"]["video"]]
+video_aspect_ratio = [i.get("name") for i in data["aspects"]]
+video_scaling = [i.get("name") for i in data["scalings"]]
+""" Audio """
+audio_containers = [i.get("name") for i in data["containers"]["audio"]]
+audio_codecs = [i.get("value") for i in data["codecs"]["audio"]]
+audio_channels = [i.get("name") for i in data["audioChannels"]]
+audio_quality = [i.get("name") for i in data["audioQualities"]]
+audio_sample_rates = [i.get("name") for i in data["sampleRates"]]
+
+""" Video & Audio Filters """
+# deband=[i.get("name") for i in data["deband"]]
+# deflicker=[i.get("name") for i in data["deflicker"]]
+# deshake=[i.get("name") for i in data["deshake"]]
+# dejudder=[i.get("name") for i in data["dejudder"]]
+# denoise=[i.get("name") for i in data["denoise"]]
+# deinterlace=[i.get("name") for i in data["deinterlace"]]
+filters = ["deband", "deflicker", "deshake",
+           "dejudder", "denoise", "deinterlace"]
+vf = [{vFilter: names} for vFilter in filters for names in [
+    [i for i in data[vFilter]]]]
+
+presets = [i.get("name") for i in data["presets"]]
+profiles = [i.get("name") for i in data["profiles"]]
+speeds = [i.get("name") for i in data["speeds"]]
+
+
+outputMap = parse("./mappings.json")
+newoutputMap = parse("./new_mappings.json")
+"""Output Mappings of commands to value
+   audioQuality -b:a 128k 
+"""
+
+
+class CommandBuilder():
+    """Takes a collection of gradio layout elements and attaches 
+    a function to each component in the context
+    to build an array of ffmpeg commands"""
+
+    def __call__(self, *args, **kwds):
+        return [i.value for i in self._component]
+
+    def do(self, *inputs, **kwds):
+        for comp in self._component:
+            if comp.label is not None:
+                self.changefunc(comp, "", comp.value)
+
+    def reset(self):
+        self.outputDict = {"vf": {}, "af": {}}
+        self.commands=""
+        self.vf, self.af, self.extra = ([] for _ in range(3))
+
+    def __init__(self, *inputs: gr.Blocks) -> None:
+        """
+        Parameters:
+            *inputs: A tuple of layout blocks containing components(Textbox,Button...).
+        """
+
+        self.outputDict = {"vf": {}, "af": {}}
+        self.formatOutputDict = {"vf": {}, "af": {}}
+        # state=gr.Variable()
+        # state2=gr.Variable()
+
+        self._component: List[Component] = []
+        self.vf, self.af, self.extra = ([] for _ in range(3))
+        self.commands = ""
+        if inputs is None:
+            return None
+        for i in inputs:
+            self._component += self._get_component_instance(i)
+        for comp in self._component:
+            state = gr.Variable()
+            state2 = gr.Variable()
+            if comp.label is not None:
+                state.value = comp
+                state2.value = comp.label
+                comp.change(fn=self.changefunc, inputs=[
+                            state, state2, comp], outputs=[])
+
+    def changefunc(self, input: gr.components.IOComponent, c_label="", newValue=""):
+        label, *_ = input.label.strip(": \n").lower().split(
+        ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+        label += "".join(_).title()
+        key = newoutputMap.get(label)
+        lst_extra, vf, af = ([] for _ in range(3))
+        if newValue not in [None, "Source", "Auto", "", "None", "none", 0]:
+            self.setVf(label, newValue)
+            self.setAf(label, newValue)
+            self.setF(label, newValue)
+            for val in self.outputDict:
+                if val == "vf":
+                    vf = self.outputDict.get(val).values()
+                    vf = ",".join(list(vf))
+                elif val == "af":
+                    af = self.outputDict.get(val).values()
+                    af = ",".join(list(af))
+                    pass
+                else:
+                    lst_extra.extend([val, self.outputDict.get(val)])
+
+        else:
+            self.outputDict.pop(key, "No Key Exists")
+            self.outputDict["vf"].pop(label, "No Key Exists")
+            self.outputDict["af"].pop(label, "No Key Exists")
+        self.vf = f"-vf '{vf}'" if vf else ""
+        self.af = f"-af '{af}'" if af else ""
+        self.extra = " ".join(lst_extra)
+        self.commands = f"{self.vf} {self.af} {self.extra}"
+
+        print(self.vf, self.af, self.extra)
+
+    def setVf(self, label:str, newValue:"str| int"):
+        """Sets Video filters 
+
+        Args:
+            label : label of components
+            newValue : value of component
+        """
+        if newoutputMap["vf"].get(label):
+            key = newoutputMap["vf"].get(label)
+            if label in ["deinterlace", "denoise"]:
+                value = "_".join(newValue.lower().split())
+                arg = key.get(value, None)
+                self.outputDict["vf"].update({label: arg})
+            else:
+                self.outputDict["vf"].update({key: key})
+
+    def setF(self, label, newValue):
+        """ Sets Extra filters 
+        Args:
+            label : label of components
+            newValue : value of component
+        """
+        if newoutputMap.get(label):
+            key = newoutputMap.get(label)
+            if label in ["video", "audio"]:
+                value=codecs.get(label).get(newValue,newValue)
+                print(value)
+                self.outputDict.update({key:value})
+            elif label in ["startTime", "stopTime"]:
+                self.outputDict.update({key: newValue})
+            else:
+                value = "".join([i.get("value", "None") for i in data.get(
+                    label) if i.get("name", None) == newValue])
+                self.outputDict.update({key: value})
+
+    def setAf(self, label:str, newValue:"str|int"):
+        """ Sets Extra filters 
+        Args:
+            label : label of components
+            newValue : value of component
+        """
+        if newoutputMap["af"].get(label):
+            value = int(newValue)/100
+            arg = f"{label}={value}"
+            self.outputDict["af"].update({label: arg})
+
+    def update(self, Component: Component):
+        for comp in self._component:
+            comp.change(lambda: gr.update(
+                value=self.outputDict), [], [Component])
+
+    def _get_component_instance(self, inputs: gr.Blocks) -> List[Component]:
+        """
+        returns components present in a layout block
+        Parameters:
+            inputs: layout block
+        """
+        res=[]
+        for i in inputs.children:
+            # print(i,hasattr(i,"children"))
+            if not (hasattr(i,"children")):
+                # res.append(gr.components.get_component_instance(i,render=True))
+                res+=[gr.components.get_component_instance(i,render=True)]
+                # print(res)
+            elif hasattr(i,"children"):
+                res+=self._get_component_instance(i)
+        # print(res)
+        return res
+        # return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
+
+    def setVideoFilters(self, options):
+        value = self.outputDict.get(options, "-")
+        filters = newoutputMap.get(options, None)
+        arg = ""
+        if options in ["deinterlace", "denoise"]:
+            value = "_".join(value.lower().split())
+            arg = filters.get(value, None)
+            # self.vf.append(arg)
+            self.outputDict["vf"].update({options: arg})
+            return True
+        if options in ["deband", "deflicker", "deshake", "dejudder"]:
+            arg = filters
+            self.outputDict["vf"].update({options: arg})
+            return True
+
+        return
+
+    def setAudioFilters(self, options):
+        value = self.outputDict.get(options, "-")
+        if options in ["acontrast"]:
+            value = int(value)/100
+            arg = f"{options}={value}"
+
+            self.outputDict["af"].update({options: arg})
+            return True
+        return
+
+    def setFormat(self, options):
+        value = self.outputDict.get(options, "-")
+        filters = newoutputMap.get(options, None)
+        if options in ["video", "audio"]:
+            value = "".join([i.get("value", "None") for i in data.get(
+                "codecs").get(options) if i.get("name", None) == value])
+            arg = f"{filters} {value}"
+            self.outputDict.update({options: arg})
+            return True
+        elif data.get(options) == None:
+            arg = f"{filters} {value}"
+            self.outputDict.update({options: arg})
+            return True
+        elif options != "clip":
+            value = "".join([i.get("value", "None") for i in data.get(
+                options) if i.get("name", None) == value])
+            arg = f"{filters} {value}"
+            self.outputDict.update({options: arg})
+
+    def build(self):
+        for i in self.outputDict:
+            if self.setVideoFilters(i):
+                continue
+            elif self.setAudioFilters(i):
+                continue
+            else:
+                self.setFormat(i)
+        lst_extra, vf, af = ([] for _ in range(3))
+        for val in self.outputDict:
+            if val == "vf":
+                vf = self.outputDict.get(val).values()
+                vf = ",".join(list(vf))
+            elif val == "af":
+                af = self.outputDict.get(val).values()
+                af = ",".join(list(af))
+            else:
+                lst_extra.append(self.outputDict.get(val))
+        # print(lst_extra, "temp x")
+        # if vf:self.vf=f"-vf '{vf}'"
+        # if af:self.af=f"-af '{af}'"
+        self.vf = f"-vf '{vf}'" if vf else ""
+        self.af = f"-af '{af}'" if af else ""
+        self.extra = " ".join(lst_extra)
+        self.commands = f"{self.vf} {self.af} {self.extra}"
+
+    def startfunc(self, input: gr.components.IOComponent, c_label="", newValue=""):
+        label, *_ = input.label.strip(": ").lower().split(
+        ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+        label += "".join(_).title()
+        if newValue not in [None, "Source", "Auto", "", "None", 0]:
+            self.outputDict["vf"].update({label: newValue})
+            self.outputDict["af"].update({label: newValue})
+            self.outputDict.update({label: newValue})
+        else:
+            self.outputDict.pop(label, "No Key Exists")
+            self.outputDict["vf"].pop(label, "No Key Exists")
+            self.outputDict["af"].pop(label, "No Key Exists")
+            # self.formatOutputDict["vf"].pop(label, "Key is None or similar")
+            # self.formatOutputDict["af"].pop(label, "Key is None or similar")
+            # self.formatOutputDict.pop(label, "Key is None or similar")
+        print(self.outputDict)
+        self.build()
+
+
+# def somefunc(input: gr.components.IOComponent, c_label=""):
+#     label = ""
+#     output = {}
+#     print(input, c_label)
+#     label, *_ = input.label.strip(": ").lower().split(
+#     ) if type(input.label) != list else "".join(input.label).strip(": ").lower().split()
+#     label += "".join(_).title()
+#     print(newoutputMap.get(label), label, c_label)
+#     if c_label not in [None, "Source", "Auto", ""]:
+#         print(input.value)
+#         output.update({label: c_label})
+#     else:
+#         output.pop(label, "No Key Exists")
+#     pprint(output)
+
+# def mediaChange(option):
+#     no_=gr.update(visible=False)
+#     if option in video_containers:
+#         output=gr.update(visible=True)
+#         return [no_,output]
+#     elif option in audio_containers:
+#         output=gr.update(visible=True)
+#         return [output,no_]
+#     else:
+#         output=gr.update(visible=False)
+#         return [no_,no_]
+
+
+def mediaChange(option:str,state)-> List[Component]:
+    """
+        Allows playing the media in various options,
+        Video, Audio or File
+
+    Args:
+        option : Clicked buttons value
+
+    Returns:
+        List[Component]: list of toggled output components to display
+    """
+    ops = {"Audio": gr.update(visible=True,value=state)}
+    ops2 = {"Video": gr.update(visible=True,value=state)}
+    ops3 = {"File": gr.update(visible=True,value=state, interactive=False)}
+
+    def chosen(x): return x.get(option, gr.update(visible=False))
+    return [chosen(ops), chosen(ops2), chosen(ops3)]
+
+
+# def videoChange(value):
+#     print(value.name)
+
+    # if option in video_containers:
+    #     output=gr.update(visible=True)
+    #     return [no_,output]
+    # elif option in audio_containers:
+    #     output=gr.update(visible=True)
+    #     return [output,no_]
+    # else:
+    #     output=gr.update(visible=False)
+    #     return [no_,no_]
+
+
+
+
+"""Helper Functions for Processing """
+
+
+# def clear(*input):
+#     print(input, " clear_func")
+#     # for i in [inp for i in input for inp in i]:
+#     #     print(i, hasattr(i,"cleared_value"),type(i))
+#     # a=default_clear(input_components)
+#     def clear_func(x): return [component.cleared_value if hasattr(
+#         component, "cleared_value") else None for component in x]
+#     print(clear_func(input))
+#     return clear_func(input)
+
+def customBitrate(choice:int)-> Component:
+    """
+        Toggle a component for custom Audio Quality 
+        visible/none
+    Args:
+        choice : Custom audio quality
+
+    Returns:
+        Component: component toggle state
+    """
+    if choice == "Custom":
+        return gr.update(visible=True)
+    else:
+        return gr.update(visible=False, value=0)
+
+
+def supported_codecs(format: str)-> List[Component]:
+    """
+        Changes video and audio components with appropriate 
+        options according to passed format 
+
+    Args:
+        format: passed media codec (x264,x265)
+
+    Returns:
+        List[Component]: list of components with updated choices
+    """
+    if format:
+        format = format.lower()
+    video_lst = [val.get("value") for val in data["codecs"]["video"]
+                 if val.get("supported") == None or format in val["supported"]]
+    audio_lst = [val.get("value") for val in data["codecs"]["audio"]
+                 if val.get("supported") == None or format in val["supported"]]
+    return [gr.update(choices=video_lst), gr.update(choices=audio_lst)]
+
+
+def supported_presets(format: str)-> Component:
+    """ 
+        Changes presets component with appropriate 
+        options according to passed format
+    Args:
+        format: passed media codec (x264,x265)
+
+    Returns:
+        Component: component with updated choice list (video codecs)
+    """ 
+    if format:
+        format = format.lower()
+    video_lst = [val.get("name") for val in data["presets"]
+                 if val.get("supported") == None or format in val["supported"]]
+    return gr.update(choices=video_lst)
+
+
+def change_clipbox(choice:str)-> List[Component]:
+    """
+    Toggles the clipping Textbox 
+    
+    Args:
+        choice: Enabled/None
+
+    Returns:
+        List[Component]: list of components with visible state of the clip components
+    """
+    if choice == "Enabled":
+        return [gr.update(visible=True, value="00:00"), gr.update(visible=True, value="00:10")]
+    else:
+        return [gr.update(visible=False, value=""), gr.update(visible=False, value="")]
+
+
+def updateOutput(file: _TemporaryFileWrapper)-> Component:
+    if file:
+        print(file.name)
+        return gr.update(value=file.name)
+
+
+def get_component_instance(inputs: gr.Blocks)-> List[Component]:
+    """ returns only components
+
+    Args:
+        inputs: layout elements
+
+    Returns:
+        List[Component]: components
+    """
+    return [gr.components.get_component_instance(i, render=True) for i in inputs.children]
+
+
+class Clear(CommandBuilder):
+    """ Class for clearing components in layouts
+    """
+
+    def __call__(self, *args, **kwds):
+        return self._component
+
+    def __str__(self):
+        return f"{self._component} __clear__ class"
+
+    def __repr__(self):
+        return self._component
+
+    def __init__(self, *input_component: gr.Blocks()) -> None:
+        """
+        Parameters:
+            *input_component: A tuple of layout blocks containing components
+        """
+        self._component = []
+        if input_component is not None:
+            for i in input_component:
+                # self._component += super()._get_component_instance(i)
+                self._component += self.__get_component_instance(i)
+
+    def __get_component_instance(self, inputs: gr.Blocks) -> list:
+        # print(inputs, " class instance")
+        res=[]
+        # print(*inputs.children)
+        for i in inputs.children:
+            # print(i,hasattr(i,"children"))
+            if not (hasattr(i,"children")):
+                # res.append(gr.components.get_component_instance(i,render=True))
+                res+=[gr.components.get_component_instance(i,render=True)]
+                # print(i)
+            elif hasattr(i,"children"):
+                # print(*i.children)
+                res+=self.__get_component_instance(i)
+                # res=[gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
+                # print(res,"__ result")
+        # print(res)
+        return res
+        # return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i, "children")]
+
+    def add(self, *args):
+        print(args, type(args))
+        if args is not None:
+            for i in args:
+                self._component += super().__get_component_instance(i)
+        return self._component
+
+    def clear(self, *args):
+        """
+        Function to clear components from a Block in the class instance
+        """
+        def clear_func(x): return [component.cleared_value if hasattr(
+            component, "cleared_value") else component.value for component in x]
+        return clear_func(self._component)

mappings.json

@@ -0,0 +1,62 @@
+{
+    "protocols": "",
+    "startTime": "-ss",
+    "stopTime": "-to",
+
+    "video": "-c:v",
+    "audio": "-c:a",
+    "bitrate": "-b:v",
+    "minrate": "-minrate",
+    "maxrate": "-maxrate",
+    "bufsize": "-bufsize",
+    "gopsize": "-g",
+    "pixelFormat": "-pix_fmt",
+
+    "containers": {
+        "video": "-c:v",
+        "audio": "-c:a"
+    },
+    "clipping": {
+        "startTime": "-ss",
+        "stopTime": "-to"
+    },
+    "codecs": "",
+    "presets": "-preset",
+    "passOptions": "-pass",
+    "pixelformats": "",
+    "frameRates": "-r",
+    "speeds": "",
+    "tunes": "-tune",
+    "profiles": "-profile:v",
+    "levels": "",
+    "fastStart": "-movflags",
+    "sizes": "",
+    "formats": "",
+    "aspects": "-aspect",
+    "scalings": "",
+
+
+    "audioStreams": "",
+    "audioChannels": "-ac",
+    "audioQualities": "-b:a",
+    "sampleRates": "-ar",
+
+    "deband": "deband",
+    "deshake": "deshake",
+    "deflicker": "deflicker",
+    "dejudder": "dejudder",
+    "denoise": {
+        "light": "removegrain=22",
+        "medium": "vaguedenoiser=threshold=3:method=soft:nsteps=5",
+        "heavy": "vaguedenoiser=threshold=6:method=soft:nsteps=5",
+        "default": "removegrain=0"
+    },
+    "deinterlace": {
+        "frame": "yadif=0:-1:0",
+        "field": "yadif=1:-1:0",
+        "frame_nospatial": "yadif=2:-1:0",
+        "field_nospatial": "yadif=3:-1:0"
+    },
+    "extraOptions": "",
+    "logLevels": ""
+}

new_mappings.json

@@ -0,0 +1,68 @@
+{
+    "vf": {
+        "deband": "deband",
+        "deshake": "deshake",
+        "deflicker": "deflicker",
+        "dejudder": "dejudder",
+        "denoise": {
+            "light": "removegrain=22",
+            "medium": "vaguedenoiser=threshold=3:method=soft:nsteps=5",
+            "heavy": "vaguedenoiser=threshold=6:method=soft:nsteps=5",
+            "default": "removegrain=0"
+        },
+        "deinterlace": {
+            "frame": "yadif=0:-1:0",
+            "field": "yadif=1:-1:0",
+            "frame_nospatial": "yadif=2:-1:0",
+            "field_nospatial": "yadif=3:-1:0"
+        }
+    },
+    "af": {
+        "acontrast": "0"
+    },
+    "protocols": "",
+    "startTime": "-ss",
+    "stopTime": "-to",
+
+    "video": "-c:v",
+    "audio": "-c:a",
+    "bitrate": "-b:v",
+    "minrate": "-minrate",
+    "maxrate": "-maxrate",
+    "bufsize": "-bufsize",
+    "gopsize": "-g",
+    "pixelFormat": "-pix_fmt",
+
+    "containers": {
+        "video": "-c:v",
+        "audio": "-c:a"
+    },
+    "clipping": {
+        "startTime": "-ss",
+        "stopTime": "-to"
+    },
+    "codecs": "",
+    "presets": "-preset",
+    "passOptions": "-pass",
+    "pixelformats": "",
+    "frameRates": "-r",
+    "speeds": "",
+    "tunes": "-tune",
+    "profiles": "-profile:v",
+    "levels": "",
+    "fastStart": "-movflags",
+    "sizes": "",
+    "formats": "",
+    "aspects": "-aspect",
+    "scalings": "",
+
+
+    "audioStreams": "",
+    "audioChannels": "-ac",
+    "audioQualities": "-b:a",
+    "sampleRates": "-ar",
+
+
+    "extraOptions": "",
+    "logLevels": ""
+}

output.json

@@ -0,0 +1,46 @@
+{
+    "format": {
+      "container": "mp4",
+      "clip": false
+    },
+    "video": {
+      "codec": "libx264",
+      "preset": "none",
+      "pass": "1",
+      "crf": 23,
+      "pixel_format": "auto",
+      "frame_rate": "auto",
+      "speed": "auto",
+      "tune": "none",
+      "profile": "none",
+      "level": "none",
+      "faststart": false,
+      "size": "source",
+      "width": "1080",
+      "height": "1920",
+      "format": "widescreen",
+      "aspect": "auto",
+      "scaling": "auto",
+      "codec_options": ""
+    },
+    "audio": {
+      "codec": "copy",
+      "channel": "source",
+      "quality": "auto",
+      "sampleRate": "auto",
+      "volume": "100"
+    },
+    "filter": {
+      "deband": false,
+      "deshake": false,
+      "deflicker": false,
+      "dejudder": false,
+      "denoise": "none",
+      "deinterlace": "none",
+      "brightness": "0",
+      "contrast": "1",
+      "saturation": "0",
+      "gamma": "0",
+      "acontrast": "33"
+    }
+  }

requirements.txt

@@ -0,0 +1,61 @@
+aiohttp==3.8.1
+aiosignal==1.2.0
+analytics-python==1.4.0
+anyio==3.6.1
+async-timeout==4.0.2
+attrs==22.1.0
+backoff==1.10.0
+bcrypt==4.0.0
+certifi==2022.6.15
+cffi==1.15.1
+charset-normalizer==2.1.1
+click==8.1.3
+cryptography==37.0.4
+cycler==0.11.0
+fastapi==0.81.0
+ffmpy==0.3.0
+fonttools==4.37.1
+frozenlist==1.3.1
+fsspec==2022.7.1
+gradio==3.3.1
+h11==0.12.0
+httpcore==0.15.0
+httpx==0.23.0
+idna==3.3
+Jinja2==3.1.2
+kiwisolver==1.4.4
+linkify-it-py==1.0.3
+markdown-it-py==2.1.0
+MarkupSafe==2.1.1
+matplotlib==3.5.3
+mdit-py-plugins==0.3.0
+mdurl==0.1.2
+monotonic==1.6
+multidict==6.0.2
+numpy==1.23.2
+orjson==3.8.0
+packaging==21.3
+pandas==1.4.3
+paramiko==2.11.0
+Pillow==9.2.0
+pycparser==2.21
+pycryptodome==3.15.0
+pydantic==1.9.2
+pydub==0.25.1
+PyNaCl==1.5.0
+pyparsing==3.0.9
+python-dateutil==2.8.2
+python-multipart==0.0.5
+pytz==2022.2.1
+PyYAML==6.0
+requests==2.28.1
+rfc3986==1.5.0
+six==1.16.0
+sniffio==1.2.0
+starlette==0.19.1
+typing-extensions==4.3.0
+uc-micro-py==1.0.1
+urllib3==1.26.12
+uvicorn==0.18.3
+websockets==10.3
+yarl==1.8.1

styles.css

@@ -0,0 +1,9 @@
+#outputtext {
+  color: green;
+}
+#acontrast {
+  width: 50%;
+}
+#button{
+  width: 30%
+}