ffmpeg-skill 3.6.1 → 3.6.3

package/scripts/speedramp.py

@@ -19,7 +19,7 @@ import argparse
 import sys
 from typing import List, Tuple
 
-from _common.decision import av_trim, frame_rate, grid_at_or_after, stream_starts
+from _common.decision import av_trim, frame_durations, frame_rate, grid_at_or_after, stream_starts
 from _common import add_common, apply_common, aac_args, default_output, die, emit, ffmpeg_base, info, probe, run, video_args, X264_PRESETS, fmt_secs, time_arg
 
 MAX_SPEED = 20.0
@@ -106,7 +106,11 @@ def main() -> int:
             die(f"--segment {start:g}-{end:g}:{factor:g} holds no frame: both ends fall on the frame at "
                 f"{bounds[i]:.3f}s; widen it or merge it into a neighbour")
         vtrim, atrim = av_trim(bounds[i], seg_end, rate)
-        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f}[{vlabel}]")
+        # the closing fps puts the sped-up frames back on the source's grid with its frame
+        # duration: concat starts the next segment after the last frame's duration, which setpts
+        # leaves at the unscaled 1/rate, so every 2x segment pushed the rest of the picture two
+        # frames late against the sound (and added those frames)
+        vparts.append(f"[0:v]{vtrim},setpts=PTS/{factor:.6f},{frame_durations(meta, rate)}[{vlabel}]")
         labels.append(f"[{vlabel}]")
         if has_audio:
             aparts.append(f"[0:a]{atrim},{atempo_chain(factor)}[{alabel}]")

package/scripts/sync.py

@@ -35,7 +35,8 @@ from typing import Dict, List
 from _common.runner import fail_if_classified
 from _common import video_args, add_common, apply_common, emit, aac_args, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, x264_args, decode_pcm_mono, rms_envelope
 from _common.emit import record_skip, warn
-from _common.decision import stream_starts
+from _common.decision import SEEK_MARGIN, frame_rate, grid_at_or_after, stream_starts
+from _common.timeline import output_timecode_args
 
 SR = 8000  # decode sample rate
 
@@ -385,7 +386,12 @@ def main() -> int:
                 cmd = cmd[:-1] + video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) + [output]
                 run(cmd)
         else:
-            if head_trim > 0 and not drift_af:
+            # A picture is never stream-copied here: a copy starts at the keyframe at or before -ss
+            # and -avoid_negative_ts make_zero shows the frames from it, so the output started
+            # early by up to a GOP (a 5 s GOP: nothing trimmed at all) and was reported as synced.
+            # Even a keyframe on the trim point moved the picture by its B-frame delay (+69 ms).
+            # The re-encode below starts on the frame itself; a sound-only file is still copied.
+            if head_trim > 0 and not drift_af and not has_video:
                 cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second, "-c", "copy"]
                 if os.path.splitext(output)[1].lower() in (".mp4", ".mov", ".m4v"):
                     cmd += ["-movflags", "+faststart"]
@@ -396,10 +402,20 @@ def main() -> int:
                     cmd = ffmpeg_base() + ["-ss", f"{head_trim:.4f}", "-i", args.second] + (video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf) if has_video else []) + audio_codec_for(output) + [output]
                     run(cmd)
             else:
+                # Seek SEEK_MARGIN early and drop the margin on the output side, as cut.py's
+                # re-encode does: an input seek straight to head_trim can land (the MP4 demuxer
+                # seeks over raw decode times) on a keyframe whose picture comes after it, and a
+                # B-frame HEVC file lost the frames before it. The output-side -ss decodes and
+                # drops the margin from both streams alike; it counts on the output's clock, which
+                # a drift fix runs faster by drift_ratio (setpts and asetrate alike).
                 cmd = ffmpeg_base()
+                out_seek: List[str] = []
                 if head_trim > 0:
-                    cmd += ["-ss", f"{head_trim:.4f}"]
-                cmd += ["-i", args.second]
+                    m = min(SEEK_MARGIN, head_trim)
+                    cmd += ["-ss", f"{head_trim - m:.6f}"]
+                    if m > 0:
+                        out_seek = ["-ss", f"{m / (drift_ratio if drift_af else 1.0):.6f}"]
+                cmd += ["-i", args.second] + out_seek
                 af_parts = on_clock + drift_af
                 if delay_ms > 0:
                     af_parts.append(f"adelay={delay_ms}:all=1")
@@ -412,6 +428,14 @@ def main() -> int:
                     if vf:
                         cmd += ["-vf", ",".join(vf)]
                     cmd += video_args(probe(args.reference) if args.replace_audio else probe(args.second), args.crf)
+                    # the output's first frame is the second file's frame at head_trim, or (padded)
+                    # one `offset` before its first: its start timecode moves with it
+                    v0, rate = stream_starts(second_meta)[0], frame_rate(second_meta)
+                    # (a trim before a picture that starts after the file's origin starts on its
+                    # first frame; only the padded head counts back before it)
+                    first = (grid_at_or_after(max(round(head_trim, 4), v0), v0, rate) - v0 if head_trim > 0
+                             else -offset if delay_ms > 0 else 0.0)
+                    cmd += output_timecode_args(second_meta, first)
                 if af_parts:
                     cmd += ["-af", ",".join(af_parts)]
                 cmd += audio_codec_for(output) + [output]