# How to Use a MiniMax H3 Reference Video Without Copying the Clip

> Give the clip one job and name what must not carry over. Keep to 3 clips and 15 s in total; a tested camera-only 4 s request at 768P cost $0.55.

- URL: https://blog.laozhang.ai/en/posts/minimax-h3-reference-video
- Published: 2026-11-03
- Updated: 2026-11-03
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: AI Video Generation
- Tags: MiniMax H3, Reference to Video, Ref2VA, AI Video Generation, Video API, ComfyUI

---
To use a reference video in MiniMax H3 without getting a copy of it, give the clip one job and say in the prompt what must not come across. Attach the clip as a `reference_video` item, with no first or last frame in the same request, and write three things in the text: the job ("Use reference video 1 only for its camera movement: a slow handheld push-in"), every visible thing in the clip you don't want ("Do not copy the person, clothing, animals or field from reference video 1"), and the complete new scene. When the reference seems ignored instead, look at the clip first: a busy clip with several people or moves gives H3 too many signals, and in ComfyUI a missing `vae` connection keeps the clip's frames from reaching the model.

That pattern was run on November 2, 2026 through LaoZhang API, a gateway that serves its own deployment of the open H3 weights rather than MiniMax's API. A 4-second 768P request, using MiniMax's own 6.06-second demo clip of a man in a pink suit holding a black lamb, came back in 45 seconds as a fisherman mending a net on a pier, filmed with a gentle push-in and with no suit, lamb or field in any frame. It cost $0.55, because the 6.06-second reference was billed as 7 seconds on top of the 4 output seconds. One run is not a guarantee, but it shows the do-not-copy sentence working.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

Check the clip before you submit it: at most 3 reference videos, each 2–15 seconds long and 15 seconds in total. In the same test, two 9.47-second clips were accepted and then failed three seconds later with a "temporary service error … Please retry" message. The real cause was the 18.95-second total, so trim the clips rather than resubmitting.

## Reference to Video, Ref2VA, r2va: one MiniMax H3 mode with four names

Reference-to-video is the H3 mode where a text prompt plus reference images, videos or audio guide a new clip, instead of an image being animated as the first frame. MiniMax's API guide calls it Reference Generation and lists the typical uses as "character, motion, camera, style, voice, or editing rhythm"; the API reference labels its example `r2va`; the open-weight checkpoint MiniMax released on August 3, 2026 is called Ref2VA; and fal, RunDiffusion, ComfyUI templates and the Hailuo web app call it Reference to Video. They are the same thing. The output is 4–15 seconds with a stereo soundtrack, at 768P or 2K on MiniMax's API ([MiniMax video generation guide](https://platform.minimax.io/docs/guides/video-generation), as of November 2, 2026).

A reference video is not a frame to animate. MiniMax's open-weight documentation describes it as a guide that is not pixel-aligned with the output and has no denoise-strength control, so words are the only steering wheel you have. Each tool expects you to name the clip a little differently:

| Where you run H3 | How the prompt names the first clip | Notes |
| --- | --- | --- |
| MiniMax API (platform.minimax.io) | "reference video 1" in plain words | Official examples count per type: "reference images 1 and 2", "reference audio 1" |
| ComfyUI local node `MiniMaxH3ReferenceToVideo` | `<Video 1>` | Also `<Picture 1>` and `<Audio 1>`, numbered per type |
| ComfyUI API node, fal, RunDiffusion | `Video 1` | Also `Image 1` and `Audio 1` |
| Hailuo web app | `@Video1` | The app takes reference videos on H3 only, not on H3 Max |

Counting per type means the first video is Video 1 even if three images come before it. If you are still deciding whether H3 is the right model for the job, [Wan 3.0 vs MiniMax H3 vs Seedance 2.5: Pick the First Model to Test](https://blog.laozhang.ai/en/posts/wan-3-vs-minimax-h3-vs-seedance-2-5) compares them by duration, references, editing and API access.

## Give the reference video one job: camera, motion, edit, continuation or sound

H3 takes from a reference video whatever the prompt tells it to, and when the prompt is vague it can take everything: the performer, the location, even the lighting. So decide first whether the clip only guides the new video or is the material being changed. MiniMax's [reference prompt writing guide on Hugging Face](https://huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/docs/VIDEO_PROMPT_WRITING_GUIDE_ref_en.md) puts it plainly: "If a reference video provides only camera movement, cuts, or rhythm, it normally belongs to `reference generation`," and only a clip that is directly modified or extended counts as `video editing` or `video continuation`. The sentences below use MiniMax's plain wording; swap in `<Video 1>` or `Video 1` if your tool uses tags.

| What the clip should give | Sentence to put in the prompt | What to rule out by name |
| --- | --- | --- |
| Camera movement only | "Use reference video 1 only for its camera movement: [describe the move]." | The people, clothing, animals and location in the clip |
| A performer's motion, on your character | "Transfer the [dance, walk, turn] from reference video 1 to the [subject] in reference image 1." | The performer's face, outfit and background |
| Cut timing or pacing | "Match the cut timing and pacing of reference video 1." | What is shown in those shots |
| The clip itself, edited | "Reference video 1 is the source video. Change only [X]; keep everything else." | Nothing else; list what must stay unchanged |
| A continuation | "Continue from the end of reference video 1: [what happens next]." | Usually nothing; the subject is meant to carry on |
| Voice or sound | "The voice in reference video 1 guides the timbre and delivery of this new line: [line]." | The original words |

![Six jobs a MiniMax H3 reference video can do, each with its prompt sentence and what to rule out: camera movement, a performer's motion, cut timing, voice, editing the clip itself, and continuing it](https://blog.laozhang.ai/posts/en/minimax-h3-reference-video/img/reference-video-jobs.webp)

The motion row is the one people get wrong most often with dance clips. MiniMax's own wording for it is "following the motion in reference video 1; the character's appearance follows reference images 1 and 2," and RunDiffusion's guide suggests "Transfer the [action] from Video 1 to [Image 1 subject]" with a clip that shows one clean action. Saying where the appearance comes from is what keeps the dancer from replacing your character.

Sound needs to be asked for. The same MiniMax guide notes that "an ordinary reference video does not create `<Audio N>` merely because the file contains sound," so if the clip's voice or music matters, say so in the prompt. If you want it handled as a separate input, extract the track to MP3 or WAV and attach it as `reference_audio`; MiniMax's API does not charge for audio input.

## Reference video limits: 3 clips, 2–15 seconds each, 15 seconds total

A reference clip has to pass every limit below or the request will be refused, sometimes at once and sometimes only after it has been accepted. These are MiniMax's published numbers from its [video generation API reference](https://platform.minimax.io/docs/api-reference/video-generation-v2-create), as of November 2, 2026:

| Check | Limit |
| --- | --- |
| Number of reference videos | Up to 3, and no more than 12 files across images, videos and audio |
| Length | Each clip 2–15 seconds; all clips together 15 seconds or less |
| Container and codecs | MP4 or MOV; H.264/AVC or H.265/HEVC video with AAC or MP3 audio |
| File size | 50 MB per video; the whole request body 64 MB |
| Frame size and shape | 256–5,760 px per side; width divided by height between 0.4 and 2.5 |
| Frame rate | 23.976–60 fps |
| How the file is sent | A public URL, `mm_file://{file_id}`, or Base64 (adds about 33% to the size) |

Three combination rules matter as much as the numbers. Reference-to-video and image-to-video are "mutually exclusive," so a `first_frame` or `last_frame` image cannot share a request with any reference video, image or audio; if you need an exact opening shot, that is a separate image-to-video request. Every request needs one non-empty text item. And audio cannot be the only reference: the tested gateway documents that rule, and a text-plus-audio request was refused there in the November 2 test.

Output settings have their own range. `MiniMax-H3` takes an integer `duration` of 4–15 seconds at 768P or 2K, while `MiniMax-H3-Max` takes 5–15 seconds and has no 2K. For reference requests `ratio` defaults to `adaptive`, and you can set 16:9, 9:16 or another fixed ratio instead. The prompt can be up to 7,000 characters.

## Write the request: the camera-only body that ran on November 2, 2026

The request is one JSON body: a model, a `content` array with the text first and the clip after it, and the output settings. These steps rebuild the tested request:

1. Put the clip at a public HTTPS address that downloads without a login or hotlink protection. The test used MiniMax's own demo clip from its API reference, so you can rerun it as is.
2. Run the preflight check in the next section, or at least confirm the clip is 2–15 seconds long.
3. Write the text in three parts: the job with the movement described in words, the do-not-copy list naming everything visible in the clip, and the new scene in full.
4. Add the clip as a `video_url` item with `"role": "reference_video"`, and add no image with a `first_frame` or `last_frame` role.
5. Start with `768P` and a 4-second `duration` while you tune the prompt, then submit, save the `task_id`, and poll every 10 seconds.

Save this as `request.json`:

```json
{
  "model": "MiniMax-H3",
  "content": [
    {
      "type": "text",
      "text": "Use reference video 1 only for its camera movement: a slow handheld push-in that drifts slightly around the subject. Do not copy the person, clothing, animals or field from reference video 1. New scene: an elderly fisherman in a yellow raincoat mends a net on a wooden pier at dawn, light rain, sea in the background."
    },
    {
      "type": "video_url",
      "role": "reference_video",
      "video_url": {
        "url": "https://cdn.hailuoai.com/prod/hailuo_demo/testsets/h3_promo_eval_ref2va/gallery/sr_v2p26_trio_seed42_20260724/inputs/297573323635_00_%E8%A7%86%E9%A2%911_YnyRbxEwio_video_20260525_163755_1927e9d3.mp4"
      }
    }
  ],
  "resolution": "768P",
  "duration": 4,
  "ratio": "16:9"
}
```

Then submit it and poll the task:

```bash
export API_KEY="your-api-key"
export BASE_URL="https://api.laozhang.ai/hailuo"   # MiniMax's own API: https://api.minimax.io

curl -s -X POST "$BASE_URL/v2/video_generation" \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d @request.json
# {"task_id": "1793634889518010650"}

export TASK_ID="paste-the-task-id"
curl -s "$BASE_URL/v2/query/video_generation/$TASK_ID" \
  -H "Authorization: Bearer $API_KEY"
# repeat every 10 s until task.status is "succeeded" or "failed",
# then download task.content.url
```

The body is the same on MiniMax's API (`POST https://api.minimax.io/v2/video_generation`) and on the gateway used for the test, so only the base address and key change. One difference: MiniMax's API also accepts `mm_file://` IDs and Base64 video, while the gateway's documentation asks for public HTTPS links for video and audio.

The tested task was submitted at 15:54 UTC on November 2, 2026. It was still `running` at the 11, 22 and 33-second polls and `succeeded` at 45 seconds. The query response reported `"input_seconds": 7, "output_seconds": 4`, and the file was 1344×768 at 24 fps, 4.46 seconds long, with stereo AAC audio. In a one-frame-per-second contact sheet, the fisherman, raincoat, pier and dawn sea are all there, the subject moves from the left third toward the center while growing slightly larger, and nothing from the pink-suit clip appears. The light rain in the prompt is hard to see. The download link refused Python's default `urllib` user agent with a 403, while `curl` worked, so set a user agent if you script the download.

Why the prompt is built this way: the job sentence describes the push-in in words as well as pointing at the clip, so the model gets the movement twice. The exclusion sentence names every visible element (person, clothing, animals, field) rather than saying "don't copy the content." And the new scene is complete, so there is no gap the reference has to fill.

## Check a clip before you pay: ffprobe preflight and a 6-second trim

A short script can test a clip against MiniMax's published limits in a second, which is cheaper than finding out from a failed task. This one uses `ffprobe` (part of FFmpeg), prints the billed seconds rounded up to whole seconds, and exits with an error when any limit is broken:

```python
#!/usr/bin/env python3
# h3_ref_check.py - check MiniMax H3 reference videos before submitting
# usage: python3 h3_ref_check.py clip1.mp4 [clip2.mp4 clip3.mp4]
import json, math, subprocess, sys

def probe(path):
    out = subprocess.run(["ffprobe", "-v", "error", "-show_entries",
        "format=duration,size,format_name:stream=codec_type,codec_name,width,height,avg_frame_rate",
        "-of", "json", path], capture_output=True, text=True, check=True).stdout
    return json.loads(out)

def check(paths):
    problems, total = [], 0.0
    if len(paths) > 3:
        problems.append(f"{len(paths)} clips: H3 accepts at most 3 reference videos")
    for p in paths:
        info = probe(p)
        fmt = info["format"]
        v = next(s for s in info["streams"] if s["codec_type"] == "video")
        dur, size_mb = float(fmt["duration"]), int(fmt["size"]) / 1e6
        num, den = map(int, v["avg_frame_rate"].split("/"))
        fps = num / den if den else 0
        w, h = v["width"], v["height"]
        total += dur
        print(f"{p}: {dur:.2f}s (billed {math.ceil(dur)}s), {w}x{h}, {fps:.3f} fps, "
              f"{v['codec_name']}, {size_mb:.1f} MB")
        if not 2 <= dur <= 15: problems.append(f"{p}: {dur:.2f}s is outside 2-15 s")
        if v["codec_name"] not in ("h264", "hevc"): problems.append(f"{p}: codec {v['codec_name']} is not H.264/H.265")
        if not ("mp4" in fmt["format_name"] or "mov" in fmt["format_name"]): problems.append(f"{p}: container is not MP4/MOV")
        if size_mb > 50: problems.append(f"{p}: {size_mb:.1f} MB is over 50 MB")
        if not (256 <= w <= 5760 and 256 <= h <= 5760): problems.append(f"{p}: {w}x{h} outside 256-5760 px")
        if not 0.4 <= w / h <= 2.5: problems.append(f"{p}: aspect ratio {w/h:.2f} outside 0.4-2.5")
        if not 23.976 <= round(fps, 3) <= 60: problems.append(f"{p}: {fps:.2f} fps outside 23.976-60")
    if total > 15: problems.append(f"total {total:.2f}s is over 15 s")
    print(f"total reference length {total:.2f}s")
    print("OK" if not problems else "FIX BEFORE SUBMITTING:\n- " + "\n- ".join(problems))
    return not problems

if __name__ == "__main__":
    sys.exit(0 if check(sys.argv[1:]) else 1)
```

On November 2, 2026 (macOS 26.1, ffprobe 9.0.2), the script passed the push-in clip from the successful task as "6.06s (billed 7s), 1920x1080, 24.000 fps, h264, 4.4 MB". It flagged the 1.5-second clip from the failed probe with "1.50s is outside 2-15 s", and two copies of a 9.47-second dance clip with "total 18.95s is over 15 s". Those are the same two requests that the gateway accepted and then failed, so the script would have caught both before any money was held.

To fix a clip that is too long, cut the part you need. This command starts 1 second in and keeps exactly 6 seconds, re-encoding to H.264 and AAC:

```bash
ffmpeg -ss 1 -i dance.mp4 -t 6 -c:v libx264 -crf 20 -preset veryfast -c:a aac dance-6s.mp4
```

The trimmed file measured 6.00 seconds, and together with the push-in clip the pair totaled 12.06 seconds and passed. Cutting to a whole number of seconds also saves money where reference seconds are rounded up: 6.00 seconds bills 6, while 6.06 bills 7. The script only checks published limits, so it cannot predict whether the output will follow the reference or whether a clip will pass content moderation.

## "Temporary service error" or a 400: what each H3 reference failure means

On the tested gateway, a reference request failed in one of two ways: rejected at once with HTTP 400, or accepted with a `task_id` and failed about 3 seconds later with a message that sounds temporary. Neither cost anything, but only the first one tells you what is wrong. All probes below ran on November 2, 2026, at 768P, 4 seconds, 16:9:

| What was sent | At submit | Final result | Charged |
| --- | --- | --- | --- |
| Four reference videos | HTTP 400 (too many references) | Not created | No |
| Reference video plus a `first_frame` image | HTTP 400 (first/last frame can't mix with references) | Not created | No |
| Reference video with no text item | HTTP 400 (needs one non-empty text) | Not created | No |
| Text plus reference audio only | HTTP 400 "Invalid request parameters" | Not created | No |
| One 1.5-second clip sent as Base64 | Accepted, `task_id` returned | `failed` after about 3 s: "temporary service error … Please retry" | Held, then refunded |
| Two 9.47-second clips, 18.95 s total | Accepted, `task_id` returned | `failed` after about 3 s: same message | Held, then refunded |
| One 6.06-second clip, the request above | Accepted | `succeeded` | Yes, 11 billed seconds |

![Three ways an H3 reference request ended in the November 2 test: HTTP 400 at submit with no charge, accepted then failed about 3 seconds later and refunded, or succeeded and billed $0.55](https://blog.laozhang.ai/posts/en/minimax-h3-reference-video/img/reference-request-outcomes.webp)

The 400 responses came back as short Chinese sentences from the gateway, not MiniMax's own error text; the meaning is in the second column. For the two "temporary" failures, the account's usage total rose by 40 cents when both tasks were created (4 seconds × $0.05 each) and returned to the starting value after they failed. The compliant request sent a minute later succeeded, which is why the 18.95-second failure should be read as a limit problem and not a busy server. Retrying the same over-limit request was not tried, but nothing in it changes between attempts, so expect the same failure. The Base64 case can't be pinned to one cause, because the clip was both too short and sent as Base64, which the gateway's documentation does not accept for video.

Other providers enforce these limits differently, which is why staying inside them matters more than learning one provider's behavior. In [Atlas Cloud's own tests of H3 reference-to-video](https://www.atlascloud.ai/blog/tips/minimax-h3-reference-to-video), published in August 2026, every malformed request returned HTTP 200 at submit and failed two to three minutes later for free. A first-frame image sent with references did not fail at all: one input was silently dropped and the job billed $0.40. Two 8-second reference audio clips, 16.1 seconds in total, completed and billed normally even though 15 seconds is the published cap. A request that breaks a limit may be refused, fail late, or quietly lose an input depending on where you send it.

## What reference seconds cost: output seconds plus reference seconds

On MiniMax's API and on the tested gateway, a reference video costs the same per second as the output video at the resolution you chose, so the formula is (output seconds + reference seconds) × the per-second price. MiniMax's [pay-as-you-go price page](https://platform.minimax.io/docs/guides/pricing-paygo) says "Video input: Billed by input duration at the output resolution of the selected model" and, as of November 2, 2026, lists `MiniMax-H3` at $0.08 per second at 768P and $0.13 at 2K, for output and input video alike. Reference audio is free, and the first 5 reference images in a task are free.

The tested request shows how rounding enters. LaoZhang API lists `MiniMax-H3` at $0.05 per second at 768P and $0.08 at 2K (prices from October 24, 2026) and rounds each reference clip up to the next whole second. The 6.06-second clip became 7 billed seconds, so the bill was (4 + 7) × $0.05 = $0.55, which matched the account's usage change to the cent. Trimmed to 6.00 seconds, the same request would be (4 + 6) × $0.05 = $0.50. On that gateway the output seconds are held when the task is created and the reference seconds are settled after it finishes.

*Disclosure: [laozhang.ai is our own service](https://blog.laozhang.ai/en/about#laozhang). Its prices are platform pricing, not an independent comparison.*

MiniMax's page does not say how it rounds input seconds. If it also counts whole seconds, a 4-second 768P output with a 6-second reference costs (4 + 6) × $0.08 = $0.80, and the same pair at 2K costs (4 + 6) × $0.13 = $1.30. `MiniMax-H3-Max` is the exception, because its input video is priced above its output: at 768P it lists $0.08 per output second but $0.143 per input second, so the same pair is 4 × $0.08 + 6 × $0.143 ≈ $1.18.

Other platforms bill references in their own way. fal's base H3 reference-to-video endpoint lists no separate charge for reference video, while fal's H3 Max endpoint bills references in tokens, 4,096 free per request and then $0.02 per 1,000; its own example puts a 5-second 24 fps 16:9 clip at 32,256 tokens at 768p, about $0.56 extra. For per-second prices across other video models, see [How Much Does an AI Video Generator Cost Per Month and Per Clip?](https://blog.laozhang.ai/en/posts/how-much-does-ai-video-generator-cost)

## Output copies the reference clip or ignores it: fixes by cause

When the result looks like the reference with small changes, the prompt left the clip's content up for grabs. Name every visible element you don't want, as in the tested prompt, describe the new subject and setting completely, and describe the movement you want in words as well. DomoAI's guide suggests the same boundary in one line: "Video 1 controls motion and camera only; ignore its performer and setting."

Light and color grade can also come across, especially when the prompt asks for two opposite things. In the Atlas Cloud tests, one prompt asked for "bright empty covered market, cold clean daylight" and also told H3 to "carry the grade and grain of the reference clip"; the night-time reference won, and the shot came out far moodier than "bright." Atlas's conclusion was that one request can't ask for the reference's look and the opposite light. So the first fix is to remove any instruction to keep the reference's grade. If the light still drifts, pick a reference shot in similar light, or drop the video and describe the camera move in words alone.

When the reference seems ignored, the clip is usually too busy. RunDiffusion's troubleshooting advice for motion that does not match is to "use a cleaner motion clip and name the exact action or camera move to transfer": one person, one action, one camera idea. It also recommends adding references one at a time, so you can tell which input stopped working. In ComfyUI, the graph itself is the next suspect, covered in the next section.

If you are on MiniMax's API, H3-Context-IR can show how the model reads your references before you pay for a video. It returns an enhanced prompt (`task_type` `h3_context_ir`) without generating anything, priced at $0.90 per million input tokens and $3.60 per million output tokens on MiniMax's [pay-as-you-go price page](https://platform.minimax.io/docs/guides/pricing-paygo) as of November 2, 2026. If the rewrite treats your camera clip as the subject source, fix the prompt before generating.

## MiniMax H3 reference video in ComfyUI: Ref2VA node settings that matter

Running the open weights in ComfyUI follows the same prompt rules, but a few node settings decide whether the reference reaches the model at all. The points below come from ComfyUI's documentation for the `MiniMaxH3ReferenceToVideo` node and its R2V tutorial as of November 2, 2026. They describe documented behavior and were not part of the November 2 test.

- **Load the `ref2va` model.** The reference workflow uses `minimax_h3_ref2va_pruned_int8_convrot`, not the `fl2va` model used for text-to-video and image-to-video.
- **Connect `vae`.** Without it, the node documentation says, "reference images and videos only condition the text encoder (no reference latents are produced)," which looks exactly like a reference being ignored.
- **Convert the clip to 24 fps.** The tutorial says the reference video "is read as 24fps with no metadata," so a 30 fps clip is read at the wrong speed. `ffmpeg -i in.mp4 -vf fps=24 -c:v libx264 -crf 20 -c:a aac in-24fps.mp4` converts it.
- **Match `length` to the part you need.** `length` counts frames at 24 fps (124 frames is about 5 seconds), and reference frames beyond that length are trimmed, so a 10-second dance against a 5-second output only uses its first 5 seconds. Cut the clip to the moves you want first.
- **Wire `ref_video_audio_N` if you want the clip's sound.** The soundtrack is used only when it is connected to the matching `ref_video_N` slot.
- **Skip the Turbo LoRA when the reference must hold.** The optional 4-step LoRA is "faster, weaker reference/audio"; the tutorial suggests 20–25 steps instead, and style LoRAs at about 0.5 strength because they compete with references.

Tags in the local node are `<Picture 1>`, `<Video 1>` and `<Audio 1>`, numbered per type. The open weights output 768p only; 2K needs MiniMax's hosted Context-IR and Regenerate-2K APIs on top of a local run.

## MiniMax H3 reference video: other questions

### Can I get a 2K video with a reference video?

Yes on MiniMax's API: `MiniMax-H3` accepts `"resolution": "2K"` with references, and the reference seconds are then billed at the 2K rate. Another way is to tune at 768P and then send the finished task to MiniMax's Video Regeneration endpoint, which turns a 768P H3 result into 2K at $0.05 per output second, according to MiniMax's [pay-as-you-go price page](https://platform.minimax.io/docs/guides/pricing-paygo) as of November 2, 2026. That step is charged separately and bills the original reference video again by its duration, at $0.05 per second. `MiniMax-H3-Max` has no 2K option.

### How long does a MiniMax H3 reference-to-video task take?

The tested 4-second 768P request with one 6-second clip finished in 45 seconds on November 2, 2026. The tested gateway's documentation says 4–5 second 768P videos usually take about a minute, with 2K and reference tasks taking longer, and recommends a 30-minute client timeout. Self-hosted runs are much slower: SGLang's guide shows one reference job taking 260 seconds against 37 seconds for text-to-video on its example GPUs.