Why AI-Generated Footage Breaks Ordinary Compression Settings
Most encoding presets were tuned for camera footage. They assume a sensor, a lens, a certain amount of photon noise, and motion that follows physical laws. Generative video does not behave that way. A diffusion model can produce razor-sharp micro-detail in one region and smooth gradients in another, with temporal shimmer that changes frame to frame. An upscaled model can add texture that looks convincing to the eye but is statistically noisy. Compressors see that noise as information and spend bits on it.
The practical symptoms are familiar: a clip that looks crisp in the preview turns mushy after export, edges crawl during slow pans, skin tones develop blocky patches in shadow, and file sizes balloon past what the runtime should require. None of this means the codec is broken. It means the source has characteristics that the encoder's rate-distortion model handles poorly.
The fix is a pipeline, not a preset. You need to understand what your footage actually contains, clean up what the encoder will waste bits on, choose a codec and bitrate strategy that match the delivery target, and verify the result by measuring and watching. This guide walks through that pipeline end to end, with concrete numbers and decision criteria you can apply to any generative video project.
Know Your Source Before You Touch an Encoder
Every optimization decision starts with an honest inventory of the source. Different generative workflows produce very different artifacts, and the correct response differs too.
Text-to-video output tends to have soft, painterly detail that compresses well but can band badly in skies, fog, and gradients. The enemy here is quantization, not bitrate starvation. Use 10-bit encoding even if you deliver 8-bit.
Image-to-video and video-to-video output often inherits detail from a sharp still frame. That detail is real high-frequency content, and it costs bits. Expect to spend 20–40% more bitrate than a text-only clip of the same length.
Upscaled footage is the worst case. An upscaler invents plausible texture, and that texture is not consistent between frames. It reads as temporal noise, which is expensive to encode and looks artificial when compressed. Always downscale to your delivery resolution before encoding, and consider a light temporal denoise first.
Multi-shot sequences assembled from separate generations introduce seams: exposure shifts, grain pattern changes, and motion discontinuities. Cut on those seams rather than letting an encoder smooth across them. A hard cut costs almost nothing; a blended transition inside a noisy region can cost thousands of bits per frame.
Run one quick diagnostic before you build a preset. Export a five-second representative segment at the same settings you plan to use, then inspect the darkest scene, the brightest scene, and the fastest motion. If any of those three looks wrong, your full-length encode will look wrong too.
Choose a Codec Before You Choose a Preset
Codec choice drives more quality-per-byte than any other single decision. Here is how the mainstream options compare for generative video delivery.
H.264 / AVC is the safe universal fallback. Every device, browser, and player decodes it, usually in hardware. It is also the least efficient option on this list, which means larger files for the same visual quality. Use it when compatibility is non-negotiable, such as email attachments, older set-top boxes, or clients who need files that open anywhere without explanation.
HEVC / H.265 typically delivers comparable quality at roughly 30–50% lower bitrate than H.264. Hardware decode is widespread on phones, tablets, smart TVs, and recent GPUs. Browser support is uneven, so it is a strong choice for app playback, downloadable files, and device-local libraries, but a risky default for a public web page.
AV1 is the best general-purpose option for on-demand web delivery today. It is royalty-free, compresses substantially better than HEVC at the same quality, and hardware decode now ships on current-generation phones and televisions. The trade-off is encode time. Software AV1 encoding can be several times slower than H.264, which matters when you are processing dozens of clips.
VVC / H.266 offers further gains on paper but remains impractical for most production pipelines because of tooling maturity and decode support. Watch it, do not build on it yet.
A simple decision rule: pick AV1 for anything you control end to end and serve from your own player; pick HEVC when the playback environment is an app or a modern device family; pick H.264 when you cannot predict the player at all. Encode one mezzanine master in a high-quality intermediate format, then derive every delivery version from that master rather than from each other.
Bitrate Strategy: CRF, Two-Pass, and Scene-Aware Allocation
Bitrate is not a single number. It is a budget you allocate across a timeline, and generative footage has wildly uneven demands.
Constant quality mode (CRF or CQ) lets the encoder decide how many bits each frame needs. This is the right default for most workflows because it protects complex shots instead of starving them. Useful starting ranges for 1080p generative content: H.264 around CRF 18–21, HEVC around CRF 20–24, AV1 around CRF 24–30. These are starting points, not laws. The correct value is the lowest one that survives a careful viewing test.
Capped CRF adds a maximum bitrate ceiling, which is essential for streaming. Without a ceiling, a single detailed shot can spike past what your player can buffer, causing stalls on the exact moment you wanted to show off.
Two-pass target bitrate is for when you must hit a specific file size or fit a fixed bandwidth window. It is less efficient than CRF in quality terms, but it is predictable. Use it for ad slots, broadcast inserts, and anywhere a hard limit exists.
Per-scene allocation is where experienced editors gain the most. Split the timeline at scene boundaries, assign each segment its own CRF based on visual complexity, then concatenate. Static dialogue shots can run at a high CRF and look identical; a fast pan through detailed foliage may need a much lower one. This avoids the common failure where a single hard scene forces the whole file into a higher average bitrate.
Whichever mode you choose, set a VBV or buffer constraint that matches the delivery platform. A generous buffer on a local file is fine; a loose buffer on a mobile stream is a recipe for rebuffering.
Pre-Encode Cleanup That Saves More Bits Than Any Codec
Cleanup is unglamorous and it outperforms codec upgrades almost every time. Thirty minutes of preparation routinely beats an hour of extra encoding.
Trim ruthlessly. Delete the first and last few frames of every generated clip. Generative models frequently produce a settling or dissolving frame at the boundaries, and those frames are both ugly and expensive.
Deflicker. If luminance pulses between frames, apply a light temporal deflicker. A pulsing exposure change is pure waste from the encoder's perspective.
Denoise with restraint. A mild temporal denoise removes shimmer that the encoder would otherwise chase. Push it too far and you get plastic skin, banded gradients, and lost texture. If you denoise heavily, consider adding a very light synthetic grain after encoding decisions are made, because grain masks banding at low bitrates.
Stabilize before compressing, not after. Global motion that jitters is harder to predict than smooth motion. Stabilizing reduces residual error and shrinks the file.
Normalize color and levels. Inconsistent black levels between shots force extra bits and look wrong on OLED displays. Set your black point and white point consistently across the timeline.
Handle audio separately. Do not let a single pass dictate both. Encode video at high quality, encode audio at a sensible bitrate in AAC or Opus, and mux them together. Audio above 192 kbps stereo rarely helps; audio below 96 kbps often hurts.
Resolution, Frame Rate, and Chroma Decisions
Two mistakes dominate this category: encoding at a resolution nobody will watch, and converting frame rate out of habit.
Encode at your delivery resolution whenever possible. If the final player shows 1080p, do not ship 4K and hope the platform downsamples gracefully. Platforms do downsample, but their transcoders are optimized for camera footage and will often produce worse results than your own controlled downscale. Do the high-quality downscale yourself with a good resampler, then encode.
Frame rate should match the source unless you have a specific reason to change it. Generative clips often run at 24 or 30 frames per second. Converting 30 to 24 requires frame blending or interpolation, both of which invent motion. If you must convert, do it in the editing stage where you can inspect every shot, not in the encoder.
Use 10-bit encoding internally even for 8-bit delivery. Ten-bit precision dramatically reduces banding in gradients, which is the single most common complaint about compressed generative footage. The file size penalty is small relative to the visual gain, and the encoded output can still be tagged as 8-bit for compatibility if needed.
Tag your color metadata explicitly. Untagged footage is guessed at by players, and the guess is often wrong, producing washed-out or oversaturated output. Specify the color primaries, transfer function, and matrix for every deliverable, and verify that the tag survives the encode by inspecting the output file rather than trusting the preset.
Build a Repeatable Encode Pipeline
Ad hoc encoding does not scale. A small, versioned pipeline pays for itself after the third project.
Start by defining a mezzanine master format: high bitrate, visually transparent, lightly compressed, and never delivered directly. Every delivery version derives from it. This prevents the generation loss that comes from re-encoding an already compressed file repeatedly.
Then define named presets for each destination. A preset should specify codec, rate control mode, quality target, maximum bitrate, buffer size, resolution, frame rate, pixel format, color tags, audio codec, and audio bitrate. Write them down in a file in the repository so they can be reviewed and diffed.
Automate the boring parts. A short script can walk a folder of masters, apply the correct preset per destination, name outputs consistently, and write a log of the settings used. Command-line encoders such as FFmpeg or Shutter Encoder are ideal for this because the settings are explicit and reproducible. GUI tools like HandBrake are excellent for one-off jobs and for learning what settings do, but they are slower to audit across dozens of files.
Include a faststart or equivalent flag so that the file's index sits at the beginning. This lets players begin playback before the full download completes, which matters for web delivery and progressive download scenarios.
Finally, keep a short README with the pipeline's assumptions: which source models produce which artifacts, which presets were tuned for them, and what the known problem cases are. Six months from now, that document will save you a day of rediscovery.
Delivery Targets: Web, Social, and Large Screens
Each destination has its own constraints, and treating them identically wastes effort.
Web hero video and landing pages benefit most from AV1 or HEVC with a faststart flag, a capped bitrate, and a poster frame. Keep the first two seconds simple and highly compressed so playback starts instantly. Long detailed intros are the most common cause of slow starts.
Vertical social formats are usually re-encoded by the platform, so your goal is a clean, well-tagged intermediate that survives their transcoder. Slightly higher bitrate than you think you need is the safer choice, because platform transcoders are aggressive. Avoid heavy grain and fine text in the first frame; both get destroyed.
Large-screen and television delivery demands a proper bitrate ladder rather than a single file. Build several renditions, from a low-bandwidth mobile tier to a high-quality tier, and make sure the ladder steps are close enough that switches are not visually jarring. Test the ladder on a real device with a throttled connection if you can.
Audio loudness should be normalized per destination. Web and social platforms generally expect something around -14 LUFS integrated, while broadcast delivery has its own standard. Mismatched loudness makes even a perfect video feel amateurish.
Quality Control: Measure, Then Watch
Objective metrics are useful and insufficient. Use both.
VMAF is the most practical perceptual metric for this work. It correlates better with human judgment than older measures, and it is fast enough to run on every candidate encode. SSIM and PSNR are still useful for catching gross regressions, such as a misconfigured color tag or an accidental resolution drop, but they punish detail loss and reward blur, which is exactly the wrong incentive for generative footage.
The real test is structured watching. Review each candidate encode at 100% zoom on a calibrated display, and again on a phone at arm's length, because that is how most of your audience will see it. Check these specific cases: the darkest scene, the brightest scene, a slow pan, a fast action shot, any frame with small text, and any human face in motion. Faces are unforgiving; banding across a cheek or a shimmer on eyelashes is immediately visible.
Keep a shortlist of previous encodes that you know look good. Comparing a new candidate against a known-good reference is faster and more reliable than judging in isolation.
Common Mistakes and How to Fix Them
Encoding at CRF 18 and calling it lossless. It is not. If you need a true intermediate, use a proper mezzanine codec at a high bitrate, and treat consumer codecs as delivery formats only.
Re-encoding a delivery file to make a smaller delivery file. Always go back to the master. Each generation compounds artifacts.
Upscaling to 4K before encoding. You are paying bits for invented detail that will be thrown away downstream.
Ignoring audio. A 64 kbps audio track can ruin an otherwise excellent export. Encode audio deliberately.
Forgetting faststart. A perfectly encoded file that takes three seconds to begin playing feels broken.
Using uncapped variable bitrate for streaming. Spikes cause stalls. Always set a ceiling and a buffer.
Over-denoising. Smooth footage compresses beautifully and looks like plastic. Preserve texture; remove only temporal instability.
Skipping color tags. Washed-out exports are almost always a tagging problem, not a codec problem.
FAQ
How do I compress generative video without visible quality loss? Encode from a high-quality master, downscale to the delivery resolution yourself, use a CRF in the high-quality range for your chosen codec, and verify with VMAF plus a careful viewing test. There is no setting that guarantees zero loss; the goal is loss that is invisible at normal viewing distance.
What bitrate should I use for 1080p AI video? For H.264, roughly 8–12 Mbps for complex scenes; for HEVC, 5–8 Mbps; for AV1, 4–7 Mbps. Clean, slow, low-detail footage can go much lower. Always test rather than trusting a table.
Is AV1 worth the extra encode time? For on-demand web delivery with modern playback support, yes. For a quick internal review file, no. Match the effort to the audience.
Should I keep a master file? Always. Storage is cheap compared with re-generating or re-editing a project because the only remaining copy is a heavily compressed export.
Why does my compressed video look worse on mobile than on my monitor? Mobile viewing happens at high pixel density on small screens with aggressive platform transcoding. Detail loss and banding that hide on a large display can be obvious on a phone. Test on a real device.
Does frame rate affect file size? Yes, roughly proportionally. Doubling the frame rate at the same quality target roughly doubles the data. If you do not need the extra temporal smoothness, do not pay for it.
