nvidia-codec 0.0.23__tar.gz → 0.0.24__tar.gz

{nvidia_codec-0.0.23/src/nvidia_codec.egg-info → nvidia_codec-0.0.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-codec
-Version: 0.0.23
+Version: 0.0.24
 Summary: Pythonic interface to Nvidia Codec
 Home-page: https://github.com/riaqn/python-nvidia-codec
 Author: Zesen Qian

{nvidia_codec-0.0.23 → nvidia_codec-0.0.24}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = nvidia-codec
-version = 0.0.23
+version = 0.0.24
 author = Zesen Qian
 author_email = nvidia-codec@riaqn.org
 description = Pythonic interface to Nvidia Codec

{nvidia_codec-0.0.23 → nvidia_codec-0.0.24}/src/nvidia_codec/utils/decode.py

@@ -273,12 +273,17 @@ class Decoder(BaseDecoder):
         frame we hand back is up to a GOP late. (ffmpeg's CLI papers over this
         with a fixed 3/23 s dts heuristic.)
 
-        Peek at the landing packet; if it isn't a keyframe, back off by a
-        growing number of frame-durations and retry. Landing on an earlier
-        keyframe than strictly needed only costs decode-forward time, so
-        overshooting backwards is safe. The peek consumes a packet, so the
-        final seek re-runs to restore the position. Raises AVException if the
-        container can't seek at all (caller falls back to the in-memory index).
+        Peek at the landing packet; if it isn't a keyframe — OR it is one but
+        its PTS is past the target (dts-space seek with B-frames: a keyframe's
+        dts precedes its pts by video_delay frames, so for a target inside
+        that window the seek picks a keyframe whose first displayed frame is
+        already too late; the on-screen frame belongs to the previous GOP) —
+        back off by a growing number of frame-durations and retry. Landing on
+        an earlier keyframe than strictly needed only costs decode-forward
+        time, so overshooting backwards is safe. The peek consumes a packet,
+        so the final seek re-runs to restore the position. Raises AVException
+        if the container can't seek at all (caller falls back to the
+        in-memory index).
         """
         fc, stream = self.track.fc, self.track.stream
         tb = self.track._time_base
@@ -289,8 +294,11 @@ class Decoder(BaseDecoder):
         for _ in range(max_tries):
             fc.seek_file(stream, ts, min_ts=-(2**63), max_ts=ts)
             first = next(fc.read_packets(stream), None)
-            if first is None or first.av.flags & AV_PKT_FLAG_KEY:
-                break                                # keyframe (or EOF — nothing to fix)
+            if first is None:
+                break                                # EOF — nothing to fix
+            pts_ok = first.av.pts == AV_NOPTS_VALUE or first.av.pts <= target_pts
+            if first.av.flags & AV_PKT_FLAG_KEY and pts_ok:
+                break                                # keyframe that displays at/before target
             landed = first.av.dts if first.av.dts != AV_NOPTS_VALUE else first.av.pts
             if landed == AV_NOPTS_VALUE:
                 break                                # can't reason about position

{nvidia_codec-0.0.23 → nvidia_codec-0.0.24}/src/nvidia_codec/utils/demux.py

@@ -246,7 +246,12 @@ class VideoTrack:
         return default if r == AVColorRange.UNSPECIFIED else r
 
     def time2pts(self, time: timedelta):
-        return int(time.total_seconds() / self._time_base) + self._start_time
+        """timedelta -> track pts (floor). Exact rational arithmetic: timedelta has
+        microsecond resolution, so 1.16 s is 1160000 us and lands on pts 14848 in a
+        1/12800 base; via float it is 14847.999... and int() would floor to the
+        PREVIOUS frame for any target exactly on a frame boundary."""
+        us = time // timedelta(microseconds=1)
+        return int(Fraction(us, 1_000_000) / self._time_base) + self._start_time
 
     def pts2time(self, pts: int):
         if pts == AV_NOPTS_VALUE:

{nvidia_codec-0.0.23 → nvidia_codec-0.0.24/src/nvidia_codec.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nvidia-codec
-Version: 0.0.23
+Version: 0.0.24
 Summary: Pythonic interface to Nvidia Codec
 Home-page: https://github.com/riaqn/python-nvidia-codec
 Author: Zesen Qian

{nvidia_codec-0.0.23 → nvidia_codec-0.0.24}/tests/test_smoke.py

@@ -133,10 +133,33 @@ def test_mpegts_start_time_and_first_gop(clip):
             assert abs(t.total_seconds() - 1.0) < 1 / FPS + 1e-3
             pts0, _ = next(iter(p.frames(torch.uint8, start=timedelta(seconds=1))))
             assert abs(p.track.pts2time(pts0).total_seconds() - 1.0) < 1 / FPS + 1e-3
+            # DTS-vs-PTS window: with B-frames the GOP-2 keyframe (pts 0.96 s) has
+            # dts ~0.88 s. A target in between must still yield the previous GOP's
+            # frame, not the keyframe (which displays after the target).
+            for target in (0.90, 0.94):
+                expect = int(target * FPS + 1e-6) / FPS
+                t, _ = p.screenshot(timedelta(seconds=target), torch.uint8, accurate=True)
+                assert abs(t.total_seconds() - expect) < 1e-3, (target, t)
+                pts0, _ = next(iter(p.frames(torch.uint8, start=timedelta(seconds=target))))
+                assert abs(p.track.pts2time(pts0).total_seconds() - expect) < 1e-3, (target, pts0)
     finally:
         shutil.rmtree(d, ignore_errors=True)
 
 
+def test_time2pts_exact_on_frame_boundaries(clip):
+    """time2pts must not floor a target that is exactly on a frame boundary to
+    the previous frame (float 1.16 * 12800 = 14847.999...)."""
+    with Player(clip) as p:
+        tb = p.track._time_base
+        for i in range(FPS * SECONDS):
+            td = timedelta(seconds=i / FPS)
+            expect = int(round(float(td.total_seconds() / tb))) + p.track._start_time
+            assert p.track.time2pts(td) == expect, i
+        # between two frames the pts lands strictly between their pts values
+        a, b = p.track.time2pts(timedelta(seconds=1.16)), p.track.time2pts(timedelta(seconds=1.20))
+        assert a < p.track.time2pts(timedelta(seconds=1.17)) < b
+
+
 def test_pixel_format_enum_values():
     from nvidia_codec.ffmpeg.include.libavutil import AVPixelFormat
     assert AVPixelFormat.YUV420P == 0 and AVPixelFormat.RGB24 == 2