crabcamera 0.8.3

Advanced cross-platform camera integration for Tauri applications
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

//! Basic timing utilities for presentation timestamps
//!
//! Simple monotonic clock for timestamp generation.

use std::sync::Arc;
use std::time::Instant;

/// Monotonic clock for presentation timestamps
///
/// All timestamps derive from this single source
/// to ensure monotonic ordering.
#[derive(Debug, Clone)]
pub struct PTSClock {
    start: Arc<Instant>,
}

impl PTSClock {
    /// Create a new PTS clock with the current instant as time zero
    pub fn new() -> Self {
        Self {
            start: Arc::new(Instant::now()),
        }
    }

    /// Create a PTS clock from an existing start instant
    ///
    /// Use this to share the same timebase between components.
    pub fn from_instant(start: Instant) -> Self {
        Self {
            start: Arc::new(start),
        }
    }

    /// Get the presentation timestamp in seconds
    ///
    /// Returns the elapsed time since clock creation.
    #[inline]
    pub fn pts(&self) -> f64 {
        self.start.elapsed().as_secs_f64()
    }

    /// Get the presentation timestamp for a given instant
    ///
    /// The instant must be after the clock's start time.
    #[inline]
    pub fn pts_at(&self, instant: Instant) -> f64 {
        instant.duration_since(*self.start).as_secs_f64()
    }

    /// Get the start instant for sharing with other components
    pub fn start_instant(&self) -> Instant {
        *self.start
    }
}

impl Default for PTSClock {
    fn default() -> Self {
        Self::new()
    }
}