use core::fmt;
use super::{FrameRate, Ratio, Rounding, TimecodeError};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Fields {
pub hours: u8,
pub minutes: u8,
pub seconds: u8,
pub frames: u8,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct Timecode {
frames: u32,
rate: FrameRate,
}
impl Timecode {
pub const fn from_frames(frames: u32, rate: FrameRate) -> Result<Self, TimecodeError> {
if frames >= rate.frames_per_day() {
return Err(TimecodeError::FrameOutOfRange);
}
Ok(Self { frames, rate })
}
pub const fn from_fields(fields: Fields, rate: FrameRate) -> Result<Self, TimecodeError> {
let Fields {
hours,
minutes,
seconds,
frames,
} = fields;
if hours > 23 || minutes > 59 || seconds > 59 || frames >= rate.nominal() {
return Err(TimecodeError::FieldOutOfRange);
}
let dropped = rate.dropped_per_minute();
if minutes % 10 != 0 && seconds == 0 && (frames as u32) < dropped {
return Err(TimecodeError::DroppedLabel);
}
let total_minutes = hours as u32 * 60 + minutes as u32;
let labels = (total_minutes * 60 + seconds as u32) * rate.nominal() as u32 + frames as u32;
let skipped = dropped * (total_minutes - total_minutes / 10);
Ok(Self {
frames: labels - skipped,
rate,
})
}
pub const fn parse(text: &str, rate: FrameRate) -> Result<Self, TimecodeError> {
let bytes = text.as_bytes();
if (bytes.len() != 11 && bytes.len() != 12) || bytes[2] != b':' || bytes[5] != b':' {
return Err(TimecodeError::InvalidSyntax);
}
let drop_separator = match bytes[8] {
b':' => false,
b';' => true,
_ => return Err(TimecodeError::InvalidSyntax),
};
let (Some(hours), Some(minutes), Some(seconds), Some(frames)) = (
digits(bytes, 0, 2),
digits(bytes, 3, 5),
digits(bytes, 6, 8),
digits(bytes, 9, bytes.len()),
) else {
return Err(TimecodeError::InvalidSyntax);
};
if drop_separator && !rate.is_drop_frame() {
return Err(TimecodeError::DropFrameSeparator);
}
if frames > u8::MAX as u16 {
return Err(TimecodeError::FieldOutOfRange);
}
Self::from_fields(
Fields {
hours: hours as u8,
minutes: minutes as u8,
seconds: seconds as u8,
frames: frames as u8,
},
rate,
)
}
pub const fn from_seconds(
seconds: Ratio,
rate: FrameRate,
rounding: Rounding,
) -> Result<Self, TimecodeError> {
let fps = rate.frames_per_second();
let numer = seconds.numer() as u128 * fps.numer() as u128;
let denom = seconds.denom() as u128 * fps.denom() as u128;
Self::from_frame_count(rounding.divide(numer, denom), rate)
}
pub const fn from_samples(
samples: u64,
sample_rate: Ratio,
rate: FrameRate,
rounding: Rounding,
) -> Result<Self, TimecodeError> {
if sample_rate.numer() == 0 {
return Err(TimecodeError::ZeroSampleRate);
}
let fps = rate.frames_per_second();
let Some(numer) =
(samples as u128 * sample_rate.denom() as u128).checked_mul(fps.numer() as u128)
else {
return Err(TimecodeError::Overflow);
};
let denom = sample_rate.numer() as u128 * fps.denom() as u128;
Self::from_frame_count(rounding.divide(numer, denom), rate)
}
pub const fn frames(self) -> u32 {
self.frames
}
pub const fn rate(self) -> FrameRate {
self.rate
}
pub const fn fields(self) -> Fields {
let rate = self.rate;
let nominal = rate.nominal() as u32;
let dropped = rate.dropped_per_minute();
let mut labels = self.frames;
if dropped > 0 {
let tens = labels / rate.frames_per_ten_minutes();
let remaining = labels % rate.frames_per_ten_minutes();
let skipped_minutes = if remaining < dropped {
0
} else {
(remaining - dropped) / rate.frames_per_minute()
};
labels += dropped * (tens * 9 + skipped_minutes);
}
let seconds = labels / nominal;
let minutes = seconds / 60;
Fields {
hours: (minutes / 60) as u8,
minutes: (minutes % 60) as u8,
seconds: (seconds % 60) as u8,
frames: (labels % nominal) as u8,
}
}
pub const fn wrapping_add_frames(self, delta: i64) -> Self {
let day = self.rate.frames_per_day() as i64;
let frames = (self.frames as i64 + delta.rem_euclid(day)) % day;
Self {
frames: frames as u32,
rate: self.rate,
}
}
pub const fn to_seconds(self) -> Ratio {
let fps = self.rate.frames_per_second();
Ratio::reduced(self.frames as u64 * fps.denom(), fps.numer())
}
pub const fn to_samples(
self,
sample_rate: Ratio,
rounding: Rounding,
) -> Result<u64, TimecodeError> {
let fps = self.rate.frames_per_second();
let numer = self.frames as u128 * fps.denom() as u128 * sample_rate.numer() as u128;
let denom = fps.numer() as u128 * sample_rate.denom() as u128;
let samples = rounding.divide(numer, denom);
if samples > u64::MAX as u128 {
return Err(TimecodeError::Overflow);
}
Ok(samples as u64)
}
const fn from_frame_count(frames: u128, rate: FrameRate) -> Result<Self, TimecodeError> {
if frames >= rate.frames_per_day() as u128 {
return Err(TimecodeError::FrameOutOfRange);
}
Ok(Self {
frames: frames as u32,
rate,
})
}
}
impl fmt::Display for Timecode {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let Fields {
hours,
minutes,
seconds,
frames,
} = self.fields();
let separator = if self.rate.is_drop_frame() { ';' } else { ':' };
write!(
f,
"{hours:02}:{minutes:02}:{seconds:02}{separator}{frames:02}"
)
}
}
const fn digits(bytes: &[u8], start: usize, end: usize) -> Option<u16> {
let mut value = 0;
let mut index = start;
while index < end {
let byte = bytes[index];
if !byte.is_ascii_digit() {
return None;
}
value = value * 10 + (byte - b'0') as u16;
index += 1;
}
Some(value)
}