Merge branch 'main' into codex/carry-rounded-timecodes

Author: EtienneLescot

.github/workflows/build.yml

@@ -507,3 +507,64 @@ jobs:
               --latest \
               --title "$TAG"
           fi
+
+      - name: Refresh the docs /download page
+        # Only a stable release changes what /releases/latest resolves to, so a
+        # pre-release would rebuild the site to byte-identical output.
+        #
+        # Dispatched against main on purpose: the github-pages environment only
+        # permits `main` to deploy, so docs.yml's old `on: release` trigger ran
+        # with a tag ref and failed its deploy every time. See docs.yml.
+        if: ${{ steps.release.outputs.is_prerelease == 'false' }}
+        timeout-minutes: 20
+        env:
+          GH_TOKEN: ${{ secrets.OPENSCREEN_RELEASE_TOKEN }}
+        run: |
+          latest_dispatch() {
+            gh run list \
+              --repo "$GITHUB_REPOSITORY" \
+              --workflow docs.yml \
+              --event workflow_dispatch \
+              --branch main \
+              --limit 1 \
+              --json databaseId \
+              --jq '.[0].databaseId // empty'
+          }
+
+          # `gh workflow run` prints nothing we can key off, so remember which
+          # dispatch was newest beforehand and wait for a different one to appear.
+          PREVIOUS_RUN_ID="$(latest_dispatch)"
+          gh workflow run docs.yml --ref main --repo "$GITHUB_REPOSITORY"
+
+          RUN_ID=""
+          for _ in $(seq 1 30); do
+            sleep 5
+            CANDIDATE="$(latest_dispatch)"
+            if [[ -n "$CANDIDATE" && "$CANDIDATE" != "$PREVIOUS_RUN_ID" ]]; then
+              RUN_ID="$CANDIDATE"
+              break
+            fi
+          done
+
+          if [[ -z "$RUN_ID" ]]; then
+            echo "::error::Dispatched docs.yml but no new run appeared within 150s"
+            exit 1
+          fi
+
+          gh run watch "$RUN_ID" --repo "$GITHUB_REPOSITORY" --interval 15 || true
+
+          CONCLUSION="$(gh run view "$RUN_ID" --repo "$GITHUB_REPOSITORY" --json conclusion --jq '.conclusion')"
+          case "$CONCLUSION" in
+            success)
+              echo "Docs rebuilt and deployed by run $RUN_ID"
+              ;;
+            cancelled)
+              # docs.yml cancels in-flight runs sharing a ref, so a push to main
+              # landing right now replaces this rebuild with a newer one.
+              echo "::warning::Docs run $RUN_ID was cancelled, most likely superseded by a newer main run"
+              ;;
+            *)
+              echo "::error::Docs run $RUN_ID concluded '$CONCLUSION' - /download may still list the previous release"
+              exit 1
+              ;;
+          esac

.github/workflows/docs.yml

@@ -12,13 +12,17 @@ on:
       - "website/**"
       - ".github/workflows/docs.yml"
   # The /download page resolves the current release's assets at build time so it
-  # can link each platform to its actual file. Without this trigger that data
-  # would freeze at whatever the last website/** change saw, and the page would
-  # keep serving the previous version's binaries after every release.
-  # Pre-releases are skipped: /releases/latest ignores them, so the built output
-  # would be byte-identical.
-  release:
-    types: [published]
+  # can link each platform to its actual file. Without a post-release rebuild that
+  # data would freeze at whatever the last website/** change saw, and the page
+  # would keep serving the previous version's binaries after every release.
+  #
+  # That rebuild is a `workflow_dispatch` fired by build.yml once the release is
+  # published, NOT an `on: release` trigger. A release event runs with
+  # github.ref = refs/tags/vX.Y.Z, and the github-pages environment only allows
+  # `main` to deploy, so the deploy job failed on every stable release (it never
+  # surfaced earlier because pre-releases skipped the build entirely). Dispatching
+  # against main both satisfies that policy and publishes main's docs rather than
+  # the release branch's older snapshot.
   workflow_dispatch:
 
 # Cancel in-flight runs on the same ref so fast follow-up pushes
@@ -34,9 +38,6 @@ jobs:
   build:
     name: Build site
     runs-on: ubuntu-latest
-    # A pre-release does not change what /releases/latest resolves to, so
-    # rebuilding for one would burn a run to produce identical output.
-    if: github.event_name != 'release' || github.event.release.prerelease == false
     steps:
       - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
@@ -66,7 +67,7 @@ jobs:
     needs: build
     if: >-
       (github.event_name == 'push' && github.ref == 'refs/heads/main')
-      || github.event_name == 'release'
+      || (github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main')
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}

crates/compositor/src/linux_decode.rs

@@ -16,6 +16,8 @@ use anyhow::{bail, Context, Result};
 use std::ffi::CString;
 use std::ptr;
 
+use crate::timeline_walk::NextFrameTime;
+
 use crate::ffi::{
     av_frame_alloc, av_frame_free, av_frame_move_ref, av_frame_unref, av_packet_alloc,
     av_packet_free, av_packet_unref, av_read_frame, av_seek_frame, avcodec_alloc_context3,
@@ -58,6 +60,11 @@ pub struct SwDecoder {
     frame: *mut AVFrame,
     sent_eof: bool,
     cur_pts: Option<i64>,
+    /// Buffer de lookahead pour `peek_next_time_sec` : symétrique de
+    /// `pipeline_macos::Decoder::peek_frame` — cf. là-bas pour la justification.
+    peek_frame: *mut AVFrame,
+    /// `true` si `peek_frame` porte une frame décodée en attente de `commit_peek`.
+    has_peek: bool,
 }
 
 /// Libère toutes les ressources ffmpeg. `Drop` ne peut pas faillir ; on
@@ -78,6 +85,9 @@ impl Drop for SwDecoder {
             if !self.pkt.is_null() {
                 av_packet_free(&mut self.pkt);
             }
+            if !self.peek_frame.is_null() {
+                av_frame_free(&mut self.peek_frame);
+            }
         }
     }
 }
@@ -177,7 +187,8 @@ impl SwDecoder {
         };
         let pkt = av_packet_alloc();
         let frame = av_frame_alloc();
-        if pkt.is_null() || frame.is_null() {
+        let peek_frame = av_frame_alloc();
+        if pkt.is_null() || frame.is_null() || peek_frame.is_null() {
             avcodec_free_context(&mut dec);
             avformat_close_input(&mut fmt);
             bail!("av_packet_alloc/av_frame_alloc (pompage sequentiel)");
@@ -192,6 +203,8 @@ impl SwDecoder {
             frame,
             sent_eof: false,
             cur_pts: None,
+            peek_frame,
+            has_peek: false,
         })
     }
 
@@ -201,21 +214,33 @@ impl SwDecoder {
     /// seek PAS : le decodeur garde son etat, donc une lecture sequentielle coute
     /// UN packet par frame au lieu d'un re-parcours de demi-GOP.
     pub unsafe fn next_frame(&mut self) -> Result<*mut AVFrame> {
+        if self.has_peek {
+            return self.commit_peek();
+        }
+        if !self.receive_into(self.frame)? {
+            return Ok(ptr::null_mut());
+        }
+        let pts = (*self.frame).best_effort_timestamp;
+        self.cur_pts = if pts == i64::MIN { None } else { Some(pts) };
+        Ok(self.frame)
+    }
+
+    /// Décode dans `into` (buffer courant ou de lookahead) jusqu'à obtenir une frame ou
+    /// l'EOF — cf. `pipeline_macos::Decoder::receive_into` pour la justification.
+    unsafe fn receive_into(&mut self, into: *mut AVFrame) -> Result<bool> {
         loop {
-            let r = avcodec_receive_frame(self.dec, self.frame);
+            let r = avcodec_receive_frame(self.dec, into);
             if r == 0 {
-                let pts = (*self.frame).best_effort_timestamp;
-                self.cur_pts = if pts == i64::MIN { None } else { Some(pts) };
-                return Ok(self.frame);
+                return Ok(true);
             }
             if r == AVERROR_EOF {
-                return Ok(ptr::null_mut());
+                return Ok(false);
             }
             if r != AVERROR_EAGAIN {
                 bail!("avcodec_receive_frame: {r}");
             }
             if self.sent_eof {
-                return Ok(ptr::null_mut());
+                return Ok(false);
             }
             let rr = av_read_frame(self.fmt, self.pkt);
             if rr < 0 {
@@ -240,6 +265,41 @@ impl SwDecoder {
         }
     }
 
+    /// Décode la prochaine frame dans le buffer de lookahead et renvoie son temps.
+    /// Cf. `pipeline_macos::Decoder::peek_next_time_sec`.
+    pub(crate) unsafe fn peek_next_time_sec(&mut self) -> Result<NextFrameTime> {
+        if !self.has_peek {
+            if !self.receive_into(self.peek_frame)? {
+                return Ok(NextFrameTime::Eof);
+            }
+            self.has_peek = true;
+        }
+        let pts = (*self.peek_frame).best_effort_timestamp;
+        // Sans pts ni time_base exploitables on ne PEUT pas dire si la frame est due :
+        // `Unknown`, et non `0.0` — qui passait pour « due » à tous les coups.
+        Ok(if pts == i64::MIN || self.stream_timebase <= 0.0 {
+            NextFrameTime::Unknown
+        } else {
+            NextFrameTime::At(pts as f64 * self.stream_timebase)
+        })
+    }
+
+    /// Promeut la frame de lookahead au rang de frame courante. Cf.
+    /// `pipeline_macos::Decoder::commit_peek`.
+    pub(crate) unsafe fn commit_peek(&mut self) -> Result<*mut AVFrame> {
+        // `bail!` et non `debug_assert!` : compilée en release, l'assertion disparaissait
+        // et l'échange promouvait un `AVFrame` jamais rempli, avec un
+        // `best_effort_timestamp` indéterminé, jusque dans le chemin de présentation.
+        if !self.has_peek {
+            bail!("commit_peek sans peek_next_time_sec préalable");
+        }
+        std::mem::swap(&mut self.frame, &mut self.peek_frame);
+        self.has_peek = false;
+        let pts = (*self.frame).best_effort_timestamp;
+        self.cur_pts = if pts == i64::MIN { None } else { Some(pts) };
+        Ok(self.frame)
+    }
+
     /// Temps source (secondes) de la derniere frame rendue par `next_frame` /
     /// `decode_at`, tire du pts REEL et non d'un compteur d'index.
     pub fn cur_time_sec(&self) -> Option<f64> {
@@ -263,6 +323,8 @@ impl SwDecoder {
     /// `AVERROR_INVALIDDATA` plutôt que de paniquer : la prochaine itération
     /// lira le packet complet suivant.
     pub unsafe fn decode_at(&mut self, frame_idx: u32) -> Result<*mut AVFrame> {
+        // Tout seek invalide un éventuel peek en attente — cf. pipeline_macos::Decoder::seek_to.
+        self.has_peek = false;
         let fps = self.fps;
         let target_ts = (frame_idx as f64 / fps) * 1_000_000.0; // AV_TIME_BASE = µs
         // `AVSEEK_FLAG_BACKWARD` vaut 1, pas 4 — 4 est `AVSEEK_FLAG_ANY`. La constante