Small video-related refactor

crates/store/re_video/examples/frames.rs

@@ -13,6 +13,8 @@ use std::{
 use indicatif::ProgressBar;
 use parking_lot::Mutex;
 
+use re_video::{decode::SyncDecoder, VideoData};
+
 fn main() {
     // frames <video.mp4>
     let args: Vec<_> = std::env::args().collect();
@@ -27,17 +29,33 @@ fn main() {
     let video = std::fs::read(video_path).expect("failed to read video");
     let video = re_video::VideoData::load_mp4(&video).expect("failed to load video");
 
-    let sync_decoder = Box::new(
-        re_video::decode::av1::SyncDav1dDecoder::new().expect("Failed to start AV1 decoder"),
-    );
-
     println!(
         "{} {}x{}",
         video.gops.len(),
         video.config.coded_width,
         video.config.coded_height
     );
 
+    let mut decoder = create_decoder(&video);
+
+    write_video_frames(&video, decoder.as_mut(), &output_dir);
+}
+
+fn create_decoder(video: &VideoData) -> Box<dyn SyncDecoder> {
+    if video.config.is_av1() {
+        Box::new(
+            re_video::decode::av1::SyncDav1dDecoder::new().expect("Failed to start AV1 decoder"),
+        )
+    } else {
+        panic!("Unsupported codec: {}", video.human_readable_codec_string());
+    }
+}
+
+fn write_video_frames(
+    video: &re_video::VideoData,
+    decoder: &mut dyn re_video::decode::SyncDecoder,
+    output_dir: &PathBuf,
+) {
     let progress = ProgressBar::new(video.samples.len() as u64).with_message("Decoding video");
     progress.enable_steady_tick(Duration::from_millis(100));
 
@@ -50,16 +68,14 @@ fn main() {
             frames.lock().push(frame);
         }
     };
-    let mut decoder =
-        re_video::decode::AsyncDecoder::new("debug_name".to_owned(), sync_decoder, on_output);
 
     let start = Instant::now();
     for sample in &video.samples {
-        decoder.decode(video.get(sample).unwrap());
+        let should_stop = std::sync::atomic::AtomicBool::new(false);
+        let chunk = video.get(sample).unwrap();
+        decoder.submit_chunk(&should_stop, chunk, &on_output);
     }
 
-    decoder.flush();
-    drop(decoder);
     let end = Instant::now();
     progress.finish();
 
@@ -72,7 +88,7 @@ fn main() {
     );
 
     println!("Writing frames to {}", output_dir.display());
-    std::fs::create_dir_all(&output_dir).expect("failed to create output directory");
+    std::fs::create_dir_all(output_dir).expect("failed to create output directory");
 
     let width = num_digits(frames.len());
     for (i, frame) in frames.iter().enumerate() {

crates/store/re_video/src/decode/mod.rs

@@ -38,7 +38,12 @@ pub trait SyncDecoder {
 }
 
 /// One chunk of encoded video data; usually one frame.
+///
+/// One loaded [`crate::Sample`].
 pub struct Chunk {
+    /// The start of a new [`crate::demux::GroupOfPictures`]?
+    pub is_sync: bool,
+
     pub data: Vec<u8>,
     pub timestamp: Time,
     pub duration: Time,
@@ -55,5 +60,6 @@ pub struct Frame {
 }
 
 pub enum PixelFormat {
+    Rgb8Unorm,
     Rgba8Unorm,
 }

crates/store/re_video/src/demux/mod.rs

@@ -144,6 +144,7 @@ impl VideoData {
                 data: data.to_vec(),
                 timestamp: sample.decode_timestamp,
                 duration: sample.duration,
+                is_sync: sample.is_sync,
             })
         }
     }
@@ -174,6 +175,9 @@ impl GroupOfPictures {
 /// A single sample in a video.
 #[derive(Debug, Clone)]
 pub struct Sample {
+    /// The start of a new [`GroupOfPictures`]?
+    pub is_sync: bool,
+
     /// Time at which this sample appears in the decoded bitstream, in time units.
     ///
     /// Samples should be decoded in this order.

crates/store/re_video/src/demux/mp4.rs

@@ -58,6 +58,7 @@ impl VideoData {
             let byte_length = sample.size as u32;
 
             samples.push(Sample {
+                is_sync: sample.is_sync,
                 decode_timestamp,
                 composition_timestamp,
                 duration,

crates/viewer/re_renderer/src/video/decoder/native_decoder.rs

@@ -129,6 +129,22 @@ fn copy_video_frame_to_texture(
     frame: &Frame,
     texture: &wgpu::Texture,
 ) -> Result<(), DecodingError> {
+    let format = match frame.format {
+        re_video::PixelFormat::Rgb8Unorm => {
+            return copy_video_frame_to_texture(
+                queue,
+                &Frame {
+                    data: crate::pad_rgb_to_rgba(&frame.data, 255_u8),
+                    format: re_video::PixelFormat::Rgba8Unorm,
+                    ..*frame
+                },
+                texture,
+            );
+        }
+
+        re_video::PixelFormat::Rgba8Unorm => wgpu::TextureFormat::Rgba8Unorm,
+    };
+
     re_tracing::profile_function!();
 
     let size = wgpu::Extent3d {
@@ -137,10 +153,6 @@ fn copy_video_frame_to_texture(
         depth_or_array_layers: 1,
     };
 
-    let format = match frame.format {
-        re_video::PixelFormat::Rgba8Unorm => wgpu::TextureFormat::Rgba8Unorm,
-    };
-
     let width_blocks = frame.width / format.block_dimensions().0;
 
     #[allow(clippy::unwrap_used)] // block_copy_size can only fail for weird compressed formats