Struct AssetVideo 

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

Archetype: A video binary.

Only MP4 containers are currently supported.

See https://rerun.io/docs/reference/video for codec support and more general information.

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_nanos = video_asset.read_frame_timestamps_nanos()?;
    let video_timestamps_nanos = frame_timestamps_nanos
        .iter()
        .copied()
        .map(rerun::components::VideoTimestamp::from_nanos)
        .collect::<Vec<_>>();
    let time_column = rerun::TimeColumn::new_duration_nanos(
        "video_time",
        // Note timeline values don't have to be the same as the video timestamps.
        frame_timestamps_nanos,
    );

    rec.send_columns(
        "video",
        [time_column],
        rerun::VideoFrameReference::update_fields()
            .with_many_timestamp(video_timestamps_nanos)
            .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_secs(1.0))
            .with_video_reference("video_asset"),
    )?;
    rec.log(
        "frame_2s",
        &rerun::VideoFrameReference::new(rerun::components::VideoTimestamp::from_secs(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.

The corresponding component is crate::components::Blob.

pub fn descriptor_media_type() -> ComponentDescriptor

Returns the ComponentDescriptor for Self::media_type.

The corresponding component is crate::components::MediaType.

impl AssetVideo

pub const NUM_COMPONENTS: usize = 2usize

The total number of components in the archetype: 1 required, 1 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_nanos(&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.

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

👎Deprecated since 0.23.0: Renamed to read_frame_timestamps_nanos

DEPRECATED: renamed to read_frame_timestamps_nanos

Trait Implementations

impl Archetype for AssetVideo

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 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 ComponentDescriptors, deserializes them into this archetype.

fn all_component_identifiers() -> impl Iterator<Item = ComponentIdentifier>

Utility method based on Self::all_components to return all component identifiers.

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 duplicate 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