Struct VideoStream

Source

pub struct VideoStream {
    pub codec: Option<SerializedComponentBatch>,
    pub sample: Option<SerializedComponentBatch>,
    pub draw_order: Option<SerializedComponentBatch>,
}

Expand description

Archetype: Video stream consisting of raw video chunks.

For logging video containers like mp4, refer to archetypes::AssetVideo and archetypes::VideoFrameReference. To learn more about video support in Rerun, check the video reference.

All components except sample are typically logged statically once per entity. sample is then logged repeatedly for each frame on the timeline.

TODO(#10422): archetypes::VideoFrameReference does not yet work with archetypes::VideoStream.

⚠️ This type is unstable and may change significantly in a way that the data won’t be backwards compatible.

Fields§

§codec: Option<SerializedComponentBatch>

The codec used to encode the video chunks.

This property is expected to be constant over time and is ideally logged statically once per stream.

§sample: Option<SerializedComponentBatch>

Video sample data (also known as “video chunk”).

The current timestamp is used as presentation timestamp (PTS) for all data in this sample. There is currently no way to log differing decoding timestamps, meaning that there is no support for B-frames. See https://github.com/rerun-io/rerun/issues/10090 for more details.

Unlike any other data in Rerun, video samples are not allowed to be logged out of order, as this may break live video playback. I.e. any appended sample should have a timestamp greater than all previously logged samples.

The samples are expected to be encoded using the codec field. Each video sample must contain enough data for exactly one video frame (this restriction may be relaxed in the future for some codecs).

Unless your stream consists entirely of key-frames (in which case you should consider archetypes::EncodedImage) never log this component as static data as this means that you loose all information of previous samples which may be required to decode an image.

See components::VideoCodec for codec specific requirements.

§draw_order: Option<SerializedComponentBatch>

An optional floating point value that specifies the 2D drawing order.

Objects with higher values are drawn on top of those with lower values. Defaults to -15.0.

Struct VideoStreamCopy item path

Fields§

Implementations§

impl VideoStream

pub fn descriptor_codec() -> ComponentDescriptor

pub fn descriptor_sample() -> ComponentDescriptor

pub fn descriptor_draw_order() -> ComponentDescriptor

impl VideoStream

pub const NUM_COMPONENTS: usize = 3usize

impl VideoStream

pub fn new(codec: impl Into<VideoCodec>) -> VideoStream

pub fn update_fields() -> VideoStream

pub fn clear_fields() -> VideoStream

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

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

pub fn with_codec(self, codec: impl Into<VideoCodec>) -> VideoStream

pub fn with_many_codec( self, codec: impl IntoIterator<Item = impl Into<VideoCodec>>, ) -> VideoStream

pub fn with_sample(self, sample: impl Into<VideoSample>) -> VideoStream

pub fn with_many_sample( self, sample: impl IntoIterator<Item = impl Into<VideoSample>>, ) -> VideoStream

pub fn with_draw_order(self, draw_order: impl Into<DrawOrder>) -> VideoStream

pub fn with_many_draw_order( self, draw_order: impl IntoIterator<Item = impl Into<DrawOrder>>, ) -> VideoStream

Trait Implementations§

impl Archetype for VideoStream

fn name() -> ArchetypeName

fn display_name() -> &'static str

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

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

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

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

fn from_arrow_components( arrow_data: impl IntoIterator<Item = (ComponentDescriptor, Arc<dyn Array>)>, ) -> Result<VideoStream, DeserializationError>

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

impl AsComponents for VideoStream

fn as_serialized_batches(&self) -> Vec<SerializedComponentBatch>

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

impl Clone for VideoStream

fn clone(&self) -> VideoStream

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

impl Debug for VideoStream

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

impl Default for VideoStream

fn default() -> VideoStream

impl SizeBytes for VideoStream

fn heap_size_bytes(&self) -> u64

fn total_size_bytes(&self) -> u64

fn stack_size_bytes(&self) -> u64

fn is_pod() -> bool

impl ArchetypeReflectionMarker for VideoStream

Auto Trait Implementations§

impl Freeze for VideoStream

impl !RefUnwindSafe for VideoStream

impl Send for VideoStream

impl Sync for VideoStream

impl Unpin for VideoStream

impl !UnwindSafe for VideoStream

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Az for T

fn az<Dst>(self) -> Dstwhere T: Cast<Dst>,

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<Src, Dst> CastFrom<Src> for Dstwhere Src: Cast<Dst>,

fn cast_from(src: Src) -> Dst

impl<T> CheckedAs for T

fn checked_as<Dst>(self) -> Option<Dst>where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dstwhere Src: CheckedCast<Dst>,

fn checked_cast_from(src: Src) -> Option<Dst>

impl<T> CloneToUninit for Twhere T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> Downcast<T> for T

fn downcast(&self) -> &T

impl<T> Downcast for Twhere T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

fn as_any(&self) -> &(dyn Any + 'static)

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Struct VideoStream

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

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

impl<T> Any for T
where T: 'static + ?Sized,

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

impl<T> CloneToUninit for T
where T: Clone,

fn conv<T>(self) -> T
where Self: Into<T>,

impl<T> Downcast for T
where T: Any,

impl<T> DowncastSync for T
where T: Any + Send + Sync,

impl<T> FromRef<T> for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

impl<Src, Dst> LosslessTryInto<Dst> for Src
where Dst: LosslessTryFrom<Src>,

impl<Src, Dst> LossyInto<Dst> for Src
where Dst: LossyFrom<Src>,

impl<T> NoneValue for T
where T: Default,

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,