moq-karp 0.11.2

Media over QUIC
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use std::fmt;

use moq_transfork::coding::*;

use derive_more::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Rem, RemAssign, Sub, SubAssign, Sum};

use derive_more::Debug;

#[derive(Clone, Debug)]
pub struct Frame {
	pub timestamp: Timestamp,
	pub keyframe: bool,

	#[debug("{}", payload.len())]
	pub payload: Bytes,
}

#[derive(
	Clone,
	Copy,
	PartialEq,
	Eq,
	PartialOrd,
	Ord,
	Default,
	Add,
	AddAssign,
	Sub,
	SubAssign,
	Mul,
	MulAssign,
	Div,
	DivAssign,
	Rem,
	RemAssign,
	Sum,
)]
pub struct Timestamp {
	micros: u64,
}

impl Timestamp {
	pub fn from_micros(micros: u64) -> Self {
		Self { micros }
	}

	pub fn from_millis(millis: u64) -> Self {
		Self { micros: millis * 1_000 }
	}

	pub fn from_seconds(seconds: u64) -> Self {
		Self {
			micros: seconds * 1_000_000,
		}
	}

	pub fn from_minutes(minutes: u64) -> Self {
		Self {
			micros: minutes * 60_000_000,
		}
	}

	pub fn from_hours(hours: u64) -> Self {
		Self {
			micros: hours * 3_600_000_000,
		}
	}

	pub fn from_units(value: u64, base: u64) -> Self {
		Self {
			micros: (value * 1_000_000) / base,
		}
	}

	pub fn as_micros(&self) -> u64 {
		self.micros
	}

	pub fn as_millis(&self) -> u64 {
		self.micros / 1_000
	}

	pub fn as_seconds(&self) -> u64 {
		self.micros / 1_000_000
	}

	pub fn as_minutes(&self) -> u64 {
		self.micros / 60_000_000
	}

	pub fn as_hours(&self) -> u64 {
		self.micros / 3_600_000_000
	}

	pub fn as_units(&self, base: u64) -> u64 {
		(self.micros * base) / 1_000_000
	}
}

impl fmt::Debug for Timestamp {
	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		if self.micros == 0 {
			return write!(f, "0");
		}

		let hours = self.micros / 3_600_000_000;
		let minutes = (self.micros % 3_600_000_000) / 60_000_000;
		let seconds = (self.micros % 60_000_000) / 1_000_000;
		let millis = (self.micros % 1_000_000) / 1_000;
		let micros = self.micros % 1_000;

		let mut parts = Vec::new();
		if hours > 0 {
			parts.push(format!("{}h", hours));
		}
		if minutes > 0 {
			parts.push(format!("{:02}m", minutes));
		}
		if seconds > 0 {
			parts.push(format!("{:02}s", seconds));
		}
		if millis > 0 {
			parts.push(format!("{:03}ms", millis));
		}
		if micros > 0 {
			parts.push(format!("{:03}us", micros));
		}

		write!(f, "{}", parts.join(" "))
	}
}