🚀 Upload Project From My GitHub

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+Models/* filter=lfs diff=lfs merge=lfs -text
+Temp/* filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

.github/copilot-instructions.md

@@ -0,0 +1,3 @@
+Use Pascal Case for Variables, Classes, Functions and Methods
+Do not include comments under functions
+use single quotes

Diff.py

@@ -0,0 +1,151 @@
+import numpy as np
+import cv2
+import time
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+Logger = logging.getLogger(__name__)
+
+def MergeBoxes(Boxes, Padding=5):
+    if len(Boxes) <= 1:
+        return Boxes
+    MergedOccurred = True
+    while MergedOccurred:
+        MergedOccurred = False
+        NewBoxes = []
+        Boxes.sort(key=lambda b: b[0])
+        Used = [False] * len(Boxes)
+        for Index in range(len(Boxes)):
+            if Used[Index]:
+                continue
+            CurrentBox = list(Boxes[Index])
+            Used[Index] = True
+            for J in range(Index + 1, len(Boxes)):
+                if Used[J]:
+                    continue
+                NextBox = Boxes[J]
+                OverlapX = max(CurrentBox[0], NextBox[0]) <= min(CurrentBox[0] + CurrentBox[2], NextBox[0] + NextBox[2]) + Padding
+                OverlapY = max(CurrentBox[1], NextBox[1]) <= min(CurrentBox[1] + CurrentBox[3], NextBox[1] + NextBox[3]) + Padding
+                if OverlapX and OverlapY:
+                    NewX = min(CurrentBox[0], NextBox[0])
+                    NewY = min(CurrentBox[1], NextBox[1])
+                    NewW = max(CurrentBox[0] + CurrentBox[2], NextBox[0] + NextBox[2]) - NewX
+                    NewH = max(CurrentBox[1] + CurrentBox[3], NextBox[1] + NextBox[3]) - NewY
+                    CurrentBox = [NewX, NewY, NewW, NewH]
+                    Used[J] = True
+                    MergedOccurred = True
+            NewBoxes.append(tuple(CurrentBox))
+        Boxes = NewBoxes
+    return Boxes
+
+def GetChangeMask(Image1, Image2, Threshold=25, MinArea=100):
+    if Image1.shape != Image2.shape:
+        Logger.warning(f'Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2.')
+        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
+
+    Gray1 = cv2.cvtColor(Image1, cv2.COLOR_BGR2GRAY)
+    Gray2 = cv2.cvtColor(Image2, cv2.COLOR_BGR2GRAY)
+    Blur1 = cv2.GaussianBlur(Gray1, (5, 5), 0)
+    Blur2 = cv2.GaussianBlur(Gray2, (5, 5), 0)
+    DiffFrame = cv2.absdiff(Blur1, Blur2)
+    _, ThresholdCalc = cv2.threshold(DiffFrame, Threshold, 255, cv2.THRESH_BINARY)
+    Kernel = np.ones((5, 5), np.uint8)
+    DilatedThreshold = cv2.dilate(ThresholdCalc, Kernel, iterations=2)
+
+    Contours, _ = cv2.findContours(DilatedThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    OutputMask = np.zeros_like(DilatedThreshold)
+    ValidContours = 0
+    if Contours:
+        for Contour in Contours:
+            if cv2.contourArea(Contour) > MinArea:
+                cv2.drawContours(OutputMask, [Contour], -1, 255, -1) # type: ignore
+                ValidContours +=1
+    Logger.info(f'GetChangeMask: Found {len(Contours)} raw contours, kept {ValidContours} after MinArea filter ({MinArea}).')
+    return OutputMask
+
+def VisualizeDifferences(Image1Path, Image2Path, OutputPath, Threshold=25, MinArea=100, OutlineColor=(0, 255, 0), FillColor=(0, 180, 0), FillAlpha=0.3):
+    Logger.info(f'🎨 Visualizing differences between {Image1Path} and {Image2Path}')
+    Image1 = cv2.imread(Image1Path)
+    Image2 = cv2.imread(Image2Path)
+
+    if Image1 is None or Image2 is None:
+        Logger.error(f'❌ Error loading images for visualization: {Image1Path} or {Image2Path}')
+        return
+
+    if Image1.shape != Image2.shape:
+        Logger.warning(f'⚠️ Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2 for visualization.')
+        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
+
+    ChangedMask = GetChangeMask(Image1, Image2, Threshold, MinArea)
+    OutputImage = Image2.copy()
+    Overlay = OutputImage.copy()
+
+    # Apply fill color to changed areas
+    Overlay[ChangedMask == 255] = FillColor
+    cv2.addWeighted(Overlay, FillAlpha, OutputImage, 1 - FillAlpha, 0, OutputImage)
+
+    # Find contours of the changed areas to draw outlines
+    Contours, _ = cv2.findContours(ChangedMask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    cv2.drawContours(OutputImage, Contours, -1, OutlineColor, 2)
+    Logger.info(f'🎨 Drew {len(Contours)} difference regions.')
+
+    try:
+        cv2.imwrite(OutputPath, OutputImage)
+        Logger.info(f'💾 Saved difference visualization to {OutputPath}')
+    except Exception as E:
+        Logger.error(f'❌ Failed to save visualization {OutputPath}: {E}')
+
+# --- Function to be used in App.py for upscaling ---
+def GetChangedRegions(Image1, Image2, Threshold=25, Padding=10, MinArea=100, MergePadding=5):
+    StartTime = time.time()
+    Logger.info('🔄 Comparing images...')
+
+    if Image1 is None or Image2 is None:
+        Logger.error('❌ Cannot compare None images.')
+        return []
+
+    if Image1.shape != Image2.shape:
+        Logger.warning(f'⚠️ Image shapes differ: {Image1.shape} vs {Image2.shape}. Resizing Image2.')
+        Image2 = cv2.resize(Image2, (Image1.shape[1], Image1.shape[0]))
+
+    Gray1 = cv2.cvtColor(Image1, cv2.COLOR_BGR2GRAY)
+    Gray2 = cv2.cvtColor(Image2, cv2.COLOR_BGR2GRAY)
+    Blur1 = cv2.GaussianBlur(Gray1, (5, 5), 0)
+    Blur2 = cv2.GaussianBlur(Gray2, (5, 5), 0)
+    DiffFrame = cv2.absdiff(Blur1, Blur2)
+    _, ThresholdCalc = cv2.threshold(DiffFrame, Threshold, 255, cv2.THRESH_BINARY)
+    Kernel = np.ones((5, 5), np.uint8)
+    DilatedThreshold = cv2.dilate(ThresholdCalc, Kernel, iterations=2)
+    Contours, _ = cv2.findContours(DilatedThreshold, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    Logger.info(f'🔎 Found {len(Contours)} raw contours.')
+
+    BoundingBoxes = []
+    if Contours:
+        ValidContours = 0
+        for Contour in Contours:
+            ContourArea = cv2.contourArea(Contour)
+            if ContourArea > MinArea:
+                ValidContours += 1
+                X, Y, W, H = cv2.boundingRect(Contour)
+                PaddedX = max(0, X - Padding)
+                PaddedY = max(0, Y - Padding)
+                MaxW = Image1.shape[1] - PaddedX
+                MaxH = Image1.shape[0] - PaddedY
+                PaddedW = min(W + (Padding * 2), MaxW)
+                PaddedH = min(H + (Padding * 2), MaxH)
+                BoundingBoxes.append((PaddedX, PaddedY, PaddedW, PaddedH))
+        Logger.info(f'📊 Filtered {ValidContours} contours based on MinArea ({MinArea}).')
+
+    InitialBoxCount = len(BoundingBoxes)
+    MergedBoundingBoxes = MergeBoxes(BoundingBoxes, MergePadding)
+    EndTime = time.time()
+    if MergedBoundingBoxes:
+        Logger.info(f'📦 Merged {InitialBoxCount} boxes into {len(MergedBoundingBoxes)} regions.')
+    else:
+        Logger.info('❌ No significant changed regions found after filtering and merging.')
+    Logger.info(f'⏱️ Region finding took {EndTime - StartTime:.3f}s')
+    return MergedBoundingBoxes
+
+# Example call for the new visualization function
+VisualizeDifferences(r'C:\Users\joris\Pictures\frame_01660.png', r'C:\Users\joris\Pictures\frame_01661.png', './Diff.png', 25, 100, (0, 255, 0), (0, 180, 0), 0.3)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Boyang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Models/2x_AniSD_G6i1_SPAN_215K.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:12269fb1f76c8f62a3ccf099abcd4d4ef25989a9cf3c023cec77eec6eb9f9f2f
+size 8958448

Models/2x_AniScale2_Omni_i16_40K.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df55746a97a22e157cf4a7fd0841da06d7f2b383ee7f7cd940a3a3d4cba5926b
+size 3405370

Models/2x_ModernSpanimationV2.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0fa4785bf6808edf3c9bc859da15444cfb7fdcedb201d2ee38f57f3b5c2ed89d
+size 8958239

Models/2x_sudo_shuffle_span_10.5m.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73c650d82db19f571e1c7312629aa9021a7fde409c78f1dc462256784c6e963c
+size 16493242

Models/BSRGAN.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5d505a0766160921e0388d76e1ddf08cb114303990f9080432bf2b1c988b1c54
+size 67046751

Models/cugan_pro-conservative-up2x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8ae5225d2d515aa3c33ef1318aadc532a42ea5ed8d564471b5a5b586783e964
+size 5155761

Models/cugan_pro-conservative-up3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a9f3c783a04b15c793b95e332bfdac524cfa30ba186cb829c1290593e28ad9e7
+size 5162673

Models/cugan_pro-denoise3x-up2x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e80ca8fc7c261e3dc8f4c0ce0656ac5501d71a476543071615c43392dbeb4c0d
+size 5155761

Models/cugan_pro-denoise3x-up3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4ddd14e2430db0d75d186c6dda934db34929c50da8a88a0c6f4accb871fe4b70
+size 5162673

Models/cugan_pro-no-denoise-up2x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ccce1f535d94c50ce38e268a53687bc7e68ef7215e3c5e6b3bfd1bfc1dacf0fa
+size 5155761

Models/cugan_pro-no-denoise-up3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c14d693a6d3316b8a3eba362e7576f178aea3407e1d89ca0bcb34e1c61269b0f
+size 5162673

Models/cugan_up2x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cfe3b23687915d08ba96010f25198d9cfe8a683aa4131f1acf7eaa58ee1de93
+size 5147249

Models/cugan_up2x-latest-denoise1x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e783c39da6a6394fbc250fdd069c55eaedc43971c4f2405322f18949ce38573
+size 5147249

Models/cugan_up2x-latest-denoise2x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8188b3faef4258cf748c59360cbc8086ebedf4a63eb9d5d6637d45f819d32496
+size 5147249

Models/cugan_up2x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a14739f3f5fcbd74ec3ce2806d13a47916c916b20afe4a39d95f6df4ca6abd8
+size 5147249

Models/cugan_up2x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f491f9ecf6964ead9f3a36bf03e83527f32c6a341b683f7378ac6c1e2a5f0d16
+size 5147249

Models/cugan_up3x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6ea5fd20380413beb2701182483fd80c2e86f3b3f08053eb3df4975184aefe3
+size 5154161

Models/cugan_up3x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39f1e6e90d50e5528a63f4ba1866bad23365a737cbea22a80769b2ec4c1c3285
+size 5154161

Models/cugan_up3x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:763f0a87e70d744673f1a41db5396d5f334d22de97fff68ffc40deb91404a584
+size 5154161

Models/cugan_up4x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8c8185def699b0883662a02df0ef2e6db3b0275170b6cc0d28089b64b273427
+size 5636403

Models/cugan_up4x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42bd8fcdae37c12c5b25ed59625266bfa65780071a8d38192d83756cb85e98dd
+size 5636403

Models/cugan_up4x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaf3ef78a488cce5d3842154925eb70ff8423b8298e2cd189ec66eb7f6f66fae
+size 5636403

Models/sudo_UltraCompact_2x_1.121.175_G.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e53987f0312dee424b4dbd9dce7b2eacbe03fdf1380e44a11f8a4d2ca88c99e3
+size 1226766

README.md

@@ -5,7 +5,7 @@ colorFrom: indigo
 colorTo: pink
 sdk: gradio
 sdk_version: 5.29.0
-app_file: app.py
+app_file: App.py
 pinned: false
 license: mit
 short_description: ♻️ Upscale any video using several models

app.py

@@ -1,7 +1,285 @@
-import gradio as gr
+from spandrel import ModelLoader
+import torch
+from pathlib import Path
+from PIL import Image
+import gradio as App
+import numpy as np
+import subprocess
+import logging
+import spaces
+import time
+import os
+import gc
+import io
+import cv2
 
-def greet(name):
-    return "Hello " + name + "!!"
+from gradio import themes
+from rich.console import Console
+from rich.logging import RichHandler
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+# ============================== #
+#          Core Settings         #
+# ============================== #
+
+Theme = themes.Citrus(primary_hue='blue', radius_size=themes.sizes.radius_xxl)
+ModelDir = Path('./Models')
+TempDir = Path('./Temp')
+os.environ['GRADIO_TEMP_DIR'] = str(TempDir)
+ModelFileType = '.pth'
+
+# ============================== #
+#        Enhanced Logging        #
+# ============================== #
+
+logging.basicConfig(level=logging.INFO, format='%(message)s', datefmt='[%X]',
+					handlers=[RichHandler(console=Console(), rich_tracebacks=True)])
+Logger = logging.getLogger('Video2x')
+logging.getLogger('httpx').setLevel(logging.WARNING)
+
+# ============================== #
+#      Device Configuration      #
+# ============================== #
+
+@spaces.GPU
+def GetDeviceName():
+	Device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+	Logger.info(f'⚙️ Using device: {Device}')
+	return Device
+
+Device = GetDeviceName()
+
+# ============================== #
+#      Optimized Functions       #
+# ============================== #
+
+def FormatTimeEstimate(Seconds):
+	Hours = int(Seconds // 3600)
+	Minutes = int((Seconds % 3600) // 60)
+	Seconds = int(Seconds % 60)
+
+	if Hours > 0:
+		return f'{Hours}h {Minutes}m {Seconds}s'
+	elif Minutes > 0:
+		return f'{Minutes}m {Seconds}s'
+	else:
+		return f'{Seconds}s'
+
+def ListModels():
+	Models = sorted([File.name for File in ModelDir.glob('*' + ModelFileType) if File.is_file()])
+	Logger.info(f'📚 Found {len(Models)} Models In Directory')
+	return Models
+
+def LoadModel(ModelName):
+	if Device.type == 'cuda':
+		torch.cuda.empty_cache()
+	Logger.info(f'🔄 Loading model: {ModelName} onto {Device}')
+	Model = ModelLoader().load_from_file(ModelDir / (ModelName + ModelFileType)).to(Device).eval() # Use .to(Device)
+	Logger.info('✅ Model Loaded Successfully')
+	return Model
+
+@spaces.GPU
+def ProcessSingleFrame(OriginalImage, Model, TileGridSize):
+	if TileGridSize > 1:
+		Logger.info(f'🧩 Processing With Tile Grid {TileGridSize}x{TileGridSize}')
+		Width, Height = OriginalImage.size
+		TileWidth, TileHeight = Width // TileGridSize, Height // TileGridSize
+		UpscaledTilesGrid = []
+
+		for Row in range(TileGridSize):
+			CurrentRowTiles = []
+			for Col in range(TileGridSize):
+				Tile = OriginalImage.crop((Col * TileWidth, Row * TileHeight,
+										  (Col + 1) * TileWidth, (Row + 1) * TileHeight))
+				TileTensor = torch.from_numpy(np.array(Tile)).permute(2, 0, 1).unsqueeze(0).float().to(Device) / 255.0
+
+				with torch.no_grad():
+					UpscaledTileTensor = Model(TileTensor)
+
+				UpscaledTileNumpy = UpscaledTileTensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
+				CurrentRowTiles.append(Image.fromarray(np.uint8(UpscaledTileNumpy.clip(0.0, 1.0) * 255.0), mode='RGB'))
+				del TileTensor, UpscaledTileTensor, UpscaledTileNumpy
+			UpscaledTilesGrid.append(CurrentRowTiles)
+
+		FirstTileWidth, FirstTileHeight = UpscaledTilesGrid[0][0].size
+		UpscaledImage = Image.new('RGB', (FirstTileWidth * TileGridSize, FirstTileHeight * TileGridSize))
+
+		for Row in range(TileGridSize):
+			for Col in range(TileGridSize):
+				UpscaledImage.paste(UpscaledTilesGrid[Row][Col], (Col * FirstTileWidth, Row * FirstTileHeight))
+	else:
+		TorchImage = torch.from_numpy(np.array(OriginalImage)).permute(2, 0, 1).unsqueeze(0).float().to(Device) / 255.0
+		with torch.no_grad():
+			ResultTensor = Model(TorchImage)
+		ResultNumpy = ResultTensor.squeeze(0).permute(1, 2, 0).cpu().numpy()
+		UpscaledImage = Image.fromarray(np.uint8(ResultNumpy.clip(0.0, 1.0) * 255.0), mode='RGB')
+		del TorchImage, ResultTensor, ResultNumpy
+
+	return UpscaledImage
+
+@spaces.GPU
+def Process(VideoInputPath, ModelName, FrameRateValue, TileGridSize, FileType, Progress=App.Progress()):
+	# First yield should match the order of outputs in the click function
+	yield None, App.update(interactive=False, value=None)
+
+	if not VideoInputPath or not ModelName or not FileType:
+		Logger.error('⛔ Missing Inputs!')
+		return None, None
+
+	VideoPath = Path(VideoInputPath)
+	OutputVideoPath = VideoPath.parent / f'{VideoPath.stem}_{Path(ModelName).stem}{"_Tiled" + str(TileGridSize) if TileGridSize > 1 else ""}{FileType}'
+
+	# Load model
+	Progress(0.0, '🔄 Loading Model')
+	Model = LoadModel(ModelName)
+
+	# Extract video info
+	Logger.info(f'🎬 Extracting Video Information From {VideoPath.name}')
+	VideoCapture = cv2.VideoCapture(str(VideoPath))
+	FrameCount = int(VideoCapture.get(cv2.CAP_PROP_FRAME_COUNT))
+
+	if not FrameRateValue:
+		FrameRateValue = VideoCapture.get(cv2.CAP_PROP_FPS)
+
+	Logger.info(f'🎞️ Processing {FrameCount} Frames At {FrameRateValue} FPS')
+
+	# In-memory frames processing
+	FrameBuffer = []
+	AllFrames = []
+
+	# Time tracking variables
+	StartTime = time.time()
+	FrameProcessingTime = None
+
+	for FrameIndex in range(FrameCount):
+		FrameStartTime = time.time()
+
+		Success, Frame = VideoCapture.read()
+		if not Success:
+			Logger.warning(f'⚠️ Failed To Read Frame {FrameIndex}')
+			continue
+
+		# Convert from BGR to RGB
+		OriginalImage = Image.fromarray(cv2.cvtColor(Frame, cv2.COLOR_BGR2RGB))
+		UpscaledImage = ProcessSingleFrame(OriginalImage, Model, TileGridSize)
+
+		# Store for preview
+		ResizedOriginalImage = OriginalImage.resize(UpscaledImage.size, Image.Resampling.LANCZOS)
+		AllFrames.append((ResizedOriginalImage, UpscaledImage.copy()))
+
+		# Save to buffer for video output
+		ImageBytes = io.BytesIO()
+		UpscaledImage.save(ImageBytes, format='PNG')
+		FrameBuffer.append(ImageBytes.getvalue())
+
+		# Calculate time estimates
+		CurrentFrameTime = time.time() - FrameStartTime
+
+		if FrameIndex == 0:
+			FrameProcessingTime = CurrentFrameTime
+			Logger.info(f'⏱️ First Frame Took {FrameProcessingTime:.2f}s To Process')
+
+		# Calculate remaining time based on average processing time so far
+		ElapsedTime = time.time() - StartTime
+		AverageTimePerFrame = ElapsedTime / (FrameIndex + 1)
+		RemainingFrames = FrameCount - (FrameIndex + 1)
+		EstimatedRemainingTime = RemainingFrames * AverageTimePerFrame
+
+		# Format time estimates for display
+		RemainingTimeFormatted = FormatTimeEstimate(EstimatedRemainingTime)
+
+		Progress(
+			(FrameIndex + 1) / FrameCount,
+			f'🔄 Frame {FrameIndex+1}/{FrameCount} | ETA: {RemainingTimeFormatted}'
+		)
+
+		del OriginalImage, UpscaledImage, ImageBytes
+		gc.collect()
+
+	VideoCapture.release()
+
+	# Write frames to temporary files for ffmpeg
+	Logger.info('💾 Preparing Frames For Video Encoding')
+	os.makedirs(TempDir, exist_ok=True)
+
+	for Index, FrameData in enumerate(FrameBuffer):
+		with open(f'{TempDir}/Frame_{Index:06d}.png', 'wb') as f:
+			f.write(FrameData)
+
+	# Create video
+	Progress(1.0, '🎥 Encoding Video')
+	Logger.info('🎥 Encoding Final Video')
+	FfmpegCmd = f'ffmpeg -y -framerate {FrameRateValue} -i "{TempDir}/Frame_%06d.png" -c:v libx264 -pix_fmt yuv420p "{OutputVideoPath}" -hide_banner -loglevel error'
+	subprocess.run(FfmpegCmd, shell=True, check=True)
+
+	# Clean up
+	for File in Path(TempDir).glob('Frame_*.png'):
+		File.unlink()
+
+	Logger.info(f'🎉 Video Saved To: {OutputVideoPath}')
+
+	# Update UI - return values directly in the order specified in the click function
+	FirstFrame = AllFrames[0] if AllFrames else None
+	DownloadValue = App.update(interactive=True, value=str(OutputVideoPath))
+	yield FirstFrame, DownloadValue
+
+	# Release resources
+	del Model, FrameBuffer, AllFrames
+	Progress(1.0, '🧹 Cleaning Up Resources')
+	gc.collect()
+	if Device.type == 'cuda':
+		torch.cuda.empty_cache()
+		Logger.info('🧹 CUDA Memory Cleaned Up')
+	Logger.info('🧹 Model Unloaded')
+	Progress(1.0, '📦 Done!')
+
+# ============================== #
+#          Streamlined UI        #
+# ============================== #
+
+with App.Blocks(title='Video Upscaler', theme=Theme, delete_cache=(60, 600)) as Interface:
+	App.Markdown('# 🎞️ Video Upscaler')
+	App.Markdown('''
+			  Space created by [Hyphonical](https://huggingface.co/Hyphonical), this space uses several models from [styler00dollar/VSGAN-tensorrt-docker](https://github.com/styler00dollar/VSGAN-tensorrt-docker/releases/tag/models)
+			  You may always request adding more models by opening a [new discussion](https://huggingface.co/spaces/Hyphonical/Video2x/discussions/new). The main program uses spandrel to load the models and ffmpeg to process the video.
+			  You may run out of time using the ZeroGPU, you could clone the space or run it locally for better performance.
+			  ''')
+
+	with App.Row():
+		with App.Column(scale=1):
+			with App.Group():
+				InputVideo = App.Video(label='Input Video', sources=['upload'], height=300)
+				ModelList = ListModels()
+				ModelNames = [Path(Model).stem for Model in ModelList]
+				InputModel = App.Dropdown(choices=ModelNames, label='Select Model', value=ModelNames[0] if ModelNames else None)
+				with App.Row():
+					InputFrameRate = App.Slider(label='Frame Rate', minimum=1, maximum=60, value=23.976, step=0.001)
+					InputTileGridSize = App.Slider(label='Tile Grid Size', minimum=1, maximum=6, value=1, step=1, show_reset_button=False)
+				InputFileType = App.Dropdown(choices=['.mp4', '.mkv'], label='Output File Type', value='.mkv', interactive=True)
+			SubmitButton = App.Button('🚀 Upscale Video')
+
+		with App.Column(scale=1, show_progress=True):
+			OutputSlider = App.ImageSlider(label='Output Preview', value=None, height=300)
+			DownloadOutput = App.DownloadButton(label='💾 Download Video', interactive=False)
+			with App.Accordion(label='📜 Instructions', open=False):
+				App.Markdown('''
+				### How To Use The Video Upscaler
+
+				1.  **Upload A Video:** Begin by uploading your video file using the 'Input Video' section.
+				2.  **Select A Model:** Choose an appropriate upscaling model from the 'Select Model' dropdown menu.
+				3.  **Adjust Settings (Optional):**
+				Modify the 'Frame Rate' slider if you want to change the output video's frame rate.
+				Adjust the 'Tile Grid Size' for memory optimization. Larger models might require a higher grid size, but processing could be slower.
+				4.  **Start Processing:** Click the '🚀 Upscale Video' button to begin the upscaling process.
+				5.  **Download The Result:** Once the process is complete, download the upscaled video using the '💾 Download Video' button.
+
+				> Tip: If you get a CUDA out of memory error, try increasing the Tile Grid Size. This will split the image into smaller tiles for processing, which can help reduce memory usage.
+				''')
+
+	SubmitButton.click(fn=Process, inputs=[InputVideo, InputModel, InputFrameRate, InputTileGridSize, InputFileType],
+					 outputs=[OutputSlider, DownloadOutput])
+
+if __name__ == '__main__':
+	os.makedirs(ModelDir, exist_ok=True)
+	os.makedirs(TempDir, exist_ok=True)
+	Logger.info('🚀 Starting Video Upscaler')
+	Interface.launch(pwa=True)

packages.txt

@@ -0,0 +1,2 @@
+python3-opencv
+ffmpeg

requirements.txt

@@ -0,0 +1,6 @@
+gradio
+rich
+numpy
+spandrel
+Pillow
+opencv-python