Struct rerun::sdk::prelude::AssetVideo

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

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,
    );

    rec.send_columns(
        "video",
        [time_column],
        rerun::VideoFrameReference::update_fields()
            .with_many_timestamp(video_timestamps_ns)
            .columns_of_unit_batches()?,
    )?;

    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: Option<SerializedComponentBatch>

The asset’s bytes.

media_type: Option<SerializedComponentBatch>

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 fn descriptor_blob() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::blob.

pub fn descriptor_media_type() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::media_type.

pub fn descriptor_indicator() -> ComponentDescriptor

Returns the ComponentDescriptor for the associated indicator component.

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 update_fields() -> AssetVideo

Update only some specific fields of a AssetVideo.

pub fn clear_fields() -> AssetVideo

Clear all the fields of a AssetVideo.

pub fn columns<I>( self, _lengths: I, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

where I: IntoIterator<Item = usize> + Clone,

Partitions the component data into multiple sub-batches.

Specifically, this transforms the existing SerializedComponentBatches data into SerializedComponentColumns instead, via SerializedComponentBatch::partitioned.

This makes it possible to use RecordingStream::send_columns to send columnar data directly into Rerun.

The specified lengths must sum to the total length of the component batch.

pub fn columns_of_unit_batches( self, ) -> Result<impl Iterator<Item = SerializedComponentColumn>, SerializationError>

Helper to partition the component data into unit-length sub-batches.

This is semantically similar to calling Self::columns with std::iter::take(1).repeat(n), where n is automatically guessed.

pub fn with_blob(self, blob: impl Into<Blob>) -> AssetVideo

The asset’s bytes.

pub fn with_many_blob( self, blob: impl IntoIterator<Item = impl Into<Blob>>, ) -> AssetVideo

This method makes it possible to pack multiple crate::components::Blob in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_blob should be used when logging a single row’s worth of data.

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.

pub fn with_many_media_type( self, media_type: impl IntoIterator<Item = impl Into<MediaType>>, ) -> AssetVideo

This method makes it possible to pack multiple crate::components::MediaType in a single component batch.

This only makes sense when used in conjunction with Self::columns. Self::with_media_type should be used when logging a single row’s worth of data.

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.

Panics if the serialized blob data doesn’t have the right datatype.

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() -> SerializedComponentBatch

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

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

Returns all component descriptors that must be provided by the user when constructing this archetype.

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

Returns all component descriptors that should be provided by the user when constructing this archetype.

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

Returns all component descriptors that may be provided by the user when constructing this archetype.

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

Returns all component descriptors that must, should and may be provided by the user when constructing this archetype.

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<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, Arc<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_serialized_batches(&self) -> Vec<SerializedComponentBatch>

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

fn to_arrow(&self) -> Result<Vec<(Field, Arc<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 Default for AssetVideo

fn default() -> AssetVideo

Returns the “default value” for a type.

impl SizeBytes for AssetVideo

fn heap_size_bytes(&self) -> u64

Returns how many bytes self uses on the heap.

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.

fn is_pod() -> bool

Is Self just plain old data?

impl ArchetypeReflectionMarker for AssetVideo