Struct MediaFrame 

pub struct MediaFrame {
    pub pts: i64,
    pub dts: i64,
    pub duration: Option<u64>,
    pub data: Bytes,
    pub codec: CodecId,
    pub frame_type: FrameType,
    pub flags: FrameFlags,
    pub track_id: u32,
}

A single decoded or encoded media sample.

data is always a bytes::Bytes slice — zero-copy cloning is safe and cheap. The same frame can be fanned-out to many subscribers without copying the underlying buffer.

Fields

pts: i64

Presentation timestamp in the stream’s time base (milliseconds).

dts: i64

Decode timestamp in the stream’s time base (milliseconds).

duration: Option<u64>

Duration of this frame in milliseconds. None = unknown.

data: Bytes

Encoded / raw payload.

codec: CodecId

Codec that produced this frame.

frame_type: FrameType

Frame type classification.

flags: FrameFlags

Bit flags.

track_id: u32

Track index (0 = first video, 1 = first audio, etc.).

Implementations

impl MediaFrame

pub fn new_video( pts: i64, dts: i64, data: Bytes, codec: CodecId, is_key: bool, ) -> Self

Build a video frame; is_key selects FrameType::Key vs FrameType::Delta. Track id defaults to 0.

pub fn new_audio(pts: i64, data: Bytes, codec: CodecId) -> Self

Build an audio frame (dts == pts, FrameType::Audio, track id 1).

pub fn is_keyframe(&self) -> bool

Whether this frame is a video keyframe (FrameType::Key).

pub fn is_audio(&self) -> bool

Whether this frame is audio.

pub fn is_video(&self) -> bool

Whether this frame is video (key or delta).

pub fn pts_duration(&self) -> Duration

The presentation timestamp as a Duration (from the absolute pts).

pub fn pts_in(&self, timescale: u32) -> i64

The presentation timestamp rescaled from the frame’s millisecond base into timescale ticks per second.

Frame timestamps are stored in milliseconds (a 1 kHz time base), but media containers and wire formats run other clocks: RTP and MPEG-TS use 90 kHz for video, RTP audio uses the sample rate, and CMAF/fMP4 pick a per-track timescale. This converts without changing how frames are stored, so a muxer/packetizer can emit timestamps in its own base:

let f = MediaFrame::new_video(1000, 1000, Bytes::new(), CodecId::H264, true);
assert_eq!(f.pts_in(90_000), 90_000); // 1000 ms → 90 kHz ticks

The math is done in i128 so a large pts × timescale cannot overflow.

pub fn dts_in(&self, timescale: u32) -> i64

The decode timestamp rescaled into timescale ticks per second. See pts_in.

pub fn duration_in(&self, timescale: u32) -> Option<i64>

The frame duration rescaled into timescale ticks per second, or None when the duration is unknown. See pts_in.

Trait Implementations

impl Clone for MediaFrame

fn clone(&self) -> MediaFrame

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MediaFrame

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

Formats the value using the given formatter.