A vertical meme clip is supposed to be 9:16. That is the shape tinydeskoutstanding.video describes as a "15-second vertical" reference, and it is the shape you will post if you send the file to Stories or Reels. Coded width and height are not enough to prove it. The file also has a sample aspect ratio (SAR) and a display aspect ratio (DAR). If those tags are missing, most players assume square pixels. If they are present and not 1:1, a 720×1280 file can display as something that is not 9:16 at all.
I re-downloaded the eight public samples from the homepage today (18 November 2026, 12:28 Asia/Shanghai), SHA-256-verified them (ok=8 fail=0), and measured coded size, SAR, DAR and display size with ffmpeg 7.1.5 and a short Python script. Two gallery files are not 9:16. The official reference is 9:16 in pixels but does not tag SAR or DAR. A synthetic clip with the same 720×1280 coded frame and SAR=2:1 displays as 1440×1280.
This is a measurement article, not a pricing article. The live pricing page today still lists a single run, same for Just Me, Back Row and Whole Band, at $9.98 (998 credits) for 480p, $12.98 (1,298) for 720p, $24.98 (2,498) for 1080p and $39.98 (3,998) for 4K, with tables recorded on November 12, 2026. I am quoting those numbers only because I re-checked the page this afternoon.
What "9:16" actually means in a file
9:16 is the displayed width over height, not merely the coded pixel grid. For a video stream:
- coded
width×heightis the number of luma samples stored in each frame -
sample_aspect_ratio(SAR) is the shape of one of those samples - display width is
coded_width × SAR, display height iscoded_height -
display_aspect_ratio(DAR) should equal display width / display height
Exact 9:16 is the rational 9/16 = 0.5625. A file is exact only when that ratio holds after SAR is applied. Integer identity width × 16 == height × 9 is a useful extra check when SAR is 1:1, because some nearby sizes (480×854, for example) cannot satisfy it.
I used ffprobe for the tags and a small script, aspect_check.py, to apply SAR, compare the ratio to 9/16, and suggest the smallest exact-9:16 canvas that can contain the picture without scaling.
A synthetic control, including a non-square SAR
The test clips are labeled synthetic. make_aspect_test_clips.py writes five 4-second files. The interesting one is a 720×1280 clip with setsar=2/1. Looking only at 720×1280, you would call it 9:16. The script does not:
syn_720x1280_sar1.mp4
coded=720x1280 SAR=1:1 DAR=9:16 (SAR used 1:1)
display=720.0000x1280.0000 ratio=0.56250000 EXACT 9:16
syn_720x1280_sar2.mp4
coded=720x1280 SAR=2:1 DAR=9:8 (SAR used 2:1)
display=1440.0000x1280.0000 ratio=1.12500000 +100.0000% vs 9:16
syn_540x940.mp4
display=540.0000x940.0000 ratio=0.57446809 +2.1277% vs 9:16
suggested pad canvas (no scale): 540x960
syn_480x854.mp4
display=480.0000x854.0000 ratio=0.56206089 -0.0781% vs 9:16
suggested pad canvas (no scale): 486x864
syn_540x960.mp4
display=540.0000x960.0000 ratio=0.56250000 EXACT 9:16
Every ffmpeg and python3 command in that run exited 0. The anamorphic file is the reason I will not trust a coded 720×1280 screenshot. Its DAR tag is 9:8, which matches 1440:1280, and the display size is twice as wide as a Stories frame. If you posted it "as 9:16" you would be posting a 9:8 picture.
The eight public samples, measured today
Short names below are the first eight hex characters of the SHA-256 in the official URL, /media/imported/<sha>.mp4.
| File | Role on the site | Coded | SAR / DAR | Display ratio | vs 9:16 |
|---|---|---|---|---|---|
db09b1c5 |
Official Just Me / Back Row / Whole Band reference | 720×1280 | N/A / N/A | 0.56250000 | exact (tags missing) |
db033545 |
Gallery, "10-second" | 540×960 | 1:1 / 9:16 | 0.56250000 | exact |
f7ff5268 |
Gallery, "Longer cut" | 540×960 | 1:1 / 9:16 | 0.56250000 | exact |
875d2458 |
Gallery, "Four-second" close-up | 540×940 | N/A / N/A | 0.57446809 | +2.1277% |
0299078c |
Gallery, desk trio then close-up and sax | 720×1280 | 1:1 / 9:16 | 0.56250000 | exact |
632c0129 |
Gallery, cat sample (not a selectable scene) | 720×1280 | 1:1 / 9:16 | 0.56250000 | exact |
947f5eb2 |
Gallery, red-haired singer | 720×1280 | 1:1 / 9:16 | 0.56250000 | exact |
8256cd87 |
Gallery, hoodie at the keys | 480×854 | N/A / N/A | 0.56206089 | −0.0781% |
Six of the eight files are exact 9:16 once you treat a missing SAR as 1:1. Five of those six also tag SAR=1:1 and DAR=9:16. The official reference is the exception in that group: its pixels are 720×1280, so 720×16 == 1280×9, but ffprobe reports SAR and DAR as N/A. The script assumes 1:1 in that case, which is what most players do, and then the picture is exact 9:16. The tags are still missing. The same three files that lack SAR/DAR (db09b1c5, 875d2458, 8256cd87) also leave color primaries, transfer, matrix and range unspecified. I am not redoing a luma-range article here; I am only noting that the untagged group is the same group.
The two files that are not 9:16 are both in the public gallery.
875d2458 is 540×940. Exact 9:16 at 540 pixels wide is 540×960, which is what the "10-second" and "Longer cut" files already use. This close-up is 20 pixels short in height, +2.1277% wider than 9:16. The suggested pad canvas is 540×960: ten pixels of pad above and below, no stretch.
8256cd87 is 480×854. The ratio 0.56206089 is close, and it is easy to call it "close enough." It is not exact, and it cannot be exact at this coded size. 480 × 16 = 7680 and 7680 / 9 = 853.333…, which is not an integer. 854 × 9 = 7686 and 7686 / 16 = 480.375, also not an integer. There is no integer 480-wide or 854-tall canvas that is 9:16. The smallest exact-9:16 canvas that contains 480×854 without scaling is 486×864 (9×54 by 16×54).
A command you can run on one file
ffprobe -v error -select_streams v:0 \
-show_entries stream=width,height,sample_aspect_ratio,display_aspect_ratio \
-of default=nw=1 clip.mp4
Then compute display_w = width * SAR (use 1:1 if SAR is missing) and compare display_w / height to 0.5625. Or run the script in this post on a folder of clips. I only quote numbers from runs that exited 0, and I did not invent customer or paid outputs — the eight inputs are the public samples, and the five controls are labeled synthetic.
If you want a Stories-safe file from the two odd gallery sizes, pad them to the suggested canvas rather than stretching. I measured that path separately; the short version is: 540×940 becomes 540×960 with 10 pixels of pad on the top and bottom, and 480×854 becomes 486×864 with a 3-pixel side pad and a 5-pixel vertical pad, with the picture size unchanged.
The studio's own reference, on the Just Me, Back Row and Whole Band pages, is the 720×1280 file. It is 9:16 in pixels. It just does not say so in the SAR and DAR tags. If you are writing a checker for files you got from this site, treat "tagged 9:16" and "pixels happen to be 9:16" as two different passing conditions.
Scripts
make_aspect_test_clips.py builds the synthetic controls. aspect_check.py prints the table for any MP4 you pass it.
#!/usr/bin/env python3
"""Build synthetic test clips with known coded sizes and SAR values (labeled synthetic)."""
from __future__ import annotations
import argparse, subprocess, sys
from pathlib import Path
def run(cmd):
print("+", " ".join(cmd), flush=True)
r = subprocess.run(cmd)
print(f"EXIT:{r.returncode}", flush=True)
if r.returncode != 0:
raise SystemExit(r.returncode)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("-o", "--outdir", type=Path, default=Path("."))
args = ap.parse_args()
args.outdir.mkdir(parents=True, exist_ok=True)
# 4-second, 30 fps color bars + 1 kHz tone. All files are synthetic.
common = [
"-hide_banner", "-y",
"-f", "lavfi", "-i", "testsrc2=size={size}:rate=30:duration=4",
"-f", "lavfi", "-i", "sine=frequency=1000:sample_rate=48000:duration=4",
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-profile:v", "high",
"-c:a", "aac", "-b:a", "128k",
"-movflags", "+faststart",
]
clips = [
# Exact 9:16, square pixels, tagged DAR 9:16
("syn_720x1280_sar1.mp4", "720x1280", ["-aspect", "9:16"]),
# Same coded frame, but anamorphic SAR 2:1 — display is 1440x1280, not 9:16
("syn_720x1280_sar2.mp4", "720x1280", ["-vf", "setsar=2/1"]),
# Gallery-like odd size 540x940 (not 9:16)
("syn_540x940.mp4", "540x940", []),
# Gallery-like 480x854 (almost, but not exactly, 9:16)
("syn_480x854.mp4", "480x854", []),
# Exact 9:16 at 540x960
("syn_540x960.mp4", "540x960", ["-aspect", "9:16"]),
]
for name, size, extra in clips:
cmd = ["ffmpeg"] + [c.format(size=size) if "{size}" in c else c for c in common]
# rebuild lavfi size
cmd = ["ffmpeg", "-hide_banner", "-y",
"-f", "lavfi", "-i", f"testsrc2=size={size}:rate=30:duration=4",
"-f", "lavfi", "-i", "sine=frequency=1000:sample_rate=48000:duration=4",
"-c:v", "libx264", "-pix_fmt", "yuv420p", "-profile:v", "high",
*extra,
"-c:a", "aac", "-b:a", "128k",
"-movflags", "+faststart",
str(args.outdir / name)]
run(cmd)
print("wrote", args.outdir)
if __name__ == "__main__":
main()
#!/usr/bin/env python3
"""Report coded WxH, SAR, DAR, display size, and distance from exact 9:16.
Display width is coded_width * (SAR). Display height is coded_height.
9:16 is exactly 0.5625. A file can have a 9:16 pixel grid and still lack
SAR/DAR tags; a file can also have a 9:16-looking coded size and a SAR
that makes the displayed picture something else.
"""
from __future__ import annotations
import argparse, json, subprocess, sys
from fractions import Fraction
from pathlib import Path
def ffprobe(path: Path) -> dict:
raw = subprocess.check_output([
"ffprobe", "-v", "error", "-print_format", "json",
"-show_format", "-show_streams", str(path),
])
return json.loads(raw)
def parse_ratio(s):
if not s or s in ("N/A", "0:1", "0/1"):
return None
if ":" in s:
a, b = s.split(":", 1)
return Fraction(int(a), int(b)) if int(b) else None
if "/" in s:
a, b = s.split("/", 1)
return Fraction(int(a), int(b)) if int(b) else None
return Fraction(s)
def analyze(path: Path) -> dict:
info = ffprobe(path)
v = next(s for s in info["streams"] if s["codec_type"] == "video")
w, h = int(v["width"]), int(v["height"])
sar_tag = v.get("sample_aspect_ratio")
dar_tag = v.get("display_aspect_ratio")
sar = parse_ratio(sar_tag)
dar = parse_ratio(dar_tag)
# If SAR is missing, players typically treat it as 1:1.
sar_used = sar if sar is not None else Fraction(1, 1)
disp_w = Fraction(w) * sar_used
disp_h = Fraction(h)
ratio = disp_w / disp_h
target = Fraction(9, 16)
# How far from exact 9:16, as a percentage of 9/16.
delta_pct = float((ratio - target) / target * 100)
# Integer canvas that is exact 9:16 and at least as large as the coded frame
# on both axes, using the usual Stories size if it already fits, else pad.
exact = (w * 16 == h * 9) and (sar_used == 1)
# Smallest exact-9:16 size that can contain the displayed frame without scaling.
# Need W/H = 9/16 and W >= disp_w and H >= disp_h, W and H integers.
# Walk k such that 9k >= ceil(disp_w) and 16k >= ceil(disp_h).
import math
need_w = math.ceil(float(disp_w))
need_h = math.ceil(float(disp_h))
k = max((need_w + 8) // 9, (need_h + 15) // 16)
pad_w, pad_h = 9 * k, 16 * k
return {
"file": path.name,
"coded_w": w,
"coded_h": h,
"sar_tag": sar_tag or "N/A",
"dar_tag": dar_tag or "N/A",
"sar_used": f"{sar_used.numerator}:{sar_used.denominator}",
"display_w": float(disp_w),
"display_h": float(disp_h),
"display_ratio": float(ratio),
"is_exact_9_16": bool(ratio == target),
"delta_pct_vs_9_16": delta_pct,
"coded_times_16_equals_height_times_9": (w * 16 == h * 9),
"suggested_pad_canvas": f"{pad_w}x{pad_h}",
"color_primaries": v.get("color_primaries") or "unspecified",
"color_transfer": v.get("color_transfer") or "unspecified",
"color_space": v.get("color_space") or "unspecified",
"color_range": v.get("color_range") or "unspecified",
"r_frame_rate": v.get("r_frame_rate"),
"pix_fmt": v.get("pix_fmt"),
}
def fmt(row):
flag = "EXACT 9:16" if row["is_exact_9_16"] else f"{row['delta_pct_vs_9_16']:+.4f}% vs 9:16"
return (
f"{row['file']}\n"
f" coded={row['coded_w']}x{row['coded_h']} "
f"SAR={row['sar_tag']} DAR={row['dar_tag']} "
f"(SAR used {row['sar_used']})\n"
f" display={row['display_w']:.4f}x{row['display_h']:.4f} "
f"ratio={row['display_ratio']:.8f} {flag}\n"
f" integer 9:16 identity (w*16==h*9): {row['coded_times_16_equals_height_times_9']}\n"
f" suggested pad canvas (no scale): {row['suggested_pad_canvas']}\n"
f" primaries={row['color_primaries']} transfer={row['color_transfer']} "
f"matrix={row['color_space']} range={row['color_range']} "
f"fps={row['r_frame_rate']} pix={row['pix_fmt']}"
)
def main():
ap = argparse.ArgumentParser()
ap.add_argument("clips", nargs="+", type=Path)
args = ap.parse_args()
print("9:16 exact ratio = 0.5625 (= 9/16)")
rows = []
for p in args.clips:
row = analyze(p)
rows.append(row)
print(fmt(row))
# JSON line for logs
print("JSON", json.dumps(rows))
return 0
if __name__ == "__main__":
sys.exit(main())
Top comments (0)