+
+ /// Converts time in given scale into timestamp in given base.
+ #[allow(clippy::collapsible_if)]
+ #[allow(clippy::collapsible_else_if)]
+ pub fn time_to_ts(time: u64, base: u64, tb_num: u32, tb_den: u32) -> u64 {
+ let tb_num = u64::from(tb_num);
+ let tb_den = u64::from(tb_den);
+ let tmp = time.checked_mul(tb_den);
+ if let Some(tmp) = tmp {
+ tmp / base / tb_num
+ } else {
+ if tb_num < base {
+ let coarse = time / tb_num;
+ if let Some(tmp) = coarse.checked_mul(tb_den) {
+ tmp / base
+ } else {
+ (coarse / base) * tb_den
+ }
+ } else {
+ let coarse = time / base;
+ if let Some(tmp) = coarse.checked_mul(tb_den) {
+ tmp / tb_num
+ } else {
+ (coarse / tb_num) * tb_den
+ }
+ }
+ }
+ }
+ /// Converts timestamp in given base into time in given scale.
+ pub fn ts_to_time(ts: u64, base: u64, tb_num: u32, tb_den: u32) -> u64 {
+ let tb_num = u64::from(tb_num);
+ let tb_den = u64::from(tb_den);
+ let tmp = ts.checked_mul(base);
+ if let Some(tmp) = tmp {
+ let tmp2 = tmp.checked_mul(tb_num);
+ if let Some(tmp2) = tmp2 {
+ tmp2 / tb_den
+ } else {
+ (tmp / tb_den) * tb_num
+ }
+ } else {
+ let tmp = ts.checked_mul(tb_num);
+ if let Some(tmp) = tmp {
+ (tmp / tb_den) * base
+ } else {
+ (ts / tb_den) * base * tb_num
+ }
+ }
+ }
+ fn get_cur_ts(&self) -> u64 { self.pts.unwrap_or_else(|| self.dts.unwrap_or(0)) }
+ fn get_cur_millis(&self) -> u64 {
+ let ts = self.get_cur_ts();
+ Self::ts_to_time(ts, 1000, self.tb_num, self.tb_den)
+ }
+ /// Checks whether the current time information is earler than provided reference time.
+ pub fn less_than(&self, time: NATimePoint) -> bool {
+ if self.pts.is_none() && self.dts.is_none() {
+ return true;
+ }
+ match time {
+ NATimePoint::PTS(rpts) => self.get_cur_ts() < rpts,
+ NATimePoint::Milliseconds(ms) => self.get_cur_millis() < ms,
+ NATimePoint::None => false,
+ }
+ }
+ /// Checks whether the current time information is the same as provided reference time.
+ pub fn equal(&self, time: NATimePoint) -> bool {
+ if self.pts.is_none() && self.dts.is_none() {
+ return time == NATimePoint::None;
+ }
+ match time {
+ NATimePoint::PTS(rpts) => self.get_cur_ts() == rpts,
+ NATimePoint::Milliseconds(ms) => self.get_cur_millis() == ms,
+ NATimePoint::None => false,
+ }
+ }
+}
+
+/// Time information for specifying durations or seek positions.
+#[derive(Clone,Copy,Debug,PartialEq,Default)]
+pub enum NATimePoint {
+ /// Time in milliseconds.
+ Milliseconds(u64),
+ /// Stream timestamp.
+ PTS(u64),
+ /// No time information present.
+ #[default]
+ None,
+}
+
+impl fmt::Display for NATimePoint {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ match *self {
+ NATimePoint::Milliseconds(millis) => {
+ let tot_s = millis / 1000;
+ let ms = millis % 1000;
+ if tot_s < 60 {
+ if ms != 0 {
+ return write!(f, "{}.{:03}", tot_s, ms);
+ } else {
+ return write!(f, "{}", tot_s);
+ }
+ }
+ let tot_m = tot_s / 60;
+ let s = tot_s % 60;
+ if tot_m < 60 {
+ if ms != 0 {
+ return write!(f, "{}:{:02}.{:03}", tot_m, s, ms);
+ } else {
+ return write!(f, "{}:{:02}", tot_m, s);
+ }
+ }
+ let h = tot_m / 60;
+ let m = tot_m % 60;
+ if ms != 0 {
+ write!(f, "{}:{:02}:{:02}.{:03}", h, m, s, ms)
+ } else {
+ write!(f, "{}:{:02}:{:02}", h, m, s)
+ }
+ },
+ NATimePoint::PTS(pts) => {
+ write!(f, "{}pts", pts)
+ },
+ NATimePoint::None => {
+ write!(f, "none")
+ },
+ }
+ }