Struct rerun::AssetVideo

pub struct AssetVideo {
    pub blob: Blob,
    pub media_type: Option<MediaType>,
}

Archetype: A video binary.

Only MP4 containers with AV1 are generally supported, though the web viewer supports more video codecs, depending on browser.

See https://rerun.io/docs/reference/video for details of what is and isn’t supported.

In order to display a video, you also need to log a archetypes::VideoFrameReference for each frame.

Examples

Video with automatically determined frames

use rerun::external::anyhow;

fn main() -> anyhow::Result<()> {
    let args = _args;
    let Some(path) = args.get(1) else {
        // TODO(#7354): Only mp4 is supported for now.
        anyhow::bail!("Usage: {} <path_to_video.[mp4]>", args[0]);
    };

    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_asset_video_auto_frames").spawn()?;

    // Log video asset which is referred to by frame references.
    let video_asset = rerun::AssetVideo::from_file_path(path)?;
    rec.log_static("video", &video_asset)?;

    // Send automatically determined video frame timestamps.
    let frame_timestamps_ns = video_asset.read_frame_timestamps_ns()?;
    let video_timestamps_ns = frame_timestamps_ns
        .iter()
        .copied()
        .map(rerun::components::VideoTimestamp::from_nanoseconds)
        .collect::<Vec<_>>();
    let time_column = rerun::TimeColumn::new_nanos(
        "video_time",
        // Note timeline values don't have to be the same as the video timestamps.
        frame_timestamps_ns,
    );
    let frame_reference_indicators =
        <rerun::VideoFrameReference as rerun::Archetype>::Indicator::new_array(
            time_column.num_rows(),
        );
    rec.send_columns(
        "video",
        [time_column],
        [&frame_reference_indicators as _, &video_timestamps_ns as _],
    )?;

    Ok(())
}

Demonstrates manual use of video frame references

use rerun::external::anyhow;

fn main() -> anyhow::Result<()> {
    let args = _args;
    let Some(path) = args.get(1) else {
        // TODO(#7354): Only mp4 is supported for now.
        anyhow::bail!("Usage: {} <path_to_video.[mp4]>", args[0]);
    };

    let rec =
        rerun::RecordingStreamBuilder::new("rerun_example_asset_video_manual_frames").spawn()?;

    // Log video asset which is referred to by frame references.
    rec.log_static("video_asset", &rerun::AssetVideo::from_file_path(path)?)?;

    // Create two entities, showing the same video frozen at different times.
    rec.log(
        "frame_1s",
        &rerun::VideoFrameReference::new(rerun::components::VideoTimestamp::from_seconds(1.0))
            .with_video_reference("video_asset"),
    )?;
    rec.log(
        "frame_2s",
        &rerun::VideoFrameReference::new(rerun::components::VideoTimestamp::from_seconds(2.0))
            .with_video_reference("video_asset"),
    )?;

    // TODO(#5520): log blueprint once supported
    Ok(())
}

Fields

blob: Blob

The asset’s bytes.

media_type: Option<MediaType>

The Media Type of the asset.

Supported values:

• video/mp4

If omitted, the viewer will try to guess from the data blob. If it cannot guess, it won’t be able to render the asset.

Implementations

impl AssetVideo

pub const NUM_COMPONENTS: usize = 3usize

The total number of components in the archetype: 1 required, 2 recommended, 0 optional

impl AssetVideo

pub fn new(blob: impl Into<Blob>) -> AssetVideo

Create a new AssetVideo.

pub fn with_media_type(self, media_type: impl Into<MediaType>) -> AssetVideo

The Media Type of the asset.

Supported values:

• video/mp4

If omitted, the viewer will try to guess from the data blob. If it cannot guess, it won’t be able to render the asset.

impl AssetVideo

pub fn from_file_path(filepath: impl AsRef<Path>) -> Result<AssetVideo, Error>

Creates a new AssetVideo from the file contents at path.

The MediaType will first be guessed from the file extension, then from the file contents if needed.

If no MediaType can be guessed at the moment, the Rerun Viewer will try to guess one from the data at render-time. If it can’t, rendering will fail with an error.

Returns an error if the file cannot be read.

pub fn from_file_contents( contents: Vec<u8>, media_type: Option<impl Into<MediaType>> ) -> AssetVideo

Creates a new AssetVideo from the given contents.

The MediaType will be guessed from magic bytes in the data.

If no MediaType can be guessed at the moment, the Rerun Viewer will try to guess one from the data at render-time. If it can’t, rendering will fail with an error.

pub fn read_frame_timestamps_ns(&self) -> Result<Vec<i64>, VideoLoadError>

Determines the presentation timestamps of all frames inside the video.

Returned timestamps are in nanoseconds since start and are guaranteed to be monotonically increasing.

Trait Implementations

impl Archetype for AssetVideo

type Indicator = GenericIndicatorComponent<AssetVideo>

The associated indicator component, whose presence indicates that the high-level archetype-based APIs were used to log the data.

fn name() -> ArchetypeName

The fully-qualified name of this archetype, e.g. rerun.archetypes.Points2D.

fn display_name() -> &'static str

Readable name for displaying in ui.

fn indicator() -> MaybeOwnedComponentBatch<'static>

Creates a ComponentBatch out of the associated Self::Indicator component.

fn required_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that must be provided by the user when constructing this archetype.

fn recommended_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that should be provided by the user when constructing this archetype.

fn optional_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that may be provided by the user when constructing this archetype.

fn all_components() -> Cow<'static, [ComponentName]>

Returns the names of all components that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentName, Box<dyn Array>)> ) -> Result<AssetVideo, DeserializationError>

Given an iterator of Arrow arrays and their respective ComponentNames, deserializes them into this archetype.

fn from_arrow( data: impl IntoIterator<Item = (Field, Box<dyn Array>)> ) -> Result<Self, DeserializationError>

where Self: Sized,

Given an iterator of Arrow arrays and their respective field metadata, deserializes them into this archetype.

impl AsComponents for AssetVideo

fn as_component_batches(&self) -> Vec<MaybeOwnedComponentBatch<'_>>

Exposes the object’s contents as a set of ComponentBatchs.

fn to_arrow(&self) -> Result<Vec<(Field, Box<dyn Array>)>, SerializationError>

Serializes all non-null Components of this bundle into Arrow arrays.

impl Clone for AssetVideo

fn clone(&self) -> AssetVideo

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AssetVideo

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl SizeBytes for AssetVideo

fn heap_size_bytes(&self) -> u64

Returns the total size of self on the heap, in bytes.

fn is_pod() -> bool

Is Self just plain old data?

fn total_size_bytes(&self) -> u64

Returns the total size of self in bytes, accounting for both stack and heap space.

fn stack_size_bytes(&self) -> u64

Returns the total size of self on the stack, in bytes.

impl ArchetypeReflectionMarker for AssetVideo