Added multiple filters and options;added Video,audio and file view

.gitignore

@@ -1 +1,3 @@
-flagged
+__pycache__/
+*.pyc
+flagged/

app.py

@@ -1,46 +1,205 @@
+import json
 import logging
 import os
 import subprocess
+from pprint import pprint
 from tempfile import _TemporaryFileWrapper
 
 from ffmpy import FFmpeg
 
 import gradio as gr
+from functions import (Clear, CommandBuilder, change_clipbox, customBitrate, mediaChange,
+                       supported_codecs, supported_presets, updateOutput, videoChange)
 
 logging.basicConfig(level=logging.INFO)
 
-def convert(file:_TemporaryFileWrapper,options:list,):
-	logging.info(f"Current working path :{os.getcwd()}")
-	logging.info(f"File name: {file.name}")
-	# options.append(["Boy","Girl"])
-	new_name,_=file.name.split(".")
-	logging.info(f"New filename:{new_name}")
-	cm=["ffmpeg","-y","-i",file.name,f"{new_name}.{options}"]
-	output_file=f"{new_name}.{options}"	
-	ffmpeg=FFmpeg(inputs={file.name:None},outputs={output_file:None},global_options=["-y","-hide_banner"])
-	print(ffmpeg)
-	ffmpeg.run()
-	# subprocess.run(cm,text=True)
-	# gr.CheckboxGroup(choices=["Fast","HD"])
-	return [output_file,ffmpeg]
-	
-app=gr.Interface(fn=convert,inputs=[gr.File(),gr.Radio(choices=["mp3","ogg","flac","wav"])],outputs=[gr.Audio(),"text"],flagging_dir="flagged")
-app.launch(server_port=3000)
-# cm=["ffmpeg","-i","/home/accel/Documents/Denouement.ogg","/home/accel/Documents/Denouement.mp3"]
-
-# subprocess.run(cm,text=True)
-# dm=gr.Blocks()
-# with dm:
-# 	gr.Markdown("Something")
-# 	with gr.Tabs():
-# 		with gr.TabItem("A tab"):
-# 			text_input=gr.Textbox()
-# 			text_output=gr.Textbox()
-# 			text_button=gr.Button("Action")
-# 		with gr.TabItem("Second tab"):
-# 			with gr.Row():
-# 				txt_input=gr.Textbox()
-# 				txt_output=gr.Textbox()
-# 				txt_button=gr.Button("Play")
-# 	text_button.click(hello,inputs=text_input,outputs=text_output)
-# dm.launch()
+choices = ["mp3", "ogg", "flac", "wav"]
+
+
+def parse(param: json) -> dict:
+    with open(param) as file:
+        return json.load(file)
+
+# global inputs,inputs_clip
+data = parse("./data.json")
+
+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("name") 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("name") 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"]]
+
+logging.info(msg=f"{video_containers}")
+
+
+def convert(file: _TemporaryFileWrapper, options: str):
+    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)
+
+        stdout, stderr=ffmpeg.run(stderr=subprocess.PIPE)
+        logging.info(f"{stdout} {stderr}")
+        output=f"{ffmpeg.cmd}"
+        video=gr.update(label=output_file,value=output_file)
+
+    except Exception as e:
+        stderr=e
+        output=f"{ffmpeg.cmd} {stderr}"
+
+    return [output_file,output_file,video,output]
+
+
+
+"""Helper Functions for Processing """
+
+
+
+def get_component_instance(inputs: gr.Blocks) -> list:
+    return [gr.components.get_component_instance(i, render=True) for i in inputs.children if not hasattr(i,"children")]
+
+# names=[{x:i} for x in ["audioChannels","audioQualities"] for i in [[i.get("name")  for i in data[x]]]]
+with gr.Blocks(css="./styles.css") as dm:
+    gr.Markdown("Something")
+    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() 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)
+                        stop_time = gr.Textbox(
+                            label="Stop Time:", placeholder="00:00", visible=False)
+                    with gr.Row().style(mobile_collapse=False):
+                        clearBtn = gr.Button("Clear")
+                        convertBtn = gr.Button("Convert", variant="primary")
+
+                # Output Buttons
+                with gr.Column():
+                    # media_output = gr.Audio(label="Output")
+                    with gr.Row().style(mobile_collapse=False):
+                        video_button=gr.Button("Video")
+                        audio_button=gr.Button("Audio")
+                        file_button=gr.Button("File")
+                    media_output_audio = gr.Audio(label="Output",visible=True,interactive=False,source="filepath")
+                    media_output_video = gr.Video(label="Output",visible=False,format="mp4")
+                    media_output_file = gr.File(label="Output",visible=False)
+                    output_textbox = gr.Textbox(elem_id="outputtext")
+                
+                resetFormat=Clear(inputs,inputs_clip)
+                clearBtn.click(resetFormat.clear, inputs=resetFormat(), outputs=resetFormat())
+                convertBtn.click(convert, inputs=[file_input, options], outputs=[
+                    media_output_audio,media_output_file,media_output_video, output_textbox])
+
+        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.Column():
+                clearBtn = gr.Button("Clear")
+            videoReset=Clear(video_inputs)
+            clearBtn.click(videoReset.clear, videoReset(), videoReset())
+
+        with gr.TabItem("Audio"):
+            with gr.Row().style(mobile_collapse=False) 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():
+                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,mobile_collapse=False) 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() as filter_inputs_1:
+                acontrastSlider=gr.Slider(label="Acontrast", elem_id="aconstrast")
+
+            with gr.Column():
+                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()
+    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],[media_output_audio,media_output_video,media_output_file])
+    video_button.click(mediaChange,[video_button],[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],[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])
+    
+dm.launch()

codecs.json

@@ -0,0 +1,23 @@
+{
+    "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"
+    },
+    "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,345 @@
+import json
+from pprint import pprint
+from tempfile import _TemporaryFileWrapper
+
+import gradio as gr
+
+
+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("name") 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("name") 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")
+"""Output Mappings of commands to value
+   audioQuality -b:a 128k 
+"""
+
+
+class CommandBuilder():
+    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.startfunc(comp,"",comp.value)
+
+    def __init__(self, *inputs: gr.Blocks) -> None:
+        self.outputDict = {}
+        self.formatOutputDict = {"vf": {}, "af": {}}
+        # state=gr.Variable()
+        # state2=gr.Variable()
+
+        self._component: list[gr.components.Changeable] = []
+        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 update(self, Component: gr.components.IOComponent):
+        for comp in self._component:
+            comp.change(lambda: gr.update(
+                value=self.commands), [], [Component])
+
+    def _get_component_instance(self, inputs: gr.Blocks) -> "list[gr.components.Component]":
+        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 = outputMap.get(options, None)
+        arg = ""
+        if options in ["deinterlace", "denoise"]:
+            value = "_".join(value.lower().split())
+            arg = filters.get(value, None)
+            # self.vf.append(arg)
+            self.formatOutputDict["vf"].update({options: arg})
+            return True
+        if options in ["deband", "deflicker", "deshake", "dejudder"]:
+            arg = filters
+            self.formatOutputDict["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.formatOutputDict["af"].update({options: arg})
+            return True
+        return
+
+    def setFormat(self, options):
+        value = self.outputDict.get(options, "-")
+        filters = outputMap.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.formatOutputDict.update({options: arg})
+            return True
+        elif data.get(options) == None:
+            arg = f"{filters} {value}"
+            self.formatOutputDict.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.formatOutputDict.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.formatOutputDict:
+            if val == "vf":
+                vf = self.formatOutputDict.get(val).values()
+                vf = ",".join(list(vf))
+            elif val == "af":
+                af = self.formatOutputDict.get(val).values()
+                af = ",".join(list(af))
+            else:
+                lst_extra.append(self.formatOutputDict.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 changefunc(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.update({label: newValue})
+        else:
+            self.outputDict.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")
+        self.build()
+        print(self.commands,"   self.commands")
+        print(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.update({label: newValue})
+        else:
+            self.outputDict.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")
+        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(outputMap.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):
+    no_=gr.update(visible=False)
+    output=gr.update(visible=True)
+    ops={"Audio":gr.update(visible=True)}
+    ops2={"Video":gr.update(visible=True)}
+    ops3={"File":gr.update(visible=True,interactive=False)}
+    # if option.lower()!="mp4" and option in video_containers:
+    #     option="mp4"
+    chosen=lambda x:x.get(option,gr.update(visible=False))
+    print(chosen(ops2),ops2.get(option,no_))
+    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_]
+
+
+def customBitrate(choice):
+    if choice == "Custom":
+        return gr.update(visible=True, value=None)
+    else:
+        return gr.update(visible=False, value=None)
+
+
+def supported_codecs(format: str, a=data):
+    # lst=[i for i in a["codecs"]["audio"]
+    # if i.get("supported")==None or "ogg" in i["supported"]]
+    if format:
+        format = format.lower()
+    video_lst = [val.get("name") for val in a["codecs"]["video"]
+                 if val.get("supported") == None or format in val["supported"]]
+    audio_lst = [val.get("name") for val in a["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, a=data):
+    if format:
+        format = format.lower()
+    video_lst = [val.get("name") for val in a["presets"]
+                 if val.get("supported") == None or format in val["supported"]]
+    print(format, video_lst)
+    return gr.update(choices=video_lst)
+
+
+"""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 change_clipbox(choice):
+    print(gr.Dropdown().postprocess("clip test"))
+    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):
+    if file:
+        print(file.name)
+        return gr.update(value=file.name)
+
+
+def get_component_instance(inputs: gr.Blocks) -> list:
+    return [gr.components.get_component_instance(i, render=True) for i in inputs.children]
+
+
+class Clear(CommandBuilder):
+    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:
+        self._component = []
+        if input_component is not None:
+            for i in input_component:
+                self._component += super()._get_component_instance(i)
+
+    def __get_component_instance(self, inputs: gr.Blocks) -> list:
+        # print(inputs, " class instance")
+        # res=[]
+        # for i in inputs.children:
+        #     print(hasattr(i,"children"))
+        #     if not (hasattr(i,"children")):
+        #         res.append(gr.components.get_component_instance(i,render=True))
+        #         print(i)
+        #     elif hasattr(i,"children"):
+        #         continue
+        # 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 += self.__get_component_instance(i)
+        return self._component
+
+    def clear(self, *args):
+        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": ""
+}

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"
+    }
+  }

styles.css

@@ -0,0 +1,6 @@
+#outputtext {
+  color: green;
+}
+#aconstrast {
+  width: 50%;
+}