AI-generated example made with MixVio's Burning Bridges AI effect. The lead is an AI-generated portrait, not a real person.

A clip can look fine in your editor and still clip after upload. Social platforms re-encode audio, and a file whose waveform already touches 0 dBFS often has inter-sample peaks above 0 dB once it is reconstructed or transcoded. You hear that as harsh distortion on the loudest beats.

This tutorial shows an ffmpeg true peak limit workflow I used on a 15-second AI party clip: measure with ebur128, resample to 48 kHz, take off a little gain, and run an oversampled limiter so the result sits at or below -1 dBTP. Everything here is about levels only. It says nothing about music rights, which are a separate question.

The example file

The example clip was made with Burning Bridges AI on MixVio: a 15-second 1280x720 video whose effect attaches the original source track after the visual edit. As delivered, its audio was 44.1 kHz stereo, about -12.6 LUFS integrated, with peaks at +1.1 dBFS, so the source track was already clipping before any platform touched it.

That makes it a good test case: we want to fix the peaks without changing the music, the timing or the video.

Step 1: measure integrated loudness and true peak

ebur128 with peak=true reports EBU R128 loudness and a 4x oversampled true-peak value:

ffmpeg -hide_banner -nostats -i in.mp4 \
  -af ebur128=peak=true -f null - 2>&1 | grep -E "I:|Peak:"

On the example clip:

I:         -12.6 LUFS
Peak:        1.1 dBFS

The Peak line in the true-peak section is the number to watch. Anything above about -1 dBTP is likely to clip after a lossy re-encode. Most platforms also normalise playback to around -14 LUFS, so a -12.6 LUFS file will simply be turned down; there is little to gain from leaving it that loud.

Step 2: understand why the sample peak lies

A sample peak only looks at the stored samples. Between two samples the reconstructed analog waveform can rise higher, especially on bright, dense mixes. AAC and Opus encoders work on that reconstructed signal, so a file with sample peaks at -0.1 dBFS can still produce encoded peaks above 0 dB.

True-peak meters estimate this by oversampling (4x here) before taking the maximum. That is why you should limit at a higher sample rate too: a limiter that only sees 48 kHz samples cannot catch overs it does not see.

Step 3: resample, trim gain, oversample and limit

This keeps the video stream untouched (-c:v copy) and only rebuilds the audio:

ffmpeg -i in.mp4 -c:v copy \
  -af "aresample=48000:resampler=soxr,volume=-1.6dB,\
aresample=192000,alimiter=limit=0.84:level=disabled,\
aresample=48000" \
  -c:a aac -b:a 192k out.mp4

What each part does:

• aresample=48000:resampler=soxr converts 44.1 kHz to 48 kHz, the rate most video platforms expect, with the high-quality SoX resampler.

• volume=-1.6dB brings the integrated loudness close to -14 LUFS. This is plain gain; it does not change the mix.

• aresample=192000 upsamples 4x so the limiter can see inter-sample overs.

• alimiter=limit=0.84:level=disabled caps the signal at about -1.5 dBFS (0.84 linear). level=disabled stops alimiter from re-normalising the output back up.

• aresample=48000 returns to the delivery rate.

• -c:a aac -b:a 192k encodes AAC at a bitrate that leaves headroom for the next encode.

Step 4: measure again

Run the same ebur128 command on out.mp4:

I:         -14.2 LUFS
Peak:       -1.9 dBFS

Integrated loudness moved by the gain change only, and the true peak is now below -1 dBTP. A quick check that the format is what the platform expects:

ffprobe -v error -select_streams a \
  -show_entries stream=sample_rate,channels -of csv=p=0 out.mp4
# 48000,2

True peak over time for the source (44.1 kHz), the 48 kHz master and the social export. Chart from ffmpeg ebur128 measurements; the final social export measured -14.3 LUFS and -2.4 dBTP.

The chart comes from a slightly different export of the same chain, which is why its numbers differ from my run by a few tenths of a dB. Both sit well under the -1 dBTP line.

Alternative: two-pass loudnorm

If you would rather target loudness directly, loudnorm can do both jobs. Run it once to measure:

ffmpeg -hide_banner -i in.mp4 \
  -af loudnorm=I=-14:TP=-1.5:LRA=11:print_format=summary \
  -f null -

Then feed the measured values back in a second pass with measured_I, measured_TP, measured_LRA, measured_thresh and linear=true. Linear mode applies a single gain where it can, which keeps the dynamics of a music track intact. If the target would push peaks over the ceiling, loudnorm falls back to dynamic mode, so always re-measure.

For short clips that are already loud, the explicit chain in Step 3 is easier to reason about: one gain value, one limiter, nothing adaptive.

Batch it

A tiny shell loop applies the same chain to a folder of exports and prints the result for each file:

#!/usr/bin/env bash
set -euo pipefail
AF="aresample=48000:resampler=soxr,volume=-1.6dB"
AF="$AF,aresample=192000,alimiter=limit=0.84:level=disabled"
AF="$AF,aresample=48000"
mkdir -p fixed
for f in exports/*.mp4; do
  out="fixed/$(basename "$f")"
  ffmpeg -nostdin -loglevel error -y -i "$f" -c:v copy \
    -af "$AF" -c:a aac -b:a 192k "$out"
  printf '%s ' "$out"
  ffmpeg -hide_banner -nostats -i "$out" -af ebur128=peak=true \
    -f null - 2>&1 | grep -E "Peak:" | tail -n 1
done

Adjust volume per file if your sources differ a lot in loudness; the limiter is there to catch peaks, not to do the loudness work.

Things to keep in mind

• Don't swap the music to fix levels. Gain and limiting change levels, not content. If a platform raises a rights question, that is not something a filter can answer.

• Keep video untouched. -c:v copy avoids a generation loss on the picture.

• Leave headroom. -1 dBTP is a common ceiling; -1.5 to -2 dBTP gives extra safety for platforms that re-encode at low bitrates.

• Check by ear. A limiter working too hard pumps. If you hear it, lower the gain before the limiter instead of pushing the limit lower.

A last note on the example: the effect page states "This is an independent AI effect and is not affiliated with Drake."

Disclosure: written by the MixVio team with AI assistance; the example video was made with MixVio's Burning Bridges AI effect from an AI-generated portrait.

Shorts, Reels and TikTok all draw their own interface on top of your video: a caption and sound label along the bottom, a column of buttons on the right, and status or search elements at the top. Text or faces in those areas get covered.

Checking that by eye on every export gets old quickly. This post builds a small Python script that grabs a few frames from a 9:16 export with ffmpeg, tints the risky areas with Pillow, and saves one contact sheet you can glance at before uploading.

The zones

Every platform draws its UI slightly differently, and the layouts change. Rather than chase exact pixel values, I use one conservative set of zones for a 1080x1920 frame:

• Top 10% (y < 192): status bar, search, account labels.
• Bottom 20% (y >= 1536): caption, sound name, progress bar.
• Right 15% (x >= 918): like, comment, share and profile buttons.

Keep titles and faces out of those areas and the video reads cleanly on all three apps. Defining the zones as fractions keeps the script working for 720x1280 exports too.

What you need

• Python 3 with Pillow (pip install pillow).
• ffmpeg on your PATH.
• A 9:16 export to check.

The example export here is a 17.5-second 1080x1920 short built from a 16:9 clip made with Burning Bridges AI on MixVio. The effect outputs 16:9 only, so the 9:16 version is a letterboxed post-production edit: the 16:9 result sits in the middle of the frame, with a title card at the start and an end card at the end. That makes it a good test case, because the titles live in the letterbox bars, right next to the zones.

The script

import subprocess
import sys
from PIL import Image, ImageDraw

W, H = 1080, 1920
ZONES = {  # name: (box as fractions x0, y0, x1, y1), RGBA tint
    "top 10%": ((0.0, 0.0, 1.0, 0.10), (255, 220, 0, 90)),
    "bottom 20%": ((0.0, 0.80, 1.0, 1.0), (255, 40, 40, 90)),
    "right 15%": ((0.85, 0.0, 1.0, 1.0), (255, 140, 0, 90)),
}


def grab(video, t, out):
    cmd = ["ffmpeg", "-v", "error", "-y", "-ss", str(t), "-i", video,
           "-frames:v", "1", out]
    subprocess.run(cmd, check=True)
    return Image.open(out).convert("RGBA")


def overlay(frame):
    w, h = frame.size
    layer = Image.new("RGBA", frame.size, (0, 0, 0, 0))
    d = ImageDraw.Draw(layer)
    for name, ((x0, y0, x1, y1), rgba) in ZONES.items():
        box = (int(x0 * w), int(y0 * h), int(x1 * w) - 1, int(y1 * h) - 1)
        d.rectangle(box, fill=rgba, outline=rgba[:3] + (255,), width=4)
    return Image.alpha_composite(frame, layer)


def sheet(video, times, out="safezone.png", scale=0.5):
    tiles = []
    for i, t in enumerate(times):
        img = overlay(grab(video, t, f"_f{i}.png"))
        img = img.resize((int(W * scale), int(H * scale)))
        ImageDraw.Draw(img).text((12, 12), f"{t:.2f} s", fill="white")
        tiles.append(img)
    tw, th = tiles[0].size
    out_img = Image.new("RGBA", (tw * len(tiles), th), "black")
    for i, tile in enumerate(tiles):
        out_img.paste(tile, (i * tw, 0))
    out_img.convert("RGB").save(out)
    return out


if __name__ == "__main__":
    print(sheet(sys.argv[1], [0.05, 11.9, 17.0]))

The script has four parts.

ZONES

Each zone is a box in fractions of the frame (x0, y0, x1, y1) plus an RGBA tint. An alpha of 90 out of 255 is enough to see the zone without hiding what is under it, and a solid outline marks the edge. Overlapping zones (the bottom-right corner) simply get darker, which is a useful hint: that corner is covered by both the caption and the buttons.

grab()

grab() asks ffmpeg for one frame at time t. Putting -ss before -i makes ffmpeg seek quickly, which is accurate enough for QA. It writes a PNG and loads it as RGBA so it can be composited.

overlay()

overlay() draws all zones onto a transparent layer the size of the frame and alpha-composites it over the frame. Drawing on a separate layer keeps the tint even; drawing straight onto the frame with a semi-transparent fill would not blend.

sheet()

sheet() grabs each time stamp, overlays the zones, scales each frame to half size, stamps the time in the corner, and pastes the frames side by side. The output is a single RGB PNG.

Choosing the sample times

Pick frames where something important is on screen. For this export:

• 0.05 s: the title card. The first frame doubles as the cover on some platforms.
• 11.9 s: a frame from the main clip, with the persistent label above it and the small print below.
• 17.0 s: the end card.

Run it with the export path:

python3 safezone.py short.mp4
# safezone.png  (1620x960 for three 1080x1920 frames at 0.5 scale)

Reading the result

AI-generated example made with MixVio's Burning Bridges AI effect. The lead is an AI-generated portrait, not a real person.

What to look for:

• Titles outside the tint. The title on the cover frame sits between the top zone and the clip, and clear of the right column.
• Faces outside the tint. The 16:9 clip sits in the middle of the frame, so the lead's face stays clear of every zone. The right edge of the clip falls under the button column; that is acceptable here because only the background is there, but it is exactly what this check is for.
• End card text. Calls to action at the very bottom are the most common mistake; the caption covers them.
• The bottom-right corner. If anything you care about is in the double-tinted corner, move it.

If something sits in a zone, fix the edit and run the script again. It takes a couple of seconds.

Variations

• More frames. Pass a longer list, or sample evenly with [i * dur / 8 for i in range(8)] after reading the duration with ffprobe.
• Different zones. If you only publish to one platform, tighten the fractions for that app's current layout.
• A grid instead of a row. For long exports, paste the tiles into rows of four.
• CI check. Save the sheet next to each export in your render pipeline so every file has a QA image.

Limits

This is a visual aid, not a guarantee. Platforms move UI elements, captions can grow to several lines, and some devices add their own system bars. Treat the zones as "keep important things out", not "everything outside is always visible".

A note on the example clip, from the effect page: "This is an independent AI effect and is not affiliated with Drake."

Disclosure: written by the MixVio team with AI assistance; the example video was made with MixVio's Burning Bridges AI effect from an AI-generated portrait.

The raw data is public: runs.csv and the exact prompts on GitHub (CC BY 4.0). If you disagree with a verdict, every prompt and setting is there to rerun.

Disclosure. I'm Alex Wang and I work on MixVio. All 14 runs were made on MixVio, so this is not a comparison of platforms. Every image and clip referenced here is AI-generated. I edited this text with help from an AI writing assistant; the numbers come from the run log.

The setup

Fixed inputs. Six AI-generated stills of fictional people and products: a ketchup jar with fries in mid-air, a studio portrait, a back view in a flower field, a cafe creator in front of a menu board, a loose pencil sketch, and a perfume bottle with start and end frames.

One variable at a time. Within a shot, either the model changed and the prompt stayed byte-for-byte identical, or the prompt changed and the model stayed the same. Runs 01 and 04 are the prompt pair: same jar, same model (Seedance 2.0), same price, different prompt. Runs 01 and 03 are a model pair with the same prompt. Duration stayed at each model's default (5 s, or 6 s for Veo 3.1 Fast). Resolution did not stay fixed, which comes up again under limitations.

Serial jobs. One job at a time on one account. Run 05's wait still includes queue time, and the log says so.

The run log schema

Thirteen columns:

run, shot, source_ratio, mode, model, settings, prompt,
credits_paid, credits_list, wait_minutes_approx,
output_resolution, kept, notes

A few of these earned their place:

• credits_paid and credits_list are separate. Four of the five models were discounted on test day, and a single price column would make the totals meaningless a week later.

• source_ratio sitting next to output_resolution exposes silent reframing. The 16:10 ketchup photo came back from Seedance 2.0 as 864x496 with the ratio on Auto, which is roughly 16:9.

• prompt is stored verbatim rather than as a template ID, so "same prompt" is checkable, not a claim.

• kept is the verdict, defined as "would I publish this clip as-is?"

Three rows, with prompts and notes shortened:

04,"Ketchup jar, scene-style prompt",16:10,start frame,Seedance 2.0,480p,"A bright studio product shot of a ketchup jar…",33,65,5,864x496,no,"Model added action nobody asked for…"
09,Cafe creator holding a donut box,16:9,start frame,MiniMax H3,5 s; 768p,"She lifts the box slightly toward the camera and says…",15,15,2,1344x768,picture only,"Stable picture and a clear menu board, but a garbled phrase was added before the line…"
12,"Perfume bottle, glass to crystal",about 9:16,start + end frame,MiniMax H3,5 s; 768p,"The clear glass slowly transforms into cut crystal…",15,15,1.5,768x1376,yes (best),Smooth change from glass to cut crystal between about 1 s and 2.5 s. …

What I'd change next time: kept ended up with five distinct values (yes, no, yes (second choice), yes (best), picture only), and wait_minutes_approx has one non-numeric cell (7.5 (incl. queue)). Fine for a human, annoying in pandas. A boolean usable, a rank and a queued flag would fix it.

Reviewing clips without scrubbing

Cuts, camera drift and text changes hide in motion, so I reviewed every clip as frame strips and contact sheets. A single-row strip at two frames per second is one command with ffmpeg's tile filter:

ffmpeg -i run11.mp4 -vf "fps=2,scale=256:-2,tile=10x1" -frames:v 1 run11-strip.png

Ten tiles at 2 fps covers a 5 s clip; widen the grid for longer ones.

For the two clips with scripted speech, I transcribed locally with Whisper and compared the text against the script. SRT output keeps timestamps, so you can see where extra words land:

whisper run09.mp4 --model base --language en --output_format srt

The metric: cost per usable clip

Average cost per run is the number a pricing page gives you, and it's the wrong one. The session cost 386 credits for 14 runs, about 28 per run. Only 7 clips were usable, so the real figure was about 55 credits per usable clip, roughly double. At list prices the same 14 runs would have cost 750 credits; MiniMax H3 was the only model that wasn't discounted.

The gap between 28 and 55 is the retry tax, and it's the part that prompting and model choice can move. The pencil sketch alone used 86 credits over three runs and produced nothing usable.

What the data showed

1. Motion prompts beat scene prompts. Run 01 described what moves and ended with "Keep the jar label sharp and unchanged, background still." Run 04 described the picture like an image prompt, at the same 33 credits, and the model invented action: whole potatoes launched out of the sack, a sparkle effect appeared, the camera rose, and a surface that isn't in the photo showed up under the jar. Explicit "keep X unchanged" clauses held up well: the jar label survived all three ketchup runs, and all nine menu-board prices survived both cafe runs.

Run 01 (motion prompt) next to run 04 (scene prompt), same photo and model. AI-generated.

2. Camera instructions were the least reliable field. Seedance 2.0 pushed "slow push-in" all the way to a label close-up. Kling 3.0 ignored it. "Locked-off camera" and "camera stays still" both drifted on Seedance 2.0. Direction words failed too: "to the left over her shoulder" went to her left on Seedance 2.0 Mini and the opposite way on Veo 3.1 Fast. She faces away from the camera, so her left is also screen left; Veo simply got it wrong. Write "screen left" anyway, so the side never depends on which way the subject faces.

3. Start and end frames went 2 for 2. Both perfume runs were usable. MiniMax H3 (15 credits, about 1.5 minutes) kept the QUIETUDE label crisp throughout the change; Seedance 2.0 at 480p got there but softer, with slight drift.

The label at four points in run 12 (MiniMax H3), from start frame to end frame. AI-generated.

4. Some inputs shouldn't be animated. The pencil sketch failed three times. Seedance 2.0 Mini redrew it as clean cel animation. Kling 3.0 hard-cut to a new angle after about 2 s and swapped the goggles for headphones. The retry with "Continuous single shot, no cuts" removed the cut, but the pencil texture was still gone.

Frames from run 11 (Kling 3.0) showing the unwanted cut. AI-generated.

5. Speech needs a transcript check. Seedance 2.0 said the line word for word. MiniMax H3 added a garbled phrase before it and slurred "gummy". The picture was good enough to ship; only the transcript caught the problem.

On wait times, Kling 3.0, MiniMax H3 and Veo 3.1 Fast finished in about 1.5 to 2 minutes, while Seedance 2.0 took 3.5 to 7.5.

Limitations

• One run per verdict. These models are stochastic and I didn't repeat any configuration, so there is no variance estimate. A "no" could be bad luck; a "yes" could be good luck.

• Resolution wasn't controlled. Seedance runs were at 480p, Kling 3.0 and Veo 3.1 Fast at 720p, MiniMax H3 at 768p. Judgments about soft text partly reflect that.

• Single platform, single day. Prices and model behavior change, and other platforms may configure the same models differently.

• One reviewer. kept is my judgment, not a blinded rating.

• No model-side failures happened, so the log says nothing about how failed jobs are billed.

• Small n. Six images and 14 runs are enough to surface failure modes, not to rank models.

If you rerun a row, especially the same row several times to get at variance, I'd like to see the result.

Where the runs were made

Every run went through MixVio's image to video tool, which puts these five models behind one upload and shows the credit price before each run; that's where the two price columns came from. I work there, which made it the convenient harness; nothing here shows it is better or worse than alternatives. Runway's image-to-video prompting guide is a good platform-neutral read on prompting with the motion a photo already implies. A longer, less technical write-up with more clips is on Medium.

Alex Wang works on MixVio AI.

Nano Banana 2.1 is useful when the job depends on readable text, multiple reference images, or a controlled edit. This guide shows a practical workflow for those cases using Nano Banana 2.1 on MixVio.

Disclosure: This guide is published by MixVio AI and describes the model as it is configured on MixVio.

1. Choose the right starting mode

Start with text-to-image when you are creating a new scene. Start with image edit when composition, identity, packaging, lighting, or another part of an existing image must survive the change.

That decision changes how you should write the prompt:

• For a new image, describe the subject, composition, exact words, typography, lighting, and output format.

• For an edit, state the requested change first, then list what must remain unchanged.

A vague edit prompt such as “make it better” gives the model too much freedom. A useful edit prompt creates a boundary around the change.

2. Build poster prompts around exact strings

For posters and product graphics, put every required line of copy in quotation marks. Then describe its role in the hierarchy.

Example prompt

Vintage concert poster, 2:3, warm sunset palette. Large headline: “SUMMER NIGHTS LIVE.” Smaller subline: “Riverside Park · Free Entry.” Bold retro typography, strong separation between text and background, silhouettes of a crowd at the bottom.

This prompt does four useful things:

1. It supplies the exact text.

2. It defines which line is primary and which is secondary.

3. It separates typography from the visual background.

4. It fixes the output shape before the scene is composed.

Use 2K or 4K when the design contains dates, labels, disclaimers, or other small text. At 1K, fine type has fewer pixels to work with and is more likely to blur.

After generation, inspect every character. Readable text is improved, but a final proofread is still part of the workflow.

3. Give every reference image a job

In image edit mode, Nano Banana 2.1 accepts 1–14 JPEG, PNG, or WebP images on MixVio. The cleanest way to use several references is to assign each upload a role by position.

Example prompt

Place the bottle from image 1 and the box from image 2 on the marble counter shown in image 3. Use soft morning window light. Keep both product labels unchanged. Preserve the bottle proportions and the box colors.

Avoid asking the model to infer why each image was uploaded. Explicit roles reduce ambiguity:

• “image 1 is the product”

• “image 2 is the packaging reference”

• “image 3 supplies the environment”

• “image 4 supplies the lighting direction”

Google’s prompt guidance mentions up to four characters and ten objects. Treat that as composition guidance, rather than a different upload limit. The practical limit on MixVio remains 14 images.

For products, preserve observable details in the prompt: label spelling, cap shape, materials, proportions, and brand colors. For people, name the features that matter and check faces and hands closely after generation.

4. Write precise edits as change-and-lock instructions

A reliable edit prompt has two parts:

1. Change: the one thing the model should modify.

2. Lock: the details that must stay the same.

Example

Change the background to pale sage green. Keep the model, outfit, pose, crop, facial features, and lighting unchanged.

For a packaging edit:

Replace only the headline on the front label with “NIGHT RENEWAL.” Keep the bottle shape, label layout, logo, colors, shadows, and camera angle unchanged.

If a result drifts, add concrete locks instead of adding general adjectives. “Keep the camera at eye level” is more actionable than “make it consistent.”

5. Match output settings to the destination

Nano Banana 2.1 supports 1K, 2K, and 4K output on MixVio. It also supports common landscape, square, portrait, and extreme aspect ratios.

A useful starting map is:

The Thinking setting controls how much reasoning the model applies to the request. It is not a simple quality selector. Minimal can be enough for a straightforward variation; Medium is a sensible default; High is better reserved for prompts with several constraints.

Optional web search is most useful when an image depends on current real-world information. Leave it off for ordinary fictional scenes, product mockups, and controlled edits.

6. Validate the result before using it

Before exporting, check the image at 100% zoom:

• Is every required word spelled correctly?

• Did any label, logo, or product feature change?

• Are faces, hands, and repeated objects consistent?

• Did the edit preserve the locked details?

• Is the crop appropriate for the destination?

• Does small text remain readable at the final display size?

When something fails, revise only the relevant part of the prompt. For example, add an exact label string or another lock constraint instead of rewriting the whole scene description.

7. Estimate the run before generating

MixVio shows the exact credit estimate before each run. Current Nano Banana 2.1 pricing is:

• 1K: 6 credits, or 7 with web search

• 2K: 9 credits, or 10 with web search

• 4K: 12 credits, or 13 with web search

Creating and editing use the same schedule. Reserved credits are released when a run fails.

A sensible test sequence is to validate composition at 1K or 2K, then move to 4K for the final version when the text, references, and crop are working. Always check the estimate shown in the generator before submitting because product pricing can change.

A reusable prompt template

For a new image:

[Format and aspect ratio]. [Main subject and composition]. Exact headline: “[TEXT].” Subline: “[TEXT].” [Typography]. [Lighting]. [Background]. Keep the text clearly separated from detailed visual elements.

For an edit:

Change [one specific element]. Keep [identity, product shape, labels, pose, crop, lighting, colors, and any other fixed details] unchanged.

You can try these workflows on the Nano Banana 2.1 model page. New MixVio accounts currently receive 40 welcome credits valid for seven days, with no credit card required.