ffmpeg-skill 3.1.5 → 3.1.6

package/scripts/graphics.py

@@ -34,14 +34,15 @@ from typing import List, Optional, Tuple
 from _platforms import PLATFORMS, PLATFORM_CHOICES, safe_margins_px, resolve as resolve_platform
 from _common import (guard_sidecar, require_filter, aac_args, add_common, brand_caption_style, script_font_for_text, apply_common, cfr_args,
                      color_hex, default_output, die, draws_chroma, drawn_chain, emit, escape_drawtext, escape_filter_path,
-                     ffmpeg_base, info, label_chain, load_brand, parse_time, probe, rgb_chain_to_bt709, run, run_keeping_subtitles, video_args,
+                     ffmpeg_base, info, layer_base_chain, load_brand, parse_time, probe, rgb_chain_to_bt709, run, run_keeping_subtitles, video_args,
                      drawtext_boxborderw, drawtext_center_align, X264_PRESETS, time_arg, fmt_secs, STATE, drawtext_text_opts,
                      LANGUAGE_NAMES, needs_shaping, detect_script, BIDI_SCRIPTS, font_family_of_file, font_family_for_script, has_emoji,
                      emoji_clusters, emoji_codepoint_name, char_script, emoji_filter_chain, emoji_asset_for, emoji_support, resolve_emoji_assets,
                      EMOJI_ASSET_HINT, text_width_em, drawtext_shaping, wrap_text, WRAP_MODES,
                      SAFE_WIDTH_FRACTION, drawtext_draws_newline_glyph, is_multiline, _DRAWTEXT_PENDING)
-from _common.emit import warn
+from _common.emit import note, warn
 from _common.fonts import font_choice, record_font_choice
+from _common.probe import display_size, square_pixels, square_pixels_note
 from _ass_overlay import text_overlay_ass, EMOJI_SENTINEL
 from _common import drawtext_fontfile  # noqa: E402
 
@@ -170,9 +171,11 @@ def main(force_route: Optional[str] = None) -> int:
         die(f"--audio-stream {args.audio_stream}: input has {len(audio_streams)} audio stream(s), 0..{len(audio_streams) - 1}")
     if args.audio_stream and not audio_streams:
         die("--audio-stream needs an input with audio streams")
-    W, H = meta["video"]["width"], meta["video"]["height"]
-    if meta["video"].get("rotation") in (90, -90, 270, -270):
-        W, H = H, W
+    # the displayed frame: rotation applied, non-square pixels squared (square_pixels(), #411)
+    W, H = display_size(meta["video"])
+    square = square_pixels(meta["video"])
+    if square:
+        note(square_pixels_note(meta["video"]))
     dur = meta.get("duration") or 0.0
     # Per-edge margins. Without --margin/--platform every edge is the brand safe margin, exactly
     # as before; --margin sets all four; --platform takes each edge from the destination's safe
@@ -373,9 +376,21 @@ def main(force_route: Optional[str] = None) -> int:
         h1 = int(base * 0.055)
         h2 = int(base * 0.038)
         pad = int(base * 0.02)
-        name_h = block_h(args.name, h1)
-        bar_h = name_h + (block_h(args.title, h2) + pad if args.title else 0) + pad * 2
-        bar_w = int(base * 0.62)
+        tx_pad = int(base * 0.035)
+        # both lines wrap to the room between the side margins, less the text's own inset, and
+        # the bar widens (up to that room) to the widest line: through 3.1.3 the bar was a fixed
+        # 62 % of the short side and a long name ran past it and off the frame (#411)
+        room = W - m_left - m_right
+        lt_frac = max(0.1, min(1.0, (room - 2 * tx_pad) / float(W))) if W else SAFE_WIDTH_FRACTION
+        lt_name = wrapped(args.name, h1, lt_frac)
+        lt_title = wrapped(args.title, h2, lt_frac) if args.title else args.title
+        widest = max([text_width_em(ln) * h1 for ln in lt_name.split("\n")]
+                     + [text_width_em(ln) * h2 for ln in (lt_title or "").split("\n")])
+        name_h = block_h(lt_name, h1)
+        bar_h = name_h + (block_h(lt_title, h2) + pad if lt_title else 0) + pad * 2
+        # the 62 % floor never takes the bar past the right margin (#416 review: at a large --scale
+        # it did)
+        bar_w = max(1, min(room, max(int(base * 0.62), int(widest + 0.999) + 2 * tx_pad)))
         y0 = H - m_bottom - bar_h
         # slide in from the left over 0.4 s, slide out over 0.3 s (overlay evaluates x per frame)
         x_expr = f"if(lt(t,{s:.3f}+0.4),-{bar_w}+({bar_w}+{m_left})*((t-{s:.3f})/0.4),if(gt(t,{e:.3f}-0.3),{m_left}-({bar_w}+{m_left})*(1-({e:.3f}-t)/0.3),{m_left}))"
@@ -383,12 +398,11 @@ def main(force_route: Optional[str] = None) -> int:
         fc.append(f"{layer_src(primary, 1.0, int(base * 0.012), bar_h)}[acc]")
         fc.append(f"[0:v][bar]overlay=x='{x_expr}':y={y0}:{en}:eof_action=pass[v1]")
         fc.append(f"[v1][acc]overlay=x='{x_expr}':y={y0}:{en}:eof_action=pass[v2]")
-        tx_pad = int(base * 0.035)
         tx = f"({x_expr})+{tx_pad}"
         x_rest, x_off = m_left + tx_pad, -bar_w + tx_pad
         draws = []
-        for text, fs, colour, ty in ((args.name, h1, text_c, y0 + pad),
-                                     (args.title, h2, primary, y0 + pad + name_h + pad // 2)):
+        for text, fs, colour, ty in ((lt_name, h1, text_c, y0 + pad),
+                                     (lt_title, h2, primary, y0 + pad + name_h + pad // 2)):
             if not text:
                 continue
             draws.append(f"drawtext={drawtext_text_opts(text)}:{fo}:fontsize={fs}:"
@@ -416,24 +430,33 @@ def main(force_route: Optional[str] = None) -> int:
             die("title needs --title")
         h1 = int(base * 0.11)
         h2 = int(base * 0.045)
+        # the title and the subtitle wrap to the frame's safe width (#411: they never did)
+        title_t = wrapped(args.title, h1)
+        sub_t = wrapped(args.subtitle, h2) if args.subtitle else args.subtitle
         fill_box(bg, 0.55, "x=0:y=0:w=iw:h=ih", 0, 0, W, H, en)
         # the title is centred as a block, so the bar and the subtitle sit below its last line:
         # `title_h` is the block's height, as the one-line layout has always taken h1; a further
         # subtitle line hangs below the first, whose position the one-line layout fixes
-        title_h = block_h(args.title, h1)
+        title_h = block_h(title_t, h1)
         sub_y = title_h // 2 + int(base * 0.03)
-        sub_extra = block_h(args.subtitle, h2) - h2 if args.subtitle else 0
-        add_text(args.title,
-                 f"drawtext={drawtext_text_opts(args.title)}:{fo}:fontsize={h1}:fontcolor={ff_color(text_c)}{drawtext_center_align()}:x=(w-text_w)/2:y=(h-text_h)/2-{h2 if args.subtitle else 0}:alpha='{fade_a}':{en}",
+        sub_extra = block_h(sub_t, h2) - h2 if sub_t else 0
+        tall = title_h + (sub_y - title_h // 2 + block_h(sub_t, h2) if sub_t else 0)
+        if tall > H:
+            # the wrap measures width only; a centred block taller than the frame loses its first
+            # and last lines off the edges (#416 review)
+            note(f"the wrapped title{' and subtitle' if sub_t else ''} are about {tall} px tall, taller than the "
+                 f"{H} px frame: the lines past its edges are not drawn -- shorten the text or lower --scale")
+        add_text(title_t,
+                 f"drawtext={drawtext_text_opts(title_t)}:{fo}:fontsize={h1}:fontcolor={ff_color(text_c)}{drawtext_center_align()}:x=(w-text_w)/2:y=(h-text_h)/2-{h2 if sub_t else 0}:alpha='{fade_a}':{en}",
                  size=h1, color=text_c, font=ass_font_family(), align=5, x=W / 2,
-                 y=H / 2 - (h2 if args.subtitle else 0), outline=max(1.0, h1 / 20.0),
+                 y=H / 2 - (h2 if sub_t else 0), outline=max(1.0, h1 / 20.0),
                  outline_color="000000", start=s, end=e, fade=(300, 300))
         acc_w, acc_h = int(base * 0.12), max(2, int(base * 0.006))
         fill_box(primary, 1.0, f"x=(iw-{acc_w})/2:y=(ih)/2+{title_h // 2}:w={acc_w}:h={acc_h}",
                  (W - acc_w) // 2, H // 2 + title_h // 2, acc_w, acc_h, en)
-        if args.subtitle:
-            add_text(args.subtitle,
-                     f"drawtext={drawtext_text_opts(args.subtitle)}:{fo}:fontsize={h2}:fontcolor={ff_color(primary)}{drawtext_center_align()}:x=(w-text_w)/2:y=(h-text_h)/2+{sub_y + sub_extra // 2}:alpha='{fade_a}':{en}",
+        if sub_t:
+            add_text(sub_t,
+                     f"drawtext={drawtext_text_opts(sub_t)}:{fo}:fontsize={h2}:fontcolor={ff_color(primary)}{drawtext_center_align()}:x=(w-text_w)/2:y=(h-text_h)/2+{sub_y + sub_extra // 2}:alpha='{fade_a}':{en}",
                      size=h2, color=primary, font=ass_font_family(), align=5, x=W / 2,
                      y=H / 2 + sub_y + sub_extra // 2, outline=max(1.0, h2 / 20.0),
                      outline_color="000000", start=s, end=e, fade=(300, 300))
@@ -444,6 +467,8 @@ def main(force_route: Optional[str] = None) -> int:
         pos = args.position or ("bottom-left" if args.template == "chapter" else "top-right")
         fs = int(base * (0.04 if args.template == "chapter" else 0.032))
         padx, pady = int(fs * 0.6), int(fs * 0.35)
+        # the chip wraps to the room between the side margins, as the sticker's does (#411)
+        chip_t = wrapped(args.title, fs, chip_frac(m_left, m_right, padx))
         xe = f"{m_left}" if "left" in pos else f"w-text_w-{m_right}"
         ye = f"{m_top}" if "top" in pos else f"h-text_h-{m_bottom}"
         box_color = ff_color(primary if args.template == "chapter" else bg, 0.9 if args.template == "chapter" else 0.7)
@@ -451,8 +476,8 @@ def main(force_route: Optional[str] = None) -> int:
         box_hex = primary if args.template == "chapter" else bg
         txt_hex = bg if args.template == "chapter" else text_c
         align = (7 if "left" in pos else 9) if "top" in pos else (1 if "left" in pos else 3)
-        add_text(args.title,
-                 f"drawtext={drawtext_text_opts(args.title)}:{fo}:fontsize={fs}:fontcolor={txt_color}:x={xe}:y={ye}:box=1:boxcolor={box_color}:boxborderw={drawtext_boxborderw(pady, padx)}:alpha='{fade_a}':{en}",
+        add_text(chip_t,
+                 f"drawtext={drawtext_text_opts(chip_t)}:{fo}:fontsize={fs}:fontcolor={txt_color}:x={xe}:y={ye}:box=1:boxcolor={box_color}:boxborderw={drawtext_boxborderw(pady, padx)}:alpha='{fade_a}':{en}",
                  size=fs, color=txt_hex, font=ass_font_family(), align=align,
                  x=(m_left if "left" in pos else W - m_right),
                  y=(m_top if "top" in pos else H - m_bottom),
@@ -587,52 +612,62 @@ def main(force_route: Optional[str] = None) -> int:
         seen: List[str] = []
         for el in elements:
             el["box_px"] = int(round(el["size"] * scale_em))
-            line = el["text"]
-            clusters = emoji_clusters(line)
-            if not clusters or emoji_mode not in ("png",):
+            if not emoji_clusters(el["text"]) or emoji_mode not in ("png",):
                 continue
-            line_w = text_width_em(line, scale_em) * el["size"]
+            # a wrapped label is several lines: each is measured from its own start and sits one
+            # line pitch below the last (#416 review: they were measured as one line, on the first)
+            all_lines = el["text"].split("\n")
             align = int(el.get("align", 7))
-            left = el["x"] if align in (7, 4, 1) else (
-                el["x"] - line_w / 2.0 if align in (8, 5, 2) else el["x"] - line_w)
             line_h = el["size"] * 1.2
-            y_top = el["y"] if align in (7, 8, 9) else (
-                el["y"] - line_h / 2.0 if align in (4, 5, 6) else el["y"] - line_h)
-            # An RTL line is rendered right-to-left: measure the suffix, not the logical prefix.
-            rtl = detect_script(line) in BIDI_SCRIPTS
-            rebuilt, cursor = "", 0
-            for idx, cluster in clusters:
-                name = emoji_codepoint_name(cluster)
-                if name not in seen:
-                    seen.append(name)
-                asset = emoji_asset_for(cluster, emoji_assets)
-                if not asset:
-                    if name not in missing:
-                        missing.append(name)
-                    rebuilt += line[cursor:idx + len(cluster)]
-                    cursor = idx + len(cluster)
+            block = len(all_lines) * line_h
+            block_top = el["y"] if align in (7, 8, 9) else (
+                el["y"] - block / 2.0 if align in (4, 5, 6) else el["y"] - block)
+            rebuilt_lines = []
+            for k, line in enumerate(all_lines):
+                clusters = emoji_clusters(line)
+                if not clusters:
+                    rebuilt_lines.append(line)
                     continue
-                if rtl:
-                    prefix_px = line_w - text_width_em(line[:idx] + cluster, scale_em) * el["size"]
-                else:
-                    prefix_px = text_width_em(line[:idx], scale_em) * el["size"]
-                if el.get("x_expr"):
-                    # the lower-third slides: the emoji rides the same expression the bar does
-                    x = f"({el['x_expr']})+{prefix_px:.0f}"
-                else:
-                    x = int(round(max(0.0, min(left + prefix_px, W - el["box_px"]))))
-                emoji_overlays.append({"asset": asset, "cluster": name, "x": x,
-                                       "y": int(round(max(0.0, min(y_top + (line_h - el["box_px"]) / 2.0,
-                                                                   H - el["box_px"])))),
-                                       "start": round(el["start"], 3), "end": round(el["end"], 3),
-                                       "box": el["box_px"],
-                                       # every template fades its text in and out over 0.3 s
-                                       # (fade_a above); the PNG rides the same envelope.
-                                       "fade_in": round(min(0.3, max(0.0, (el["end"] - el["start"]) / 2.0)), 3),
-                                       "fade_out": round(min(0.3, max(0.0, (el["end"] - el["start"]) / 2.0)), 3)})
-                rebuilt += line[cursor:idx] + EMOJI_SENTINEL
-                cursor = idx + len(cluster)
-            el["text"] = rebuilt + line[cursor:]
+                line_w = text_width_em(line, scale_em) * el["size"]
+                left = el["x"] if align in (7, 4, 1) else (
+                    el["x"] - line_w / 2.0 if align in (8, 5, 2) else el["x"] - line_w)
+                y_top = block_top + k * line_h
+                # An RTL line is rendered right-to-left: measure the suffix, not the logical prefix.
+                rtl = detect_script(line) in BIDI_SCRIPTS
+                rebuilt, cursor = "", 0
+                for idx, cluster in clusters:
+                    name = emoji_codepoint_name(cluster)
+                    if name not in seen:
+                        seen.append(name)
+                    asset = emoji_asset_for(cluster, emoji_assets)
+                    if not asset:
+                        if name not in missing:
+                            missing.append(name)
+                        rebuilt += line[cursor:idx + len(cluster)]
+                        cursor = idx + len(cluster)
+                        continue
+                    if rtl:
+                        prefix_px = line_w - text_width_em(line[:idx] + cluster, scale_em) * el["size"]
+                    else:
+                        prefix_px = text_width_em(line[:idx], scale_em) * el["size"]
+                    if el.get("x_expr"):
+                        # the lower-third slides: the emoji rides the same expression the bar does
+                        x = f"({el['x_expr']})+{prefix_px:.0f}"
+                    else:
+                        x = int(round(max(0.0, min(left + prefix_px, W - el["box_px"]))))
+                    emoji_overlays.append({"asset": asset, "cluster": name, "x": x,
+                                           "y": int(round(max(0.0, min(y_top + (line_h - el["box_px"]) / 2.0,
+                                                                       H - el["box_px"])))),
+                                           "start": round(el["start"], 3), "end": round(el["end"], 3),
+                                           "box": el["box_px"],
+                                           # every template fades its text in and out over 0.3 s
+                                           # (fade_a above); the PNG rides the same envelope.
+                                           "fade_in": round(min(0.3, max(0.0, (el["end"] - el["start"]) / 2.0)), 3),
+                                           "fade_out": round(min(0.3, max(0.0, (el["end"] - el["start"]) / 2.0)), 3)})
+                    rebuilt += line[cursor:idx] + EMOJI_SENTINEL
+                    cursor = idx + len(cluster)
+                rebuilt_lines.append(rebuilt + line[cursor:])
+            el["text"] = "\n".join(rebuilt_lines)
         # `or 60` would swallow --emoji-max 0, the one value meaning "none at all".
         _max = 60 if args.emoji_max is None else int(args.emoji_max)
         if len(emoji_overlays) > _max:
@@ -673,7 +708,7 @@ def main(force_route: Optional[str] = None) -> int:
         drawboxes.append(f"drawbox={geo}:color={ff_color(colour, alpha)}:t=fill:{enable}")
     filters = [("" if as_layers else drawboxes[int(f[len(BOX):])]) if f.startswith(BOX) else f for f in filters]
     filters = [f for f in filters if f]
-    base_label = label_chain(meta, meta) if (layers or converted) else ""
+    base_label = layer_base_chain(meta) if (layers or converted) else ""
     text = (drawn_chain(",".join(filters), meta, re.findall(r"color=([0-9A-Za-z#@.]+)", ",".join(filters)),
                         labelled=bool(base_label)) if filters else "")
     if layers:
@@ -686,10 +721,12 @@ def main(force_route: Optional[str] = None) -> int:
     fc = [c.replace(TEXT, text or "null") for c in fc]
     if fc and base_label:
         fc = [f"[0:v]{base_label}null[gbase]"] + [c.replace("[0:v]", "[gbase]") for c in fc]
+    if fc and square:
+        fc = [f"[0:v]{square}[gsq]"] + [c.replace("[0:v]", "[gsq]") for c in fc]
 
     cmd = ffmpeg_base() + ["-i", args.input]
     if route == "ass" or emoji_overlays:
-        chains = list(fc) if fc else [f"[0:v]{text or 'null'}[vout]"]
+        chains = list(fc) if fc else [f"[0:v]{(square + ',') if square else ''}{text or 'null'}[vout]"]
         last = "vout"
         if route == "ass":
             vf = f"ass=filename={escape_filter_path(ass_path)}"
@@ -702,7 +739,7 @@ def main(force_route: Optional[str] = None) -> int:
             last = "vtxt"
         eo, emoji_inputs = emoji_filter_chain({"overlays": emoji_overlays}, last, "vfinal", first_input=1,
                                               to_yuv=rgb_chain_to_bt709(meta),
-                                              base_chain=label_chain(meta, meta) if rgb_chain_to_bt709(meta) else "")
+                                              base_chain=layer_base_chain(meta))
         for spec in emoji_inputs:
             cmd += spec
             asset = spec[-1]
@@ -716,7 +753,7 @@ def main(force_route: Optional[str] = None) -> int:
     elif fc:
         cmd += ["-filter_complex", ";".join(fc), "-map", "[vout]", "-map", f"0:a:{args.audio_stream}?"]
     else:
-        cmd += ["-vf", text, "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
+        cmd += ["-vf", (square + "," if square else "") + text, "-map", "0:v:0", "-map", f"0:a:{args.audio_stream}?"]
     cmd += video_args(meta, args.crf, args.preset) + cfr_args(meta)
     cmd += aac_args() if meta.get("audio") else ["-an"]
     dropped_streams = run_keeping_subtitles(cmd, output)

package/scripts/grid.py

@@ -26,15 +26,34 @@ import os
 import sys
 
 from _common import add_common, apply_common, aac_args, cfr_args, default_output, die, emit, X264_PRESETS, fmt_secs, \
-    draws_chroma, drawn_chain, escape_drawtext, ffmpeg_base, info, label_chain, matrix_chain, probe, run, validate_color, video_args
+    as_limited, draws_chroma, drawn_chain, escape_drawtext, ffmpeg_base, info, label_chain, matrix_chain, range_chain, probe, run, validate_color, video_args
 from _common.fonts import font_choice, record_font_choice
 from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
+from _common.fonts import script_font_for_text  # noqa: E402
+from _common.probe import square_pixels  # noqa: E402
+from _common.wrap import text_width_em  # noqa: E402
 
 LABEL_MARGIN = 10
 
 
+def _fit_label(stem: str, cell_width: int, font_size: int) -> str:
+    """The label as drawn: `stem` when it fits the cell (less the margin and the box's border on
+    each side), else its head with an ellipsis. It is right-aligned, so a label wider than the
+    cell used to lose its start off the left edge and show only its tail (#411). The width is the
+    averaged advance table's estimate."""
+    room = (cell_width - 2 * LABEL_MARGIN - 8) / float(max(1, font_size))
+    if text_width_em(stem) <= room:
+        return stem
+    if room <= 1:
+        return stem[:1]  # no room for an ellipsis: keep the start, as a shortened label does (#416 review)
+    head = stem
+    while head and text_width_em(head + "\u2026") > room:
+        head = head[:-1]
+    return (head.rstrip() + "\u2026") if head else stem[:1]
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("inputs", nargs="+", help="video clips, filled into the grid left-to-right, top-to-bottom")
@@ -69,6 +88,9 @@ def main() -> int:
     n = args.cols * args.rows
     if args.cols <= 0 or args.rows <= 0:
         die(f"--cols/--rows must be > 0, got cols={args.cols} rows={args.rows}")
+    if n == 1:
+        # xstack takes two inputs or more: a 1x1 grid used to reach ffmpeg and fail there (exit 222)
+        die("--cols 1 --rows 1 is a single cell; a grid needs at least two (fit.py letterboxes one clip)")
     if len(args.inputs) != n:
         die(f"--cols {args.cols} --rows {args.rows} needs exactly {n} inputs, got {len(args.inputs)}")
     if args.cell_width <= 0 or args.cell_height <= 0:
@@ -95,10 +117,26 @@ def main() -> int:
     durations = [m.get("duration") or 0.0 for m in metas]
     target_duration = max(durations) if args.pad else min(durations)
 
-    font_used = font_choice(args.font)  # the label font, reported as `font_used` when labels are drawn
-    font_file = font_used["file"]
+    # each label is drawn with a font that covers its own script, as every other text-drawing tool
+    # picks one (through 3.1.3 a Japanese or Thai filename came out as tofu, #411); `font_used` is
+    # the first label's choice, and a grid whose labels needed different fonts says so in a note
+    stems = [os.path.splitext(os.path.basename(p))[0] for p in args.inputs]
+    font_explicit = args.font != ap.get_default("font")
+    label_fonts = []
+    for stem in (stems if args.label == "auto" else []):
+        _sc, script_file, script_family = script_font_for_text(stem, font=args.font, font_explicit=font_explicit)
+        label_fonts.append(font_choice(args.font, script_file=script_file, script_family=script_family))
+    font_used = label_fonts[0] if label_fonts else font_choice(args.font)
     if args.label == "auto":
         record_font_choice(font_used)
+        if len({f.get("file") for f in label_fonts}) > 1:
+            note("cell labels drawn with more than one font, by script: "
+                 + "; ".join(sorted({str(f.get("family") or f.get("file")) for f in label_fonts})))
+    labels = [_fit_label(stem, args.cell_width, args.font_size) for stem in stems]
+    cut = [stem for stem, lab in zip(stems, labels) if lab != stem]
+    if args.label == "auto" and cut:
+        note(f"{len(cut)} cell label(s) wider than the {args.cell_width} px cell at --font-size "
+             f"{args.font_size} were shortened from the end with an ellipsis")
     output = args.output or default_output(args.inputs[0], "grid")
 
     cmd = ffmpeg_base()
@@ -117,6 +155,8 @@ def main() -> int:
     convert = [matrix_chain(m, None) for m in metas]
     if any(convert) or chroma:
         convert = [c or label_chain(m, None) for c, m in zip(convert, metas)]
+    # xstack mixes samples: a full-range cell beside a limited one is taken to limited range (#410)
+    convert = [c + range_chain(m, None) for c, m in zip(convert, metas)]
     parts = []
     for i, p in enumerate(args.inputs):
         drawn = [  # (with this colour, with black)
@@ -129,17 +169,19 @@ def main() -> int:
         elif not args.pad:
             drawn.append((f"trim=duration={target_duration:.3f}",) * 2)
         if args.label == "auto":
-            stem = os.path.splitext(os.path.basename(p))[0]
+            font_file = label_fonts[i]["file"]
             font_opt = drawtext_fontfile(font_file) if font_file else f"font='{escape_drawtext(args.font)}'"
-            drawn.append((f"drawtext=text='{escape_drawtext(stem)}':{font_opt}:fontsize={args.font_size}:"
+            drawn.append((f"drawtext=text='{escape_drawtext(labels[i])}':{font_opt}:fontsize={args.font_size}:"
                           f"fontcolor={args.font_color}:x=w-tw-{LABEL_MARGIN}:y=h-th-{LABEL_MARGIN}:"
                           f"box=1:boxcolor=black@0.5:boxborderw=4", "null"))
         gap_r = args.gap if i % args.cols < args.cols - 1 else 0
         gap_b = args.gap if i // args.cols < args.rows - 1 else 0
         if chroma and (gap_r or gap_b):
             drawn.append((f"pad=iw+{gap_r}:ih+{gap_b}:0:0:color={args.background}", f"pad=iw+{gap_r}:ih+{gap_b}:0:0:color=black"))
-        chain = f"fps={args.fps:g},scale={args.cell_width}:{args.cell_height}:force_original_aspect_ratio=decrease,"
-        chain += drawn_chain(",".join(c for c, _n in drawn), metas[i], colours, ",".join(n for _c, n in drawn),
+        # a non-square-pixel clip is squared at its display aspect before it is fitted (#411)
+        sq = (square_pixels(metas[i]["video"]) + ",") if square_pixels(metas[i]["video"]) else ""
+        chain = f"fps={args.fps:g},{sq}scale={args.cell_width}:{args.cell_height}:force_original_aspect_ratio=decrease,"
+        chain += drawn_chain(",".join(c for c, _n in drawn), as_limited(metas[i]), colours, ",".join(n for _c, n in drawn),
                              line_meta=None, tag=f"c{i}", labelled=True)
         parts.append(f"[{i}:v]{convert[i]}{chain}[v{i}]")
 

package/scripts/insert.py

@@ -29,6 +29,8 @@ import sys
 
 from _common import still_input_args  # noqa: E402
 from _common import add_common, apply_common, default_output, die, emit, ffmpeg_base, info, parse_time, probe, run, video_args, X264_PRESETS, time_arg, fmt_secs
+from _common.emit import note
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 
 def even(n: float) -> int:
@@ -69,7 +71,11 @@ def main() -> int:
     if (meta.get("duration") or 0) > 0.5 or meta.get("audio"):
         die(f"{args.input} is a video, not a still image; insert.py animates a still (Ken Burns). "
             f"For a clip use broll.py (cutaway) or cut.py/join.py")
-    sw, sh = meta["video"]["width"], meta["video"]["height"]
+    # the displayed picture: ffmpeg turns an EXIF-rotated still upright on decode (probe reads
+    # the Orientation off the decoded frame), and non-square pixels are squared (#411)
+    sw, sh = display_size(meta["video"])
+    if square_pixels(meta["video"]):
+        note(square_pixels_note(meta["video"]))
     ratio = sw / sh
 
     if args.width and args.height:
@@ -115,6 +121,8 @@ def main() -> int:
             f"fps={args.fps:g}",
         ]
 
+    if square_pixels(meta["video"]):
+        vf.insert(0, square_pixels(meta["video"]))  # the scale and crop above size the squared picture
     output = args.output or default_output(args.input, "insert", "mp4")
     cmd = ffmpeg_base() + ["-loop", "1", *still_input_args(args.input), "-i", args.input, "-t", f"{target:.3f}", "-vf", ",".join(vf)]
     # the SDR line, whatever the image is; its RGB (PNG) or BT.601 (JPEG) pixels are converted to

package/scripts/join.py

@@ -42,8 +42,10 @@ import sys
 from typing import Any, Dict, List, Optional, Tuple
 
 from _common.probe import SILENT_PEAK_DBFS, signatures_match, stream_signature
-from _common import STATE, AUDIO_MEDIA_EXT, concat_list_line, guard_sidecar, place_output, refuse, sibling_temp, draws_chroma, drawn_chain, label_chain, matrix_chain, video_args, aac_args, add_common, apply_common, audio_codec_for, default_output, die, dry_run_input_pending, emit, ffmpeg_base, info, measured_level_dbfs, is_audio_output, probe, require_tool, run, validate_color, X264_PRESETS, fmt_secs
-from _common.emit import warn
+from _common import STATE, AUDIO_MEDIA_EXT, concat_list_line, guard_sidecar, place_output, refuse, sibling_temp, as_limited, draws_chroma, drawn_chain, label_chain, matrix_chain, range_chain, video_args, aac_args, add_common, apply_common, audio_codec_for, default_output, die, dry_run_input_pending, emit, ffmpeg_base, info, measured_level_dbfs, is_audio_output, probe, require_tool, run, validate_color, X264_PRESETS, fmt_secs
+from _common.emit import note, warn
+from _common.decision import av_clip_length, av_trim, stream_starts
+from _common.probe import display_size, square_pixels, square_pixels_note
 
 TRANSITIONS = ["fade", "dissolve", "wipeleft", "wiperight", "wipeup", "wipedown", "slideleft", "slideright",
                "circleopen", "circleclose", "fadeblack", "fadewhite", "smoothleft", "smoothright", "radial", "none"]
@@ -103,16 +105,11 @@ def overlap_report(durs: List[float], expected: Optional[float]) -> Dict[str, An
 
 def clip_length(meta: Dict[str, Any], fps: float) -> float:
     """The one length a clip holds in a join, for its picture and its sound alike: the
-    video stream's, or the audio stream's when the sound runs more than a frame past the picture
-    (narration is never cut; an AAC tail adds no frame). The container duration (audio priming,
-    a longer track) is only the fallback when a stream length is unknown (a pending input)."""
-    v = (meta.get("video") or {}).get("duration")
-    a = (meta.get("audio") or {}).get("duration")
-    if not v:
-        return meta.get("duration") or 0.0
-    if a and fps and a > v + 1.0 / fps:
-        return a
-    return v
+    video stream's, or up to where the sound ends when it runs more than a frame past the picture
+    (narration is never cut; an AAC tail adds no frame), counted from the first frame. The container
+    duration (audio priming, a longer track) is only the fallback when a stream length is unknown
+    (a pending input). Shared with reverse.py as av_clip_length."""
+    return av_clip_length(meta, fps)
 
 
 def find_duplicates(paths: List[str]) -> List[Dict[str, Any]]:
@@ -655,9 +652,8 @@ def main() -> int:
     if args.copy:
         return join_copy(args, metas)
     first = metas[0]["video"]
-    fw, fh = first["width"], first["height"]
-    if first.get("rotation") in (90, -90, 270, -270):
-        fw, fh = fh, fw
+    # the first clip's displayed frame: rotation applied, non-square pixels squared (#411)
+    fw, fh = display_size(first)
     if args.width and args.height:
         w, h = args.width, args.height
     elif args.width:
@@ -721,13 +717,22 @@ def main() -> int:
     chroma_pad = args.fit != "crop" and draws_chroma([args.pad_color], line)
     if any(convert) or chroma_pad:
         convert = [c or label_chain(m, line) for c, m in zip(convert, metas)]
+    # concat/xfade mix samples: a full-range clip (VP9/AV1 full range, 10-bit pc) beside a limited
+    # one is taken to limited range first, or it was shown with the other's range (#410)
+    convert = [c + range_chain(m, line) for c, m in zip(convert, metas)]
+
+    for p, m in zip(args.inputs, metas):
+        if square_pixels(m.get("video")):
+            note(square_pixels_note(m["video"], p))
 
     def geo(i: int) -> str:
+        # every clip is squared at its display aspect before it is fitted (#411)
+        sq = (square_pixels(metas[i].get("video")) + ",") if square_pixels(metas[i].get("video")) else ""
         if args.fit == "crop":
-            return f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h}"
+            return f"{sq}scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h}"
         pad = f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2:color="
-        return (f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
-                + drawn_chain(pad + args.pad_color, metas[i], [args.pad_color], pad + "black", line_meta=line,
+        return (f"{sq}scale={w}:{h}:force_original_aspect_ratio=decrease,"
+                + drawn_chain(pad + args.pad_color, as_limited(metas[i]), [args.pad_color], pad + "black", line_meta=line,
                               tag=f"pad{i}", labelled=True))
     # the audio-only join keeps the widest layout; the video join used to force stereo and
     # silently dropped the centre/LFE of 5.1 material. A pending input's stub has no measured
@@ -741,7 +746,12 @@ def main() -> int:
         info(f"channel counts differ ({', '.join(str(c) for c in chans)}); every clip becomes {layout}")
     for i in range(n):
         parts.append(f"[{i}:v]{convert[i]}{geo(i)},setsar=1,setpts=PTS-STARTPTS,fps={fps:g},format={pixfmt},settb=AVTB[v{i}]")
-        parts.append(f"[{audio_src[i]}]aformat=sample_rates=48000:channel_layouts={layout},asetpts=PTS-STARTPTS[a{i}]")
+        # the sound is shifted by the picture's start, not to its own (#409): #338 started each
+        # clip's picture at 0, and a per-stream PTS-STARTPTS then moved a sound that starts 0.3 s
+        # after its picture 0.3 s early. Sound before the first frame is dropped and a late sound
+        # is padded, as cut.py's re-cut does; a generated silent track starts at 0 already.
+        shift = (av_trim(stream_starts(metas[i])[0], None)[1] + ",") if metas[i].get("audio") else ""
+        parts.append(f"[{audio_src[i]}]{shift}aformat=sample_rates=48000:channel_layouts={layout},asetpts=PTS-STARTPTS[a{i}]")
 
     # pad the shorter stream to the clip's length: the audio with silence, the picture by holding
     # its last frame, then cut both there -- each clip boundary is then the same for both chains

package/scripts/look.py

@@ -22,6 +22,8 @@ from _common import STATE, require_tool, add_common, apply_common, default_font_
 from _common import drawtext_fontfile  # noqa: E402
 from _common import ffmpeg_filters, filter_missing_hint  # noqa: E402
 from _common.emit import note, record_fallback  # noqa: E402
+from _common.color import bt709_label_filter  # noqa: E402
+from _common.probe import display_size, square_pixels, square_pixels_note  # noqa: E402
 
 FONT = "fontcolor=white:fontsize=h/18:box=1:boxcolor=black@0.55:boxborderw=6:x=8:y=8"
 
@@ -41,6 +43,12 @@ def timecode_filter(font_prefix: str, offset: float = 0.0) -> str:
     return f"drawtext=text='%{{pts\\:hms}}':{font_prefix}{FONT}"
 
 
+def _half_height(half: int, size: "tuple") -> int:
+    """The even height a `half`-wide picture of displayed `size` scales to (16:9 when unknown)."""
+    w, h = size
+    return max(2, int(round(half * (h / w if w and h else 9 / 16) / 2)) * 2)
+
+
 def _png_size(png_path: str) -> "Optional[tuple]":
     # run_analysis(): the same wall-clock ceiling and #234 UTF-8 decoding as every other
     # ffprobe/ffmpeg measurement in this codebase, check=False since a probe failure here is
@@ -189,10 +197,7 @@ def main() -> int:
     if args.safe:
         z = PLATFORMS[args.safe]["safe"]
         frame = PLATFORMS[args.safe]["frame"]
-        src = meta["video"]
-        dw, dh = src.get("width") or 0, src.get("height") or 0
-        if src.get("rotation") in (90, -90, 270, -270):
-            dw, dh = dh, dw
+        dw, dh = display_size(meta["video"])
         if dw and dh and abs(dw / dh - frame["w"] / frame["h"]) > 0.02:
             info(f"--safe {args.safe}: this source is {dw}x{dh}, not {args.safe}'s "
                  f"{frame['w']}x{frame['h']} -- the zones are drawn as fractions of the frame you gave, "
@@ -221,11 +226,25 @@ def main() -> int:
         tc = "," + tm.rstrip(",") + tc
         info("HDR source: frames are tone-mapped to SDR for display")
     outputs: List[str] = []
+    # An untagged SDR source is BT.709 (what players and every encoder line here take it as), but the
+    # conversion to the PNG's RGB reads "unknown" as BT.601: C03028 came out B31F28 (#410). Its
+    # frames are labelled first (tags only), so that conversion reads them as BT.709.
+    lab = bt709_label_filter(meta)
+    lab = lab + "," if lab else ""
+    # every picture is squared at its display aspect before it is scaled (#411): a DV or HDV
+    # frame's stored size is not the picture a player shows
+    square = square_pixels(meta["video"])
+    sq = square + "," if square else ""
+    if square:
+        note(square_pixels_note(meta["video"]))
 
     if args.compare:
         if not args.at:
             die("--compare needs --at TIME")
-        probe(args.compare)
+        cmeta = probe(args.compare)
+        lab2 = bt709_label_filter(cmeta)
+        lab2 = lab2 + "," if lab2 else ""
+        csq = (square_pixels(cmeta.get("video")) + ",") if square_pixels(cmeta.get("video")) else ""
         for idx, t in enumerate(args.at):
             sec = time_arg(t, "--at", meta["video"].get("fps") if meta.get("video") else None)
             if args.output and len(args.at) == 1:
@@ -238,8 +257,15 @@ def main() -> int:
             half = args.width // 2
             stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{font_prefix}{FONT}"
             tcs = tc.replace("," + timecode_filter(font_prefix), "") + stamp
-            fc = (f"[0:v]scale={half}:-2{tcs}[a];[1:v]scale={half}:-2{tcs}[b];"
-                  f"[a][b]scale2ref=w=iw:h=ih[a2][b2];[a2][b2]hstack=inputs=2[out]")
+            # each picture keeps its own aspect inside a half-width box as tall as the taller of the
+            # two (letterboxed, not stretched): through 3.1.3 scale2ref forced the first to the
+            # second's size, so a 4:3 beside a 16:9 came out squashed (#411)
+            box_h = max(_half_height(half, display_size(meta["video"])),
+                        _half_height(half, display_size(cmeta.get("video"))))
+            fit = (f"scale={half}:{box_h}:force_original_aspect_ratio=decrease,"
+                   f"pad={half}:{box_h}:(ow-iw)/2:(oh-ih)/2:color=0x202020,setsar=1")
+            fc = (f"[0:v]{lab}{sq}{fit}{tcs}[a];[1:v]{lab2}{csq}{fit}{tcs}[b];"
+                  f"[a][b]hstack=inputs=2[out]")
             cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-ss", f"{sec:.3f}", *still_input_args(args.compare), "-i", args.compare,
                                    "-filter_complex", fc, "-map", "[out]", "-frames:v", "1", "-update", "1", out]
             run(cmd)
@@ -255,7 +281,7 @@ def main() -> int:
                 # several frames, or -o given as a stem/prefix without an image extension
                 out = os.path.join(outdir, f"{args.output and Path(args.output).stem or stem}_{sec:.3f}s.png")
             stamp = "" if args.no_timecode else f",drawtext=text='{escape_drawtext(fmt_hms(sec))}':{font_prefix}{FONT}"
-            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-vf", f"scale={args.width}:-2{tc.replace(',' + timecode_filter(font_prefix), '')}{stamp}", "-frames:v", "1", "-update", "1", out]
+            cmd = ffmpeg_base() + ["-ss", f"{sec:.3f}", *still_input_args(args.input), "-i", args.input, "-vf", f"{lab}{sq}scale={args.width}:-2{tc.replace(',' + timecode_filter(font_prefix), '')}{stamp}", "-frames:v", "1", "-update", "1", out]
             run(cmd)
             outputs.append(out)
     else:
@@ -278,11 +304,14 @@ def main() -> int:
         # sample at the middle of each slice so the first/last tiles are not black lead-in/out frames
         # with only a handful of frames a mid-slice seek skips past them all: start at 0 instead
         seek = 0.0 if frames_avail < 4 else step / 2
-        # the seek resets pts to 0, so the burned-in timecode gets the seek added back
-        tc_sheet = tc.replace(timecode_filter(font_prefix), timecode_filter(font_prefix, seek)) if seek else tc
-        vf = (f"select='isnan(prev_selected_t)+gte(t-prev_selected_t\\,{step * 0.98:.6f})',scale={tile_w}:-2{tc_sheet},"
+        # -copyts -start_at_zero keeps each frame's own timestamp through the seek, counted from
+        # the file's start, so the stamp is the frame's pts as it is. What an input -ss alone
+        # resets pts to differs by container: an MPEG-TS (which starts at 1.4 s) came out
+        # labelled one seek late when the seek was added back (#411)
+        tc_sheet = tc
+        vf = (f"select='isnan(prev_selected_t)+gte(t-prev_selected_t\\,{step * 0.98:.6f})',{lab}{sq}scale={tile_w}:-2{tc_sheet},"
               f"tile={cols}x{rows}:padding=2:margin=2:color=0x202020")
-        cmd = ffmpeg_base() + ["-ss", f"{seek:.6f}", *still_input_args(args.input), "-i", args.input, "-vf", vf, "-frames:v", "1", "-update", "1", out]
+        cmd = ffmpeg_base() + ["-copyts", "-start_at_zero", "-ss", f"{seek:.6f}", *still_input_args(args.input), "-i", args.input, "-vf", vf, "-frames:v", "1", "-update", "1", out]
         run(cmd)
         outputs.append(out)
         info(f"contact sheet: {n} frames every {step:.2f}s")