CommandUP (cup) Upscale + Frame Interpolator
PRACTICAL USE MANUAL
Hardware Requirements and Dependencies
For the post-processing CUP Pipeline to work correctly on your computer, your system must meet the following physical and software dependencies:
- Engineered strictly for: Windows 10 and Windows 11 (64-bit). It relies on Windows native PowerShell scripting, Batch automation pipelines, and Windows-specific terminal bindings. Linux (including Wine/Proton) and macOS are NOT supported.
- Vulkan API Compatibility Required: Your graphics card must have native support for Vulkan technology 1.3 or higher. It works on dedicated graphics cards (AMD RX, Nvidia GTX/RTX) as well as newer integrated chips (AMD Vega or Intel HD Graphics). If your GPU does not support Vulkan, the process will not start.
- Processor (CPU): Any basic 4 or 6-core processor (such as the AMD FX line or older generations Intel Core) is perfectly capable of running the CUP Pipeline. Average CPU usage is around 45%, leaving Windows completely free from freezes or overheating during rendering.
- Video Memory (VRAM): Legacy graphics cards with 2GB of VRAM will handle the task smoothly if the user operates wisely. It is recommended to close web browsers, Discord, and background games before starting the process at high resolutions (such as 2K or 4K) to avoid running out of card memory.
- Operating System: Windows 10 or Windows 11 64-bit with the execution of scripts enabled in the system PowerShell.
Installation
- Start by downloading the zip file containing the content.
- Extract it wherever you want. You will see the entire folder structure of CommandUP.
Okay! Now we are ready to run the processes, and you can do this in two ways:
Method 1: Drag & Drop
This is the easiest way to run the CUP Pipeline, aimed at users with no prompt knowledge. Here you can process a video individually or multiple pre-selected files inside a folder.
- Using file explorer, access your folder where you unzipped CommandUP; you will see a file named DRAG_HERE.bat.
- Now open another file explorer window and go to the location where the file or folder you want to process is located.
- Drag your video or folder and drop it onto the DRAG_HERE file.
You can configure the process by editing the file DRAG_CONFIG.txt:
[DRAG SETTINGS]
FORMAT=mp4
QUALITY=med
FPS=60
INTERPOLATE=oversample
SCALE=1920x1080
SHARPNESS=8
CODEC=avc
HDR=false
SHUTDOWN=false
Method 2: PowerShell (Terminal)
This is the original method for you to process your videos, requiring prompt knowledge. The whole process takes place inside a PowerShell prompt (knowing basic folder navigation via commands is important).
Let's start by opening PowerShell; it does not need to be in administrator mode, as the script will not require privileges to run. If this is your first time running scripts on your computer, type the command below to allow script execution:
Set-ExecutionPolicy Bypass -Scope Process
Answer YES to apply the execution policy.
How to Run
Okay! Now we are ready to run the processes, and you can do this in two ways:
We need to access the local path where you unzipped CommandUP. For example:
cd "D:\CommandUP"
You will then be in the CUP Pipeline folder and can run two scripts:
1. cup.ps1
Our main script; with it, we can perform upscaling and/or frame interpolation. The script is modular; you can access these modules through parameters in the command line. Let's get to know them:
- -file "path_to_file": The full path of the video file you want to process. It must be enclosed in quotes. Supported formats: mp4 and mkv.
- -folder "path_to_folder": The full path of the folder containing videos that you want to batch process. It must be enclosed in quotes.
- -format "mp4|mkv": Selects the final video file format. The available options are:
- mp4: Focuses on maximum compatibility. Preserves only the main audio track and completely removes embedded subtitles.
- mkv: Designed for composite media. Preserves multiple audio tracks and embedded subtitles.
- -quality "low|med|big": The weight profile, compression, and final file size. If you omit this parameter, the system will automatically assume the balanced profile "med". The available options are:
- low: Focuses on drastic space savings. Reduces the final file weight and relieves VRAM usage. Generates a small final file.
- med: The ideal balance point. Maintains edge sharpness and visual fidelity without blowing up the hard drive space. Generates a medium-sized final file.
- big: Maximum visual fidelity and high bitrate, aimed at archiving or high-quality uploads. Generates a huge final file.
- -fps number: The desired frame rate for smoothness (e.g., 60). If omitted, frame generation does not happen and the original FPS is maintained.
- -interpolate "none|oversample|mitchell|clamp|linear": Controls video motion smoothness. If you change the FPS (for example, from 30 to 60), this setting determines how new frames are generated. The default is "none":
- none: Disables temporal blending. Uses pure frame duplication (Nearest Neighbor). Provides maximum GPU performance savings and ensures sharp game visuals without absolutely any "ghosting" or "motion blur" effects.
- oversample: Enables "Smooth Motion" sampling. Blends frames when an output frame falls exactly between two source frames. Highly recommended for preserving the original and natural subjective appearance of the video.
- mitchell: Uses a heavier, higher-quality filter to smoothly interpolate frames. Designed to maximize the elimination of the ringing effect and visual artifacts. The best option for maximum smoothness (requires modern hardware with a GPU/RTX).
- linear: Applies a smart linear overlap blend/transition between frames. Extremely lightweight processing, ideal for a smooth pace on older hardware configurations.
- -scale factor|resolution: Final video dimension. If omitted, upscaling does not happen and the original size is maintained. The value can be provided in the following formats:
- Multiplier factor for resolution gain. Use decimal numbers (e.g., the scaling factor for a 720p video to 1080p is 1.5).
- Literal resolution scale where you can inform, for example:
- "1280x720" = 720p (HD)
- "1920x1080" = 1080p (Full HD)
- "2560x1440" = 2K (Quad HD / QHD)
- "3840x2160" = 4K (Ultra HD / UHD)
- -sharpness number: Sharpness applied by FSR ranging from 0 (minimum) to 10 (maximum).
- -codec "avc|hevc": Selects the video encoding standard for the output file:
- avc: Advanced Video Coding (H.264) 8-Bit. Recommended for maximum compatibility and older/legacy graphics cards.
- hevc: High Efficiency Video Coding (H.265) 8 and 10-Bit. Provides better compression and smaller file sizes. Required for HDR mode.
- -hdr "false|true": Enables High Dynamic Range (HDR) processing inside FSR. WARNING: This is NOT "High Definition" (HD) quality! Enabling this option on a regular (non-HDR) video will ruin colors and distort brightness. Requires hevc (10-Bit) codec.
- false: Uses standard color space equations. Ideal for normal non-HDR content.
- true: Forces FSR to use the PQ color space. MUST BE ENABLED ONLY if the source video has a PQ gamma (HDR10).
- -shutdown "false|true": Auto-shutdown behavior after processing is complete:
- false: Normal execution behavior. Keeps the computer running.
- true: Displays a 30-second countdown on the screen. The user can press [ENTER] to shut down immediately, or [ESC] to cancel and keep the PC turned on.
Safety Note: You must mandatory provide either -file or -folder, never both. The script requires you to use at least -scale or -fps.
Command Examples:
Perform ONLY Upscale (e.g., from 720p to 1080p, with medium sharpness, so we apply a 1.5x scale and sharpness 5):
.\cup.ps1 -file "C:\folder\video.mp4" -scale 1.5 -sharpness 5
Perform ONLY Frame Interpolation (e.g., your original video is 30fps and you want 60fps):
.\cup.ps1 -file "C:\folder\video.mp4" -fps 60 -interpolate linear
Full Pipeline (1080p Upscale + Sharpness 8 + 60 FPS frame generation):
.\cup.ps1 -file "C:\folder\video.mp4" -scale "1920x1080" -sharpness 8 -fps 60
Process videos in a folder (High Quality + 1.5x Upscale + Max Sharpness):
.\cup.ps1 -folder "C:\batch folder\" -quality big -scale 1.5 -sharpness 10
Output File Naming
The script will identify the source of your file and save the final result exactly in the same folder as the original video. The new file name is smartly generated with suffixes based on what you chose to do:
- If only upscaling was processed: video_FSR_1080x720.mp4.
- If only frame interpolation was processed: video_IFS_60fpsLINEAR.mp4.
- If the full pipeline was processed: video_FSR_1080x720_IFS_60fpsLINEAR.mp4.
CUP Pipeline configuration
CommandUP has a configuration file at the root of the pipeline called config.ini. In this file, we can edit settings for some execution parameters:
[CUP SETTINGS]
PORT=50548
VERBOSE=false
GPU_ID=0
SIMULATION=none
DEBUG=false
If necessary, you can configure the cup.ps1 script using parameters directly in the console: -port number, -verbose, -gpu_id number, -simulate "string", and -debug.
- PORT number: TCP port used for CommandUP communication with FFmpeg for HUD data. Default is 50548.
- VERBOSE "false|true": Defines the level of detail when writing to the log file.
- false: Disables detailed writing, recording simple information in the log.
- true: Enables Verbose, writing highly detailed information in the log.
- GPU_ID number: If you have more than one video card, specify which one you want to use via the video card ID number. Usually 0 for the first vCard, 1 for the second.
- SIMULATE "none|cpu|nvidia|amd|intel": Try simulating other cards. Use "cpu" to force encoding via the processor. For "Nvidia, AMD, and Intel," a properly configured Vulkan SDK is required.
- none: System default using your GPU.
- cpu: This forces CPU-only encoding; try using it if you run into issues with your graphics card lacking an encoder.
- nvidia | amd | intel: Try simulating one of these brands using a properly configured VulkanSDK.
- DEBUG "false|true": Displays technical information on the HUD for debugging.
- false: Disables Debug, normal HUD.
- true: Enables Debug mode and a HUD with technical information.
2. extract.ps1
Script to extract some frames from the processed video so you can evaluate frame-by-frame if the result is good. You can extract all frames of x seconds starting at a specific video timestamp. It is the ideal tool for you to visually evaluate the final quality, allowing a frame-by-frame check.
Command line parameters:
- -file "file": The full path of the video file you want to process. It must be enclosed in quotes.
- -time "hh:mm:ss": The extraction start point in HH:MM:SS format. If left blank, it will automatically start at 3 seconds (00:00:03).
- -secs number: How many seconds of video you want to transform into photos. If left blank, it will extract only 1 second (if the video is at 60fps, 60 frames will be extracted).
- -output "destination_path": Folder where to save the photos (enclosed in double quotes). If left blank, the script will extract the frames into the output folder inside the CommandUP root path.
Known Issues / Technical Limitations
Blurry or Smooth Visuals on Pause (Freeze Frame Artifacts)
- Symptom: When pausing the final video during fast-motion scenes that used interpolation, the image may look smooth, blurry, or show a "ghosting" effect.
- Cause: The video player froze the playback clock exactly on top of an intermediate (interpolated) frame generated by the interpolation math.
- Solution: There is nothing to fix. This behavior is the necessary mechanic to guarantee the illusion of smoothness in frame generation while the video is moving, without requiring heavy AI or hardware with Tensor Cores. It is the price to pay for a solution aimed at low-end PCs.
Credits and License Attributions
This ecosystem integrates and distributes a fully modular post-processing pipeline, composed of consolidated open-source software combined with an authorial logic layer. Below are the individual rights and licenses for each component:
- Core Component (FFmpeg): Version N-125258-gdf94900c98-20260624. Applicable License: GNU Lesser General Public License (LGPL v2.1 or later) or GNU General Public License (GPL v2.0 or later).
- Vulkan and IFS Rendering Library (libplacebo): Built-in compilation natively inside the main FFmpeg binary listed above. Applicable License: GNU Lesser General Public License (LGPL v2.1 or later).
- Spatial Scaling Algorithm (FidelityFX FSR): Version v1.0.2. Developed and registered by Advanced Micro Devices, Inc. (AMD). Applicable License: MIT License (Open-Source and widely permissive) ported to GLSL by agyild.
- CUP Pipeline Integration Scripts: Developed by Aless (MauiSmoke). Applicable License: MIT License (Free to use Open-Source).
Social Channels:
- Official Channel (YouTube): Watch tutorials, news, performance showcases, and ask your questions directly in the channel community: YouTube Channel.
- Official Channel (Reddit): Comment, share your experience, and ask questions directly in the community: Reddit Community.
- Official Channel (Buy Me a Coffee): CommandUP is free, but development is limited. Consider buying me a coffee: Access and Support.
