Topaz Labs Proteus 4

Introduction

Soft footage and compressed footage fail in different ways, and they need different controls. Compression destroys information in flat areas, which is what the repair weights address. Softness is a focus or resampling problem: the information is spread across neighbouring pixels rather than missing, and getting it back means telling the model where the edges should have been.

Proteus splits that work across three controls, each acting at a different point. settings.focusFixLevel is a preprocessing step for footage where the subject is genuinely out of focus. preblur handles aliasing and mild blur inside the enhancement pass, and blur sets how much sharpening lands on the result.

The clinic clip went in soft and low-resolution, the sort of handheld take that gets shot once and cannot be reshot. It took two passes to get there, one to correct the focus and one to enlarge the corrected frame, for the reason covered below. The result is a recovery rather than a clip that was in focus all along.

Fixing an out-of-focus subject

settings.focusFixLevel accepts none, normal, and strong, and defaults to leaving the frame alone. It works by downscaling the input before the enhancement runs, so the model rebuilds from a smaller frame and corrects the blur harder on the way back up. strong shrinks further than normal and therefore corrects more aggressively.

The three levels below all ran on the same 854 × 480 source, and all three came back at that size, so they are directly comparable:

normal pulls the jacket and the parcel edges back toward definition, and strong pushes further into the brickwork. The none take is the odd one out, and worth understanding: it carries no focus correction at all, but it is the only take that got the 1920 × 1080 it asked for, so at page size it reads as the sharpest of the four. More pixels beat better edges when everything is displayed at the same width.

Getting both the correction and the size

Two calls, in order. Correct the focus first, then feed that result back in for the enlargement:

The second pass is an ordinary request with no focusFixLevel at all, taking the corrected 854 × 480 clip and asking for 1920 × 1080. The blur correction from the first call survives into it, and the frame arrives at delivery size.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'topazlabs:proteus@4',
  deliveryMethod: 'async',
  width: 854,
  height: 480,
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4'
  },
  settings: {
    focusFixLevel: 'normal',
    enhancement: {
      mode: 'relative',
      blur: 0.3
    }
  }
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "topazlabs:proteus@4",
            "deliveryMethod": "async",
            "width": 854,
            "height": 480,
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
            },
            "settings": {
                "focusFixLevel": "normal",
                "enhancement": {
                    "mode": "relative",
                    "blur": 0.3
                }
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "a8b9c0d1-2e3f-4a4b-b5c6-d7e8f9a0b1c2",
      "model": "topazlabs:proteus@4",
      "deliveryMethod": "async",
      "width": 854,
      "height": 480,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
      },
      "settings": {
        "focusFixLevel": "normal",
        "enhancement": {
          "mode": "relative",
          "blur": 0.3
        }
      }
    }
  ]'

runware run topazlabs:proteus@4 \
  deliveryMethod=async \
  width=854 \
  height=480 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4 \
  settings.focusFixLevel=normal \
  settings.enhancement.mode=relative \
  settings.enhancement.blur=0.3

{
  "taskType": "upscale",
  "taskUUID": "a8b9c0d1-2e3f-4a4b-b5c6-d7e8f9a0b1c2",
  "model": "topazlabs:proteus@4",
  "deliveryMethod": "async",
  "width": 854,
  "height": 480,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
  },
  "settings": {
    "focusFixLevel": "normal",
    "enhancement": {
      "mode": "relative",
      "blur": 0.3
    }
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "b9c0d1e2-3f4a-4b5c-c6d7-e8f9a0b1c2d3",
    "videoUUID": "3d4e5f60-7182-493a-b4c5-d6e7f8091a2b",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/3d4e5f60-7182-493a-b4c5-d6e7f8091a2b.mp4"
  }
]

The first call asks for the size it is going to get anyway, which keeps the request honest about what comes back. The second call is where the enlargement happens.

Cleaning up aliasing with preblur

preblur is the anti-aliasing and deblurring weight, running from −1 to 1 like the other tuning values. Aliasing is the stair-stepping and shimmer that lands on thin lines and small type, and screen recordings or exported graphics are where it shows up, because those sources are full of one-pixel edges.

The chart lines stop crawling and the axis labels hold their shape. Anti-aliasing works before the detail reconstruction, which is why it belongs here rather than in the sharpening pass: a stepped edge that survives into the rebuild gets reconstructed as a stepped edge, sharper than it was.

import { createClient } from '@runware/sdk'

const client = await createClient({ apiKey: process.env.RUNWARE_API_KEY })
await client.connect()

const [result] = await client.run({
  model: 'topazlabs:proteus@4',
  deliveryMethod: 'async',
  width: 1920,
  height: 1080,
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4'
  },
  settings: {
    enhancement: {
      mode: 'relative',
      preblur: 0.6,
      blur: 0.3
    }
  }
})

import asyncio
import os

from runware import Runware


async def main():
    async with Runware(api_key=os.environ["RUNWARE_API_KEY"]) as client:
        results = await client.run({
            "model": "topazlabs:proteus@4",
            "deliveryMethod": "async",
            "width": 1920,
            "height": 1080,
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
            },
            "settings": {
                "enhancement": {
                    "mode": "relative",
                    "preblur": 0.6,
                    "blur": 0.3
                }
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "a8b9c0d1-2e3f-4a4b-b5c6-d7e8f9a0b1c2",
      "model": "topazlabs:proteus@4",
      "deliveryMethod": "async",
      "width": 1920,
      "height": 1080,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
      },
      "settings": {
        "enhancement": {
          "mode": "relative",
          "preblur": 0.6,
          "blur": 0.3
        }
      }
    }
  ]'

runware run topazlabs:proteus@4 \
  deliveryMethod=async \
  width=1920 \
  height=1080 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4 \
  settings.enhancement.mode=relative \
  settings.enhancement.preblur=0.6 \
  settings.enhancement.blur=0.3

{
  "taskType": "upscale",
  "taskUUID": "a8b9c0d1-2e3f-4a4b-b5c6-d7e8f9a0b1c2",
  "model": "topazlabs:proteus@4",
  "deliveryMethod": "async",
  "width": 1920,
  "height": 1080,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f708192-a3b4-4c5d-e6f7-08192a3b4c5d.mp4"
  },
  "settings": {
    "enhancement": {
      "mode": "relative",
      "preblur": 0.6,
      "blur": 0.3
    }
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "a8b9c0d1-2e3f-4a4b-b5c6-d7e8f9a0b1c2",
    "videoUUID": "3d4e5f60-7182-493a-b4c5-d6e7f8091a2b",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/3d4e5f60-7182-493a-b4c5-d6e7f8091a2b.mp4"
  }
]

Anti-aliasing and sharpening are both enhancement weights, so they travel inside settings.enhancement and keep the size you asked for, unlike focus fix.

Setting sharpness with blur

blur sets how much sharpening the result carries. It is the weight most likely to be reached for and overdone, because sharpening looks like detail at a glance and looks like a mistake at full size.

At +0.5 the stitching on the wheel and the grain of the dashboard trim read cleanly. At 1.0 the edges pick up the pale outline that says oversharpened, and a viewer reads that as a processed clip rather than a better one. Sharpening is also the repair that survives a delivery encode worst, since the ringing it leaves compresses badly and comes back exaggerated.

Which control for which failure

Match the control to what actually went wrong, since the three are not interchangeable.

• The subject is out of focus in the original. Reach for focusFixLevel, starting at normal, and expect to upscale in a second call.
• Thin lines shimmer or step, typically on screen captures and graphics. Reach for preblur.
• The frame is clean but flat, with nothing wrong beyond a lack of bite. Reach for blur, in small amounts.
• The frame is blocky rather than soft. None of these apply. That is compression damage, covered in tuning the enhancement weights.

The failures stack in real footage, so a single clip often needs a focus-fix level on the input and an anti-alias weight inside the pass. Remember that the two do not share a request comfortably, since focus fix decides the output size.

Tips

1. Diagnose before you tune. Softness, aliasing, and blocking look similar at small sizes and need different controls. Look at the source at full size first.

2. Start focus fix at normal. strong quarters the input instead of halving it, which corrects harder and costs more of the original frame. Move up only when normal leaves the subject soft.

3. Budget two calls when you use focus fix. It returns the source resolution and discards the width and height you sent, so the enlargement has to happen in a second request. On a clip that is small but already sharp, skip focus fix entirely.

4. Anti-alias before you sharpen. A stepped edge that reaches the reconstruction gets rebuilt as a stepped edge. preblur clears it first.

5. Keep blur under 0.5 for anything with faces. Skin picks up ringing before hard surfaces do, and it is the first thing a viewer notices.

6. Check sharpening after the delivery encode. Ringing compresses badly, so a result that looks fine in the master can look overcooked once it has been through the platform's encoder.