From 187b673e124f9f45bee5b2a63b7c73aebbb30655 Mon Sep 17 00:00:00 2001
From: Emil Ernerfeldt <emil.ernerfeldt@gmail.com>
Date: Tue, 8 Oct 2024 15:21:04 +0200
Subject: [PATCH] Refactor video decoding (#7625)

### What
* Closes #7583

This refactors the video decoder to unify the native and web decoder
logic.

It changes how error handling is done quite a bit, so this will require
some testing.

This PR also hides the spinner if the current frame is less than 400ms
outdated.
This means a small hickup during decoding will not cause the spinner to
show up,
but jumping a big step in the video stream (moving the time cursor by a
large step), will make the spinner show up immediately, making Rerun
feel responsive.

### Checklist
* [x] I have read and agree to [Contributor
Guide](https://github.com/rerun-io/rerun/blob/main/CONTRIBUTING.md) and
the [Code of
Conduct](https://github.com/rerun-io/rerun/blob/main/CODE_OF_CONDUCT.md)
* [x] I've included a screenshot or gif (if applicable)
* [x] I have tested the web demo (if applicable):
* Using examples from latest `main` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/7625?manifest_url=https://app.rerun.io/version/main/examples_manifest.json)
* Using full set of examples from `nightly` build:
[rerun.io/viewer](https://rerun.io/viewer/pr/7625?manifest_url=https://app.rerun.io/version/nightly/examples_manifest.json)
* [x] The PR title and labels are set such as to maximize their
usefulness for the next release's CHANGELOG
* [x] If applicable, add a new check to the [release
checklist](https://github.com/rerun-io/rerun/blob/main/tests/python/release_checklist)!
* [x] If have noted any breaking changes to the log API in
`CHANGELOG.md` and the migration guide

- [PR Build Summary](https://build.rerun.io/pr/7625)
- [Recent benchmark results](https://build.rerun.io/graphs/crates.html)
- [Wasm size tracking](https://build.rerun.io/graphs/sizes.html)

To run all checks from `main`, comment on the PR with `@rerun-bot
full-check`.
---
 crates/store/re_video/examples/frames.rs      |   6 +-
 crates/store/re_video/src/demux/mod.rs        |  31 +-
 crates/store/re_video/src/demux/mp4.rs        | 150 +++----
 crates/store/re_video/src/lib.rs              |   9 +
 crates/store/re_video/src/mp4.rs              |  93 ----
 crates/viewer/re_data_ui/src/blob.rs          |  24 +-
 .../re_renderer/src/video/decoder/mod.rs      | 413 ++++++++++++++++--
 .../src/video/decoder/native_av1.rs           | 278 ++----------
 .../src/video/decoder/no_native_decoder.rs    |  21 -
 .../re_renderer/src/video/decoder/web.rs      | 373 +++-------------
 crates/viewer/re_renderer/src/video/mod.rs    |  22 +-
 .../src/visualizers/videos.rs                 |  35 +-
 scripts/lint.py                               |   1 +
 13 files changed, 642 insertions(+), 814 deletions(-)
 delete mode 100644 crates/store/re_video/src/mp4.rs
 delete mode 100644 crates/viewer/re_renderer/src/video/decoder/no_native_decoder.rs

diff --git a/crates/store/re_video/examples/frames.rs b/crates/store/re_video/examples/frames.rs
index 1b95e8fd1868..663b74df8d07 100644
--- a/crates/store/re_video/examples/frames.rs
+++ b/crates/store/re_video/examples/frames.rs
@@ -13,8 +13,6 @@ use std::{
 use indicatif::ProgressBar;
 use parking_lot::Mutex;
 
-use re_video::demux::mp4::load_mp4;
-
 fn main() {
     // frames <video.mp4>
     let args: Vec<_> = std::env::args().collect();
@@ -27,11 +25,11 @@ fn main() {
     println!("Decoding {video_path}");
 
     let video = std::fs::read(video_path).expect("failed to read video");
-    let video = load_mp4(&video).expect("failed to load video");
+    let video = re_video::VideoData::load_mp4(&video).expect("failed to load video");
 
     println!(
         "{} {}x{}",
-        video.segments.len(),
+        video.gops.len(),
         video.config.coded_width,
         video.config.coded_height
     );
diff --git a/crates/store/re_video/src/demux/mod.rs b/crates/store/re_video/src/demux/mod.rs
index ce2f7e5abdb1..8b70c440e0bb 100644
--- a/crates/store/re_video/src/demux/mod.rs
+++ b/crates/store/re_video/src/demux/mod.rs
@@ -1,6 +1,6 @@
 //! Video demultiplexing.
 //!
-//! Parses a video file into a raw [`VideoData`] struct, which contains basic metadata and a list of [`Segment`]s.
+//! Parses a video file into a raw [`VideoData`] struct, which contains basic metadata and a list of [`GroupOfPictures`]s.
 //!
 //! The entry point is [`VideoData::load_from_bytes`]
 //! which produces an instance of [`VideoData`] from any supported video container.
@@ -26,9 +26,9 @@ pub struct VideoData {
     /// Duration of the video, in time units.
     pub duration: Time,
 
-    /// We split video into segments, each beginning with a key frame,
+    /// We split video into GOPs, each beginning with a key frame,
     /// followed by any number of delta frames.
-    pub segments: Vec<Segment>,
+    pub gops: Vec<GroupOfPictures>,
 
     /// Samples contain the byte offsets into `data` for each frame.
     ///
@@ -54,7 +54,8 @@ impl VideoData {
     /// at the very least the should be a way to extract only metadata.
     pub fn load_from_bytes(data: &[u8], media_type: &str) -> Result<Self, VideoLoadError> {
         match media_type {
-            "video/mp4" => mp4::load_mp4(data),
+            "video/mp4" => Self::load_mp4(data),
+
             media_type => {
                 if media_type.starts_with("video/") {
                     Err(VideoLoadError::UnsupportedMimeType {
@@ -111,7 +112,7 @@ impl VideoData {
     pub fn frame_timestamps_ns(&self) -> impl Iterator<Item = i64> + '_ {
         // Segments are guaranteed to be sorted among each other, but within a segment,
         // presentation timestamps may not be sorted since this is sorted by decode timestamps.
-        self.segments.iter().flat_map(|seg| {
+        self.gops.iter().flat_map(|seg| {
             self.samples[seg.range()]
                 .iter()
                 .map(|sample| sample.composition_timestamp.into_nanos(self.timescale))
@@ -138,18 +139,20 @@ impl VideoData {
     }
 }
 
-/// A segment of a video.
+/// A Group of Pictures (GOP) always starts with an I-frame, followed by delta-frames.
+///
+/// See <https://en.wikipedia.org/wiki/Group_of_pictures> for more.
 #[derive(Debug, Clone)]
-pub struct Segment {
-    /// Decode timestamp of the first sample in this segment, in time units.
+pub struct GroupOfPictures {
+    /// Decode timestamp of the first sample in this GOP, in time units.
     pub start: Time,
 
-    /// Range of samples contained in this segment.
+    /// Range of samples contained in this GOP.
     pub sample_range: Range<u32>,
 }
 
-impl Segment {
-    /// The segment's `sample_range` mapped to `usize` for slicing.
+impl GroupOfPictures {
+    /// The GOP's `sample_range` mapped to `usize` for slicing.
     pub fn range(&self) -> Range<usize> {
         Range {
             start: self.sample_range.start as usize,
@@ -163,11 +166,15 @@ impl Segment {
 pub struct Sample {
     /// Time at which this sample appears in the decoded bitstream, in time units.
     ///
+    /// Samples should be decoded in this order.
+    ///
     /// `decode_timestamp <= composition_timestamp`
     pub decode_timestamp: Time,
 
     /// Time at which this sample appears in the frame stream, in time units.
     ///
+    /// The frame should be shown at this time.
+    ///
     /// `decode_timestamp <= composition_timestamp`
     pub composition_timestamp: Time,
 
@@ -245,7 +252,7 @@ impl std::fmt::Debug for VideoData {
             .field("config", &self.config)
             .field("timescale", &self.timescale)
             .field("duration", &self.duration)
-            .field("segments", &self.segments)
+            .field("gops", &self.gops)
             .field(
                 "samples",
                 &self.samples.iter().enumerate().collect::<Vec<_>>(),
diff --git a/crates/store/re_video/src/demux/mp4.rs b/crates/store/re_video/src/demux/mp4.rs
index 04721da582ba..14732f1f0469 100644
--- a/crates/store/re_video/src/demux/mp4.rs
+++ b/crates/store/re_video/src/demux/mp4.rs
@@ -1,89 +1,91 @@
 #![allow(clippy::map_err_ignore)]
 
-use super::{Config, Sample, Segment, VideoData, VideoLoadError};
+use super::{Config, GroupOfPictures, Sample, VideoData, VideoLoadError};
 
 use crate::{Time, Timescale};
 
-pub fn load_mp4(bytes: &[u8]) -> Result<VideoData, VideoLoadError> {
-    let mp4 = re_mp4::Mp4::read_bytes(bytes)?;
-
-    let mp4_tracks = mp4.tracks().iter().map(|(k, t)| (*k, t.kind)).collect();
-
-    let track = mp4
-        .tracks()
-        .values()
-        .find(|t| t.kind == Some(re_mp4::TrackKind::Video))
-        .ok_or_else(|| VideoLoadError::NoVideoTrack)?;
-
-    let codec = track
-        .codec_string(&mp4)
-        .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
-    let description = track
-        .raw_codec_config(&mp4)
-        .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
-
-    let coded_height = track.height;
-    let coded_width = track.width;
-
-    let config = Config {
-        codec,
-        description,
-        coded_height,
-        coded_width,
-    };
-
-    let timescale = Timescale::new(track.timescale);
-    let duration = Time::new(track.duration as i64);
-    let mut samples = Vec::<Sample>::new();
-    let mut segments = Vec::<Segment>::new();
-    let mut segment_sample_start_index = 0;
-    let data = track.data.clone();
-
-    for sample in &track.samples {
-        if sample.is_sync && !samples.is_empty() {
-            let start = samples[segment_sample_start_index].decode_timestamp;
-            let sample_range = segment_sample_start_index as u32..samples.len() as u32;
-            segments.push(Segment {
+impl VideoData {
+    pub fn load_mp4(bytes: &[u8]) -> Result<Self, VideoLoadError> {
+        let mp4 = re_mp4::Mp4::read_bytes(bytes)?;
+
+        let mp4_tracks = mp4.tracks().iter().map(|(k, t)| (*k, t.kind)).collect();
+
+        let track = mp4
+            .tracks()
+            .values()
+            .find(|t| t.kind == Some(re_mp4::TrackKind::Video))
+            .ok_or_else(|| VideoLoadError::NoVideoTrack)?;
+
+        let codec = track
+            .codec_string(&mp4)
+            .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
+        let description = track
+            .raw_codec_config(&mp4)
+            .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
+
+        let coded_height = track.height;
+        let coded_width = track.width;
+
+        let config = Config {
+            codec,
+            description,
+            coded_height,
+            coded_width,
+        };
+
+        let timescale = Timescale::new(track.timescale);
+        let duration = Time::new(track.duration as i64);
+        let mut samples = Vec::<Sample>::new();
+        let mut gops = Vec::<GroupOfPictures>::new();
+        let mut gop_sample_start_index = 0;
+        let data = track.data.clone();
+
+        for sample in &track.samples {
+            if sample.is_sync && !samples.is_empty() {
+                let start = samples[gop_sample_start_index].decode_timestamp;
+                let sample_range = gop_sample_start_index as u32..samples.len() as u32;
+                gops.push(GroupOfPictures {
+                    start,
+                    sample_range,
+                });
+                gop_sample_start_index = samples.len();
+            }
+
+            let decode_timestamp = Time::new(sample.decode_timestamp as i64);
+            let composition_timestamp = Time::new(sample.composition_timestamp as i64);
+            let duration = Time::new(sample.duration as i64);
+
+            let byte_offset = sample.offset as u32;
+            let byte_length = sample.size as u32;
+
+            samples.push(Sample {
+                decode_timestamp,
+                composition_timestamp,
+                duration,
+                byte_offset,
+                byte_length,
+            });
+        }
+
+        if !samples.is_empty() {
+            let start = samples[gop_sample_start_index].decode_timestamp;
+            let sample_range = gop_sample_start_index as u32..samples.len() as u32;
+            gops.push(GroupOfPictures {
                 start,
                 sample_range,
             });
-            segment_sample_start_index = samples.len();
         }
 
-        let decode_timestamp = Time::new(sample.decode_timestamp as i64);
-        let composition_timestamp = Time::new(sample.composition_timestamp as i64);
-        let duration = Time::new(sample.duration as i64);
-
-        let byte_offset = sample.offset as u32;
-        let byte_length = sample.size as u32;
-
-        samples.push(Sample {
-            decode_timestamp,
-            composition_timestamp,
+        Ok(Self {
+            config,
+            timescale,
             duration,
-            byte_offset,
-            byte_length,
-        });
-    }
-
-    if !samples.is_empty() {
-        let start = samples[segment_sample_start_index].decode_timestamp;
-        let sample_range = segment_sample_start_index as u32..samples.len() as u32;
-        segments.push(Segment {
-            start,
-            sample_range,
-        });
+            gops,
+            samples,
+            data,
+            mp4_tracks,
+        })
     }
-
-    Ok(VideoData {
-        config,
-        timescale,
-        duration,
-        segments,
-        samples,
-        data,
-        mp4_tracks,
-    })
 }
 
 fn unknown_codec_fourcc(mp4: &re_mp4::Mp4, track: &re_mp4::Track) -> re_mp4::FourCC {
diff --git a/crates/store/re_video/src/lib.rs b/crates/store/re_video/src/lib.rs
index c0a600738310..dbde69d6d1b1 100644
--- a/crates/store/re_video/src/lib.rs
+++ b/crates/store/re_video/src/lib.rs
@@ -88,6 +88,15 @@ impl Time {
     }
 }
 
+impl std::ops::Add for Time {
+    type Output = Self;
+
+    #[inline]
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0.saturating_add(rhs.0))
+    }
+}
+
 impl std::ops::Sub for Time {
     type Output = Self;
 
diff --git a/crates/store/re_video/src/mp4.rs b/crates/store/re_video/src/mp4.rs
deleted file mode 100644
index 23a551cbb4eb..000000000000
--- a/crates/store/re_video/src/mp4.rs
+++ /dev/null
@@ -1,93 +0,0 @@
-#![allow(clippy::map_err_ignore)]
-
-use super::{Config, Sample, Segment, Time, Timescale, VideoData, VideoLoadError};
-
-pub fn load_mp4(bytes: &[u8]) -> Result<VideoData, VideoLoadError> {
-    let mp4 = re_mp4::Mp4::read_bytes(bytes)?;
-
-    let mp4_tracks = mp4.tracks().iter().map(|(k, t)| (*k, t.kind)).collect();
-
-    let track = mp4
-        .tracks()
-        .values()
-        .find(|t| t.kind == Some(re_mp4::TrackKind::Video))
-        .ok_or_else(|| VideoLoadError::NoVideoTrack)?;
-
-    let codec = track
-        .codec_string(&mp4)
-        .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
-    let description = track
-        .raw_codec_config(&mp4)
-        .ok_or_else(|| VideoLoadError::UnsupportedCodec(unknown_codec_fourcc(&mp4, track)))?;
-
-    let coded_height = track.height;
-    let coded_width = track.width;
-
-    let config = Config {
-        codec,
-        description,
-        coded_height,
-        coded_width,
-    };
-
-    let timescale = Timescale::new(track.timescale);
-    let duration = Time::new(track.duration);
-    let mut samples = Vec::<Sample>::new();
-    let mut segments = Vec::<Segment>::new();
-    let mut segment_sample_start_index = 0;
-    let data = track.data.clone();
-
-    for sample in &track.samples {
-        if sample.is_sync && !samples.is_empty() {
-            let start = samples[segment_sample_start_index].decode_timestamp;
-            let sample_range = segment_sample_start_index as u32..samples.len() as u32;
-            segments.push(Segment {
-                start,
-                sample_range,
-            });
-            segment_sample_start_index = samples.len();
-        }
-
-        let decode_timestamp = Time::new(sample.decode_timestamp);
-        let composition_timestamp = Time::new(sample.composition_timestamp);
-        let duration = Time::new(sample.duration);
-
-        let byte_offset = sample.offset as u32;
-        let byte_length = sample.size as u32;
-
-        samples.push(Sample {
-            decode_timestamp,
-            composition_timestamp,
-            duration,
-            byte_offset,
-            byte_length,
-        });
-    }
-
-    if !samples.is_empty() {
-        let start = samples[segment_sample_start_index].decode_timestamp;
-        let sample_range = segment_sample_start_index as u32..samples.len() as u32;
-        segments.push(Segment {
-            start,
-            sample_range,
-        });
-    }
-
-    Ok(VideoData {
-        config,
-        timescale,
-        duration,
-        segments,
-        samples,
-        data,
-        mp4_tracks,
-    })
-}
-
-fn unknown_codec_fourcc(mp4: &re_mp4::Mp4, track: &re_mp4::Track) -> re_mp4::FourCC {
-    let stsd = &track.trak(mp4).mdia.minf.stbl.stsd;
-    match &stsd.contents {
-        re_mp4::StsdBoxContent::Unknown(four_cc) => *four_cc,
-        _ => Default::default(),
-    }
-}
diff --git a/crates/viewer/re_data_ui/src/blob.rs b/crates/viewer/re_data_ui/src/blob.rs
index 77db7cff569d..719b152849b4 100644
--- a/crates/viewer/re_data_ui/src/blob.rs
+++ b/crates/viewer/re_data_ui/src/blob.rs
@@ -246,21 +246,11 @@ fn show_video_blob_info(
                     );
 
                     match video.frame_at(render_ctx, decode_stream_id, timestamp_in_seconds) {
-                        Ok(frame) => {
-                            let is_pending;
-                            let texture = match frame {
-                                VideoFrameTexture::Ready(texture) => {
-                                    is_pending = false;
-                                    texture
-                                }
-
-                                VideoFrameTexture::Pending(placeholder) => {
-                                    is_pending = true;
-                                    ui.ctx().request_repaint();
-                                    placeholder
-                                }
-                            };
-
+                        Ok(VideoFrameTexture {
+                            texture,
+                            is_pending,
+                            show_spinner,
+                        }) => {
                             let response = crate::image::texture_preview_ui(
                                 render_ctx,
                                 ui,
@@ -270,6 +260,10 @@ fn show_video_blob_info(
                             );
 
                             if is_pending {
+                                ui.ctx().request_repaint(); // Keep polling for an up-to-date texture
+                            }
+
+                            if show_spinner {
                                 // Shrink slightly:
                                 let smaller_rect = egui::Rect::from_center_size(
                                     response.rect.center(),
diff --git a/crates/viewer/re_renderer/src/video/decoder/mod.rs b/crates/viewer/re_renderer/src/video/decoder/mod.rs
index 990a6466c1e6..1ce8d1363c89 100644
--- a/crates/viewer/re_renderer/src/video/decoder/mod.rs
+++ b/crates/viewer/re_renderer/src/video/decoder/mod.rs
@@ -1,66 +1,393 @@
 #[cfg(target_arch = "wasm32")]
 mod web;
 
-#[cfg(not(target_arch = "wasm32"))]
-mod no_native_decoder;
-
 #[cfg(feature = "video_av1")]
 #[cfg(not(target_arch = "wasm32"))]
 mod native_av1;
 
+use std::{ops::Range, sync::Arc, time::Duration};
+
+use web_time::Instant;
+
+use re_video::{Chunk, Time};
+
 use crate::{
     resource_managers::GpuTexture2D,
     wgpu_resources::{GpuTexturePool, TextureDesc},
     RenderContext,
 };
 
-use std::{sync::Arc, time::Duration};
-
-use super::{DecodeHardwareAcceleration, DecodingError, FrameDecodingResult};
+use super::{DecodeHardwareAcceleration, DecodingError, VideoFrameTexture};
 
+/// Ignore hickups lasting shorter than this.
+///
 /// Delaying error reports (and showing last-good images meanwhile) allows us to skip over
 /// transient errors without flickering.
-#[allow(unused)]
-pub const DECODING_ERROR_REPORTING_DELAY: Duration = Duration::from_millis(400);
+///
+/// Same with showing a spinner: if we show it too fast, it is annoying.
+const DECODING_GRACE_DELAY: Duration = Duration::from_millis(400);
+
+#[allow(unused)] // Unused for certain build flags
+struct TimedDecodingError {
+    time_of_first_error: Instant,
+    latest_error: DecodingError,
+}
+
+impl TimedDecodingError {
+    #[allow(unused)] // Unused for certain build flags
+    pub fn new(latest_error: DecodingError) -> Self {
+        Self {
+            time_of_first_error: Instant::now(),
+            latest_error,
+        }
+    }
+}
+
+/// A texture of a specific video frame.
+struct VideoTexture {
+    pub texture: GpuTexture2D,
+
+    /// What part of the video this video frame covers.
+    pub time_range: Range<Time>,
+}
+
+/// Decode video to a texture.
+///
+/// If you want to sample multiple points in a video simultaneously, use multiple decoders.
+trait VideoChunkDecoder: 'static + Send {
+    /// Start decoding the given chunk.
+    fn decode(&mut self, chunk: Chunk, is_keyframe: bool) -> Result<(), DecodingError>;
+
+    /// Get the latest decoded frame at the given time
+    /// and copy it to the given texture.
+    ///
+    /// Drop all earlier frames to save memory.
+    ///
+    /// Returns [`DecodingError::EmptyBuffer`] if the internal buffer is empty,
+    /// which it is just after startup or after a call to [`Self::reset`].
+    fn update_video_texture(
+        &mut self,
+        render_ctx: &RenderContext,
+        video_texture: &mut VideoTexture,
+        presentation_timestamp: Time,
+    ) -> Result<(), DecodingError>;
+
+    /// Reset the video decoder and discard all frames.
+    fn reset(&mut self) -> Result<(), DecodingError>;
+
+    /// Return and clear the latest error that happened during decoding.
+    fn take_error(&mut self) -> Option<TimedDecodingError>;
+}
 
 /// Decode video to a texture.
 ///
 /// If you want to sample multiple points in a video simultaneously, use multiple decoders.
-pub trait VideoDecoder: 'static + Send {
+pub struct VideoDecoder {
+    data: Arc<re_video::VideoData>,
+    chunk_decoder: Box<dyn VideoChunkDecoder>,
+
+    video_texture: VideoTexture,
+
+    current_gop_idx: usize,
+    current_sample_idx: usize,
+
+    error: Option<TimedDecodingError>,
+    error_on_last_frame_at: bool,
+}
+
+impl VideoDecoder {
+    pub fn new(
+        debug_name: &str,
+        render_ctx: &RenderContext,
+        data: Arc<re_video::VideoData>,
+        hw_acceleration: DecodeHardwareAcceleration,
+    ) -> Result<Self, DecodingError> {
+        // We need these allows due to `cfg_if`
+        #![allow(
+            clippy::needless_pass_by_value,
+            clippy::needless_return,
+            clippy::unnecessary_wraps,
+            unused
+        )]
+
+        let debug_name = format!("{debug_name}, codec: {}", data.config.codec);
+
+        cfg_if::cfg_if! {
+            if #[cfg(target_arch = "wasm32")] {
+                let decoder = web::WebVideoDecoder::new(data.clone(), hw_acceleration)?;
+                return Ok(Self::from_chunk_decoder(render_ctx, data, decoder));
+            } else if #[cfg(feature = "video_av1")] {
+                if !data.config.is_av1() {
+                    return Err(DecodingError::UnsupportedCodec {
+                        codec: data.config.codec.clone(),
+                    });
+                }
+
+                if cfg!(debug_assertions) {
+                    return Err(DecodingError::NoNativeDebug); // because debug builds of rav1d are so slow
+                } else {
+                    let decoder = native_av1::Av1VideoDecoder::new(debug_name)?;
+                    return Ok(Self::from_chunk_decoder(render_ctx, data, decoder));
+                };
+            } else {
+                return Err(DecodingError::NoNativeSupport);
+            }
+        }
+    }
+
+    #[allow(unused)] // Unused for certain build flags
+    fn from_chunk_decoder(
+        render_ctx: &RenderContext,
+        data: Arc<re_video::VideoData>,
+        chunk_decoder: impl VideoChunkDecoder,
+    ) -> Self {
+        let texture = alloc_video_frame_texture(
+            &render_ctx.device,
+            &render_ctx.gpu_resources.textures,
+            data.config.coded_width as u32,
+            data.config.coded_height as u32,
+        );
+
+        Self {
+            data,
+            chunk_decoder: Box::new(chunk_decoder),
+
+            video_texture: VideoTexture {
+                texture,
+                time_range: Time::MAX..Time::MAX,
+            },
+
+            current_gop_idx: usize::MAX,
+            current_sample_idx: usize::MAX,
+
+            error: None,
+            error_on_last_frame_at: false,
+        }
+    }
+
     /// Get the video frame at the given time stamp.
     ///
     /// This will seek in the video if needed.
     /// If you want to sample multiple points in a video simultaneously, use multiple decoders.
-    fn frame_at(
+    pub fn frame_at(
         &mut self,
         render_ctx: &RenderContext,
         presentation_timestamp_s: f64,
-    ) -> FrameDecodingResult;
-}
+    ) -> Result<VideoFrameTexture, DecodingError> {
+        if presentation_timestamp_s < 0.0 {
+            return Err(DecodingError::NegativeTimestamp);
+        }
+        let presentation_timestamp = Time::from_secs(presentation_timestamp_s, self.data.timescale);
+        let presentation_timestamp = presentation_timestamp.min(self.data.duration); // Don't seek past the end of the video.
 
-pub fn new_video_decoder(
-    debug_name: &str,
-    render_context: &RenderContext,
-    data: Arc<re_video::VideoData>,
-    hw_acceleration: DecodeHardwareAcceleration,
-) -> Result<Box<dyn VideoDecoder>, DecodingError> {
-    #![allow(unused, clippy::unnecessary_wraps, clippy::needless_pass_by_value)] // only for some feature flags
-
-    cfg_if::cfg_if! {
-        if #[cfg(target_arch = "wasm32")] {
-            let decoder = web::WebVideoDecoder::new(render_context, data, hw_acceleration)?;
-        } else if #[cfg(feature = "video_av1")] {
-            let decoder = if cfg!(debug_assertions) {
-                return Err(DecodingError::NoNativeDebug); // because debug builds of rav1d are so slow
+        let result = self.frame_at_internal(render_ctx, presentation_timestamp);
+
+        match result {
+            Ok(()) => {
+                let is_active_frame = self
+                    .video_texture
+                    .time_range
+                    .contains(&presentation_timestamp);
+
+                let is_pending = !is_active_frame;
+                if is_pending && self.error_on_last_frame_at {
+                    // If we switched from error to pending, clear the texture.
+                    // This is important to avoid flickering, in particular when switching from
+                    // benign errors like DecodingError::NegativeTimestamp.
+                    // If we don't do this, we see the last valid texture which can look really weird.
+                    clear_texture(render_ctx, &self.video_texture.texture);
+                    self.video_texture.time_range = Time::MAX..Time::MAX;
+                }
+
+                self.error_on_last_frame_at = false;
+
+                let show_spinner = if presentation_timestamp < self.video_texture.time_range.start {
+                    // We're seeking backwards and somehow forgot to reset.
+                    true
+                } else if presentation_timestamp < self.video_texture.time_range.end {
+                    false // it is an active frame
+                } else {
+                    let how_outdated = presentation_timestamp - self.video_texture.time_range.end;
+                    if how_outdated.into_secs(self.data.timescale)
+                        < DECODING_GRACE_DELAY.as_secs_f64()
+                    {
+                        false // Just outdated by a little bit - show no spinner
+                    } else {
+                        true // Very old frame - show spinner
+                    }
+                };
+
+                Ok(VideoFrameTexture {
+                    texture: self.video_texture.texture.clone(),
+                    is_pending,
+                    show_spinner,
+                })
+            }
+
+            Err(err) => {
+                self.error_on_last_frame_at = true;
+                Err(err)
+            }
+        }
+    }
+
+    fn frame_at_internal(
+        &mut self,
+        render_ctx: &RenderContext,
+        presentation_timestamp: Time,
+    ) -> Result<(), DecodingError> {
+        re_tracing::profile_function!();
+
+        // Some terminology:
+        //   - presentation timestamp = composition timestamp
+        //     = the time at which the frame should be shown
+        //   - decode timestamp
+        //     = determines the decoding order of samples
+        //
+        // Note: `decode <= composition` for any given sample.
+        //       For some codecs, the two timestamps are the same.
+        // We must enqueue samples in decode order, but show them in composition order.
+
+        // 1. Find the latest sample where `decode_timestamp <= presentation_timestamp`.
+        //    Because `decode <= composition`, we never have to look further ahead in the
+        //    video than this.
+        let Some(decode_sample_idx) = latest_at_idx(
+            &self.data.samples,
+            |sample| sample.decode_timestamp,
+            &presentation_timestamp,
+        ) else {
+            return Err(DecodingError::EmptyVideo);
+        };
+
+        // 2. Search _backwards_, starting at `decode_sample_idx`, looking for
+        //    the first sample where `sample.composition_timestamp <= presentation_timestamp`.
+        //    This is the sample which when decoded will be presented at the timestamp the user requested.
+        let Some(requested_sample_idx) = self.data.samples[..=decode_sample_idx]
+            .iter()
+            .rposition(|sample| sample.composition_timestamp <= presentation_timestamp)
+        else {
+            return Err(DecodingError::EmptyVideo);
+        };
+
+        // 3. Do a binary search through GOPs by the decode timestamp of the found sample
+        //    to find the GOP that contains the sample.
+        let Some(requested_gop_idx) = latest_at_idx(
+            &self.data.gops,
+            |gop| gop.start,
+            &self.data.samples[requested_sample_idx].decode_timestamp,
+        ) else {
+            return Err(DecodingError::EmptyVideo);
+        };
+
+        // 4. Enqueue GOPs as needed.
+
+        // First, check for decoding errors that may have been set asynchronously and reset if it's a new error.
+        if let Some(error) = self.chunk_decoder.take_error() {
+            // For each new (!) error after entering the error state, we reset the decoder.
+            // This way, it might later recover from the error as we progress in the video.
+            //
+            // By resetting the current GOP/sample indices, the frame enqueued code below
+            // is forced to reset the decoder.
+            self.current_gop_idx = usize::MAX;
+            self.current_sample_idx = usize::MAX;
+
+            self.error = Some(error);
+        }
+
+        // We maintain a buffer of 2 GOPs, so we can always smoothly transition to the next GOP.
+        // We can always start decoding from any GOP, because GOPs always begin with a keyframe.
+        //
+        // Backward seeks or seeks across many GOPs trigger a reset of the decoder,
+        // because decoding all the samples between the previous sample and the requested
+        // one would mean decoding and immediately discarding more frames than we need.
+        if requested_gop_idx != self.current_gop_idx {
+            if self.current_gop_idx.saturating_add(1) == requested_gop_idx {
+                // forward seek to next GOP - queue up the one _after_ requested
+                self.enqueue_gop(requested_gop_idx + 1)?;
+            } else {
+                // forward seek by N>1 OR backward seek across GOPs - reset
+                self.reset()?;
+                self.enqueue_gop(requested_gop_idx)?;
+                self.enqueue_gop(requested_gop_idx + 1)?;
+            }
+        } else if requested_sample_idx != self.current_sample_idx {
+            // special case: handle seeking backwards within a single GOP
+            // this is super inefficient, but it's the only way to handle it
+            // while maintaining a buffer of only 2 GOPs
+            if requested_sample_idx < self.current_sample_idx {
+                self.reset()?;
+                self.enqueue_gop(requested_gop_idx)?;
+                self.enqueue_gop(requested_gop_idx + 1)?;
+            }
+        }
+
+        self.current_gop_idx = requested_gop_idx;
+        self.current_sample_idx = requested_sample_idx;
+
+        let result = self.chunk_decoder.update_video_texture(
+            render_ctx,
+            &mut self.video_texture,
+            presentation_timestamp,
+        );
+
+        if let Err(err) = result {
+            if err == DecodingError::EmptyBuffer {
+                // No buffered frames
+
+                // Might this be due to an error?
+                //
+                // We only care about decoding errors when we don't find the requested frame,
+                // since we want to keep playing the video fine even if parts of it are broken.
+                // That said, practically we reset the decoder and thus all frames upon error,
+                // so it doesn't make a lot of difference.
+                if let Some(timed_error) = &self.error {
+                    if DECODING_GRACE_DELAY <= timed_error.time_of_first_error.elapsed() {
+                        // Report the error only if we have been in an error state for a certain amount of time.
+                        // Don't immediately report the error, since we might immediately recover from it.
+                        // Otherwise, this would cause aggressive flickering!
+                        return Err(timed_error.latest_error.clone());
+                    }
+                }
+
+                // Don't return a zeroed texture, because we may just be behind on decoding
+                // and showing an old frame is better than showing a blank frame,
+                // because it causes "black flashes" to appear
+                Ok(())
             } else {
-                native_av1::Av1VideoDecoder::new(debug_name, render_context, data)?
-            };
+                Err(err)
+            }
         } else {
-            let decoder = no_native_decoder::NoNativeVideoDecoder::default();
+            Ok(())
         }
-    };
+    }
 
-    Ok(Box::new(decoder))
+    /// Enqueue all samples in the given GOP.
+    ///
+    /// Does nothing if the index is out of bounds.
+    fn enqueue_gop(&mut self, gop_idx: usize) -> Result<(), DecodingError> {
+        let Some(gop) = self.data.gops.get(gop_idx) else {
+            return Ok(());
+        };
+
+        let samples = &self.data.samples[gop.range()];
+
+        for (i, sample) in samples.iter().enumerate() {
+            let chunk = self.data.get(sample).ok_or(DecodingError::BadData)?;
+            let is_keyframe = i == 0;
+            self.chunk_decoder.decode(chunk, is_keyframe)?;
+        }
+
+        Ok(())
+    }
+
+    /// Reset the video decoder and discard all frames.
+    fn reset(&mut self) -> Result<(), DecodingError> {
+        self.chunk_decoder.reset()?;
+        self.error = None;
+        self.current_gop_idx = usize::MAX;
+        self.current_sample_idx = usize::MAX;
+        Ok(())
+    }
 }
 
 #[allow(unused)] // For some feature flags
@@ -98,6 +425,30 @@ fn alloc_video_frame_texture(
     texture
 }
 
+/// Clears the texture that is shown on pending to black.
+fn clear_texture(render_ctx: &RenderContext, texture: &GpuTexture2D) {
+    // Clear texture is a native only feature, so let's not do that.
+    // before_view_builder_encoder.clear_texture(texture, subresource_range);
+
+    // But our target is also a render target, so just create a dummy renderpass with clear.
+    let mut before_view_builder_encoder =
+        render_ctx.active_frame.before_view_builder_encoder.lock();
+    let _ = before_view_builder_encoder
+        .get()
+        .begin_render_pass(&wgpu::RenderPassDescriptor {
+            label: crate::DebugLabel::from("clear_video_texture").get(),
+            color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                view: &texture.default_view,
+                resolve_target: None,
+                ops: wgpu::Operations::<wgpu::Color> {
+                    load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
+                    store: wgpu::StoreOp::Store,
+                },
+            })],
+            ..Default::default()
+        });
+}
+
 /// Returns the index of:
 /// - The index of `needle` in `v`, if it exists
 /// - The index of the first element in `v` that is lesser than `needle`, if it exists
diff --git a/crates/viewer/re_renderer/src/video/decoder/native_av1.rs b/crates/viewer/re_renderer/src/video/decoder/native_av1.rs
index 691f6593e044..c7c7bc9b78b9 100644
--- a/crates/viewer/re_renderer/src/video/decoder/native_av1.rs
+++ b/crates/viewer/re_renderer/src/video/decoder/native_av1.rs
@@ -2,243 +2,85 @@
 
 use std::sync::Arc;
 
-use crate::{
-    resource_managers::GpuTexture2D,
-    video::{DecodingError, FrameDecodingResult, VideoFrameTexture},
-    RenderContext,
-};
-
-// TODO(#7298): remove `allow` once we have native video decoding
-#[allow(unused_imports)]
-use super::latest_at_idx;
-
-use re_video::{Frame, Time};
+use re_video::{Chunk, Frame, Time};
 
 use parking_lot::Mutex;
-use web_time::Instant;
 
-use super::{VideoDecoder, DECODING_ERROR_REPORTING_DELAY};
+use crate::{video::DecodingError, RenderContext};
 
+use super::{latest_at_idx, TimedDecodingError, VideoChunkDecoder, VideoTexture};
+
+#[derive(Default)]
 struct DecoderOutput {
     frames: Vec<Frame>,
 
-    last_decoding_error: Option<DecodingError>,
-
-    /// Whether we reset the decoder since the last time an error was reported.
-    reset_since_last_reported_error: bool,
-
-    /// Time at which point `last_decoding_error` changed from `None` to `Some`.
-    time_when_entering_error_state: Instant,
-}
-
-impl Default for DecoderOutput {
-    fn default() -> Self {
-        Self {
-            frames: Vec::new(),
-            last_decoding_error: None,
-            reset_since_last_reported_error: false,
-            time_when_entering_error_state: Instant::now(),
-        }
-    }
+    /// Set on error; reset on success.
+    error: Option<TimedDecodingError>,
 }
 
 /// Native AV1 decoder
 pub struct Av1VideoDecoder {
-    data: Arc<re_video::VideoData>,
-    queue: Arc<wgpu::Queue>,
-    texture: GpuTexture2D,
     decoder: re_video::av1::Decoder,
-
     decoder_output: Arc<Mutex<DecoderOutput>>,
-
-    last_used_frame_timestamp: Time,
-    current_segment_idx: usize,
-    current_sample_idx: usize,
 }
 
 impl Av1VideoDecoder {
-    pub fn new(
-        debug_name: &str,
-        render_context: &RenderContext,
-        data: Arc<re_video::VideoData>,
-    ) -> Result<Self, DecodingError> {
+    pub fn new(debug_name: String) -> Result<Self, DecodingError> {
         re_tracing::profile_function!();
-        let full_debug_name = format!("{debug_name}, codec: {}", data.config.codec);
 
-        if !data.config.is_av1() {
-            return Err(DecodingError::UnsupportedCodec {
-                codec: data.config.codec.clone(),
-            });
-        }
-
-        re_log::debug!("Initializing native video decoder…");
         let decoder_output = Arc::new(Mutex::new(DecoderOutput::default()));
 
         let on_output = {
             let decoder_output = decoder_output.clone();
-            let full_debug_name = full_debug_name.clone();
+            let debug_name = debug_name.clone();
             move |frame: re_video::av1::Result<Frame>| match frame {
                 Ok(frame) => {
                     re_log::trace!("Decoded frame at {:?}", frame.timestamp);
                     let mut output = decoder_output.lock();
                     output.frames.push(frame);
-                    // We successfully decoded a frame, reset the error state.
-                    output.last_decoding_error = None;
+                    output.error = None; // We successfully decoded a frame, reset the error state.
                 }
                 Err(err) => {
-                    re_log::warn_once!("Error during decoding of {full_debug_name}: {err}");
+                    re_log::warn_once!("Error during decoding of {debug_name}: {err}");
+                    let err = DecodingError::Decoding(err.to_string());
                     let mut output = decoder_output.lock();
-                    if output.last_decoding_error.is_none() {
-                        output.time_when_entering_error_state = Instant::now();
+                    if let Some(error) = &mut output.error {
+                        error.latest_error = err;
+                    } else {
+                        output.error = Some(TimedDecodingError::new(err));
                     }
-                    output.last_decoding_error = Some(DecodingError::Decoding(err.to_string()));
-                    output.reset_since_last_reported_error = false;
                 }
             }
         };
-        let decoder = re_video::av1::Decoder::new(full_debug_name, on_output);
-
-        let queue = render_context.queue.clone();
-
-        let texture = super::alloc_video_frame_texture(
-            &render_context.device,
-            &render_context.gpu_resources.textures,
-            data.config.coded_width as u32,
-            data.config.coded_height as u32,
-        );
+        let decoder = re_video::av1::Decoder::new(debug_name, on_output);
 
         Ok(Self {
-            data,
-            queue,
-            texture,
             decoder,
             decoder_output,
-            last_used_frame_timestamp: Time::MAX,
-            current_segment_idx: usize::MAX,
-            current_sample_idx: usize::MAX,
         })
     }
 }
 
-impl VideoDecoder for Av1VideoDecoder {
-    fn frame_at(
+impl VideoChunkDecoder for Av1VideoDecoder {
+    /// Start decoding the given chunk.
+    fn decode(&mut self, chunk: Chunk, _is_keyframe: bool) -> Result<(), DecodingError> {
+        self.decoder.decode(chunk);
+        Ok(())
+    }
+
+    fn update_video_texture(
         &mut self,
         render_ctx: &RenderContext,
-        presentation_timestamp_s: f64,
-    ) -> FrameDecodingResult {
-        re_tracing::profile_function!();
-
-        if presentation_timestamp_s < 0.0 {
-            return Err(DecodingError::NegativeTimestamp);
-        }
-        let presentation_timestamp = Time::from_secs(presentation_timestamp_s, self.data.timescale);
-        let presentation_timestamp = presentation_timestamp.min(self.data.duration); // Don't seek past the end of the video.
-
-        let Some(requested_segment_idx) = latest_at_idx(
-            &self.data.segments,
-            |segment| segment.start,
-            &presentation_timestamp,
-        ) else {
-            return Err(DecodingError::EmptyVideo);
-        };
-
-        let Some(requested_sample_idx) = latest_at_idx(
-            &self.data.samples,
-            |sample| sample.decode_timestamp,
-            &presentation_timestamp,
-        ) else {
-            return Err(DecodingError::EmptyVideo);
-        };
-
-        // Enqueue segments as needed.
-        //
-        // First, check for decoding errors that may have been set asynchronously and reset if it's a new error.
-        {
-            let decoder_output = self.decoder_output.lock();
-            if decoder_output.last_decoding_error.is_some()
-                && !decoder_output.reset_since_last_reported_error
-            {
-                // For each new (!) error after entering the error state, we reset the decoder.
-                // This way, it might later recover from the error as we progress in the video.
-                //
-                // By resetting the current segment/sample indices, the frame enqueued code below
-                // is forced to reset the decoder.
-                self.current_segment_idx = usize::MAX;
-                self.current_sample_idx = usize::MAX;
-            }
-        };
-        // We maintain a buffer of 2 segments, so we can
-        // always smoothly transition to the next segment.
-        // We can always start decoding from any segment, because segments always begin
-        // with a keyframe.
-        // Backward seeks or seeks across many segments trigger a reset of the decoder,
-        // because decoding all the samples between the previous sample and the requested
-        // one would mean decoding and immediately discarding more frames than we otherwise
-        // need to.
-        if requested_segment_idx != self.current_segment_idx {
-            let segment_distance =
-                requested_segment_idx as isize - self.current_segment_idx as isize;
-            if segment_distance == 1 {
-                // forward seek to next segment - queue up the one _after_ requested
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            } else {
-                // forward seek by N>1 OR backward seek across segments - reset
-                self.reset();
-                self.enqueue_segment(requested_segment_idx)?;
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            }
-        } else if requested_sample_idx != self.current_sample_idx {
-            // special case: handle seeking backwards within a single segment
-            // this is super inefficient, but it's the only way to handle it
-            // while maintaining a buffer of 2 segments
-            let sample_distance = requested_sample_idx as isize - self.current_sample_idx as isize;
-            if sample_distance < 0 {
-                self.reset();
-                self.enqueue_segment(requested_segment_idx)?;
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            }
-        }
-
-        self.current_segment_idx = requested_segment_idx;
-        self.current_sample_idx = requested_sample_idx;
-
+        video_texture: &mut VideoTexture,
+        presentation_timestamp: Time,
+    ) -> Result<(), DecodingError> {
         let mut decoder_output = self.decoder_output.lock();
         let frames = &mut decoder_output.frames;
 
-        if !frames.is_empty() {
-            re_log::trace_once!(
-                "Looking for frame timestamp {presentation_timestamp:?} among frames {:?} - {:?}",
-                frames.first().unwrap().timestamp,
-                frames.last().unwrap().timestamp
-            );
-        }
-
         let Some(frame_idx) =
             latest_at_idx(frames, |frame| frame.timestamp, &presentation_timestamp)
         else {
-            // No buffered frames - texture will be blank.
-
-            // Might this be due to an error?
-            //
-            // We only care about decoding errors when we don't find the requested frame,
-            // since we want to keep playing the video fine even if parts of it are broken.
-            // That said, practically we reset the decoder and thus all frames upon error,
-            // so it doesn't make a lot of difference.
-            if let Some(last_decoding_error) = &decoder_output.last_decoding_error {
-                if decoder_output.time_when_entering_error_state.elapsed()
-                    >= DECODING_ERROR_REPORTING_DELAY
-                {
-                    // Report the error only if we have been in an error state for a certain amount of time.
-                    // Don't immediately report the error, since we might immediately recover from it.
-                    // Otherwise, this would cause aggressive flickering!
-                    return Err(last_decoding_error.clone());
-                }
-            }
-
-            // Don't return a zeroed texture, because we may just be behind on decoding
-            // and showing an old frame is better than showing a blank frame,
-            // because it causes "black flashes" to appear
-            return Ok(VideoFrameTexture::Pending(self.texture.clone()));
+            return Err(DecodingError::EmptyBuffer);
         };
 
         // drain up-to (but not including) the frame idx, clearing out any frames
@@ -249,63 +91,32 @@ impl VideoDecoder for Av1VideoDecoder {
         let frame_idx = 0;
         let frame = &frames[frame_idx];
 
-        // This handles the case when we have a buffered frame that's older than the requested timestamp.
-        // We don't want to show this frame to the user, because it's not actually the one they requested,
-        // so instead return the last decoded frame.
-        if presentation_timestamp - frame.timestamp > frame.duration {
-            return Ok(VideoFrameTexture::Pending(self.texture.clone()));
-        }
-
-        if self.last_used_frame_timestamp != frame.timestamp {
-            self.last_used_frame_timestamp = frame.timestamp;
-            copy_video_frame_to_texture(&self.queue, frame, &self.texture.texture)?;
-        }
-
-        Ok(VideoFrameTexture::Ready(self.texture.clone()))
-    }
-}
-
-impl Av1VideoDecoder {
-    pub fn duration_ms(&self) -> f64 {
-        self.data.duration_sec()
-    }
-
-    pub fn width(&self) -> u32 {
-        self.data.config.coded_width as u32
-    }
-
-    pub fn height(&self) -> u32 {
-        self.data.config.coded_height as u32
-    }
+        let frame_time_range = frame.timestamp..frame.timestamp + frame.duration;
 
-    /// Enqueue all samples in the given segment.
-    ///
-    /// Does nothing if the index is out of bounds.
-    fn enqueue_segment(&mut self, segment_idx: usize) -> Result<(), DecodingError> {
-        let Some(segment) = self.data.segments.get(segment_idx) else {
-            return Ok(());
-        };
-
-        let samples = &self.data.samples[segment.range()];
-
-        for sample in samples {
-            let chunk = self.data.get(sample).ok_or(DecodingError::BadData)?;
-            self.decoder.decode(chunk);
+        if frame_time_range.contains(&presentation_timestamp)
+            && video_texture.time_range != frame_time_range
+        {
+            copy_video_frame_to_texture(&render_ctx.queue, frame, &video_texture.texture.texture)?;
+            video_texture.time_range = frame_time_range;
         }
 
         Ok(())
     }
 
     /// Reset the video decoder and discard all frames.
-    fn reset(&mut self) {
+    fn reset(&mut self) -> Result<(), DecodingError> {
         self.decoder.reset();
 
         let mut decoder_output = self.decoder_output.lock();
-        decoder_output.reset_since_last_reported_error = true;
+        decoder_output.error = None;
         decoder_output.frames.clear();
 
-        self.current_segment_idx = usize::MAX;
-        self.current_sample_idx = usize::MAX;
+        Ok(())
+    }
+
+    /// Return and clear the latest error that happened during decoding.
+    fn take_error(&mut self) -> Option<TimedDecodingError> {
+        self.decoder_output.lock().error.take()
     }
 }
 
@@ -314,6 +125,8 @@ fn copy_video_frame_to_texture(
     frame: &Frame,
     texture: &wgpu::Texture,
 ) -> Result<(), DecodingError> {
+    re_tracing::profile_function!();
+
     let size = wgpu::Extent3d {
         width: frame.width,
         height: frame.height,
@@ -333,7 +146,6 @@ fn copy_video_frame_to_texture(
 
     let bytes_per_row_unaligned = width_blocks * block_size;
 
-    re_tracing::profile_scope!("write_texture");
     queue.write_texture(
         wgpu::ImageCopyTexture {
             texture,
diff --git a/crates/viewer/re_renderer/src/video/decoder/no_native_decoder.rs b/crates/viewer/re_renderer/src/video/decoder/no_native_decoder.rs
deleted file mode 100644
index 10aa5f42fba5..000000000000
--- a/crates/viewer/re_renderer/src/video/decoder/no_native_decoder.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use crate::{
-    video::{DecodingError, FrameDecodingResult},
-    RenderContext,
-};
-
-use super::VideoDecoder;
-
-/// A [`VideoDecoder`] that always fails with [`DecodingError::NoNativeSupport`]
-#[derive(Default)]
-pub struct NoNativeVideoDecoder {}
-
-impl VideoDecoder for NoNativeVideoDecoder {
-    #[allow(clippy::unused_self)]
-    fn frame_at(
-        &mut self,
-        _render_ctx: &RenderContext,
-        _presentation_timestamp_s: f64,
-    ) -> FrameDecodingResult {
-        Err(DecodingError::NoNativeSupport)
-    }
-}
diff --git a/crates/viewer/re_renderer/src/video/decoder/web.rs b/crates/viewer/re_renderer/src/video/decoder/web.rs
index a4a4d5537b04..3562eb68fc97 100644
--- a/crates/viewer/re_renderer/src/video/decoder/web.rs
+++ b/crates/viewer/re_renderer/src/video/decoder/web.rs
@@ -2,33 +2,32 @@ use std::sync::Arc;
 
 use js_sys::{Function, Uint8Array};
 use parking_lot::Mutex;
-use re_video::{Time, Timescale};
 use wasm_bindgen::{closure::Closure, JsCast as _};
 use web_sys::{
     EncodedVideoChunk, EncodedVideoChunkInit, EncodedVideoChunkType, VideoDecoderConfig,
     VideoDecoderInit,
 };
-use web_time::Instant;
+
+use re_video::{Time, Timescale};
 
 use crate::{
-    resource_managers::GpuTexture2D,
-    video::{DecodeHardwareAcceleration, DecodingError, FrameDecodingResult, VideoFrameTexture},
-    DebugLabel, RenderContext,
+    video::{DecodeHardwareAcceleration, DecodingError},
+    RenderContext,
 };
 
-use super::{latest_at_idx, VideoDecoder, DECODING_ERROR_REPORTING_DELAY};
+use super::{latest_at_idx, TimedDecodingError, VideoChunkDecoder, VideoTexture};
 
 #[derive(Clone)]
 #[repr(transparent)]
-struct VideoFrame(web_sys::VideoFrame);
+struct WebVideoFrame(web_sys::VideoFrame);
 
-impl Drop for VideoFrame {
+impl Drop for WebVideoFrame {
     fn drop(&mut self) {
         self.0.close();
     }
 }
 
-impl std::ops::Deref for VideoFrame {
+impl std::ops::Deref for WebVideoFrame {
     type Target = web_sys::VideoFrame;
 
     #[inline]
@@ -43,35 +42,21 @@ struct BufferedFrame {
 
     duration: Time,
 
-    inner: VideoFrame,
+    inner: WebVideoFrame,
 }
 
 struct DecoderOutput {
     frames: Vec<BufferedFrame>,
 
-    last_decoding_error: Option<DecodingError>,
-
-    /// Whether we reset the decoder since the last time an error was reported.
-    reset_since_last_reported_error: bool,
-
-    /// Time at which point `last_decoding_error` changed from `None` to `Some`.
-    time_when_entering_error_state: Instant,
+    /// Set on error; reset on success.
+    error: Option<TimedDecodingError>,
 }
 
 pub struct WebVideoDecoder {
     data: Arc<re_video::VideoData>,
-    queue: Arc<wgpu::Queue>,
-    texture: GpuTexture2D,
-
     decoder: web_sys::VideoDecoder,
     decoder_output: Arc<Mutex<DecoderOutput>>,
     hw_acceleration: DecodeHardwareAcceleration,
-
-    last_used_frame_timestamp: Time,
-    current_segment_idx: usize,
-    current_sample_idx: usize,
-
-    error_on_last_frame_at: bool,
 }
 
 // SAFETY: There is no way to access the same JS object from different OS threads
@@ -88,11 +73,11 @@ unsafe impl Sync for WebVideoDecoder {}
 
 #[allow(unsafe_code)]
 #[allow(clippy::undocumented_unsafe_blocks)]
-unsafe impl Send for VideoFrame {}
+unsafe impl Send for WebVideoFrame {}
 
 #[allow(unsafe_code)]
 #[allow(clippy::undocumented_unsafe_blocks)]
-unsafe impl Sync for VideoFrame {}
+unsafe impl Sync for WebVideoFrame {}
 
 impl Drop for WebVideoDecoder {
     fn drop(&mut self) {
@@ -100,7 +85,7 @@ impl Drop for WebVideoDecoder {
         if let Err(err) = self.decoder.close() {
             if let Some(dom_exception) = err.dyn_ref::<web_sys::DomException>() {
                 if dom_exception.code() == web_sys::DomException::INVALID_STATE_ERR
-                    && self.decoder_output.lock().last_decoding_error.is_some()
+                    && self.decoder_output.lock().error.is_some()
                 {
                     // Invalid state error after a decode error may happen, ignore it!
                     return;
@@ -117,193 +102,56 @@ impl Drop for WebVideoDecoder {
 
 impl WebVideoDecoder {
     pub fn new(
-        render_context: &RenderContext,
         data: Arc<re_video::VideoData>,
         hw_acceleration: DecodeHardwareAcceleration,
     ) -> Result<Self, DecodingError> {
         let decoder_output = Arc::new(Mutex::new(DecoderOutput {
             frames: Vec::new(),
-            last_decoding_error: None,
-            reset_since_last_reported_error: false,
-            time_when_entering_error_state: Instant::now(),
+            error: None,
         }));
         let decoder = init_video_decoder(&decoder_output, data.timescale)?;
-        let queue = render_context.queue.clone();
-
-        // NOTE: both textures are assumed to be rgba8unorm
-        let texture = super::alloc_video_frame_texture(
-            &render_context.device,
-            &render_context.gpu_resources.textures,
-            data.config.coded_width as u32,
-            data.config.coded_height as u32,
-        );
 
         Ok(Self {
             data,
-            queue,
-            texture,
-
             decoder,
             decoder_output,
             hw_acceleration,
-
-            last_used_frame_timestamp: Time::MAX,
-            current_segment_idx: usize::MAX,
-            current_sample_idx: usize::MAX,
-
-            error_on_last_frame_at: false,
         })
     }
 }
 
-impl VideoDecoder for WebVideoDecoder {
-    fn frame_at(
+impl VideoChunkDecoder for WebVideoDecoder {
+    /// Start decoding the given chunk.
+    fn decode(
         &mut self,
-        render_ctx: &RenderContext,
-        presentation_timestamp_s: f64,
-    ) -> FrameDecodingResult {
-        let result = self.frame_at_internal(presentation_timestamp_s);
-        match &result {
-            Ok(VideoFrameTexture::Ready(_)) => {
-                self.error_on_last_frame_at = false;
-            }
-            Ok(VideoFrameTexture::Pending(_)) => {
-                if self.error_on_last_frame_at {
-                    // If we switched from error to pending, clear the texture.
-                    // This is important to avoid flickering, in particular when switching from
-                    // benign errors like DecodingError::NegativeTimestamp.
-                    // If we don't do this, we see the last valid texture which can look really weird.
-                    self.clear_video_texture(render_ctx);
-                }
-
-                self.error_on_last_frame_at = false;
-            }
-            Err(_) => {
-                self.error_on_last_frame_at = true;
-            }
-        }
-        result
-    }
-}
-
-impl WebVideoDecoder {
-    fn frame_at_internal(&mut self, presentation_timestamp_s: f64) -> FrameDecodingResult {
-        if presentation_timestamp_s < 0.0 {
-            return Err(DecodingError::NegativeTimestamp);
-        }
-        let presentation_timestamp = Time::from_secs(presentation_timestamp_s, self.data.timescale);
-        let presentation_timestamp = presentation_timestamp.min(self.data.duration); // Don't seek past the end of the video.
-
-        self.enqueue_requested_segments(presentation_timestamp)?;
-        self.try_present_frame(presentation_timestamp)
+        video_chunk: re_video::Chunk,
+        is_keyframe: bool,
+    ) -> Result<(), DecodingError> {
+        let data = Uint8Array::from(video_chunk.data.as_slice());
+        let type_ = if is_keyframe {
+            EncodedVideoChunkType::Key
+        } else {
+            EncodedVideoChunkType::Delta
+        };
+        let web_chunk = EncodedVideoChunkInit::new(
+            &data,
+            video_chunk.timestamp.into_micros(self.data.timescale),
+            type_,
+        );
+        web_chunk.set_duration(video_chunk.duration.into_micros(self.data.timescale));
+        let web_chunk = EncodedVideoChunk::new(&web_chunk)
+            .map_err(|err| DecodingError::CreateChunk(js_error_to_string(&err)))?;
+        self.decoder
+            .decode(&web_chunk)
+            .map_err(|err| DecodingError::DecodeChunk(js_error_to_string(&err)))
     }
 
-    fn enqueue_requested_segments(
+    fn update_video_texture(
         &mut self,
+        render_ctx: &RenderContext,
+        video_texture: &mut VideoTexture,
         presentation_timestamp: Time,
     ) -> Result<(), DecodingError> {
-        re_tracing::profile_function!();
-
-        // Some terminology:
-        //   - presentation timestamp = composition timestamp
-        //     = the time at which the frame should be shown
-        //   - decode timestamp
-        //     = determines the decoding order of samples
-        //
-        // Note: `composition >= decode` for any given sample.
-        //       For some codecs, the two timestamps are the same.
-        // We must enqueue samples in decode order, but show them in composition order.
-
-        // 1. Find the latest sample where `decode_timestamp <= presentation_timestamp`.
-        //    Because `composition >= decode`, we never have to look further ahead in the
-        //    video than this.
-        let Some(decode_sample_idx) = latest_at_idx(
-            &self.data.samples,
-            |sample| sample.decode_timestamp,
-            &presentation_timestamp,
-        ) else {
-            return Err(DecodingError::EmptyVideo);
-        };
-
-        // 2. Search _backwards_, starting at `decode_sample_idx`, looking for
-        //    the first sample where `sample.composition_timestamp <= presentation_timestamp`.
-        //    This is the sample which when decoded will be presented at the timestamp the user requested.
-        let Some(requested_sample_idx) = self.data.samples[..=decode_sample_idx]
-            .iter()
-            .rposition(|sample| sample.composition_timestamp <= presentation_timestamp)
-        else {
-            return Err(DecodingError::EmptyVideo);
-        };
-
-        // 3. Do a binary search through segments by the decode timestamp of the found sample
-        //    to find the segment that contains the sample.
-        let Some(requested_segment_idx) = latest_at_idx(
-            &self.data.segments,
-            |segment| segment.start,
-            &self.data.samples[requested_sample_idx].decode_timestamp,
-        ) else {
-            return Err(DecodingError::EmptyVideo);
-        };
-
-        // 4. Enqueue segments as needed.
-        //
-        // First, check for decoding errors that may have been set asynchronously and reset if it's a new error.
-        {
-            let decoder_output = self.decoder_output.lock();
-            if decoder_output.last_decoding_error.is_some()
-                && !decoder_output.reset_since_last_reported_error
-            {
-                // For each new (!) error after entering the error state, we reset the decoder.
-                // This way, it might later recover from the error as we progress in the video.
-                //
-                // By resetting the current segment/sample indices, the frame enqueued code below
-                // is forced to reset the decoder.
-                self.current_segment_idx = usize::MAX;
-                self.current_sample_idx = usize::MAX;
-            }
-        };
-        // We maintain a buffer of 2 segments, so we can always smoothly transition to the next segment.
-        // We can always start decoding from any segment, because segments always begin with a keyframe.
-        //
-        // Backward seeks or seeks across many segments trigger a reset of the decoder,
-        // because decoding all the samples between the previous sample and the requested
-        // one would mean decoding and immediately discarding more frames than we need.
-        if requested_segment_idx != self.current_segment_idx {
-            let segment_distance = requested_segment_idx.checked_sub(self.current_segment_idx);
-            if segment_distance == Some(1) {
-                // forward seek to next segment - queue up the one _after_ requested
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            } else {
-                // Startup, forward seek by N>1, or backward seek across segments -> reset decoder
-                self.reset()?;
-                self.enqueue_segment(requested_segment_idx)?;
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            }
-        } else if requested_sample_idx != self.current_sample_idx {
-            // special case: handle seeking backwards within a single segment
-            // this is super inefficient, but it's the only way to handle it
-            // while maintaining a buffer of 2 segments
-            let sample_distance = requested_sample_idx as isize - self.current_sample_idx as isize;
-            if sample_distance < 0 {
-                self.reset()?;
-                self.enqueue_segment(requested_segment_idx)?;
-                self.enqueue_segment(requested_segment_idx + 1)?;
-            }
-        }
-
-        // At this point, we have the requested segments enqueued. They will be output
-        // in _composition timestamp_ order, so presenting the frame is a binary search
-        // through the frame buffer as usual.
-
-        self.current_segment_idx = requested_segment_idx;
-        self.current_sample_idx = requested_sample_idx;
-
-        Ok(())
-    }
-
-    fn try_present_frame(&mut self, presentation_timestamp: Time) -> FrameDecodingResult {
-        re_tracing::profile_function!();
-
         let mut decoder_output = self.decoder_output.lock();
 
         let frames = &mut decoder_output.frames;
@@ -313,29 +161,7 @@ impl WebVideoDecoder {
             |frame| frame.composition_timestamp,
             &presentation_timestamp,
         ) else {
-            // No buffered frames - texture will be blank.
-
-            // Might this be due to an error?
-            //
-            // We only care about decoding errors when we don't find the requested frame,
-            // since we want to keep playing the video fine even if parts of it are broken.
-            // That said, practically we reset the decoder and thus all frames upon error,
-            // so it doesn't make a lot of difference.
-            if let Some(last_decoding_error) = &decoder_output.last_decoding_error {
-                if decoder_output.time_when_entering_error_state.elapsed()
-                    >= DECODING_ERROR_REPORTING_DELAY
-                {
-                    // Report the error only if we have been in an error state for a certain amount of time.
-                    // Don't immediately report the error, since we might immediately recover from it.
-                    // Otherwise, this would cause aggressive flickering!
-                    return Err(last_decoding_error.clone());
-                }
-            }
-
-            // Don't return a zeroed texture, because we may just be behind on decoding
-            // and showing an old frame is better than showing a blank frame,
-            // because it causes "black flashes" to appear
-            return Ok(VideoFrameTexture::Pending(self.texture.clone()));
+            return Err(DecodingError::EmptyBuffer);
         };
 
         // drain up-to (but not including) the frame idx, clearing out any frames
@@ -346,93 +172,27 @@ impl WebVideoDecoder {
         let frame_idx = 0;
         let frame = &frames[frame_idx];
 
-        // This handles the case when we have a buffered frame that's older than the requested timestamp.
-        // We don't want to show this frame to the user, because it's not actually the one they requested,
-        // so instead return the last decoded frame.
-        if presentation_timestamp - frame.composition_timestamp > frame.duration {
-            return Ok(VideoFrameTexture::Pending(self.texture.clone()));
-        }
-
-        if self.last_used_frame_timestamp != frame.composition_timestamp {
-            self.last_used_frame_timestamp = frame.composition_timestamp;
-            copy_video_frame_to_texture(&self.queue, &frame.inner, &self.texture.texture);
-        }
-
-        Ok(VideoFrameTexture::Ready(self.texture.clone()))
-    }
-
-    /// Clears the texture that is shown on pending to black.
-    fn clear_video_texture(&self, render_ctx: &RenderContext) {
-        // Clear texture is a native only feature, so let's not do that.
-        // before_view_builder_encoder.clear_texture(texture, subresource_range);
-
-        // But our target is also a render target, so just create a dummy renderpass with clear.
-        let mut before_view_builder_encoder =
-            render_ctx.active_frame.before_view_builder_encoder.lock();
-        let _ = before_view_builder_encoder
-            .get()
-            .begin_render_pass(&wgpu::RenderPassDescriptor {
-                label: DebugLabel::from("clear_video_texture").get(),
-                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                    view: &self.texture.default_view,
-                    resolve_target: None,
-                    ops: wgpu::Operations::<wgpu::Color> {
-                        load: wgpu::LoadOp::Clear(wgpu::Color::BLACK),
-                        store: wgpu::StoreOp::Store,
-                    },
-                })],
-                ..Default::default()
-            });
-    }
+        let frame_time_range =
+            frame.composition_timestamp..frame.composition_timestamp + frame.duration;
 
-    /// Enqueue all samples in the given segment.
-    ///
-    /// Does nothing if the index is out of bounds.
-    fn enqueue_segment(&self, segment_idx: usize) -> Result<(), DecodingError> {
-        let Some(segment) = self.data.segments.get(segment_idx) else {
-            return Ok(());
-        };
-
-        let samples = &self.data.samples[segment.range()];
-
-        // The first sample in a segment is always a key frame:
-        self.enqueue_sample(&samples[0], true)?;
-        for sample in &samples[1..] {
-            self.enqueue_sample(sample, false)?;
+        if frame_time_range.contains(&presentation_timestamp)
+            && video_texture.time_range != frame_time_range
+        {
+            copy_video_frame_to_texture(
+                &render_ctx.queue,
+                &frame.inner,
+                &video_texture.texture.texture,
+            );
+            video_texture.time_range = frame_time_range;
         }
 
         Ok(())
     }
 
-    /// Enqueue the given sample.
-    fn enqueue_sample(&self, sample: &re_video::Sample, is_key: bool) -> Result<(), DecodingError> {
-        let data = Uint8Array::from(
-            &self.data.data[sample.byte_offset as usize
-                ..sample.byte_offset as usize + sample.byte_length as usize],
-        );
-        let type_ = if is_key {
-            EncodedVideoChunkType::Key
-        } else {
-            EncodedVideoChunkType::Delta
-        };
-        let chunk = EncodedVideoChunkInit::new(
-            &data,
-            sample
-                .composition_timestamp
-                .into_micros(self.data.timescale),
-            type_,
-        );
-        chunk.set_duration(sample.duration.into_micros(self.data.timescale));
-        let chunk = EncodedVideoChunk::new(&chunk)
-            .map_err(|err| DecodingError::CreateChunk(js_error_to_string(&err)))?;
-        self.decoder
-            .decode(&chunk)
-            .map_err(|err| DecodingError::DecodeChunk(js_error_to_string(&err)))
-    }
-
     /// Reset the video decoder and discard all frames.
     fn reset(&mut self) -> Result<(), DecodingError> {
         re_log::trace!("Resetting video decoder.");
+
         if let Err(_err) = self.decoder.reset() {
             // At least on Firefox, it can happen that reset on a previous error fails.
             // In that case, start over completely and try again!
@@ -449,15 +209,17 @@ impl WebVideoDecoder {
 
         {
             let mut decoder_output = self.decoder_output.lock();
-            decoder_output.reset_since_last_reported_error = true;
+            decoder_output.error = None;
             decoder_output.frames.clear();
         }
 
-        self.current_segment_idx = usize::MAX;
-        self.current_sample_idx = usize::MAX;
-
         Ok(())
     }
+
+    /// Return and clear the latest error that happened during decoding.
+    fn take_error(&mut self) -> Option<TimedDecodingError> {
+        self.decoder_output.lock().error.take()
+    }
 }
 
 fn copy_video_frame_to_texture(
@@ -523,7 +285,7 @@ fn init_video_decoder(
             let composition_timestamp =
                 Time::from_micros(frame.timestamp().unwrap_or(0.0), timescale);
             let duration = Time::from_micros(frame.duration().unwrap_or(0.0), timescale);
-            let frame = VideoFrame(frame);
+            let frame = WebVideoFrame(frame);
 
             let mut output = decoder_output.lock();
             output.frames.push(BufferedFrame {
@@ -532,22 +294,21 @@ fn init_video_decoder(
                 inner: frame,
             });
 
-            // We successfully decoded a frame, reset the error state.
-            output.last_decoding_error = None;
+            output.error = None; // We successfully decoded a frame, reset the error state.
         }) as Box<dyn Fn(web_sys::VideoFrame)>)
     };
 
     let on_error = {
         let decoder_output = decoder_output.clone();
         Closure::wrap(Box::new(move |err: js_sys::Error| {
-            let err = js_error_to_string(&err);
+            let err = DecodingError::Decoding(js_error_to_string(&err));
 
             let mut output = decoder_output.lock();
-            if output.last_decoding_error.is_none() {
-                output.time_when_entering_error_state = Instant::now();
+            if let Some(error) = &mut output.error {
+                error.latest_error = err;
+            } else {
+                output.error = Some(TimedDecodingError::new(err));
             }
-            output.last_decoding_error = Some(DecodingError::Decoding(err));
-            output.reset_since_last_reported_error = false;
         }) as Box<dyn Fn(js_sys::Error)>)
     };
 
diff --git a/crates/viewer/re_renderer/src/video/mod.rs b/crates/viewer/re_renderer/src/video/mod.rs
index 75cd3b296693..a3e43a99a1eb 100644
--- a/crates/viewer/re_renderer/src/video/mod.rs
+++ b/crates/viewer/re_renderer/src/video/mod.rs
@@ -11,8 +11,11 @@ use crate::{resource_managers::GpuTexture2D, RenderContext};
 
 /// Error that can occur during frame decoding.
 // TODO(jan, andreas): These errors are for the most part specific to the web decoder right now.
-#[derive(thiserror::Error, Debug, Clone)]
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
 pub enum DecodingError {
+    #[error("The decoder is lagging behind")]
+    EmptyBuffer,
+
     #[error("Failed to create VideoDecoder: {0}")]
     DecoderSetupFailure(String),
 
@@ -65,12 +68,15 @@ pub enum DecodingError {
 pub type FrameDecodingResult = Result<VideoFrameTexture, DecodingError>;
 
 /// Information about the status of a frame decoding.
-pub enum VideoFrameTexture {
-    /// The requested frame got decoded and is ready to be used.
-    Ready(GpuTexture2D),
+pub struct VideoFrameTexture {
+    /// The texture to show.
+    pub texture: GpuTexture2D,
+
+    /// If true, the texture is outdated. Keep polling for a fresh one.
+    pub is_pending: bool,
 
-    /// The returned texture is from a previous frame or a placeholder, the decoder is still decoding the requested frame.
-    Pending(GpuTexture2D),
+    /// If true, this texture is so out-dated that it should have a loading spinner on top of it.
+    pub show_spinner: bool,
 }
 
 /// Identifier for an independent video decoding stream.
@@ -82,7 +88,7 @@ pub enum VideoFrameTexture {
 pub struct VideoDecodingStreamId(pub u64);
 
 struct DecoderEntry {
-    decoder: Box<dyn decoder::VideoDecoder>,
+    decoder: decoder::VideoDecoder,
     frame_index: u64,
 }
 
@@ -210,7 +216,7 @@ impl Video {
         let decoder_entry = match decoders.entry(decoder_stream_id) {
             Entry::Occupied(occupied_entry) => occupied_entry.into_mut(),
             Entry::Vacant(vacant_entry) => {
-                let new_decoder = decoder::new_video_decoder(
+                let new_decoder = decoder::VideoDecoder::new(
                     &self.debug_name,
                     render_context,
                     self.data.clone(),
diff --git a/crates/viewer/re_space_view_spatial/src/visualizers/videos.rs b/crates/viewer/re_space_view_spatial/src/visualizers/videos.rs
index d3d091805bc0..f508ab6c258d 100644
--- a/crates/viewer/re_space_view_spatial/src/visualizers/videos.rs
+++ b/crates/viewer/re_space_view_spatial/src/visualizers/videos.rs
@@ -195,7 +195,11 @@ impl VideoFrameReferenceVisualizer {
                 video_resolution = glam::vec2(video.width() as _, video.height() as _);
 
                 match video.frame_at(render_ctx, decode_stream_id, video_timestamp.as_seconds()) {
-                    Ok(frame) => {
+                    Ok(VideoFrameTexture {
+                        texture,
+                        is_pending,
+                        show_spinner,
+                    }) => {
                         // Make sure to use the video instead of texture size here,
                         // since the texture may be a placeholder which doesn't have the full size yet.
                         let top_left_corner_position =
@@ -205,22 +209,19 @@ impl VideoFrameReferenceVisualizer {
                         let extent_v =
                             world_from_entity.transform_vector3(glam::Vec3::Y * video_resolution.y);
 
-                        let texture = match frame {
-                            VideoFrameTexture::Ready(texture) => texture,
-                            VideoFrameTexture::Pending(placeholder) => {
-                                // Show loading rectangle:
-                                self.data.loading_spinners.push(LoadingSpinner {
-                                    center: top_left_corner_position + 0.5 * (extent_u + extent_v),
-                                    half_extent_u: 0.5 * extent_u,
-                                    half_extent_v: 0.5 * extent_v,
-                                });
-
-                                // Keep polling for the decoded result:
-                                ctx.viewer_ctx.egui_ctx.request_repaint();
-
-                                placeholder
-                            }
-                        };
+                        if is_pending {
+                            // Keep polling for a fresh texture
+                            ctx.viewer_ctx.egui_ctx.request_repaint();
+                        }
+
+                        if show_spinner {
+                            // Show loading rectangle:
+                            self.data.loading_spinners.push(LoadingSpinner {
+                                center: top_left_corner_position + 0.5 * (extent_u + extent_v),
+                                half_extent_u: 0.5 * extent_u,
+                                half_extent_v: 0.5 * extent_v,
+                            });
+                        }
 
                         let textured_rect = TexturedRect {
                             top_left_corner_position,
diff --git a/scripts/lint.py b/scripts/lint.py
index c5d7edce26c1..ce9a83ec8392 100755
--- a/scripts/lint.py
+++ b/scripts/lint.py
@@ -1177,6 +1177,7 @@ def main() -> None:
 
     exclude_paths = (
         "./.github/workflows/reusable_checks.yml",  # zombie TODO hunting job
+        "./.nox",
         "./.pytest_cache",
         "./CODE_STYLE.md",
         "./crates/build/re_types_builder/src/reflection.rs",  # auto-generated