P-Video-Upscale

Introduction

fps sets the frame rate of the output, from 16 to 60, on the same pass that raises the resolution. Leave it out and the clip keeps its own rate. Set it above the source and the model builds the missing frames by interpolation, drawing new in-between frames from the motion on either side, so a 24 fps clip can come back at 60.

Both halves are 1080p upscales of the same 24 fps serve, the left at its own rate and the right at fps: 60. Watch the racket on its way up to the ball: at 24 fps it jumps between positions, and at 60 it sweeps through them.

The frames below cover the same twelfth of a second of that swing, as the racket head swings up beside her raised arm. The 24 fps clip holds three frames in that span, and the 60 fps clip holds six, with the racket drawn at the positions in between.

This guide covers the request, how to pick a rate, what a rate above 30 does to the price and the longest clip you can send, and how interpolation handles a camera move. Sizing and the rest of the request are in upscaling video.

The request

Add fps to an ordinary upscale. It takes a whole number from 16 to 60.

import { createClient } from '@runware/sdk'

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

const [result] = await client.run({
  model: 'prunaai:p-video@upscale',
  deliveryMethod: 'async',
  resolution: '1080p',
  fps: 60,
  inputs: {
    video: 'https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f7a8b9c-0d1e-4f2a-b3c4-d5e6f7a8b9c0.mp4'
  }
})

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": "prunaai:p-video@upscale",
            "deliveryMethod": "async",
            "resolution": "1080p",
            "fps": 60,
            "inputs": {
                "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f7a8b9c-0d1e-4f2a-b3c4-d5e6f7a8b9c0.mp4"
            }
        })


asyncio.run(main())

curl https://api.runware.ai/v1 \
  -H "Authorization: Bearer $RUNWARE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '[
    {
      "taskType": "upscale",
      "taskUUID": "2c4e6a8b-1d3f-4b5a-8c7e-9f0a1b2c3d4e",
      "model": "prunaai:p-video@upscale",
      "deliveryMethod": "async",
      "resolution": "1080p",
      "fps": 60,
      "inputs": {
        "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f7a8b9c-0d1e-4f2a-b3c4-d5e6f7a8b9c0.mp4"
      }
    }
  ]'

runware run prunaai:p-video@upscale \
  deliveryMethod=async \
  resolution=1080p \
  fps=60 \
  inputs.video=https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f7a8b9c-0d1e-4f2a-b3c4-d5e6f7a8b9c0.mp4

{
  "taskType": "upscale",
  "taskUUID": "2c4e6a8b-1d3f-4b5a-8c7e-9f0a1b2c3d4e",
  "model": "prunaai:p-video@upscale",
  "deliveryMethod": "async",
  "resolution": "1080p",
  "fps": 60,
  "inputs": {
    "video": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/6f7a8b9c-0d1e-4f2a-b3c4-d5e6f7a8b9c0.mp4"
  }
}

[
  {
    "taskType": "upscale",
    "taskUUID": "2c4e6a8b-1d3f-4b5a-8c7e-9f0a1b2c3d4e",
    "videoUUID": "a0b1c2d3-e4f5-4a6b-8c7d-9e0f1a2b3c4d",
    "videoURL": "https://vm.runware.ai/video/os/a14d18/ws/2/vi/a0b1c2d3-e4f5-4a6b-8c7d-9e0f1a2b3c4d.mp4"
  }
]

Without fps the output keeps the source rate, up to 60. With it, any rate above the source is interpolated, and the clip keeps its duration, so the audio stays in step with the picture.

Picking a rate

Choose by what the clip shows and where it plays, because a frame rate is a look as much as a number.

• Keep 24 for narrative and cinematic footage. Interpolating a film-look clip to 60 gives its motion the smooth, live-broadcast feel that viewers read as video rather than film.
• 30 matches what phones record and most social feeds play, and it stays in the same price tier as the source, since the higher rate only starts above 30.
• 60 is for fast motion the eye tracks: sports, gameplay, product spins and quick camera moves, where 24 fps steps are easy to see.

Price and length above 30 fps

Two rules change once the output passes 30 frames per second. The per-second rate doubles at every preset, whether the 60 comes from fps or from a source that is already 60 fps. And the model rebuilds 30 frames per second in full and interpolates the rest, which holds for a native 60 fps source as well.

The frame cap counts the same way, at no more than 30 frames per second. That makes 60 fps cost no extra length over 30 at 1080p and above. For a 24 fps source, the longest clip each preset accepts is:

At 720p a second budget takes over first. The source frames plus 0.55 for every output frame must stay under 4,320, which stops a 24 fps clip at about 75 seconds when you ask for 60. A clip over either limit is rejected, not trimmed.

Camera moves

A fast pan is where 24 fps steps the most visibly, because the whole frame moves at once instead of one subject inside it. The tracking shot below is the same 1080p upscale at both rates.

Look past the car at the shrubs and the guardrail, and down at the lane markings. At 24 fps they step past in jumps, and at 60 they slide by evenly, while the car holds its place in the frame in both.

Tips

1. Leave fps out to keep the original timing. The source rate passes through as it is, which is the right call for anything shot for a cinematic look.

2. Ask for 30 before 60. It smooths a 24 fps clip at the standard price, and 60 is worth its doubled rate only where motion is fast.

3. Budget 60 fps like 30. Above 30 the frame cap counts 30 per second, so a clip that fits at 30 fps also fits at 60 at 1080p and above.

4. Check the length at 4k. At 30 or 60 fps the cap is 10 seconds, against 12.5 at a 24 fps source rate.

5. Interpolate the moving shots, not the whole edit. Talking heads and slow scenes gain little from 60 fps. Spend the higher rate on fast action and camera moves.