Video Aspect Ratio: Common Sizes, Formats, and How to Change It

One video aspect ratio ran the industry for more than half a century. The 4:3 frame held from the first moving-picture cameras until widescreen formats arrived in 1953 to answer television, and then 16:9 became the international HDTV standard, which settled the question for about two decades.

Mobile unsettled it again. A single 1920×1080 master now has to land on a 21:9 ultrawide monitor, a 16:9 living-room TV, and a 9:16 phone held upright. The width-to-height decisions in your pipeline decide whether it fills the screen or shows up boxed in black.

Video aspect ratio is the proportion between a frame’s width and its height. That sounds like one number you set once.

In a real pipeline it’s four numbers set in four places, and they can disagree with each other. That disagreement is what produces stretched faces, sideways phone clips, and layouts that jump when a player switches quality.

What Is Video Aspect Ratio?

Video aspect ratio is the proportional relationship between a video frame’s width and its height, written as width:height. A 16:9 frame is 16 units wide for every 9 units tall, which works out to 1.778:1.

Two things follow from that definition.

The ratio describes shape, not size. A 640×360 clip and a 3840×2160 clip are both 16:9. They differ in resolution, pixel count, and file size, but they’re the same shape, so they fill the same screen without bars or distortion.

The ratio is also a display property, not just a storage property. What you count in the file is a pixel grid, and what the viewer sees is that grid rendered on a display. Those two can differ if the pixels aren’t square.

Most modern video uses square pixels, so the grid and the display shape match. Older and anamorphic formats break that assumption.

Aspect ratio exists because capture and display hardware evolved separately. Cameras, film gauges, broadcast standards, monitors, and phones each settled on their own frame shape, so any real delivery chain has to reconcile at least two of them.

Video Aspect Ratio vs Resolution vs Pixel Aspect Ratio

These three get used interchangeably, and mixing them up is the root cause of most stretched-video bugs. Here’s the split.

Resolution is the pixel count: 1920×1080, 3840×2160, 1080×1920. It’s an absolute measurement of detail.

Aspect ratio is the shape those pixels form when displayed. Derived, relative, unitless.

Pixel aspect ratio (PAR) is the shape of one individual pixel. Square pixels are 1:1. Anything else means the stored grid and the displayed frame have different proportions.

One formula connects all three. Storage aspect ratio times pixel aspect ratio equals display aspect ratio, or SAR × PAR = DAR.

Storage aspect ratio is what you get by dividing the stored width by the stored height. Display aspect ratio is the shape the viewer actually sees. Run the numbers on two real formats:

• PAL standard definition, 16:9. Stored at 720×576, so SAR is 1.25. PAR is 64:45, or 1.422. Multiply: 1.25 × 1.422 = 1.778, which is 16:9 on screen. The same 720×576 grid with a 16:15 PAR displays as 4:3 instead.
• Anamorphic HDV. Stored at 1440×1080, so SAR is 1.333. PAR is 4:3, or 1.333. Multiply: 1.333 × 1.333 = 1.778. Again 16:9, from a grid that counts as 4:3.

One naming trap trips up nearly everyone reading FFmpeg output. In the H.264 specification and in FFmpeg logs, “SAR” means sample aspect ratio, which is the same thing as pixel aspect ratio. It isn’t storage aspect ratio.

So a line like 1920x1080 [SAR 1:1 DAR 16:9] is telling you the pixels are square and the display shape is 16:9.

Check which values a file actually carries before you assume:

ffprobe -v error -select_streams v:0 \
  -show_entries stream=width,height,sample_aspect_ratio,display_aspect_ratio \
  -of csv=p=0 input.mp4

If that returns 1920,1080,1:1,16:9, the file agrees with itself. If it returns 1440,1080,4:3,16:9, you’re holding anamorphic video and any tool that ignores PAR will render it squeezed.

Common Video Aspect Ratios and Their Resolutions

Aspect ratio choice is really a distribution decision, so it helps to know which shape belongs to which screen.

16:9 (Widescreen)

The default for landscape video and the international HDTV standard. Every common landscape resolution is 16:9: 1280×720, 1920×1080, 2560×1440, and 3840×2160.

Use it for anything watched on a TV, monitor, or laptop. That includes OTT catalogs, webinars, product demos, gaming streams, and long-form YouTube. If you only ship one landscape master, ship this one.

9:16 (Vertical)

16:9 rotated. The standard resolution is 1080×1920, with 720×1280 as the lighter option.

It fills a phone screen held upright, which is why TikTok, Instagram Reels, YouTube Shorts, and Stories all default to it. If your audience discovers content on a phone, vertical is the native shape, and our guide to vertical video dimensions goes deeper on the numbers.

1:1 (Square)

1080×1080. A square frame takes more vertical space in a feed than landscape without committing to a full-height portrait crop.

It’s the safe middle when one asset has to work across several social feeds. It’s a compromise, though, so it wins nowhere outright.

4:5 (Portrait Feed)

1080×1350. Taller than square, shorter than full vertical.

Instagram and Facebook in-feed posts favor it because it claims screen height while still leaving room for the caption and interaction row.

4:3 (Fullscreen)

640×480, 1024×768, or 1440×1080 anamorphic. This was the broadcast and early-computer standard before widescreen.

You’ll still meet it in archive footage, older camera output, document cameras, and plenty of IP security cameras. If you ingest from cameras over RTSP, expect some 4:3 sources and plan how you’ll frame them.

21:9 (Ultrawide / Cinematic)

2560×1080 and 3440×1440. The marketing name says 21:9, but 2560×1080 reduces to 64:27, which is 2.37:1.

It matches ultrawide monitors and approximates theatrical widescreen. Outside cinema and PC gaming it’s rare, and it letterboxes heavily on a normal TV.

2.39:1 and 1.85:1 (Theatrical)

The two projection standards. 1.85:1 is the American flat standard, and 2.39:1 is anamorphic scope. In a DCI 4K container that’s 3996×2160 for flat and 4096×1716 for scope.

Feature and premium episodic content is finished here, which is why so much streaming catalog content shows black bars on a 16:9 display.

How to Calculate Video Aspect Ratio

To find the aspect ratio of a video, divide the pixel width by the pixel height, then reduce that fraction to its smallest whole numbers using the greatest common divisor.

Three steps:

1. Divide width by height for the decimal ratio. 1920 ÷ 1080 = 1.778.
2. Find the greatest common divisor of the two numbers. For 1920 and 1080, that’s 120.
3. Divide both sides by it. 1920 ÷ 120 = 16 and 1080 ÷ 120 = 9, so the ratio is 16:9.

Run the same method on other resolutions:

• 3840×2160 → GCD 240 → 16:9
• 1280×720 → GCD 80 → 16:9
• 1080×1920 → GCD 120 → 9:16
• 1024×768 → GCD 256 → 4:3
• 1080×1350 → GCD 270 → 4:5
• 2560×1080 → GCD 40 → 64:27 (sold as 21:9)

Two of those results are worth pausing on. 16:9 and 9:16 are the same ratio with the terms swapped, which is why a vertical clip is just a rotated widescreen frame.

And 2560×1080 shows that marketed ratios are sometimes rounded. Calculate rather than trust the label.

Reverse the math to get dimensions from a target ratio. For 9:16 at 1080 wide, multiply 1080 by 16/9 to get 1920 tall.

One constraint to respect: keep both numbers even. H.264 and H.265 with 4:2:0 chroma subsampling store color at half resolution in each direction, so odd dimensions either fail to encode or get silently adjusted.

H.264 also works in 16×16 macroblocks, so dimensions that are multiples of 16 avoid the cropping flags encoders otherwise have to write into the bitstream.

Where Aspect Ratio Gets Set in a Video Pipeline

Aspect ratio isn’t one setting. It’s recorded or implied at four stages, and a mismatch at any one of them produces a visible bug.

1. Capture and ingest. The camera or encoder decides the source frame. A phone shoots 1080×1920, a webcam 1280×720, an IP camera maybe 1024×768. If you accept RTMP or SRT from third parties, treat the incoming ratio as unknown until you probe it.

2. Transcode. This is where you can change shape by scaling, cropping, or padding. It’s also where video transcoding settings can accidentally change shape, usually by scaling width and height independently.

3. Bitstream and container metadata. The ratio gets written twice, in two places that can disagree. H.264 signals it in the SPS VUI through aspect_ratio_idc or explicit sar_width/sar_height, while MP4 signals it in the pasp box in the video track. When those two conflict, different players resolve it differently, which is exactly why one file looks right in VLC and squeezed in a browser.

4. Packaging and playback. Your manifest carries resolution per rendition, and the player element carries a box that the frames get fitted into. Both stages can override what the viewer sees.

The rotation matrix in the MP4 tkhd box deserves its own mention, because it causes the classic sideways-phone-video bug. A phone often records 1920×1080 landscape pixels plus a 90-degree rotation flag, expecting the player to turn the frame.

Players that honor the flag show correct vertical video. Tools that ignore it show a sideways 16:9 frame.

Modern FFmpeg auto-rotates by default. But anything that reads raw dimensions from the container without checking that matrix will get the shape wrong.

Video Aspect Ratio by Platform

Every destination publishes its own preferred frame, and they don’t agree. Here’s what to target as of 2026.

Two rules make this table easier to act on.

Match the output ratio to the primary consumption device, not the capture device. Reframe a 16:9 webcam feed to 9:16 when your audience is phone-first, rather than shipping the ratio it happened to record in.

And respect safe zones. Platform UI covers part of the frame, so keep captions, logos, and lower-third graphics inside the middle 70% vertically on 9:16 content. YouTube’s upload encoding recommendations spell out the same idea for landscape.

When one production has to reach several of these destinations, pick one ingest ratio and let your distribution layer fan it out. That’s the practical shape of streaming to multiple platforms at once.

What Goes Wrong When Aspect Ratios Don’t Match

No pipeline avoids mismatches entirely, because sources and destinations genuinely differ. What matters is which failure mode you choose.

Letterboxing and pillarboxing

Put a wide frame in a tall window and you get horizontal black bars above and below, which is letterboxing. Put a tall frame in a wide window and you get vertical bars on the sides, which is pillarboxing.

Both preserve the whole image and the correct geometry. They cost screen area, and on a phone a pillarboxed 16:9 clip can end up using less than a third of the display.

The fix: reframe for the destination instead of relying on the player to pad.

Stretching and squeezing

Scale width and height by different factors and every object in the frame distorts. Faces widen, circles turn into ovals.

Viewers notice this one immediately. It almost always comes from forcing an output resolution without accounting for the source ratio.

The fix: scale proportionally, then pad or crop for the difference.

Lost content from cropping

Cropping fills the frame, but everything outside the crop window is gone. Center-cropping a 16:9 interview to 9:16 discards roughly two thirds of the width, which routinely cuts off a second speaker or burned-in captions.

The fix: reframe around the subject, or shoot wider than your delivery ratio so there’s margin to work with.

Metadata disagreement

The bitstream says one PAR, the container says another, and each player picks a winner. The file then renders correctly in one app and squeezed in the next, with no visible cause in the pixels themselves.

The fix: normalize the metadata on ingest so both layers state the same thing.

Encoding artifacts from odd dimensions

Non-even dimensions collide with 4:2:0 chroma subsampling, and dimensions far off a multiple of 16 add cropping flags that some decoders handle poorly. Symptoms range from a one-pixel green edge to an outright encoder error.

The fix: round every output dimension to an even number, and to a multiple of 16 where you can.

Wasted bitrate on padded pixels

Bake black bars into the frame and you’re encoding those bars. They compress well, so the cost is small, but it isn’t zero, and it’s permanent. A padded 9:16 upload of a 16:9 source spends part of its bitrate budget on black.

The fix: pad at playback with the player box rather than in the encoded frame, whenever the destination allows it.

Now that you know how the ratio behaves and where it breaks, here’s how to control it: the commands that change it, the pipeline settings that hold it, and the checklist for picking one.

How to Change a Video’s Aspect Ratio

Three operations change the shape of a frame: crop, pad, or rewrite the metadata. Which one you pick depends on whether you’re willing to lose content, lose screen area, or neither.

Option 1: Crop to fill the frame

Cropping cuts pixels away so the remaining frame matches the target ratio. It fills the screen and loses whatever fell outside the window.

Convert 1920×1080 to 9:16:

ffmpeg -i input.mp4 \
  -vf "crop='trunc(ih*9/16/2)*2':ih,scale=1080:1920" \
  -c:a copy output.mp4

The trunc(...)*2 wrapper is doing real work. A 9:16 crop of a 1080-pixel-tall frame wants 607.5 pixels of width, and that isn’t a legal dimension, so the expression rounds down to the nearest even number. The scale step then resizes to exactly 1080×1920.

By default crop centers the window. Shift it with explicit x and y values when your subject isn’t centered:

ffmpeg -i input.mp4 -vf "crop=606:1080:400:0,scale=1080:1920" -c:a copy output.mp4

Option 2: Pad to letterbox or pillarbox

Padding keeps the entire image and fills the leftover space with bars. Nothing is lost and nothing is distorted.

Fit a 1080×1920 vertical source into a 16:9 frame:

ffmpeg -i input.mp4 \
  -vf "scale=1920:1080:force_original_aspect_ratio=decrease:force_divisible_by=2,\
pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black" \
  -c:a copy output.mp4

Two flags carry this command. force_original_aspect_ratio=decrease scales the source to fit inside the target box without distortion, and force_divisible_by=2 keeps the result even. The pad filter then centers that scaled frame in a 1920×1080 canvas.

Swap black for any color if bars are part of your brand treatment.

Option 3: Rewrite the metadata only

Sometimes the pixels are fine and only the signaled ratio is wrong. The setsar and setdar filters change what the file claims without resampling anything, and the FFmpeg filter documentation spells out how they interact.

ffmpeg -i input.mp4 -vf "setsar=1/1,setdar=16/9" -c:v libx264 -crf 20 -c:a copy output.mp4

Use this to fix anamorphic source that players are rendering squeezed, or to strip an incorrect PAR from a legacy file. It won’t fix a genuinely mis-shaped frame, because no pixels move.

Option 4: Scale within the same ratio

If the shape is already right and you only need different dimensions, scale one axis and let FFmpeg derive the other:

ffmpeg -i input.mp4 -vf "scale=1280:-2" -c:a copy output.mp4

The -2 tells FFmpeg to compute the height from the source ratio and round to an even number. This is the safest resize you can run, because it can’t distort geometry.

Do it with an API instead of a render farm

Running these commands once is easy. Running them for every upload, at every rung of a ladder, is a service you now have to operate, along with the queue, the retries, and the storage around it.

That’s the point where a video API earns its keep. LiveAPI accepts RTMP, SRT, RTSP, and direct file uploads up to 4K, then encodes into an adaptive bitrate ladder and HLS output. Instant encoding means videos are playable seconds after upload no matter how long they run.

You set the frame shape at your encoder or in your source file, and the platform carries it through transcoding, packaging, and its embeddable HTML5 player. No transcode workers to maintain. The video upload API covers files of any size or format, including URL imports.

Verify before you ship

Always probe the output rather than trusting the command:

ffprobe -v error -select_streams v:0 \
  -show_entries stream=width,height,sample_aspect_ratio,display_aspect_ratio,r_frame_rate \
  -of default=noprint_wrappers=1 output.mp4

Check three things in the output:

• Both dimensions are even numbers
• The sample aspect ratio is 1:1 for square-pixel delivery
• The display aspect ratio is the shape you intended

How to Handle Video Aspect Ratio in a Streaming Pipeline

For live and on-demand streaming, the ratio has to survive four more stages after the file is correct. Each one needs a decision.

Keep the ladder in one ratio

Every rung of your adaptive bitrate ladder must share the same aspect ratio. If one rung is 16:9 and another is 4:3, players resize the video element mid-stream on a quality switch and viewers see the frame jump.

A clean 16:9 ladder looks like 3840×2160, 1920×1080, 1280×720, 854×480, and 640×360. Note the 854 rather than 853.33, rounded up to stay even. For 9:16, run 1080×1920, 720×1280, 540×960, and 360×640.

Hold frame rate and keyframe interval constant across rungs too, so switches stay invisible.

Signal the ratio in the manifest

HLS declares dimensions per variant in the RESOLUTION attribute of each #EXT-X-STREAM-INF tag:

#EXT-X-STREAM-INF:BANDWIDTH=5000000,RESOLUTION=1920x1080,CODECS="avc1.640028,mp4a.40.2"
1080p/index.m3u8

MPEG-DASH is more explicit. Representation elements carry @width, @height, and @sar, and the parent AdaptationSet carries @par for the picture aspect ratio, so a compliant player can size its viewport before it fetches a single segment.

Both formats assume your fragmented MP4 segments agree with what the manifest claims. When they don’t, players trust the bitstream and your layout breaks.

Size the player container correctly

Client-side, the aspect ratio is a CSS problem. Reserve the space with aspect-ratio so the page doesn’t shift while the stream loads, then decide how frames fit the box:

.player-wrapper {
  width: 100%;
  aspect-ratio: 16 / 9;
  background: #000;
}

.player-wrapper video {
  width: 100%;
  height: 100%;
  object-fit: contain; /* letterbox: shows the whole frame */
}

object-fit: contain preserves the full frame and adds bars where the shapes differ. object-fit: cover fills the container and crops the overflow. fill stretches, so avoid it in delivery code.

If you’re wiring this up with hls.js or a framework component, read dimensions from the loaded level rather than hardcoding them, and our React video player guide shows that pattern. A video player API that handles responsive sizing removes the problem from your codebase entirely.

Normalize on ingest

Probe every incoming stream and normalize it to one house ratio before you transcode. It’s the single most useful habit in a multi-source pipeline.

Four steps do it:

• Set an explicit PAR
• Strip or apply the rotation flag
• Round both dimensions to even numbers
• Record the source ratio so you can reframe later

That single step prevents most downstream surprises, whether frames arrive from a phone, a browser capture, or a hardware live streaming encoder. It also makes embedding predictable when you embed a live stream on a website with a fixed layout.

Choosing the Right Aspect Ratio for Your Project

Pick the ratio from where your video gets watched, then work backwards to capture.

Go with 16:9 if:

• Viewers watch on TVs, laptops, or desktop monitors
• You’re shipping OTT, webinars, courses, or long-form video
• Your content has wide framing, multiple speakers, or shared screens
• You want one master that works across the most destinations
• Your archive is already landscape

Go with 9:16 if:

• Discovery happens on TikTok, Reels, or Shorts
• Your audience watches almost entirely on phones
• The subject is a single person, product, or close-up
• You’re building a mobile-first app where video is full-screen

Go with 1:1 or 4:5 if:

• The asset has to work across several social feeds without recuts
• In-feed impressions matter more than immersive playback

Reconsider a single ratio if:

• You publish to both TV-class and phone-first destinations
• Your source is 4:3 or theatrical and neither crop nor pad is acceptable
• Reframing would cut off captions, graphics, or a second subject

In that last case, produce two outputs rather than compromising on one. Capture wider than your delivery ratio, cut a landscape master and a vertical version, and run both through the same encoding workflow so quality stays consistent.

Video Aspect Ratio FAQ

What is the standard video aspect ratio?

16:9 is the standard for landscape video and the international HDTV format. It covers 1280×720, 1920×1080, 2560×1440, and 3840×2160. For mobile-first content, 9:16 at 1080×1920 is the de facto standard.

What is 16:9 in pixels?

16:9 isn’t a fixed pixel count, since it’s a shape. Common 16:9 resolutions are 640×360, 1280×720, 1920×1080, 2560×1440, and 3840×2160. Any width and height that divide down to 16:9 qualifies.

What’s the difference between aspect ratio and resolution?

Resolution is the absolute pixel count, like 1920×1080. Aspect ratio is the proportion those pixels form, like 16:9. Different resolutions can share one ratio, which is exactly how an adaptive bitrate ladder switches quality without changing frame shape.

Why does YouTube add black bars to my video?

YouTube’s player is 16:9, so anything narrower gets pillarboxed with vertical bars and anything wider gets letterboxed with horizontal bars. Upload at 16:9 for standard videos, or 9:16 for Shorts, and the bars disappear.

How do I change the aspect ratio of a video without cropping?

Pad instead of crop. Scale the source proportionally to fit inside the target frame, then fill the remaining space with bars using FFmpeg’s scale with force_original_aspect_ratio=decrease followed by pad. Nothing gets cut and nothing gets distorted, but you lose some screen area.

Does aspect ratio affect video quality or file size?

Not directly, since ratio describes shape and resolution drives pixel count. It affects file size indirectly in two ways: taller frames at the same width carry more pixels, and baked-in black bars consume a small share of your bitrate.

What is the best aspect ratio for live streaming?

16:9 for desktop and TV destinations like Twitch, LinkedIn Live, and standard YouTube, and 9:16 for phone-first destinations. Decide before you go live, because reframing a live stream mid-broadcast means either cropping or padding in real time.

What is pixel aspect ratio and do I still need to care?

Pixel aspect ratio is the shape of an individual pixel. Modern video uses square 1:1 pixels, so you can usually ignore it. It still matters with standard-definition, anamorphic, and older camera formats, where a non-square PAR is what makes a 1440×1080 grid display as 16:9.

Is 4:3 still used anywhere?

Yes, in narrower places. Archive footage, older camera output, document cameras, and many IP security cameras still produce 4:3. If you ingest from third-party sources, handle it rather than assuming everything arrives widescreen.

Can I deliver more than one aspect ratio from one stream?

Not from a single encoded rendition, since each rendition has one frame shape. You’d produce separate outputs from the same source, either by encoding two ladders or by reframing server-side. Keep each ladder internally consistent so quality switches stay smooth.

Getting the Frame Right

Video aspect ratio looks like a creative choice and behaves like a pipeline property. The shape gets asserted at capture, changed at transcode, recorded in both the bitstream and the container, declared in the manifest, and finally interpreted by a player box.

Any of those five can contradict the other four.

Five habits prevent nearly every aspect ratio bug:

• Probe your source instead of assuming its shape
• Normalize everything to one house ratio on ingest
• Keep every dimension even
• Hold the ratio constant across your ABR ladder
• Let the player pad, rather than baking bars into pixels

Ready to ship video that holds its shape end to end? LiveAPI handles RTMP, SRT, and RTSP ingest up to 4K, instant encoding into an HLS adaptive bitrate ladder, and an embeddable player that plays back correctly across screen sizes. Try LiveAPI free and go live in days instead of months.