Struct cdtoc::Duration

source ·

pub struct Duration(/* private fields */);

Expand description

(CDDA Sector) Duration.

This struct holds a non-lossy — at least up to about 7.8 billion years — CD sector duration (seconds + frames) for one or more tracks.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
let duration = track.duration();

// The printable format is Dd HH:MM:SS+FF, though the day part is only
// present if non-zero.
assert_eq!(duration.to_string(), "00:01:55+04");

// The same as intelligible pieces:
assert_eq!(duration.dhmsf(), (0, 0, 1, 55, 4));

// If that's too many pieces, you can get just the seconds and frames:
assert_eq!(duration.seconds_frames(), (115, 4));

The value can also be lossily converted to more familiar formats via Duration::to_std_duration_lossy or Duration::to_f64_lossy.

Durations can also be combined every which way, for example:

use cdtoc::{Toc, Duration};

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let duration: Duration = toc.audio_tracks()
    .map(|t| t.duration())
    .sum();
assert_eq!(duration.to_string(), "00:34:41+63");

Implementations§

source §

impl Duration

source

pub const fn from_cdda_samples(total_samples: u64) -> Result<Self, TocError>

From CDDA Samples.

Derive the duration from the total number of a track’s CDDA-quality samples.

This method assumes the count was captured at a rate of 44.1 kHz, and requires it divide evenly into the samples-per-sector size used by standard audio CDs (588).

For more flexible (and/or approximate) sample/duration conversions, use Duration::from_samples instead.

Examples

use cdtoc::Duration;

let duration = Duration::from_cdda_samples(5_073_852).unwrap();
assert_eq!(
    duration.to_string(),
    "00:01:55+04",
);

Errors

This will return an error if the sample count is not evenly divisible by 588, the number of samples-per-sector for a standard audio CD.

source

pub fn from_samples(sample_rate: u32, total_samples: u64) -> Self

From Samples (Rescaled).

Derive the equivalent CDDA duration for a track with an arbitrary sample rate (i.e. not 44.1 kHz) or sample count.

This operation is potentially lossy and may result in a duration that is off by ±1 frame.

For standard CDDA tracks, use Duration::from_cdda_samples instead.

Examples

use cdtoc::Duration;

let duration = Duration::from_samples(96_000, 17_271_098);
assert_eq!(
    duration.to_string(),
    "00:02:59+68",
);

source §

impl Duration

source

pub const fn dhmsf(self) -> (u64, u8, u8, u8, u8)

Days, Hours, Minutes, Seconds, Frames.

Carve up the duration into a quintuple of days, hours, minutes, seconds, and frames.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().dhmsf(),
    (0, 0, 1, 55, 4),
);

source

pub const fn samples(self) -> u64

Total Samples.

Return the total number of samples.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().samples(),
    5_073_852,
);

source

pub const fn seconds_frames(self) -> (u64, u8)

Seconds + Frames.

Return the duration as a tuple containing the total number of seconds and remaining frames (some fraction of a second).

Audio CDs have 75 frames per second, so the frame portion will always be in the range of 0..75.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().seconds_frames(),
    (115, 4),
);

source

pub const fn sectors(self) -> u64

Number of Sectors.

Return the total number of sectors.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().sectors(),
    8629,
);

source

pub fn to_f64_lossy(self) -> f64

To `f64` (Lossy).

Return the duration as a float (seconds.subseconds).

Given that 75ths don’t always make the cleanest of fractions, there will likely be some loss in precision.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().to_f64_lossy(),
    115.05333333333333,
);

source

pub fn to_std_duration_lossy(self) -> Duration

To `std::time::Duration` (Lossy).

Return the value as a “normal” std::time::Duration.

Note that the std struct only counts time down to the nanosecond, so this value might be off by a few frames.

Examples

use cdtoc::Toc;

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().to_std_duration_lossy().as_nanos(),
    115_053_333_333,
);

source

pub fn to_string_pretty(self) -> String

To String Pretty.

Return a string reprsentation of the non-zero parts with English labels, separated Oxford-comma-style.

Examples

use cdtoc::{Toc, Duration};

let toc = Toc::from_cdtoc("9+96+5766+A284+E600+11FE5+15913+19A98+1E905+240CB+26280").unwrap();
let track = toc.audio_track(9).unwrap();
assert_eq!(
    track.duration().to_string_pretty(),
    "1 minute, 55 seconds, and 4 frames",
);

// Empty durations look like this:
assert_eq!(
    Duration::default().to_string_pretty(),
    "0 seconds",
);